Neo
The Application Engine for the AI Era. A multi-threaded, AI-native runtime with a persistent Scene Graph, enabling AI agents to introspect and mutate the living application structure in real-time.
Last verified:
What is Neo?
Neo.mjs is the multi-threaded Application Engine for the AI Era, designed for building ultra-fast, desktop-class, AI-native web applications. It uses a pioneering Off-Main-Thread (OMT) architecture that leverages true multithreading via web workers to eliminate UI freezes and jank, even during computationally intensive tasks like complex data processing, real-time updates, or advanced graphics rendering.
Key features include true multithreading with dedicated workers (App Worker, VDom Worker, Data Worker, Canvas Worker, Task Worker), a zero-build development mode where apps run natively as ES Modules without transpilation or bundling, a comprehensive batteries-included component library with 20+ form field types, advanced data grids, trees, charts, and multi-window support for synchronized browser windows with shared state. The framework features a unique two-tier reactivity system (push-based afterSet hooks and pull-based Effect), persistent component instances that maintain state across UI changes, AI-native architecture with a local Knowledge Base for querying, JSON-blueprint VDOM that is AI-readable/writable, and enterprise-scale capabilities handling 50,000+ live-updating records at 60 FPS.
Neo.mjs is ideal for developers building data-intensive applications, real-time dashboards, web-based IDEs, banking/trading applications with live feeds, complex multi-window applications, Gen AI interfaces, enterprise-grade SPAs, and any application where performance and responsiveness are non-negotiable. It targets teams tired of UI freezes from single-threaded frameworks like React, Vue, or Angular, and is particularly suited for those working with AI agents due to its deterministic structure and comprehensive documentation.
Neo pricing
Pricing model: Freemium
Neo.mjs is 100% free and open-source under the MIT license. There are no paid plans, subscriptions, or tiers. The framework can be used freely for any project (personal, commercial, enterprise) as long as you include the license and copyright notice. Development was made possible through the maintainer's personal savings, and the project accepts sponsors/backers via GitHub Sponsors ($10/month backer tier suggested, but not required for use). No enterprise licensing, no feature gating, no premium support tiers - all features are available to everyone.
Neo pros
- True multithreading eliminates UI freezes and jank completely
- Zero-build development mode with instant reloads on file save
- No transpilation needed - runs natively as ES Modules in browser
- 40,000+ delta updates per second in optimized environments
- 50,000 record grid streaming at 60 FPS with zero overhead
- Comprehensive batteries-included component library (no external dependencies)
- 20+ native form field types with integrated validation
- Multi-window support with shared state and cross-window drag-and-drop
- Persistent component instances maintain state across UI changes
- Two-tier reactivity system (push afterSet + pull Effect)
- AI-native architecture with Knowledge Base for semantic querying
- JSON-blueprint VDOM is AI-readable and AI-writable
- Inherent security by using direct DOM API vs innerHTML (XSS prevention)
- Zero runtime dependencies - smaller bundles, no dependency hell
- Unparalleled debugging - inspect full component tree without source maps
- Async-aware lifecycle with initAsync() prevents race conditions
- Off-screen Canvas worker for smooth chart animations at 60 FPS
- Soft hydration (Turbo Mode) for instant initial rendering
- Virtual Fields add calculated fields with 0 bytes memory per record
- Fixed-DOM-Order strategy achieves O(1) scrolling performance
Neo cons
- Steeper learning curve due to unique architecture different from React/Vue
- No JSX - uses JSON blueprints which can feel verbose initially
- Requires modern browsers with ES6+ and Web Worker support
- Desktop-only for multi-window features (Safari lacks SharedWorker support)
- Smaller community compared to React, Vue, or Angular
- Limited third-party ecosystem integration
- Class-based components may feel outdated vs functional hooks
- Solo-maintained project (tobiU) with heavy AI agent reliance
- Documentation is extensive but can be overwhelming for beginners
- No TypeScript requirement may concern enterprise teams
Frequently asked questions about Neo
What is Neo.mjs and how is it different from React?
Neo.mjs is a multi-threaded frontend framework that moves all application logic off the main thread into dedicated web workers (App Worker, VDom Worker, Data Worker, Canvas Worker). Unlike React which is single-threaded and runs everything on the main thread causing UI freezes under load, Neo.mjs guarantees UI responsiveness by keeping the main thread idle except for surgical DOM updates. Neo uses JSON blueprints instead of JSX, has persistent component instances instead of ephemeral re-renders, offers a two-tier reactivity system (push afterSet + pull Effect) vs React's hooks, requires zero build tools in dev mode vs React's Vite/Webpack dependency, and is AI-native with a Knowledge Base vs React's manual documentation search.
How does the multithreading architecture work?
Neo.mjs uses an Off-Main-Thread (OMT) architecture with 5-6 dedicated workers: App Worker runs your entire application (components, state, business logic), VDom Worker handles VDOM diffing and patching calculations, Data Worker manages store operations and data transformations, Canvas Worker handles OffscreenCanvas rendering for charts/graphics, Task Worker processes generic background tasks, and Main Thread only performs DOM updates. Workers communicate via JSON-RPC postMessage protocol. This architecture ensures expensive computations never block the main thread, achieving 40,000+ delta updates/second and eliminating UI jank completely.
Do I need a build step to use Neo.mjs?
No. Neo.mjs's zero-build development mode lets apps run natively as ES Modules directly in the browser without any transpilation or bundling. You get instant reloads on file save, debug the exact code you wrote without source maps, and maintain 100% web standards alignment. Build tools are optional and only needed for production optimizations. This contrasts with React/Vue/Angular which require Vite, Webpack, or CLI tools even for development.
Can I use Neo.mjs for multi-window applications?
Yes, Neo.mjs excels at multi-window applications unlike traditional SPAs. The architecture supports single App Worker managing multiple browser windows with shared state in real-time. You can move entire component trees across windows while keeping the same JavaScript instances alive, enabling cross-window state management, cross-window drag-and-drop, and window-specific theming. Use cases include trading dashboards, monitoring systems, web-based IDEs, and multi-monitor workflows. Desktop-only (Chrome v83+, Edge, Firefox) as Safari doesn't support SharedWorkers yet.
What components are included out of the box?
Neo.mjs is batteries-included with a comprehensive component library: Containers (Base, Panel, Viewport, Accordion), 20+ Form fields (Text, Number, Date, Time, Picker, ComboBox, Chip, Color, Country, Currency, Phone, Email, URL, Password, Search, Range, FileUpload, Hidden, Switch, Radio, CheckBox, TextArea), Data Display (Grid with sorting/filtering/cell editing, Table, List with selection models, Tree with expand/collapse, Gallery, Helix 3D carousel), Navigation (Tab, Breadcrumb, Menu, Toolbar), Feedback (Toast, Dialog, Progress, Tooltip), and third-party wrappers (AmCharts, MapboxGL, Monaco Editor, CesiumJS, Google Maps, OpenStreetMap).
How does Neo.mjs handle state management?
Neo.mjs uses Neo.state.Provider for hierarchical, application-wide state management that lives entirely in the App Worker. Components subscribe only to precise state slices via concise bind configs, bypassing intermediate components. Bind functions act as inline formulas allowing components to automatically react to changes and combine data from multiple state providers. This surgical subscription model is more performant than React's Context API (which re-renders all consumers by default) and scales better for global state changes. The system also supports push-based reactive configs with afterSet hooks and pull-based Effect with automatic dependency tracking.
Is Neo.mjs suitable for AI-assisted development?
Yes, Neo.mjs is AI-native by design. It features a deterministic structure with clear guidelines, a local AI Knowledge Base indexing 191,000+ lines of source code with semantic search via vector embeddings, JSON-blueprint VDOM that is AI-readable and AI-writable, 30,000+ lines of JSDoc providing rich context for every class/method/config, pre-calculated class inheritance chains for fast queries, and comprehensive documentation (35,937 lines of learning materials). The framework was architected for AI agent collaboration from the ground up, with the Neural Link enabling multi-agent concurrent access and Whitebox E2E testing allowing agents to assert internal component states.
What performance can I expect with large datasets?
Neo.mjs handles extreme scales: 50,000 live-updating records with 60+ fields each at 60 FPS in the DevIndex flagship app, 40,000+ delta updates per second in optimized environments, 784 deltas per scrolling frame with zero insertNode/removeNode/moveNode commands (pure DOM pooling), under 3ms payload serialization even for 800 JSON objects, and constant memory usage via row pooling. The Grid achieves O(1) scrolling through Fixed-DOM-Order strategy with hardware-accelerated translate3d, Soft Hydration (Turbo Mode) for instant rendering, and Virtual Fields adding calculated fields with 0 bytes memory per record.
How do I get started with Neo.mjs?
Run the one-liner: npx neo-app@latest. This sets up everything in one go: a new app workspace, pre-configured app shell, local development server, and launches your app in a new browser window. No complex setup needed. The command generates a complete workspace with dev server configured. After running, follow the setup prompts to customize your application. For learning, dive into the 35,937 lines of documentation including Gets Started guides, 62 fundamental/advanced guides, 5 hands-on tutorials, and 485 files of working examples across component, feature, integration, layout, and form categories.
What is the licensing and cost structure?
Neo.mjs is 100% free and open-source under the MIT license. You can use it for any project (personal, commercial, enterprise) indefinitely as long as you include the license and copyright notice. There are no paid plans, subscriptions, feature gating, or premium tiers. The project accepts voluntary sponsors via GitHub Sponsors (a $10/month backer tier is suggested as 'a cup of coffee' for the maintainer), but sponsorship is completely optional and not required for use. No enterprise licensing fees, no support contracts, no paid features - everything is available to everyone forever.