crommacode

CrommaCode is a native, GPU-drawn desktop app for coding agents. You run your own coding CLI in its terminal: Claude Code, Codex, Gemini CLI, Cursor CLI or OpenCode. CrommaCode watches every tool call the agent makes and plays the session back as a game beside the terminal. When a task is wide, the agent splits it and sends worker bees: headless agents, each in its own git worktree and branch, on the model provider you pick.

It is free. It runs on macOS, Windows and Linux.

This repository is the public home of CrommaCode: what it is, how it is built and where to get it. It holds no source code. The app is developed in a private monorepo.

Contents

• Download
• The idea
• What it does
• Game View
• The swarm
• Architecture
• Tech stack
• Updates
• Privacy
• FAQ
• Links

Download

Get it at cromma.ai/code, or straight from the release bucket. The links always point at the latest stable version.

• The two macOS disk images are notarized by Apple. Pick the one for your chip: the Apple Silicon build does not open on an Intel Mac.
• The Windows installer needs no administrator rights and installs per user.
• The current version and its checksums are in latest.json.

The idea

A coding agent in a terminal is a wall of scrolling text. You cannot tell at a glance what it is doing, how hard it is working or whether it is stuck. So you either stare at the log or you stop looking.

CrommaCode makes the agent's work watchable.

1. The game is a side channel. Your CLI stays exactly as it is. A tool hook reports every call the agent and its sub-agents make. CrommaCode turns that stream into a show next to the terminal. Nothing is injected into the agent's context and nothing slows it down.
2. Every call lands exactly once. Reads, edits, shell commands, searches and sub-agent launches each become one beat. Parallel sub-agents never blur together: the show plays calls in order, folds repeats into ×N and shows the backlog.
3. One agent is a game. Many agents are a swarm. When a task is wide, the main agent writes briefs and flies worker bees. You watch them leave the hive, work a flower bed and land.
4. The machine is the explanation. Each view is a precise, machined instrument whose motion is the agent's activity. A dial turns to the tool in use. A loom weaves a row per call. A belt carries a box per call. You read the session the way you read a gauge.

What it does

• Terminals. One sidebar for projects, their terminals and files. The selected terminal floats as a resizable frosted-glass card over the dashboard.
• Two faces per terminal. The TUI face is your own CLI, untouched. The GUI face is a separate Agent Client Protocol (ACP) session with structured messages, tool cards and permission buttons. Flip with ⇧⌘J.
• Game View. The main agent at work, in five modes.
• Bees. Worker bees fly from the hive to the garden on a pixel meadow. Each bee lands only when it finishes.
• Files. A fuzzy file finder and a read-only reader with tree-sitter highlighting, Markdown rendering, images, tables and a hex view.
• Git. A read-only history drawn as a metro map, staged and unstaged changes with diffs, and a branch switcher.
• Traces. What shaped this session: instruction files, images, memories, plans, visits, artifacts and sub-agents.
• Stats. Token use across every coding CLI on this machine, by week, month and year. It never leaves the machine.
• Ranks. The developer leaderboard as an endless plane of seats, and the sponsor boards of Game View.

Game View

Five ways to watch the same session. Switch at any time.

Nothing to set up. When a coding CLI starts in a CrommaCode terminal, Game View recognizes it and adds its tool hook to that CLI's user settings, keeping a backup. Codex runs only reviewed hooks: run /hooks in Codex once and trust the hook.

Game View also has sound: live-synthesized music that follows the session's intensity and one hit per tool. Both have a switch.

The swarm

Open Settings → Bees, pick a model provider and paste its key. Then tell your CLI in plain words to use the swarm. The main agent plans, writes one brief per bee, launches them, merges their branches and verifies.

• Each bee is a headless coding agent in its own git worktree and branch.
• Providers that speak Anthropic Messages are reached directly. Providers that speak OpenAI Chat or Responses go through a local gateway on 127.0.0.1. Your real key never leaves that process.
• The provider list is a priority list. If the first provider has no key, no balance or no such model, the swarm falls back to the next one and records why.

You can also fly bees by hand:

bees fly <name> <brief.md>     # fly one bee and wait for it to land
bees swarm <dir>               # fly every brief in <dir> in parallel
bees merge <name>...           # merge bee branches with --no-ff
bees status                    # this terminal's hive

Architecture

        your coding CLI in a CrommaCode terminal
   Claude Code · Codex · Gemini CLI · Cursor CLI · OpenCode
        │                                   │
        │ tool hook: one line per call      │ `bees` command
        ▼                                   ▼
  ┌───────────────┐                 ┌─────────────────────┐
  │  the hive     │◄── landings ────│  worker bees        │
  │  one folder   │