Astro 7: What's New, What's Faster, and What Breaks

Astro 7, released June 22, 2026, is a speed release. The .astro compiler got rewritten in Rust, the Markdown pipeline got rebuilt in Rust, and the bundler switched to Vite 8 with Rolldown. It is the same framework on faster infrastructure. Builds on real production Astro sites are 15 to 61 percent faster, with the biggest wins on sites where Markdown and .astro compilation dominate the build.

What Astro 7 actually is

Astro 7 is an infrastructure release. The component format, the island architecture, the routing model: all the same. What changed is what sits underneath. The official announcement calls it the speed release, and that is the honest framing. Four systems got rebuilt or swapped, five experimental features went stable, and the result is faster builds without a new mental model.

The closest parallel is TypeScript 7 rewriting its compiler in Go: keep the surface still, rebuild the engine. Astro 7 does the same, with Rust, across more layers.

Vite 8 and Rolldown

Astro 7 upgrades to Vite 8, which ships Rolldown as its bundler. Rolldown is a Rust bundler that replaces both esbuild and Rollup in the Vite pipeline, and runs 10 to 30 times faster than Rollup in benchmarks. If you had esbuild options or rollupOptions in your config, Vite 8 auto-converts them. The plugin API is the same, so existing Vite plugins keep working.

Vite is Astro’s build core: dev server, dependency optimization, production bundling. A faster bundler there is a faster everything.

Astro 7’s new Rust compiler

The .astro compiler was rewritten in Rust. It was Go before. The new compiler is built on oxc and Lightning CSS, and Astro reports about a 6 percent improvement in isolation. That sounds modest next to the Vite 8 jump, and it is. The compiler was already fast. But 6 percent compounds on a large build that runs thousands of .astro files.

Two behavior changes, both making the compiler stricter. It no longer auto-corrects HTML: markup is treated as-is. Unclosed tags are now errors, not warnings. If you had sloppy markup the Go compiler quietly fixed, the Rust compiler will tell you. It ships as native binaries per platform, with a WASM fallback.

Sätteri: Markdown and MDX in Rust

Sätteri is the new default Markdown and MDX pipeline. It is Rust-powered, built by Erika on pulldown-cmark and oxc, and it replaces the unified/remark/rehype stack Astro used before.

The performance is real. Astro’s docs build and Cloudflare’s docs build each shed over a minute. On a content-heavy site like this one, that is the win you feel.

Sätteri ships built-in support for GFM, smartypants, heading IDs, directives, math, frontmatter, and wikilinks. The plugin API works differently from unified: plugins declare the node types they care about, and Sätteri routes only those. If you need the old stack, unified() is still available via @astrojs/markdown-remark. But for most sites, Sätteri is the default and the faster path.

Queued rendering is now the default

Queued rendering was experimental in Astro 6. In Astro 7 it is stable and default. The old renderer walked the component tree recursively. Queued rendering uses a queue-based approach instead, and Astro reports roughly 2.4x faster rendering on expression-dense pages. You do not configure this. It is just on. The queuedRendering experimental flag is gone.

Advanced routing with src/fetch.ts

Advanced routing gives you a src/fetch.ts entrypoint with full control over the request pipeline. It uses the standard fetch handler pattern, the same Request in, Response out shape you see in Cloudflare Workers and WinterCG runtimes. It is Hono-compatible, so Hono middleware drops in directly.

The interesting part is composability. Individual Astro features can be composed as middleware: auth before your actions, a logging layer before everything, all in one file that owns the request lifecycle. src/fetch.ts is a reserved filename, so rename any existing file with that name.

Route caching and CDN providers

Route caching is now stable. You configure it with routeRules specifying maxAge and swr per route. Astro also ships experimental CDN cache providers for Netlify, Vercel, and Cloudflare, so cached responses live at the edge instead of in your origin’s memory.

For a docs site or a blog, this is straightforward. Set a maxAge on your content routes, a shorter one with swr for pages that update occasionally, and the framework handles invalidation. The CDN providers mean the cache survives deploys on those platforms, which is the part that was missing before.

What breaks when upgrading to Astro 7

The migration guide lists the breaking changes. Here is what to expect:

• Rust compiler is stricter. Unclosed tags error. No more HTML auto-correction. Fix your markup.
• Sätteri is the default Markdown processor. If you depend on a specific remark or rehype plugin, install @astrojs/markdown-remark to keep the unified pipeline.
• compressHTML defaults to jsx instead of true. Update your config if you relied on the old default.
• Experimental flags removed: rustCompiler, queuedRendering, advancedRouting, cache, and logger. Their behaviors are now standard or gone.
• @astrojs/db is removed. If you used the experimental database integration, you need a replacement.
• src/fetch.ts is a reserved filename. Rename any existing file with that name.
• Container renderer imports changed to the /container-renderer entrypoint.

There are also two AI-oriented additions: a background dev server mode for agents, and JSON logging output. Both are aimed at tooling that drives Astro programmatically.

Should you upgrade to Astro 7?

Yes, and soon if your site is content-heavy. The build speedup alone is worth it. The migration is mostly mechanical: remove the dead experimental flags, check your Markdown plugins, fix any markup the new compiler rejects.

Do the upgrade in an isolated git worktree so your main checkout keeps building while you shake out the Sätteri differences and the stricter compiler.

The broader story is the one I keep writing about. The JavaScript ecosystem is rewriting its foundations in native code. TypeScript went to Go, pnpm went to Rust, Vite swapped its bundler for Rolldown. And now Astro has rewritten its compiler, its Markdown pipeline, and its rendering engine in Rust, all in one release. The tools you use every day are getting faster underneath you, and the surface you write against is staying still. That is the best kind of progress.