Pure Registry
Drop-in npm replacement
Switch one URL and your npm dependencies are served as high-performance compiled binaries. Keep running in Node.js — your workflow doesn't change.
$ npm config set registry https://registry.pure.devSame Code.Different Bill.
Pure compiles Node into native binaries, cutting compute, memory, and startup time without a rewrite or new hires.
- potential cost reduction
- 80%
- HTTP throughput
- 8.7×
- faster cold starts
- 40×
- less memory
- 2.3×
- output parity with Node.js
- 100%
Pure Compiler
Full application compilation
Compile your entire application to a native binary. One API call, zero code changes. Deploy anywhere — no runtime required.
$ curl -X POST https://api.pure.dev/compile -F "source=@./my-app"One API call. That's it.
Everything else stays the same — your code, your stack, your team.
01
Send the project.
POST the source bundle to /v1/compile or point npm at the Pure registry. No annotations, custom config, or new language.
~/your-project
curl -X POST https://api.pure.dev/compile \ -H "Authorization: Bearer $PURE_KEY" \ -F "source=@./my-app"
02
Pure produces a fixed build.
Our patent-pending engine analyzes your code and emits an optimized native binary. The same input produces the same output, every time.
~/your-project
→ analyzing 1,284 modules → resolving types: ok → emitting native: x86_64-linux ✓ compiled in 4.2s
03
Ship the binary.
Drop the artifact into the infrastructure you already use. No Node runtime, no new operations model, and a smaller production surface.
~/your-project
$ docker build -t my-app . $ kubectl apply -f deploy.yaml ✓ rollout complete · 64% less CPU
Pure performance,
without a rewrite.
No interpreter loop
Compiled native code. No interpreter overhead, no warmup, no garbage collector pauses.
Less to ship*
The production artifact has fewer moving parts than a runtime-backed deployment.
Smaller workloads
A fraction of the compute and memory of interpreted Node. Same workload, smaller bill.
Keep Node
Send existing JS or TS and get a binary back. The development workflow stays familiar.
* Applies to ahead-of-time-compiled code. eval(), new Function(), and native .node modules fall outside the static guarantee. Read more.
Same code. Different results.
Measured on real workloads. The kind of difference your finance team notices on the cloud bill — and your users notice in the app.
Fast boot
Services start without a warmup period.
Compiled artifacts are ready to run as soon as the process starts.
More headroom
HTTP services use the machine more directly.
The runtime does less work before your handler receives the request.
Less overhead
Typical services carry a smaller runtime footprint.
The deployed artifact can be smaller because it does not ship the full Node runtime path.
Native ship
Build once and deploy the binary.
Pure keeps the application workflow familiar while changing the production artifact.
Linux 6.17, Intel Core Ultra 7, Node 25.9 vs. Pure native build. Request the full benchmark report
See what you'd save.
Tell us what your workload looks like. We'll project the savings against your current cloud bill.
$25,000
$1k$500k+
Workload mix100%
Pick a snippet. Watch it compile.
A taste of the API. In production, you point Pure at your whole project — no annotations, no rewrites.
import { z } from 'zod';
const User = z.object({
id: z.string().uuid(),
email: z.string().email(),
});
export async function getUser(id: string) {
const r = await fetch(`/api/users/${id}`);
return User.parse(await r.json());
}
$ pure compile fetch.ts
Questions, answered.
Yes. Pure ingests standard JavaScript and TypeScript. Package support is expanding during the private beta; if your project uses something unsupported, we'll tell you before you compile.
No. That's the whole point. You write JavaScript or TypeScript exactly the way you do today. Pure handles the conversion to native code transparently.
V8 and bun are runtimes — they interpret or JIT your code at execution time. Pure compiles your code ahead of time to a standalone native binary. No runtime needed, no warmup, no GC pauses.
Pure handles your direct dependencies and their transitive trees. You can also use the Pure Registry as a drop-in npm replacement to get pre-compiled versions of common packages without changing anything else.
Yes. Source uploaded to our compiler is processed in isolation, kept only as long as the compile takes, and never used for training.
We're in private beta now. Join the waitlist and we'll reach out — design partners get hands-on support and influence over the roadmap.
Keep the code.
Lose the runtime tax.
Join the waitlist. Design partners get priority onboarding and direct input into the compiler roadmap.