Hallu is a web framework where an LLM hallucinates your entire app.

With Hallu, you've already shipped features you never even thought of. It's an agent harness that takes a request and acts like a web app against a real database. It's the "interpreter" to Claude Code's "compiler": Application logic is generated at runtime instead of at build time. Think per-request (proofless) program synthesis against an informal prose spec.

Every request routes to a model with a SQL tool and instructions to return html. The model is the controller, the ORM, and the template engine.

Point one of the examples to Haiku and click around to watch a working app assemble itself one feature at a time.

Don't just have Claude write your app. Have Claude be your app.

How it works

Runs on Bun + Hono. Uses SQLite by default, supports Postgres. Bring your own model.

One catch-all route

GET /* asks the model for the page body. A client runtime intercepts form submits and POSTs them to /__hallu/action.

One tool

The model reads and writes the database through a single sql tool in a loop.

Wire format

Actions stream back <hallu-update target="id">...</hallu-update> blocks. The client swaps each region in by id. It feels like an SPA.

Streaming

With streamResponses, an action streams into a container through a stream tool. The framework appends your wrapper markup, fills it as tokens arrive, and fires a hallu:finalize event at the end. Two modes: literal text by default (markup escaped), or html: true to render the stream as live HTML as the tokens land.

Page chat

With pageChat, a floating panel lets the user revise the current page by instruction. The framework posts the page and instruction to /__hallu/revise and the model rewrites it in place. The edit is saved by path glob and re-applied on every later render of a matching page, so it sticks.

Caching

Rendered pages are cached per path so warm loads skip the model. A DB write invalidates affected pages (coarse by default, or scoped with a glob).

Two schema modes

Fixed (tables is the whole schema) or autoSchema (the model creates tables on the fly for paths it hasn't seen)

autoSchema mode

The schema grows as you browse. Visit a path for the first time and the model will design a table, create it, and render the page to html. Add /new to the path, and the model will generate a form. Submit the form and the model will insert the record and render the page. Add /delete to the path, and the model will present you with an "Are you sure?" form and then delete the record, as requested.

tables mode

Pin the schema yourself. Declare your tables in the config and the framework creates them on boot. The model reads and writes only within them and never runs DDL, so the shape of your data is fixed and known.

Examples

NeuroMUD

A Neuromancer-themed MUD.

Hallupedia

A "real world" encyclopedia. Every article is generated on-demand from the model's knowledge graph, and the same model generates the SQL and html.

Slop Overflow

A programmer Q&A site on Postgres, hybrid autoSchema and declared tables.

Chatty

A ChatGPT-style chat app on streamResponses. The model streams html token-by-token into the thread.

Salesfarce

A schema-less CRM. Visit an object and the model designs and creates its table and seeds it.

Shamazon

A store where the whole catalog is invented on demand: products, prices, reviews, then saved so the page is stable on return.

Get started

Requires Bun.

bunx hallujs generate myapp   # defaults: Anthropic + SQLite
cd myapp && bun install
echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
bun dev

generate takes flags for the backend and provider: --postgres, and --anthropic (default) / --openai / --ollama.

Vibes

Vibing on a Hallu app is kind of like vibe coding through a game of telephone. Use bun quality hallu.config.ts to sanity check your vibed vibes.

Configuration

hallu.config.ts default-exports defineConfig({...}). Required: name, description, model.

Tenant is { account, context? }

SqlEvent is { query, ok, mutated, error? }

SQLite path defaults to ./hallu.db (per-account files under dir, ./data)

Postgres schema defaults to public.

Caveats

• It's slow: A page is a model call, sometimes several. Pages take ~2s to load on Haiku. It's a website powered by a tool calling LLM though. What'd you expect?
• It costs tokens: Every cold request hits the model. There's a cache, so it's not insane, and Haiku is relatively cheap and does the job perfectly.
• It's non-deterministic: The same URL renders slightly differently on every cold load and cache invalidation.
• The security model isn't perfect: The framework passes untrusted input to an LLM and asks it to write arbitrary SQL. That's dangerous. There's a script in the repo that tests common SQL-injection techniques. But yeah, it's an LLM hallucinating SQL. Don't use this for anything important.