Neutron vs Next.js, Astro & Remix: Web Framework Benchmarks 2026

Disclaimer: These benchmarks were run internally on Neutron team hardware. They represent our testing methodology and specific scenarios, not independent verification. Results will vary based on workload, hardware, and configuration. We're publishing the test code on GitHub so you can reproduce them. Always benchmark your own application against your own workload.

With that said — we think benchmark transparency is important, even when the person publishing them has an obvious interest in the results. Here's what we measured, how we measured it, and what the numbers mean.

Updated 2026-07-15 with re-measured figures from the current profile-baseline benchmark run. Earlier drafts of this post carried per-scenario numbers we could no longer reproduce; they have been replaced with the verified results below.

Test Setup

Hardware: Apple M2 Pro (10-core, 16GB RAM) OS: macOS Benchmarking tool: autocannon Method: Production builds for every framework. Each route was hit with 80 concurrent connections for 5 seconds, one run — the "profile baseline" configuration. Figures below were measured 2026-07-15.

Frameworks tested:

• Neutron 0.1.0 — both the default Preact renderer and React-compat mode
• Astro 5
• Next.js 15
• Remix 2 and Remix 3

Database calls were mocked with in-memory data to isolate framework overhead from database performance. Because this is a single 5-second run per scenario rather than a long averaged soak, treat the numbers as a directional profile, not a precise ranking — and re-run them on your own hardware.

Results: Throughput

Average requests/sec across the profile's scenarios:

| Framework | Avg req/s | |-----------|-----------| | Neutron (React-compat) | 19,538 | | Neutron (Preact) | 18,510 | | Astro 5 | 11,140 | | Next.js 15 | 6,762 | | Remix 2 | 6,158 | | Remix 3 | 5,185 |

Static-route throughput — no data fetching, pure HTML delivery:

| Framework | Static req/s | |-----------|--------------| | Neutron (React-compat) | 33,504 | | Neutron (Preact) | 21,966 | | Astro 5 | 16,556 | | Next.js 15 | 10,772 |

Reading these honestly: Neutron's Preact default averages ~2.7x Next.js and ~1.7x Astro; on static routes it's ~2x Next.js and ~1.3x Astro. Astro is genuinely fast — its static output (~16.5K req/s) is in the same league as Neutron's, not an order of magnitude behind. The highest single-run throughput we saw for Neutron was 39,331 req/s; Next.js peaked at 11,657.

Why the static gap exists: Static routes are pure string concatenation. No React server render, no component tree, no virtual DOM. The template function returns a string and the server sends it. Next.js and Remix carry React server-rendering overhead even for simple pages; Astro, which also ships zero JS on static routes, is the closest competitor here.

Results: Bundle Size

What the browser downloads for an interactive page — the metric that matters most for real users:

| Framework | Interactive Page Bundle | |-----------|------------------------| | Neutron (static route) | 0 KB | | Neutron (app route) | ~3 KB (Preact runtime) | | Astro (with React island) | ~46 KB | | Remix | ~58 KB | | Next.js App Router | ~91 KB |

Static routes ship nothing — this isn't a compression trick, there is genuinely no JavaScript. App routes ship the ~3KB Preact runtime plus component code (Preact is ~3KB minified+gzipped vs React's ~45KB). For content-heavy sites this drives Time to Interactive to near zero; for dashboards you pay ~3KB instead of 60–90KB.

What the Numbers Actually Mean

Neutron's static routes are genuinely faster, and the gap is real — not a benchmark trick. Static routes do less work by design. If your page doesn't need client-side JavaScript, don't ship it.

Neutron's app routes (Preact SSR) are meaningfully faster than Next.js and Remix — roughly 2.7x on average in this profile. But for most applications your database, not your framework, will be the bottleneck: a framework that's faster at returning mocked data won't make a slow query fast. The headroom matters when you scale horizontally, not on every request.

The bundle size numbers matter more than the throughput numbers for most user-facing applications. A 91KB JavaScript bundle takes ~300ms to parse on a mid-range mobile device. A 3KB bundle takes ~10ms. A 0KB bundle takes 0ms. This is the real performance win.

Where Next.js and Remix Win

Let's be honest about the tradeoffs.

Ecosystem. Next.js has thousands of examples, tutorials, and third-party integrations. If you need a specific library or pattern, there's probably a Next.js guide for it.

Community. Next.js and Remix have large, active communities. Neutron is early-stage. If you hit a weird bug at midnight, Stack Overflow won't have the answer.

Production battle-testing. Next.js runs major production applications. Neutron has not been battle-tested at that scale.

Deployment. Vercel for Next.js is a seamless experience that's hard to match. Neutron targets Vercel, Cloudflare, and Docker, but the tooling is less polished.

If you're building something that needs to go live soon and can't tolerate rough edges, use Next.js or Remix. They're excellent frameworks.

If you're building a new project and you're willing to work with an early-stage framework in exchange for the performance and bundle size wins — and you want Nucleus's multi-model database under the hood — Neutron is worth exploring.

Reproducing the Benchmarks

We're publishing the benchmark setup at /ts/benchmarks/ in the Neutron GitHub repo. Run node run-comparison.mjs to reproduce the results on your hardware. We expect numbers to vary depending on machine.

git clone https://github.com/neutron-build/neutron
cd neutron/ts/benchmarks
npm install
node run-comparison.mjs