upwindA Next.js deployment adapter, and the runtime that serves what it builds.
The adapter runs inside your own next build and writes a deployment bundle — every route, prerender and static file by content, and the Functions that run the application’s code. The build talks to nothing and needs no credentials: what comes out is a directory, and uploading it is the host’s half of the arrangement.
Start an application
pnpm create upwindWrites a Next.js 16 application with Tailwind 4, wired to upwind, and installs it.
What a build writes
Next.js calls the adapter through its own Adapter API — modifyConfig before the build, onBuildComplete after it — and everything a deployment needs is written under one directory, .arkor/.
bundle.json- Entrypoints, prerenders, routing tables, header rules, cache-life profiles: what to serve, and what may be served out of storage rather than by a Function.
- Blobs, by content
- Every prerendered shell and static file addressed by the hash of what is in it, so a deployment that changed one page ships one blob.
- The
appFunction - The application’s own code, bundled with its pages, route handlers and cache.
- The
middlewareFunction - The project’s
proxy.ts, built on its own, so a request that only needs a rewrite never wakes the application.
The adapter makes no service calls, and no build needs an account to produce a bundle.
Development, with the front door in place
A deployment has an edge in front of it, and the platform’s own paths are the edge’s to answer. Under next dev there is no edge. upwind dev is that front door locally: it holds the port, answers its own paths, and hands every other request to the project’s own Next.js — the same dev bundler, the same HMR, the same error overlay.
/__upwind- What this run is: the versions, the address, the project directory, the adapter it named.
/__upwind/health200once Next.js is ready,503while it is starting.
Both are answered by the front door rather than by the application, which is why they answer while the application is still compiling — and while a compile of it is failing.
What it serves
One bundle per build, whatever the application turned out to be made of.
- App Router
- Server Components and streaming, with a prerendered shell served from storage and resumed by the Function.
- Pages Router
- Including the
_next/dataoutputs the client router asks for by name, under the build id. - Images
/_next/image, optimized at the edge, in the formats and sizes the application configured.proxy.ts- A project’s proxy becomes a Function of its own, run before a request reaches the application.
- Scheduled work
- Cron jobs declared beside
next.config, checked at build time and carried into the bundle. - Static export
output: exportwrites the same bundle with the server parts empty, every document served from storage.- WebAssembly
- A compiled module travels with the Function whose code reads it.
next/og- Open Graph images, drawn by the build where a route is static and by the Function where it is not — including the card this page shares.
Next.js >=16.2.0 <17
The range the adapter’s rewrites of Next.js’s own output are held to, on every release in it and against the canary.
One release, one generation
Every package here is versioned with the others and published from one signed tag — so what scaffolds a project and what runs it are always of the same generation.
The CLI.
upwind devruns the project’s Next.js behind upwind’s front door;upwind buildis the project’s ownnext buildwith the adapter named.Runs inside
next build, writes the bundle, and builds the Functions that serve what it wrote.What a deployment’s Function contains: the routing tables, middleware, prerenders and cache used to serve your app.
The vocabulary the others speak — the bundle’s shape, the cache’s terms, and the protocol between an edge and a Function.
An application’s own D1, KV and R2, read the same way locally and in a deployment, with nothing to configure.
Better Auth with nothing to configure: the config beside your app is mounted for you and handed the project’s own database. In development, while you have configured neither OAuth credentials nor a signing key, upwind answers as the provider itself and no request leaves your machine.
pnpm create upwind, and the application it writes.
Before 1.0
Early software, and it says so rather than letting you find out.
- The deployment bundle carries a version of its own, and its shape is expected to change before it settles.
- No release carries a compatibility shim for the minor before it.
- A build nobody here has seen is the most useful thing you can send: what your application does that this does not serve yet.
Licence: MIT or Apache-2.0, at the recipient’s option