# NEON NOODLE OS — an AI-native web desktop

> **What happens to the PC when software stops being something you *install* — and
> becomes something you *describe*?**

For 40 years the desktop has been a fixed set of apps someone else shipped. NEON NOODLE
OS is a research prototype exploring the next step: an operating system where the
interface **generates itself on demand**, around what you need in the moment. The unit
of computing shifts from the *app* to the *intent*.

It's a single-page web app that behaves like a real desktop OS — windows, apps, and
state are genuinely functional, not a mockup. The heart of the system is an AI that
**generates missing applications on demand** and installs them live.

> Open the assistant (`⌘/Ctrl + Space`), type *"build me a calculator"*, and a few
> seconds later a fully working, on-brand calculator is sitting on your desktop. If it
> crashes, it repairs itself.

Built by **[ZeroPerson](https://github.com/ZeroPersonAI)**, where we research AI use
cases. This one probes a simple question: when generating software becomes nearly free
and instant, what is an "operating system" even *for*?

## Quick start

```bash
npm install
npm run dev                 # → http://localhost:5173
```

The OS boots and runs **without** any key — you get the full desktop, window manager,
filesystem, terminal, and built-in apps. The AI features (app generation, the
assistant chat, terminal `ai`, self-healing) light up once you add a key.

**Add a key in Settings → Language Model.** Pick a provider and paste a key — keys are
stored locally in your browser (IndexedDB) and never hard-coded. Supported providers:

| Provider | API shape |
|----------|-----------|
| Anthropic (Claude) | Messages API |
| OpenAI · OpenRouter · Grok (xAI) · Groq · Cerebras | OpenAI-compatible |

Prefer env vars? Copy `.env.example` to `.env` and set `VITE_ANTHROPIC_API_KEY` — it
seeds the Anthropic provider on boot, and Settings still overrides it.

## What it does

- **Boot → Lockscreen → Desktop** with a coherent "NEON NOODLE OS" amber/dark glass aesthetic.
- **Real window manager**: drag, resize from any edge/corner, snap-to-edge (left/right/top),
  maximize, minimize-to-dock, z-stacking, multiple windows.
- **Spotlight** (`⌘/Ctrl + Space`): search installed apps or describe a new one to build.
- **AI app generation**: returns strict JSON `{name, icon, category, defaultSize, code}`,
  the code is Babel-transformed and run in a **sandboxed scope** (only React + the OS SDK
  are reachable — `fetch`, `localStorage`, `eval`, etc. are blocked).
- **Self-healing**: if a generated app crashes, an error boundary offers to let the AI
  read the error and rewrite the code.
- **Persistence**: the virtual filesystem and installed apps live in IndexedDB and
  survive a reload.

## Built-in apps

| App | What it is |
|-----|------------|
| **Assistant** | Chat with the OS AI; turn any request into an app. |
| **App Builder** | Watch the generation pipeline; one-click app ideas. |
| **Files** | Browse & edit the virtual filesystem. |
| **Terminal** | `ls`, `cd`, `cat`, `mkdir`, `touch`, `rm`, `echo > file`, `open`, and `ai <prompt>`. |
| **Settings** | Theme (light/dark), wallpaper, manage installed apps. |

## The System SDK (what generated apps may use)

Every app — built-in or generated — receives an injected `os` object and may **only**
touch the outside world through it:

- `os.fs` — virtual filesystem (`read/write/list/delete/mkdir/exists`)
- `os.window` — `setTitle / close / setSize / minimize`
- `os.ai` — `ask(prompt)`, `stream(prompt, onToken)`, `available`
- `os.notify(title, body)` — system notifications
- `os.storage` — per-app key/value persistence
- `os.theme` — current design tokens (apps style themselves on-brand)
- `os.bus` — inter-app message bus

## Architecture

```
src/
  kernel/      state (zustand), fs (IndexedDB), ai + providers (multi-provider LLM), sdk, appRuntime (Babel+sandbox), registry
  design/      design tokens — the single source of visual truth
  system-ui/   Boot, Lockscreen, Desktop, MenuBar, Dock, Window(Manager), Spotlight, Notifications
  apps/        Files, Terminal, Settings, Assistant, AppBuilder
```

Build it iteratively in this order if you want to read along: boot + desktop +
window manager → a static app → the AI generation pipeline.

## Notes

- In dev, LLM requests route through a same-origin Vite proxy so every provider works
  without CORS headaches. A production build calls the provider directly — for a real
  deployment, proxy the API through a backend so keys never reach the client.
- The generated-app sandbox (Babel transform + restricted `new Function` scope) is
  **defense-in-depth, not a true security boundary** — generated code shares the page
  realm. Real isolation would use an iframe/worker. Fine for a local research prototype.
- The bundle is large because `@babel/standalone` (the in-browser JSX compiler) ships
  with it. That's the cost of compiling AI-authored React in the browser.

## About ZeroPerson

We research AI use cases — prototypes that probe where AI changes the shape of software,
not just its features. NEON NOODLE OS is one such probe into the future of the desktop.
MIT-licensed; explore, fork, and build on it.