Describe anything. Get everything.
NOVA transforms a single sentence into a complete, production-grade web application — live, interactive, and fully functional. No code templates. No fixed output patterns. Just pure creative intelligence that adapts to whatever you imagine.
You type a description. NOVA thinks, designs, and builds — in real-time, token by token, right before your eyes. What you get back isn't a mockup or a wireframe. It's a working application with real logic, real interactivity, and real polish.
"Build a crypto trading dashboard with live charts and order book" → You get a fully interactive trading terminal with simulated live data, candlestick charts, a working order book, and portfolio tracking.
"Build a mobile OS simulator with app grid and notifications" → You get a phone-like interface with swiping home screens, opening apps, a notification center, and settings panels.
"Build a 3D solar system explorer" → You get orbiting planets with realistic mechanics, clickable bodies with info panels, and camera controls.
NOVA doesn't pick from templates. It doesn't follow fixed patterns. It analyzes what you want and decides — on its own — the best architecture, design, and implementation strategy for that specific request.
Your words
↓
┌─────────────────────────────────────────────────┐
│ ARCHITECT │
│ Analyzes your request, designs a plan │
│ Decides: features, architecture, visual design │
└──────────────────────┬──────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ CODER │
│ Builds the complete application │
│ Streams code live — you watch it appear │
└──────────────────────┬──────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ ANALYZER │
│ Static analysis — catches bugs before you do │
│ 4 bug types detected in <1ms │
└──────────────────────┬──────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ PROBE │
│ Actually clicks buttons, types in inputs │
│ Verifies the app works — not just "no errors" │
└──────────────────────┬──────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ AUTO-FIX (if needed) │
│ Sends found errors back to the AI │
│ Iterates up to 3× until clean │
└──────────────────────┬──────────────────────────┘
↓
Working application
No fixed patterns. Most AI builders have presets: "if game → use Canvas", "if todo → use checklist". NOVA uses keyword detection to route web apps vs code, then the AI decides the architecture within that category and chooses its own approach. A dice game gets dice. A trading dashboard gets charts. A solar system gets orbital mechanics. The AI decides.
Live token streaming. You don't wait 60 seconds for a spinner. You watch the code appear character by character — HTML structure, CSS styling, JavaScript logic — all flowing in real-time. The preview updates as the code arrives.
Deep reasoning mode. NOVA enables thinking mode on all primary Z.AI calls (not on Qwen/Kimi fallbacks — their APIs don't support it) — architect, code generation, refinement, and bug fixing. The model reasons deeply about architecture before generating, producing more complete and functional apps.
It actually verifies. NOVA doesn't just generate and hope. After building, it loads the app in a sandbox, clicks every button, types in every input, and checks if the DOM actually changes. If the probe finds runtime errors, NOVA automatically sends them back to the AI for fixing. Up to 3 iterations. The user can also trigger it manually.
Cross-build memory. Build something, then rebuild it later? Instant. NOVA caches every build in IndexedDB. Rebuilding a previous request takes 0ms instead of 60s. It also suggests similar past builds as you type.
Survives anything. SSE stream drops? NOVA polls the server and recovers the result. AI model fails? Circuit breaker tracks failures and falls back on error. Architect fails? The coder proceeds without a plan. Network timeout? Client-side detection kicks in at 300s.
| Request | What NOVA Delivers |
|---|---|
| Crypto trading dashboard | Live charts, order book, portfolio tracker, simulated market data |
| Mobile OS simulator | Home screen, app grid, notifications, settings, app switching |
| Banking dashboard | Accounts, transfers, transaction history, spending analytics |
| 3D solar system | Orbital mechanics, planet info, camera controls, starfield |
| Music production studio | Multi-track sequencer, effects, mixer, waveform visualization |
| Data visualization dashboard | Real-time charts, KPI cards, filters, responsive layout |
| Dice game | Roll animation, two-player scoring, game-over screen |
| Snake game | Canvas rendering, score, game-over, restart |
| Anything you can describe | The AI decides the best approach |
- Static Analysis — Detects missing element IDs, undefined functions, infinite loops, uncleared intervals, missing try/catch, missing await, empty event listeners — all in <1ms, before you see the result
- Interaction Probe — Actually runs the app, clicks buttons, types text, verifies state changes occur
- Auto-Fix Loop — If errors are found, sends them back to the AI with full context and retries — up to 3 iterations
- Quality Scoring — 0-100 score based on structure, functions, CSS rules, event listeners, and accessibility
- SSE Recovery — If the stream drops, client polls
/api/build/resultto recover the completed build - Circuit Breaker — Tracks model failures; after 3 consecutive failures, temporarily disables the model (2-min cooldown)
- Graceful Degradation — Architect failure returns
plan:null(not 502); the coder proceeds without a plan - Client Timeout — 300-second read timeout detects half-open TCP connections
- Multi-Model Fallback — Z.AI → Qwen → Kimi K3 automatic failover on all routes (architect, code, refine, enhance) with circuit breaker
- IndexedDB Cache — Every build stored for instant rebuild (0ms vs 30-60s)
- Similar Build Search — Reverse cursor scans recent builds, fuzzy matches by mission keywords
- Normalized Matching — Word-order independent: "build snake game" = "game snake build"
- 30-day TTL — Old builds auto-pruned; max 200 entries
- Dark/Light Mode — CSS-only toggle, zero hydration mismatch
- 10 Color Themes — Slate, midnight, ocean, forest, sunset, amber, rose, violet, emerald, cyan
- Responsive Preview — Full / Desktop (1280px) / Tablet (768px) / Mobile (375px)
- Live Pipeline Progress — Visual stage tracker with real-time text updates
- Diff View — LCS-based line diff comparing current build with previous
- Multi-File Viewer — Syntax highlighting for 9 languages, file tree, ZIP download
- Chat Refine — "make it blue", "add dark mode", "add a chart" — iterative refinement
- Sandboxed Preview — Strict CSP, null-origin iframe, no access to parent storage
- Settings Panel — Configure API keys (Z.AI, DashScope, TokenRouter) via UI; keys stored in memory, take precedence over env vars
- Code Execution — Run generated Python/JS/Bash code in a sandboxed environment with stdin support
- Backup System — Export/Import builds as ZIP, list and download backups
- Forge Bridge — One-click deploy to Forge (forge.rabotatony.workers.dev) for live hosting
src/
├── app/
│ ├── api/
│ │ ├── build/
│ │ │ ├── architect/route.ts → Stage 1: Plan generation
│ │ │ ├── code/route.ts → Stage 2: Code generation (SSE streaming)
│ │ │ └── result/route.ts → Polling fallback endpoint
│ │ └── refine/route.ts → Chat-driven refinement (SSE)
│ ├── layout.tsx → Root layout + ThemeProvider
│ └── page.tsx → Main UI
├── components/
│ ├── theme-toggle.tsx → Dark/light CSS-only toggle
│ ├── file-viewer.tsx → Multi-file code viewer + syntax highlighting
│ ├── diff-viewer.tsx → LCS diff viewer
│ ├── pipeline-progress.tsx → Visual stage tracker
│ └── preview-error-boundary.tsx → Crash protection
├── lib/
│ ├── llm.ts → Z.AI SDK wrapper (dynamic import)
│ ├── tokenrouter.ts → Kimi K3 backend
│ ├── dashscope.ts → Qwen (DashScope) backend (dynamic import)
│ ├── model-circuit-breaker.ts → Failure tracking + auto-disable
│ ├── build-store.ts → In-memory result store (SSE recovery)
│ ├── build-memory.ts → IndexedDB cross-build cache
│ ├── static-analysis.ts → 10+ bug type detector
│ ├── interaction-probe.ts → Runtime testing (clicks, types, verifies)
│ ├── error-recovery.ts → Smart error categorization
│ ├── multi-file.ts → Multi-file output parsing
│ ├── diff.ts → LCS diff engine
│ ├── zip.ts → Dependency-free ZIP encoder
│ ├── runtime-errors.ts → Error capture script injected into previews
│ ├── design-tokens.ts → 10 theme palettes + CSS variables
│ └── ... → Utilities (html-utils, form-fixer, css-fixer, etc.)
└── tests/ → 2840 tests, 0 failures
bun install
cp .env.example .env # Add TOKENROUTER_API_KEY for Kimi K3 (optional)
bun run dev # Open http://localhost:3000| Variable | Required | Description |
|---|---|---|
ZAI_API_KEY |
Auto | Auto-loaded from /etc/.z-ai-config in Z.ai sandbox; or set via Settings UI |
DASHSCOPE_API_KEY |
Optional | For Qwen fallback; set via env var or Settings UI |
TOKENROUTER_API_KEY |
Optional | For Kimi K3 fallback (free at tokenrouter.com); set via env var or Settings UI |
FORGE_URL |
Optional | Forge deployment endpoint (defaults to https://forge.rabotatony.workers.dev) |
DATABASE_URL |
Optional | SQLite path for Prisma (future use; NOVA v1 is in-memory) |
Note: API keys can also be configured at runtime via the Settings panel in the UI. Settings UI keys take precedence over environment variables.
| Layer | Technology |
|---|---|
| Framework | Next.js 16 + App Router + Turbopack |
| Language | TypeScript 5 (strict) |
| Styling | Tailwind CSS 4 + shadcn/ui |
| Primary AI | Z.AI SDK |
| Fallback AI | Kimi K3 via TokenRouter (free, OpenAI-compatible) |
| Memory | IndexedDB |
| Streaming | Server-Sent Events (SSE) |
| Testing | Bun test — 2840 tests, 4935 assertions |
bun test # 2840 tests, 0 failuresNOVA is built on a simple principle: the AI should decide how to build, not follow a script.
Most AI app builders have a library of templates and patterns. "If the user says 'game', use Canvas and requestAnimationFrame." "If they say 'todo', use a checklist." This produces predictable, homogeneous output.
NOVA has no such presets. The AI receives the request, analyzes it, and decides — from scratch — the best architecture, design, and implementation for that specific thing. A dice game gets 3D dice. A trading dashboard gets candlestick charts. A solar system gets orbital mechanics. Each build is unique because the AI adapts.
The result: you get what you asked for, not what the template dictated.
MIT