DEVERSE

Design and code, finally the same thing. Describe, sketch, or screenshot an idea → AI builds a real full-stack app → you refine it live, visually or in code, on one infinite canvas. No mockups that drift from code, no black-box output — one real, running app you own.

This repository is the open-source, all-TypeScript rebuild of DEVERSE (Apache 2.0). The product already exists and runs in production (originally a Django + Next.js stack); this monorepo re-implements it in one language so it can be self-hosted and contributed to. The full path now runs end to end — clone → bun run setup → add one LLM key → bun run dev → sign up, describe an app, watch agents build it live (see Quick start).

Quick start (self-host)

Requires Bun ≥ 1.2, Node ≥ 18, and git.

git clone https://github.com/DEVERSE-APPS/deverse && cd deverse
bun run setup        # install deps + create apps/{api,web}/.env + migrate the DB

# add ONE LLM key to apps/api/.env — Gemini by default:
#   GOOGLE_API_KEY=...   (free key: https://aistudio.google.com/apikey)
#   (or set AGENT_MODEL=anthropic:… / openai:… + the matching key)

bun run dev          # api → http://localhost:8080 · web → http://localhost:3000

Open http://localhost:3000, create an account (the verification link prints to the api console in local dev), create a project, and the agents build it live. The web app defaults to the local api with no extra config; see apps/api/.env.example for every key.

What it does (the vision)

Idea → app

• Describe an app in chat, sketch it on the canvas, or drop in a screenshot — agents plan, build, and run a real full-stack app.

Design ↔ code — the same artifact

• Edit the running app live: select, move, resize, inline-edit text.
• Change colors, fonts, and brand; switch themes — applied to real CSS.
• Drop into the built-in code editor; click any element to jump straight to its code.
• Visual edits and code edits stay in sync — it's one real codebase, and it's yours.

Output & hosting

• Output is a Bun monorepo: a router entry point plus on-demand artifacts (web app, API, dashboard, slides) — all TypeScript (React/Vite + Hono).
• Self-host with just Node + Bun + an LLM API key. No containers required.

Repo layout

apps/
  web/          Next.js frontend (the editor + dashboard)
  api/          Hono backend (agents, projects, files, auth)
packages/
  agent-core/   agent graph, tools, prompts (LangGraph)
  sandbox/      workspace runtime — one interface, local + cloud drivers
  contracts/    Zod schemas shared by api + web (single source of truth)
  themes/       theme presets + design engine
  sdk/          typed API client (generated)
starters/       registry/index for the artifact templates (the templates themselves
                are separate GitHub repos, cloned at runtime — not vendored here)

It's one repo, one product — everything you need to run DEVERSE is here. The hosted offering differs only operationally (managed infra, managed LLM credits, team features), not in withheld source. Behavior that differs between local and hosted (e.g. the workspace runtime) sits behind a single interface with a local default.

Stack

Bun · Turborepo · TypeScript · Next.js · Hono · Drizzle (SQLite local / Postgres cloud)

Develop

bun install
bun run dev          # all apps + packages
bun run lint
bun run check-types
bun run test         # smoke checks across workspaces (turbo fan-out)

# Backend database (apps/api — SQLite locally)
bun run db:generate  # generate Drizzle migrations from the schema
bun run db:migrate   # apply migrations

Every command runs from the repo root. Scoped to one workspace with a filter, e.g. bun run test --filter '@deverse/api'. Requires Bun ≥ 1.2 and Node ≥ 18.

Status

The core is ported and runs end to end: auth, projects, the file-ops WebSocket, the workspace runtime (host subprocess — no containers), the agent core (LangChain.js createAgent, agents-as-tools), and live SSE streaming. Create a project from a description and the agents plan → build → stream it back. Still early and under active hardening — expect rough edges. Repo layout + how the pieces wire: ref/PHASE1_SETUP.md.

License

DEVERSE is open source under the Apache License 2.0 — use, modify, self-host, and build on it freely. The starters/ templates and the apps DEVERSE generates for you are MIT — fully yours, unencumbered. Contributions just need a DCO sign-off (git commit -s).