dim0

A single board: notes, a mind map, mini-apps, documents, and the agent - all in the same workspace.

Features

• ♾️ Infinite canvas: thousands of nodes and nested boards, smooth at scale
• 🎨 A real whiteboard underneath: hand-drawn and geometric shapes, arrows, images and media, and a huge icon library (200,000+ via Iconify)
• 🤖 Board-aware agent: reads your canvas and selected nodes, takes multi-step tool actions, and writes results back as editable nodes
• 🧩 Mini-apps: describe a tool, get a real interactive React app on the board: open it, edit it, export it
• 📝 Rich notes: Notion-style rich text, math, code, and sub-pages, edited in place
• 💻 Code & documents: run code in sandboxes; drop in files that the agent can search (RAG)
• 🔌 Bring your own model: OpenAI, Anthropic, Gemini, Mistral, DeepSeek, Qwen, and more, switch anytime
• 👥 Real-time multiplayer: live cursors, shared edits, a shared agent; conflict-free sync, solo or fifty people deep
• 🎬 Present from the canvas: drop frames on the board and run them as a slideshow, no export to a separate slides tool
• 🔓 Open-source & private: MIT, self-hostable, your data stays yours (no training, no telemetry)

See it in action:

https://github.com/user-attachments/assets/cdc7d3d4-eb59-4d7d-a9ff-6f0206ba82df

Why Dim0?

You already have a chat assistant, a whiteboard, and a doc tool. Dim0 is what you get when they're the same surface, and the AI can actually touch it.

The short version: mini-apps and agent output live on the board next to your notes and data (editable, persistent, and shared with your team in real time), instead of being buried in a chat thread you'll never find again.

Quickstart

Run the published images. Docker is the only prerequisite.

git clone https://github.com/vcmf/dim0.git && cd dim0
cp .env.sample .env          # then set the three keys below
make pull && make run        # pulls latest images and starts everything

Set these three in .env before make run:

Open http://localhost:3000 → create a board → type a prompt. Done.

Stop it with make down-run (add make kill-run to wipe volumes).

Want to hack on the source instead of the images? See Run from source below.

Desktop app

Prefer a native app? Dim0 ships a standalone desktop build (macOS · Linux · Windows) that runs fully local and offline on your own keys — boards live on-device and the agent calls providers directly. Sign in to use managed AI and sync boards across devices.

macOS / Linux

curl -fsSL https://raw.githubusercontent.com/vcmf/dim0/main/install.sh | sh

Windows (PowerShell)

irm https://raw.githubusercontent.com/vcmf/dim0/main/install.ps1 | iex

The install scripts fetch the latest release from your terminal, so the app launches without a Gatekeeper / SmartScreen prompt (it's ad-hoc signed; not yet notarized). You can also grab installers straight from the Releases page — a browser download shows the usual first-run security prompt until we notarize.

What it is

Most AI tools start with a chat box and bolt the rest of the product on around it. Dim0 goes the other way - the board is the workspace, and the agent is one of the things living on it.

The board holds notes, code sandboxes, mini-apps, documents, nested boards, and presentation frames, all sitting next to each other - and your whole team can be on it at once. The agent can see what's there, take multiple steps with tools, and drop its results back onto the same canvas.

Node types

Everything on the board is a node:

• Shapes - diagrams and spatial structure
• Notes - rich text, edited in place
• Code sandboxes - write code, run it
• Mini-apps - real, interactive React apps: calculators, charts, visualizers, quizzes
• Documents - uploaded files, also fed into retrieval
• Nested boards - for when one board isn't enough
• Frames - turn the canvas into a presentation

Shapes for diagrams, flowcharts, and spatial layout.

Notes are first-class - rich text, math, code, edited in place.

Describe a tool and Dim0 builds a real, interactive app - it lives on the board, reads the data next to it, and you can open, edit, and export the React code.

Mix shapes and notes to think through a topic spatially.

https://github.com/user-attachments/assets/ad5de9f4-6f44-43a2-b59a-5279232d7f60

Canvas engine

The board is built on canvas-harness, a canvas-rendered node-graph library we maintain separately. Boards can hold thousands of nodes and still pan, zoom, and edit smoothly, comparable to tldraw and Excalidraw, and on par with hosted tools like Miro or FigJam.

Collaboration

Every board is real-time multiplayer. Live cursors, shared edits, and a shared agent - the same board works identically whether you're solo or fifty people deep. Edits sync over WebSocket with operational transforms, so concurrent changes merge without conflicts or lost work.

It's the same canvas either way: no separate "shared mode," no export-to-collaborate step. Open a board, send the link, work together.

Agent layer

Built on the OpenAI Agents SDK, with board-aware tools wired in:

• Board context - current graph and selected nodes
• Notes - create, edit, link
• Web - search and fetch
• Code - run in Daytona-backed sandboxes
• Mini-apps - generate real, interactive React apps inline
• Memory - semantic store and recall, via Qdrant

Models: OpenAI, Anthropic, Google Gemini, Mistral, Moonshot, DeepSeek, Qwen, Z.ai.

Ask a question on the board - the agent answers with a mini-app, a mindmap, or a note, dropped back where you're working.

Themes

Light, dark, and a set of paper-and-ink variants. The canvas adapts; so do notes, mini-apps, and shapes.

A few of the available themes.

Try it

• Hosted: https://app.dim0.net
• Site: https://dim0.net
• Self-host: see below

Repo layout

• backend/ - API, agent logic, prompts, model integrations, persistence
• webui/ - React frontend (canvas, chat, board UX)
• build/ - Docker Compose and build helpers

Getting started

Prerequisites

• Node.js (LTS)
• uv for Python deps
• Docker + Docker Compose (recommended for local services)

Environment

Copy .env.sample to .env and fill in the keys. The three required keys are covered in Quickstart; the rest of .env.sample adds more providers and tools.

cp .env.sample .env

A couple of things worth knowing:

• Backend and frontend both read the root .env
• Only variables prefixed with VITE_ reach the frontend

Run from source

If you'd rather run the source instead of the published images:

Local databases

make up-db

Backend

cd backend
uv sync
uv run python -m topix.api.app

Port comes from API_PORT in .env (defaults to 8081).

Frontend

cd webui
npm install
npm run dev

Port comes from APP_PORT in .env (defaults to 5175).

Environment variables

.env.sample i