By ByteBot
Dominic Gannaway — the engineer behind Inferno and a three-year stint on Meta’s React core team — launched Octane on July 27, a compiled JavaScript framework that runs React’s full programming model without a virtual DOM. Hooks, Suspense, and Actions all work. The Rules of Hooks don’t apply. Dependency arrays are gone. In one week, the GitHub repository collected 907 stars and the Hacker News thread hit 248 comments.
React developers have managed the same friction since 2018: memorize hook call order, maintain dependency arrays, absorb the reconciler’s overhead. Octane’s thesis is that all three were implementation compromises, not design requirements. A compiler can eliminate them without changing how you write components.
What Octane Eliminates — and Why It Matters
React tracks state and effects at runtime, which forces the framework to constrain when and where you can call hooks. The virtual DOM is the runtime diffing layer. Dependency arrays are the developer-managed hint system telling the runtime what changed. Every one of these is a consequence of doing tracking at runtime.
Move tracking to compile time and the constraints evaporate. The Octane compiler assigns hook slots by call site, not call order — meaning a useState on line 12 of a component is stable regardless of what executes before it. This makes the following valid Octane code:
// React throws a "Rule of Hooks" error here.
// Octane compiles this cleanly.
function AdminPanel({ isAdmin }) {
if (!isAdmin) return <div>No access</div>;
const [data, setData] = useState(null);
return <div>{data}</div>;
}The compiler also infers what each effect, memo, and callback captures — no more hand-written dependency arrays. Performance follows. According to Octane’s benchmark suite, React 19 runs at 2.9× geometric mean against a baseline while Octane sits at ~1.1×, matching SolidJS and vanilla JS. The framework ships with 3,900+ behavioral tests covering conformance, SSR/hydration, and compiler edge cases.
Why This Octane Launch Has More Credibility Than Most
Gannaway didn’t approach this from the outside. He built Inferno in 2017 as the fastest React-like library of its era, spent three years on Meta’s React core team, and contributed to Svelte 5. When he says React’s implementation choices were workarounds rather than features, that isn’t criticism from a newcomer — it’s a conclusion from someone who spent years inside the architecture.
Ecosystem buy-in arrived immediately. Tanner Linsley, creator of TanStack — the most widely used family of React utility libraries — commented within hours: “Octane is pretty slick. We are almost done with support for Start and we already have adapters either done or in the works for all of our other libraries.” That single endorsement matters. Most compiled React alternatives stall because developers can’t bring their existing tools with them.
Octane also ships OctaneCompat, a compatibility layer that embeds Octane islands inside React 19 apps — component by component, without a full rewrite. Native event delegation is preserved, and real React context remains accessible via use(). The incremental migration path is the feature most previous alternatives lacked entirely.
What Octane Doesn’t Do Yet
Octane is in alpha. It deliberately excludes React Server Components, class components, and the synthetic event system. For teams running Next.js App Router with heavy server component usage, there is no migration path today — and Octane’s authors are clear that RSC is out of scope by design, not oversight.
It’s also worth separating Octane from the React Compiler, which reached stable release alongside Next.js 16 this year. The React Compiler adds memoization to existing React code at build time — the virtual DOM, runtime reconciler, and hook rules all remain intact. That’s the inside bet: improve React without breaking its architecture. Octane is the outside bet: eliminate runtime tracking from the ground up. These are different strategies for different constraints, not the same idea at different maturity levels.
If your stack depends heavily on RSC, the React Compiler is your path for now. If you’re building a client-heavy SPA and can live without server components, Octane is worth running in a side project today.
How to Try Octane Today
Octane ships with a CLI and a single command to scaffold a new project:
npm create octane my-appNew projects can use the .tsrx file format, which adds template directives like @if, @for, and @switch for cleaner component syntax. Existing React 19 apps can test Octane behavior via OctaneCompat before committing to anything. The official documentation includes an octane doctor command for configuration diagnostics. The Hacker News discussion is the sharpest community analysis of where Octane wins versus where the React Compiler is the better call.
Key Takeaways
- Octane launched July 27 and compiles React’s hook model to direct DOM code — no virtual DOM, no Rules of Hooks, no manual dependency arrays
- Creator Dominic Gannaway built Inferno, spent three years on Meta’s React core team, and contributed to Svelte 5 — this is not a toy project
- TanStack adapters are already in progress; OctaneCompat enables gradual migration from React 19 without a full rewrite
- React Server Components are excluded by design — teams running RSC-heavy apps should track Octane but not migrate yet
- Octane and the React Compiler are different bets: one optimizes inside React’s architecture, the other replaces the runtime entirely
