Documentation

Get started

  • Getting started — Scaffold, develop, build, and deploy a June app in four commands.
  • Build & prerender — What june build freezes at build time, and how opt-in prerender ships exactly what was tested.
  • Deployment — One portable core, one host seam, one adapter per target — Workers, Vercel, and Deno Deploy ship today on the same bundle.
  • Stability & roadmap — What you can build on today, what's still moving, and what's experimental — June is 0.0.x, and this page says exactly where each piece stands.

Concepts

  • Dual audience — One page definition serves humans (HTML) and agents (markdown, JSON, MCP).
  • Web Standards end to end — The whole framework is one fetch handler — Request in, Response out, Web Streams in between. Standards are the portability mechanism, not a checkbox.
  • React Server Components, server-first — Every page is a server component tree rendered on the server; client code is an explicit island; actions are server functions with one authorization gate.
  • The data model — Resources are declared, not wired. db / kv / blob ride an ambient scope — never ctx, which is identity only. Bring Juno or your own.
  • Runtime: Bun-first toolchain, runtime-agnostic core — One tool runs install/test/dev; the core assumes no runtime at all — which is why the same app serves from Bun, Node, and workerd.
  • Auth & the scoped principal — One authorization gate for both audiences — run(input, ctx). ctx is the principal; an agent at /mcp is just another caller through the same gate.

Features

  • App Router: the filesystem is the route table — page.tsx is a route, [slug] is a param, (group) shapes the tree without the URL, _anything colocates — one matcher drives dev and the build.
  • Layouts: nested, composed, frozen — layout.tsx wraps its segment and everything below; chains compose root → leaf, and the build freezes the same chain dev resolves.
  • Islands: zero client JS by default — Pages ship no JavaScript unless a subtree opts in — one <Island> hydrates against an explicit registry while the rest stays server-rendered HTML.
  • Navigation: instant without a client router — Hover prerenders the next page (Speculation Rules), the click is zero-network, View Transitions animate the swap — the browser is the router.
  • Client Router: the opt-in SPA layer — Off by default — turn it on for app-like surfaces that need in-memory state to survive navigation. Soft swaps over the same HTML the server already serves, with <Island persist> for websockets.
  • Live updates: a connection that survives navigation — Put a server-push connection (SSE or WebSocket) inside a persist island — it keeps streaming across soft navigations instead of reconnecting on every click. Plus what to know about connection limits when you deploy.
  • Styling: global CSS, Tailwind, CSS Modules — app/global.css is auto-linked (no import); Tailwind v4 is the blessed default; *.module.css scopes deterministically. Dev serves readable CSS with HMR, build ships hashed, immutable, minified.
  • Markdown without drift — Append .md to any page and get markdown — for authored content it's your source file byte-for-byte, never a lossy HTML reconstruction.
  • Built-in MCP — Every June app is an MCP server — defineAction() is simultaneously a server action, an MCP tool, and a manifest entry, behind one authorization gate.
  • Built-in llms.txt — The agent discovery surface — llms.txt, sitemap, robots, api-catalog, and per-route manifests — derives from your routes automatically.
  • Queries & caching — How to read and write through the ambient db — the query surface, plain-SQL migrations, and the auto-batch / auto-invalidate cache.
  • OG images, typeset at the edge — Social cards as a route that returns a PNG — satori + resvg in the worker, with runtime font subsetting so CJK titles work.
  • The june CLI — Five verbs — dev, build, deploy, gen, info — installed locally by the scaffold, version-pinned per project, with --dry-run as the CI contract.
  • DX: a loop with no assembly — Zero-config dev, dev/built parity by construction, an oracle for every artifact — and push-based HMR on the experimental runtime track.

Agents: every doc serves its authored markdown at /docs/<slug>.md.