A coding agent that fits in 636 KB – no Node, no Python, no NPM

License: source is available for study and personal/internal use — selling or cloning is prohibited, and any public disclosure must be non-profit and credited to the project. See LICENSE.

Delta Agent is a coding agent that lives in your terminal. Site: descz.github.io/delta · downloads: Releases

You talk in natural language and it does the work: reads and writes files, runs commands, handles git, searches the web, keeps memory and explains what it found — with the model you choose.

It is a single executable written in C11, with no dependencies at all: no Node, Python, npm, pip or framework installer. On Windows it is 636 KB and about 1.7 MB of private memory.

| Files | reads, creates, edits precisely (exact-block edit ), searches the project, shows diffs | | Shell | runs commands, keeps background jobs, /terminal shows the output in a chat block | | Git | status, diff, log, commit and checkpoint before changing anything | | Web | downloads pages, extracts data, reads documentation — and speaks MCP over HTTP or stdio | | Skills | saved workflows in SKILL.md — six ship built in (code design, spreadsheets/PDF, docs, automation, verification, systematic debugging); indexed in the system prompt and read on demand | | Memory | durable facts across sessions, searchable by text | | Project graph | indexes symbols and imports once, then answers without re-reading every file | | Models | models.dev catalog with hundreds of models and providers | | Sessions | per-folder history in JSONL with the thinking preserved; delta always starts a new chat,delta continue reopens that folder's last one | | Streaming | token by token, cut immediately when you send a message mid-turn |

All inside the terminal, with its own TUI: mouse selection and copy, rendered markdown (headings, lists, code, tables), OkLCH colors, themes, i18n (pt, en, es, zh, ja) and an installer with an HTML screen served by the executable itself.

Download from Releases. Each system has one file that already is the installer:

The installer asks where to keep the data, creates the folder, copies the binary, puts delta on the PATH and creates the shortcut (taskbar on Windows, .desktop + GNOME favorites on Linux, Delta.app + Dock on macOS). Windows may warn on SmartScreen the first time (More info → Run anyway) because the binary is not code-signed.

Being explicit, because "compiles" is not "works":

There is no ready-made macOS binary: the package ships the source and a .command that checks the Xcode Command Line Tools (free), builds and opens the installer — there is no reliable cross-compile to Mach-O.

$ delta
sem chave de API · use /login para colar a chave do provedor

/login                          # pick the provider, paste the key, get a default model
/projects D:\dev\my-app         # where it works (saved for next time)
read src/main.c and explain the flow

Next time, delta starts a new chat in that folder. To pick up the previous one — messages, tool calls and the model's thinking included — run delta continue.

Inside the app, /new starts a fresh session and /clear wipes the screen.

delta --setup reopens the installer: a small HTML window (Edge/Chrome app mode, no tabs) served by the executable on 127.0.0.1 with a random token — it closes with the window and never leaves a server behind. Without a Chromium browser it falls back to a native terminal screen. delta wiki just prints the docs address. delta update does the same job without opening the app: delta update --check only reports, and the command replaces the running executable in place (on Windows it is renamed, so the file can be swapped while it runs). The TUI checks for a new release once a day and shows a notice at startup; turn that off with "updateCheck": false in config.json or DELTA_NO_UPDATE_CHECK=1.

Typing while it works is supported: the message appears in the chat marked queued and the agent cuts the reply mid-stream to read it — no waiting for the final message.

A turn is: prompt → model (streaming) → tool calls → result → next step, until the model stops. Delta owns the loop and the tools; the model only asks.

• Own renderer (ui.c ): cell grid with OkLCH colors (faithful port of OkLch/OkHsl), markdown →Doc of styled lines, tool boxes, multi-line editor with cursor. The transcript is rebuiltincrementally , block by block (tr_y /tr_fast_from ), keeping a frame at ~0.5 ms even in long conversations.
• Terminal (term.c ): raw mode withReadConsoleInput on Windows andtermios on POSIX; mouse (click, wheel, drag), paste, resize, alternate screen and modified-key shortcuts.
• Network (provider.c ): WinHTTP on Windows,curl on POSIX — SSE read line by line, with mid-streamabort when you step in.
• Agent (agent.c ): typed history (user /assistant /tool ), tool calls with ids, JSONL v3 sessions per folder, system prompt rebuilt every turn (with skills indexed and the project graph).
• Project graph (codegraph.c ): indexes files, symbols and imports once into~/.deltaCore/graphs/<slug>.graph ; the agent queries it with thegraph tool instead of reading the whole codebase on every input.
• Tools (tools.c ,tools_ext.c ): 40+ operations grouped in families (fs ,shell ,git ,web ,skills ,mcp ,memory ,code ,assert ,agent ,extend ), with timeouts, output limits and console encoding conversion. Every write keeps an undo snapshot.
• Installer (setup.c ): local HTTP server (Winsock/Berkeley) serving an embedded page (~13 KB, fonts in base64), opens the browser and performs the install — native folder picker, binary copy,PATH , shortcuts and pinning.

The look (themes, color tokens, sizes) follows the same vocabulary as a modern editor: 56 theme tokens, plain .json files in themes/.

One folder, chosen at install time (default C:\Users\<you>\.deltaCore):

.deltaCore/
  config.json        provider, model, language, thinking, projectDir
  auth.json          one API key per provider
  models.v2.json     cached models.dev catalog
  memory.json        durable memory
  sessions/          --<folder-slug>--/<date>_<id>.jsonl
  skills/            <name>/SKILL.md
  mcps/              one .json per MCP server (url or command)
  extensions/        pluggable extensions
  graphs/            project graph cache (symbols/imports)
  update.json        last release check (version, asset, timestamp)
  system/prompt.md   rules it must always follow
  paste/ jobs/ themes/ undo/

system/prompt.md is re-read every turn: that is where you write your team rules.

Several windows at once is supported. Every file in this folder is written to a temporary and swapped in one step (file_write_atomic), so a second delta — or a subagent — never reads a half-written config.json, auth.json, memory.json or catalog. Without that, the instance that reads a truncated config loses provider and key and its session looks dead.

You only need a C compiler and the system libc.

Windows (MinGW-w64 / Git Bash):

build.bat            :: bin\delta.exe
package.bat          :: dist\Delta.exe + zip

Linux / macOS:

./build.sh           # bin/delta
./build.sh --test    # + core tests
./package.sh         # tarball + .run (Linux) | .app + zip + dmg (macOS)

On macOS the Xcode Command Line Tools (xcode-select --install) are enough. At runtime Linux uses curl to talk to the provider.

Two suites, no framework:

bash tests/run_all.sh     # Windows: 60+ checks (TUI replay, provider mock, installer)
bash tests/run_posix.sh   # Linux/macOS: build, core, replay, real streaming, installer, docs

The replay mode runs the real application without a terminal (--replay script.txt 110 36) and dumps the screen as text — that is how the TUI is tested in CI. The fake provider (tests/mock_openai.py) covers streaming, tool calls, HTTP errors, retries and mid-stream steering.

src/
  main.c        TUI, commands, editor, transcript
  agent.c       agent loop, sessions, system prompt, config/auth
  provider.c    streaming (WinHTTP / curl), tool calls, token usage
  codegraph.c   project graph: files, symbols, imports
  tools.c       fs, shell, git, diff, web, undo
  tools_ext.c   skills, mcp (HTTP/stdio), memory, code, assert, agent, extend
  setup.c       installer (local server + embedded HTML screen)
  ui.c          cell grid, markdown, components
  term.c        terminal (Win32 / POSIX)
  theme.c okcolor.c  themes and OkLCH colors
  clipboard.c   paste (text, image, files)
  json.c util.c i18n.c extensions.c modelsdev.c
installer/      installer page (embedded in the exe)
docs/           landing page (GitHub Pages)
assets/         logo, hero, screenshots
tests/          replay scripts + mocks + suites

Source-available, non-commercial. The source is public for study and personal/internal use, but the license forbids selling, renting, paid access and cloning — and requires credit to the product in any public disclosure.

Mandatory credit: Delta Agent — https://github.com/descz/delta. Commercial permission, cloning or special redistribution: open an issue in the repository.