Now in private beta · Pre-seed

Your Code.Pure Performance.

Pure converts your Node.js apps into optimized native binaries.
No rewrites. No new hires. Just faster, cheaper, safer software.

Be first to know when Pure launches. No spam — ever.

8.7×
HTTP throughput, same hardware
40×
faster cold starts
2.3×
less memory for typical services
100%
output parity with Node.js
How it works

One API call. That's it.

Everything else stays the same — your code, your stack, your team.

01

Send your code.

POST your project to /v1/compile or set our registry as your npm mirror. No annotations, no config files, no language to learn.

step-01
curl -X POST https://api.pure.dev/compile \
  -H "Authorization: Bearer $PURE_KEY" \
  -F "source=@./my-app"
02

Pure compiles deterministically.

Our patent-pending engine analyzes your code and emits an optimized native binary. The same input produces the same output, every time.

step-02
→ analyzing 1,284 modules
→ resolving types: ok
→ emitting native: x86_64-linux
✓ compiled in 4.2s
03

Deploy. Run faster.

Drop the binary into your existing infrastructure. No runtime to install. No new ops playbook. Just a smaller, faster, safer build artifact.

step-03
$ docker build -t my-app .
$ kubectl apply -f deploy.yaml
✓ rollout complete · 64% less CPU
Cost calculator

See what you'd save.

Tell us what your workload looks like. We'll project the savings against your current cloud bill.

Your workload
$25,000
$1k$500k+
Workload mixAlways sums to 100%
Projected with Pure
$19,250
saved / month
$231,000 / year· 77% reduction
Today (Node.js)$25,000
With Pure$5,750

* Per-axis ratios from internal benchmarks: CPU-bound ~85% less compute, memory-bound ~50%, network-bound ~88% (8.7× HTTP throughput). Weighted by your workload mix. Actual savings vary.

What changes

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.

Faster cold starts
40×

Serverless and CLI tools that took 360ms to boot now respond in 9ms.

Node.js361 ms
Pure9 ms
More requests per second
8.7×

A simple HTTP echo handler goes from 3,600 to 31,600 ops/sec on the same hardware.

Node.js3,645 ops/sec
Pure31,637 ops/sec
Less memory for typical services
2.3×

A small HTTP service that holds 89 MB of resident memory in Node holds 39 MB compiled — same workload, smaller footprint.

Node.js89 MB
Pure39 MB
Typical end-to-end speedup
5–9×

Across our benchmark suite, Pure-compiled programs finish in 1/5th to 1/9th the wall-clock time.

Node.js100
Pure14
Honest note: not every operation gets faster. A few hot paths (e.g. tuned V8 regex) come out roughly even. Across full applications, the wins compound.
Request the full benchmark report
Internal report · Linux 6.17 · Intel Core Ultra 7 · Node 25.9 vs Pure native build
Try it

Pick a snippet. Watch it compile.

A taste of the API. In production, you point Pure at your whole project — no annotations, no rewrites.

Examples

Runs against our hosted compiler. Your code never leaves the request.

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.tsready
Two ways to use Pure

Start light. Go all-in.

Pick the integration that fits where you are. Use one. Use both. Switch when you're ready.

Drop-in npm replacement
Start here

Pure Registry

Switch one URL. Your npm dependencies are served as pre-compiled native binaries. Keep running Node — your workflow doesn't change.

  • ✓Zero code changes
  • ✓Works with existing Node
  • ✓Per-package speedups
~/your-project
$ npm config set registry \ https://registry.pure.dev
// next install pulls native-compiled deps automatically
Full application compilation
Go all-in

Pure Compiler

Compile your entire application to a single native binary. One API call. Deploy anywhere — no Node runtime required.

  • ✓Single static binary
  • ✓No Node runtime
  • ✓Best-in-class perf
~/your-project
$ curl -X POST https://api.pure.dev/compile \ -F "source=@./app"
// emits a single native binary — runs anywhere
Why Pure

Pure performance,
without a rewrite.

01 / SPEED

Pure Speed

Compiled native code. No interpreter overhead, no warmup, no garbage collector pauses.

02 / SECURITY

Pure Security*

Memory-safety bugs eliminated at compile time. Buffer overflows, use-after-free — gone.

03 / EFFICIENCY

Pure Efficiency

A fraction of the compute and memory of interpreted Node. Same workload, smaller bill.

04 / SIMPLICITY

Pure Easy

Send your existing JS or TS. Get a binary back. Your team writes JavaScript on Monday.

* Applies to ahead-of-time-compiled code. eval(), new Function(), and native .node modules fall outside the static guarantee. Read more.

FAQ

Questions, answered.

Yes. Pure ingests standard JavaScript and TypeScript. We currently support 130+ npm packages with 100% output parity, with new packages added weekly. If your project uses something we don't yet, we'll tell you up front.

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.

Get early access

Faster software,
without the rewrite.

Join the waitlist. Design partners get priority onboarding and direct input into what we build next.

12 patent-pending inventions