On March 10, 2026, Astro 6.0 shipped as stable, followed by Astro 6.1 in April with image optimization fixes, i18n improvements, and Lightning CSS regression patches. Calling this "a routine major release" badly understates what changed. Astro 6 rebuilt the dev server and build pipeline onto a single shared code path, sat that path on top of Vite's new Environment API, and made non-Node runtimes — Cloudflare Workers, Bun, Deno — reproduce locally in dev exactly as they will run in production. At the same time, the Go-based .astro compiler got a Rust rewrite as an experimental opt-in (compilation phase up to 100× faster on large content sites), the Fonts API and Content Security Policy API got promoted into core, and Live Content Collections — experimental in 5.10 — went stable. The heaviest operational changes, though, sit elsewhere: Astro.glob() permanently removed, Node 22 mandated, Astro.locals.runtime removed (replaced by direct cloudflare:workers imports), and the astro:schema / z from 'astro:content' path deprecated in favor of astro/zod (Zod v4). This post organizes the 6.0/6.1 surface into five axes, walks through the seven build-breaking migration items, and shares the four-week migration checklist ManoIT validated while moving its marketing and docs sites from v5 to v6.

1. Why 6 Is the Inflection Point — "Content Site = Static Build" Ends

Through Astro 5, the framework leaned into static site generation as a content-first posture. v4 added Content Layer API to free collections from local files; v5 added Server Islands and Sessions to mainstream partial SSR. v6 is the completion of that arc, and it lands in two sentences. First, the default for "build-once, deploy anywhere" shifts from build time to request time. With Live Content Collections and Route Caching stabilizing, content sites can serve fresh-per-request data while still letting CDN cache headers control delivery. Second, "works in dev, breaks in prod" disappears. Thanks to Vite's Environment API, the dev server boots non-Node runtimes (workerd, Bun, Deno) locally and uses the same runtime for prerendering. You import env from cloudflare:workers in dev, not a process.env shim.

The table below collapses the v5.x → v6.0/6.1 operational surface onto a single page.

The two highest-cost rows for operations are Content Collections and Schema validation. The auto-compatibility window for Astro.glob() finally closed, and z from 'astro:content' migrated to a Zod v4-based astro/zod. Both break builds, so we burned week 1 of our migration entirely on these two rows.

2. Astro 6 Runtime Architecture — Five-Axis Layout

┌──────────── Source ────────────┐
│  src/pages/*.astro             │
│  src/content/**.{md,mdx}       │
│  src/content.config.ts (zod v4)│
└─────────────┬──────────────────┘
              │
       ┌──────▼──────┐
       │  Compiler   │   ❶ Go (default) | Rust (experimental, ~100×)
       │  .astro →   │
       │  ESM module │
       └──────┬──────┘
              │
   ┌──────────▼─────────────────────────────────────────┐
   │  Vite Environment API                              │  ❷ dev = prod runtime
   │  ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐    │
   │  │  Node  │  │ workerd│  │  Bun   │  │  Deno  │    │
   │  └────┬───┘  └────┬───┘  └────┬───┘  └────┬───┘    │
   └───────┼───────────┼───────────┼───────────┼────────┘
           │           │           │           │
   ┌───────▼───────────▼───────────▼───────────▼────────┐
   │  Astro core 6                                      │  ❸ Adapters
   │  • Fonts API   (preload, fallback metric)          │
   │  • CSP API     (nonce, strict-dynamic)             │
   │  • Live Content Collections (request-time loaders) │
   │  • Route Caching API (experimental, web-standard)  │
   │  • Sessions, Server Islands, Actions               │
   └───────┬────────────────────────────────────────────┘
           │
   ┌───────▼────────────────────────────────────────────┐
   │  Output                                             │  ❹ static / hybrid / SSR
   │  • Static pages (HTML)                              │
   │  • Server entry (Cloudflare Workers / Node / Bun)   │
   │  • Live API routes / RSC-style streaming            │
   └─────────────────────────────────────────────────────┘

Figure 1. Astro 6 five axes — ❶ compiler is Go-default with Rust experimental ❷ Vite Environment API supplies the same runtime to dev/prerender/prod ❸ core surfaces Fonts/CSP/Live Collections/Route Caching directly ❹ adapters (Cloudflare/Node/Bun/Deno) split the output.

2.1 Axis ① Compiler — Go to Rust, gradually

Astro 6 ships an experimental Rust rewrite of the compiler that turns .astro files into ESM modules. The stable build is still Go; Rust is opt-in. Two consequences. First, on cold builds of large content sites, the compilation phase alone shows ~100× speedups (the more files you have, the bigger the win). Second, once Rust stabilizes, it slots cleanly next to Vite Rolldown (same Rust toolchain, room for Oxc/SWC interop). The operational decision is straightforward — keep Go as the default through 6.1 and opt into Rust only on a CI regression-test job.

2.2 Axis ② Vite Environment API — dev = prod runtime

Vite's Environment API splits the module graph per environment. Astro 6 sits its dev server on top of that, so each environment (Node, workerd, Bun, Deno) handles requests with its own runtime. The clearest payoff is Cloudflare Workers. v5 emulated Node in dev and exposed only some platform APIs; v6 runs workerd in dev/prerender/prod. Code that imports env from cloudflare:workers, KV/R2/D1 bindings, and Service Bindings all work in dev too — the entire "works in dev, breaks in prod" class of regressions is gone.

2.3 Axis ③ Core APIs — Fonts, CSP, Live Collections, Route Caching

The Fonts API treats local files, Google Fonts, and Fontsource as one interface — handling self-hosting, automatic preload links, and fallback metric (measuring the original font's ascent/descent/line-gap so the system fallback simulates the same metrics) to cut CLS. The CSP API auto-injects nonces into inline scripts and emits strict-dynamic, upgrade-insecure-requests, and frame-ancestors headers per-adapter. Astro Islands' inline hydration scripts have been the obstacle to clean CSP for years; v6 closes that problem. Live Content Collections is a new loader shape that fetches data at request time on top of the Content Layer. Route Caching API declares per-route cache-control, cdn-cache-control, and surrogate-key headers, abstracting platform differences (Cloudflare/Vercel/Netlify).

2.4 Axis ④ Adapters — Cloudflare / Node / Bun / Deno

Adapters wrap the core's build output into each platform's entrypoint. The biggest v6 change is @astrojs/cloudflare running workerd at every stage. As a side effect, Astro.locals.runtime.env is gone and the same data is reached via env from cloudflare:workers (see §5). The Node adapter now requires Node 22 minimum, and Bun/Deno adapters get much better dev parity from Environment API.

2.5 Axis ⑤ Output — static / hybrid / SSR + Live API

Output modes are still static, hybrid, and server. The difference is how routes opt in. Live API routes declare export const prerender = false and use a Live Collection to return request-time data. The Route Caching API on the same route declares cache headers to govern CDN/edge caches.

3. v5 → v6 Migration — The Seven Build-Breaking Changes

Below are the seven items from ManoIT's migration retro that actually break builds. Going top to bottom in one pass closes week 1.

1 is the most common and the simplest. Astro.glob('../posts/*.md') becomes import.meta.glob('../posts/*.md', { eager: true }), or — preferred — wrap it in a content collection. #2 means the auto-compatibility window closed in v6: the implicit upgrade to the new Content Layer API that v5.x allowed without experimental.contentLayer is gone. Define every collection in src/content.config.ts, and supply an explicit loader (see §4). #3 and #4 ride the same Zod release wave, so handle them together rather than splitting across weeks.

4. Live Content Collections — The Request-Time Loader Pattern

Below is the recommended Astro 6 collection shape. Build-time (blog posts) and request-time live (live inventory) collections sit side-by-side in the same file.

// src/content.config.ts — Astro 6 recommended layout
import { defineCollection, defineLiveCollection } from 'astro:content';
import { z } from 'astro/zod';                     // ❶ astro/zod (Zod v4)
import { glob } from 'astro/loaders';
import { liveLoader } from '@astrojs/live-collections';

// ❷ Build-time: src/content/posts/**/*.md
const posts = defineCollection({
  loader: glob({ pattern: '**/*.{md,mdx}', base: './src/content/posts' }),
  schema: z.object({
    title: z.string().min(8).max(120),
    publishedAt: z.coerce.date(),
    tags: z.array(z.string()).default([]),
    cover: z.string().url().optional(),
  }),
});

// ❸ Request-time live: external inventory API
const inventory = defineLiveCollection({
  loader: liveLoader(async ({ entry, request }) => {
    const res = await fetch(`https://api.manoit.co.kr/inventory/${entry}`, {
      headers: { 'cache-control': 'no-store' },
    });
    if (!res.ok) throw new Error(`Inventory ${entry}${res.status}`);
    return res.json();
  }),
  schema: z.object({
    sku: z.string(),
    stock: z.number().int().nonnegative(),
    price: z.number().nonnegative(),
    lastUpdated: z.coerce.date(),
  }),
});

export const collections = { posts, inventory };

Two points. First, defineCollection is fetched once at build time and rendered into static pages. Second, defineLiveCollection runs per request so const item = await getEntry('inventory', sku) returns fresh data every call while keeping the same API. Routes that use a live collection automatically flip to prerender = false.

5. First-Class Cloudflare Workers — workerd-on-everywhere

Below is the v5 → v6 diff for a Cloudflare-adapter route. Astro.locals.runtime is gone; cloudflare:workers is imported directly. The dev server runs the exact same code path, so the "process.env in dev, env in prod" branch is gone.

// src/pages/api/keys/[name].ts — Astro 6 + Cloudflare Workers
import type { APIContext } from 'astro';
import { env } from 'cloudflare:workers';     // ❶ Replaces Astro.locals.runtime.env

export const prerender = false;               // ❷ Live API route

export async function GET({ params, request }: APIContext) {
  const value = await env.MY_KV.get(`tenant:${params.name}`);
  if (!value) {
    return new Response(JSON.stringify({ error: 'not_found' }), {
      status: 404,
      headers: { 'content-type': 'application/json' },
    });
  }

  return new Response(value, {
    headers: {
      'content-type': 'application/json',
      // ❸ Route Caching API: 60s at the edge, surrogate-key for invalidation
      'cache-control': 'public, max-age=0, s-maxage=60',
      'cache-tag': `tenant:${params.name}`,
    },
  });
}

❶ env exposes the wrangler.toml KV/R2/D1 bindings and secrets in dev too. ❷ A single line flips the route to SSR. ❸ cache-tag is invalidated by Cloudflare's purge by tag; the Route Caching API translates the header to whatever name each adapter expects (Vercel uses x-vercel-cache-tag, Netlify uses netlify-cdn-cache-tag).

6. Fonts and CSP API — The Last Two Pieces of the Islands Era

The Fonts API lands in astro.config.ts like this — self-hosting, preload, and fallback metric in one go.

// astro.config.ts — Fonts API + CSP API
import { defineConfig } from 'astro/config';
import cloudflare from '@astrojs/cloudflare';

export default defineConfig({
  output: 'server',
  adapter: cloudflare({ mode: 'directory' }),
  fonts: [
    {
      name: 'Pretendard',
      cssVariable: '--font-sans',
      provider: 'fontsource',                 // ❶ google | fontsource | local
      weights: [400, 600, 800],
      subsets: ['latin', 'korean'],
      fallbacks: ['Apple SD Gothic Neo', 'sans-serif'],
      display: 'swap',
    },
    {
      name: 'JetBrains Mono',
      cssVariable: '--font-mono',
      provider: 'google',
      weights: [400, 600],
      preload: true,
    },
  ],
  csp: {
    enabled: true,
    directives: {
      'default-src': ["'self'"],
      'script-src': ["'self'", "'strict-dynamic'"],   // ❷ nonce auto
      'style-src': ["'self'", "'unsafe-inline'"],
      'img-src': ["'self'", 'https://cdn.manoit.co.kr', 'data:'],
      'connect-src': ["'self'", 'https://api.manoit.co.kr'],
    },
  },
  experimental: {
    routeCaching: true,                       // ❸ enable route cache headers
  },
});

Use them in CSS as font-family: var(--font-sans) / var(--font-mono). Astro computes SHA-256 hashes for inline scripts at build time and adds them to script-src, or — on SSR routes — generates a per-request nonce. Our policy is 'strict-dynamic' + nonce so child scripts spawned by hydration are trusted automatically.

7. ManoIT's Four-Week Migration Checklist

Concrete, gated steps. Each week ends on a regression-green gate before the next begins.

Four weeks compresses with site size. ManoIT's marketing site (~380 pages, 80 MDX, 4 collections) finished in 7 working days. The biggest week-1 sink was the Zod v3 → v4 schema realignment: z.string().required() collapses to z.string() in v4 (required by default), and z.input<T> / z.output<T> had to be split for any schema that coerced types.

8. Conclusion — Astro 6 Installs SSR as the Default for Content Sites

Through v5, Astro's posture was "static where you can, SSR where you must." v6 doesn't reverse that posture. It just drops the friction of choosing SSR to nearly zero, using every major surface to do it: dev=prod runtime parity, first-class workerd, live collections, route caching, Fonts/CSP in core, the Rust compiler. Adding one SSR line to a content site costs an order of magnitude less than it did in v5. But every gain arrives after the migration gate. Until you've cleaned out Astro.glob(), astro:schema, Astro.locals.runtime, and Node 18 in one pass, the new v6 surface looks only like build-breaking edges. ManoIT's three sites — marketing, docs, customer portal — landed on v6 within 28 days of the 6.0 stable release; route caching and live collections roll into the next quarter.

This article was co-authored by Anthropic Claude Opus 4.6 and ManoIT. Primary sources: Astro 6.0 (2026-03-10) and 6.1 release notes, @astrojs/cloudflare, Vite Environment API documentation, and ManoIT's internal migration retros (2026-04-13 through 2026-05-02). © 2026 ManoIT.

Originally published at ManoIT Tech Blog.