Forget React. Forget Solid. Forget every other framework. Autumn.js isn’t just a framework — it’s a reactive, deterministic, GPU-aware, ultra-low-latency frontend engine built to annihilate every bottleneck in the DOM.
Designed for 10M+ row grids, real-time dashboards, and interactive UIs — every frame is accounted for, every interaction is instantaneous.
Other frameworks are:
- Heavy → VDOM diffing, hooks, compiler magic
- Slow → GC spikes, wasted cycles, frame drops
- Opinionated → mental model overload
Autumn.js is a full-stack frontend runtime:
- Reactive DAG — state flows like electricity; updates propagate deterministically
- Zero re-renders — DOM is a leaf, never a bottleneck
- Sub-millisecond updates — frame-perfect, predictable, deterministic
- Multi-threaded — heavy computations offloaded to Web Workers
- GPU-accelerated rendering — DOM + Canvas + WebGL + custom targets
Result: Every scroll, filter, and animation runs flawlessly, even under extreme load.
Example: a 10M+ row table running 120fps while sorting, filtering, and scrolling simultaneously.
- Multithreaded sorting/filtering using SharedArrayBuffer
- Display millions of rows at O(1), limited only by browser RAM
- Zero frame drops — 120fps scrolling, filtering, and sorting simultaneously
- Zero-copy datatypes for insane memory efficiency
- Custom virtualization — bypasses browser div height limits
- Non-passive scrolling — rows always rendered instantly
- Works on phones — 60fps even on older devices
- DOM-based grid optimized to hardware limits
- SharedArrayBuffer stores row order/filtering, computed off-thread in Web Workers
- Full DOM reuse, zero garbage generation
- Custom event loop prioritizes tasks, never drops a frame
- Scrolling engine optimized for mobile and desktop
- Synthetic event loop ensures instant row rendering
Benchmarks (1M rows, M2 Max Pro):
| Action | Score |
|---|---|
| Scroll 40 rows/frame | 120fps |
| Filtering | 200ms |
| Initialize & render | 1.5ms |
| Filter + sort simultaneously | 120fps |
Every frame counted. Zero GC spikes. Zero wasted cycles.
- Application Layer: Ultra-fast UI — grids, tables, inputs, dashboards
- Signals & Reactivity: Atomic DAG nodes, ephemeral caches, deterministic updates
- Scheduler / Loop Engine: Input → Animation → Render → BG, frame-perfect execution
- Renderer Layer: Atomic DOM commits, GPU transforms, off-thread diffing
- Data & Memory Layer: Object pools, SharedArrayBuffers, typed arrays, zero-copy concurrency
Every layer is observable, predictable, and GC-spike free.
| Feature | React | Solid | Vue | Qwik | Autumn.js |
|---|---|---|---|---|---|
| Rendering | VDOM diffing | Signals fine-grained | VDOM + reactivity | Resumable VDOM | Reactive DAG, zero VDOM |
| Massive datasets | Lag >100k | Good <1M | Lag >500k | Lazy load | 10M+ rows 60–120fps |
| Boilerplate | Hooks/state | Signals verbose | Options API | Mental model heavy | Auto-signals, zero ceremony |
| Runtime overhead | Heavy | Light | Medium | Lazy | Sub-millisecond deterministic |
| Rendering targets | DOM only | DOM only | DOM only | DOM only | DOM + Canvas + WebGL + custom |
Extras: AutoScroller, Signal DAG visualizer, zero-copy multithreaded filtering & sorting, FPS overlays — all built-in.
- Layered architecture — inspect every layer
- Auto-signals — write intent, not reactivity
- GPU transforms & atomic DOM commits — zero frame drops
- SharedArrayBuffer lanes — zero-copy concurrency
- Event-loop optimized for scrolling, rendering, sorting, and filtering simultaneously
- Non-passive scrolling — instant row rendering
- Custom virtualization beyond browser div height limits
- Multi-device optimized — 60fps on old phones
- Heavy computations → Web Worker lanes
- Wrap hot-path changes in signals
- Object pools for tight loops
- Disable overlays in production for ultimate performance
- iPhone Safari → multithreading fallback
- Zoom & scroll → relative to scroll track
- Resize columns & custom cells
- WebGPU renderer path
- Deterministic replay & trace capture
- Native shell adapters (WASM + native UI glue)
- Expand synthetic event-loop → scroll & render cells
- GC optimization → reuse cell classes
- Full column sort/filter & text selection correctness
# Clone, install, and run example demo in one go
git clone https://github.com/pavanscales/autumnjs && cd autumnjs/example && bun install && bun run devThe example folder runs the full
autumn-coreengine. Core is modular, lightweight, and fully powers all reactive DAGs, zero-copy concurrency, and GPU-accelerated rendering.
“Other frameworks optimize the past. Autumn.js builds the future.”
- Blazing real-time UIs at data-center scale
- Smarter reactive core than any runtime
- Zero mental overhead
- 10M+ rows, 120fps, zero frame drops
- Live in <10s, demo-ready
MIT — examples, benchmark harness, DAG inspector, FPS overlays included.