<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Rust on Fulgurion Systems Blog</title><link>https://fulgurion.com/blog/tags/rust/</link><description>Recent content in Rust on Fulgurion Systems Blog</description><image><title>Fulgurion Systems Blog</title><url>https://fulgurion.com/blog/images/Logo-linkedin.png</url><link>https://fulgurion.com/blog/images/Logo-linkedin.png</link></image><generator>Hugo</generator><language>en-us</language><lastBuildDate>Thu, 30 Apr 2026 00:00:00 -0300</lastBuildDate><atom:link href="https://fulgurion.com/blog/tags/rust/index.xml" rel="self" type="application/rss+xml"/><item><title>Streaming LLM Tokens Through AWS API Gateway</title><link>https://fulgurion.com/blog/posts/rust-on-aws-lambda-streaming/</link><pubDate>Thu, 30 Apr 2026 00:00:00 -0300</pubDate><guid>https://fulgurion.com/blog/posts/rust-on-aws-lambda-streaming/</guid><description>&lt;p&gt;The previous four posts (&lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda/"&gt;Part 1&lt;/a&gt;, &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start/"&gt;Part 2&lt;/a&gt;, &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start-anatomy/"&gt;Part 3&lt;/a&gt;, &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda-wrong-tool/"&gt;Part 4&lt;/a&gt;) covered Rust on Lambda from cold starts to architectural fit. This one is a sibling rather than a sequel, focused on a specific AWS gotcha that bites anyone wiring an LLM behind API Gateway: &lt;strong&gt;HTTP API v2 does not support response streaming&lt;/strong&gt;. The modern, recommended Gateway flavor is the wrong tool for streaming LLM tokens. The older REST API got streaming support in &lt;strong&gt;November 2025&lt;/strong&gt;. If you reach for HTTP API v2 by reflex (and most &amp;ldquo;use the modern one&amp;rdquo; guides will tell you to), your token stream silently collapses into a single buffered response.&lt;/p&gt;</description></item><item><title>Rust Meets Serverless, Part 4: When Lambda Is the Wrong Tool</title><link>https://fulgurion.com/blog/posts/rust-on-aws-lambda-wrong-tool/</link><pubDate>Fri, 24 Apr 2026 00:00:00 -0300</pubDate><guid>https://fulgurion.com/blog/posts/rust-on-aws-lambda-wrong-tool/</guid><description>&lt;p&gt;In &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda/"&gt;Part 1&lt;/a&gt;, &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start/"&gt;Part 2&lt;/a&gt;, and &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start-anatomy/"&gt;Part 3&lt;/a&gt; I argued for Rust on Lambda and measured where the gains come from. This post draws the other edge of that fence: the shapes of work where Lambda is the wrong architectural choice, however lean the binary, and whichever language you wrote it in. The common thread across every case below is a single billing fact: &lt;strong&gt;Lambda charges you for wall-clock duration, including the time your handler spends waiting on IO.&lt;/strong&gt;&lt;/p&gt;</description></item><item><title>Rust Meets Serverless, Part 3: Anatomy of a Cold Start</title><link>https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start-anatomy/</link><pubDate>Wed, 22 Apr 2026 00:00:00 -0300</pubDate><guid>https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start-anatomy/</guid><description>&lt;p&gt;In &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start/"&gt;Part 2&lt;/a&gt; I measured the cold start of a minimal Rust Lambda at 18 to 22 ms. This post breaks down what that init window is actually paying for, and which parts you can move.&lt;/p&gt;
&lt;p&gt;The short version: out of the four phases that make up a cold start, only two are under your control. The rest is AWS infrastructure that you inherit whether you like it or not.&lt;/p&gt;
&lt;h2 id="the-four-phases"&gt;The Four Phases&lt;/h2&gt;
&lt;p&gt;&lt;img alt="Lambda init phase breakdown for Rust" loading="lazy" src="https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start-anatomy/lambda-init.svg"&gt;&lt;/p&gt;</description></item><item><title>Rust Meets Serverless, Part 2: Cold Start Times</title><link>https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start/</link><pubDate>Tue, 21 Apr 2026 00:00:00 -0300</pubDate><guid>https://fulgurion.com/blog/posts/rust-on-aws-lambda-cold-start/</guid><description>&lt;p&gt;In &lt;a href="https://fulgurion.com/blog/posts/rust-on-aws-lambda/"&gt;Part 1&lt;/a&gt; I covered why Rust on AWS Lambda is worth exploring and laid out the project setup. This post measures the one number that matters most for serverless latency: cold start time. To get a clean floor measurement, I used the simplest possible endpoint with no database, no external calls, and no middleware.&lt;/p&gt;
&lt;h2 id="the-benchmark-setup"&gt;The Benchmark Setup&lt;/h2&gt;
&lt;p&gt;The handler is a single health endpoint built with Axum and Cargo Lambda:&lt;/p&gt;</description></item><item><title>Rust Meets Serverless, Part 1: Getting Started with AWS Lambda</title><link>https://fulgurion.com/blog/posts/rust-on-aws-lambda/</link><pubDate>Mon, 20 Apr 2026 00:00:00 -0300</pubDate><guid>https://fulgurion.com/blog/posts/rust-on-aws-lambda/</guid><description>&lt;p&gt;After watching &lt;a href="https://www.youtube.com/watch?v=SYUUNO3M6zw"&gt;Benjamen Pyle&amp;rsquo;s talk on Rust and AWS Lambda&lt;/a&gt; at QCon 2025, I got curious enough to try it myself. Rust is known to be one of the best languages for building high-performing services, used across different industries where performance and stability are non-negotiable. One would expect these services to run on dedicated instances (either in the cloud or on bare-metal machines) in order to take full advantage of its benefits. However, in this post I explore whether Rust can be efficiently used in AWS Lambda.&lt;/p&gt;</description></item></channel></rss>