An editor built around my own habits — with the agent built in.
Obelus is a code editor that runs in its own window or in a terminal. It doesn't try to have every feature. It's built around how I work: you hand a task to an agent, and it makes the changes in a separate worktree. You can look in on it whenever you like. When it's done you try it, have it reviewed, and open a pull request to merge it. You never leave the editor, and you never type a git command.
Pick your system, download the package and double-click it. To install with one command instead, or to get the terminal version too, read on.
| System | Download |
|---|---|
| macOS (Intel and Apple silicon) | Obelus.app |
| Windows x64 | Installer (.msi) · Archive (.zip) |
| Windows ARM64 | Installer (.msi) · Archive (.zip) |
| Linux x86_64 | .deb · .rpm · AppImage |
| Linux arm64 | .deb · .rpm · AppImage |
obg, the window version. For ob, the terminal version, use the script below or grab an archive from the releases page, which also lists every file's SHA256.xattr -dr com.apple.quarantine /Applications/Obelus.app in a terminal.The script downloads the latest release, checks it against the release's SHA256SUMS, and puts obg, the window version, somewhere on your PATH.
curl -fsSL https://raw.githubusercontent.com/obelus-editor/obelus/master/contrib/install.sh | shirm https://raw.githubusercontent.com/obelus-editor/obelus/master/contrib/install.ps1 | iexob, the terminal version, is a separate program and you have to ask for it. On Windows you can't pass arguments through a pipe, so download the script first and then run it.
curl -fsSL https://raw.githubusercontent.com/obelus-editor/obelus/master/contrib/install.sh | sh -s -- --bin bothirm https://raw.githubusercontent.com/obelus-editor/obelus/master/contrib/install.ps1 -OutFile install.ps1
.\install.ps1 -Binary both--bin ob installs only the terminal version, --dir says where to put it, and --help lists the rest.-NoShortcut skips it). On Linux it adds launcher entries and an icon under ~/.local/share so any app launcher can find it, omarchy's Apps menu included (--no-desktop skips them). If the directory isn't on your PATH, the script tells you which line to add.-Uninstall on Windows, or --uninstall on Linux and macOS. If you installed with --dir, pass it again. Your settings are left alone either way.ob instead.mise tool-alias set obg 'github:obelus-editor/obelus[matching=obg-]'
mise use -g obgmise tool-alias set ob 'github:obelus-editor/obelus[matching=ob-]'
mise use -g obobg, the window version, and the second ob, the terminal version. Run both for both.matching picks which archive to download. mise upgrade keeps them up to date.obg by name.ob. mise doesn't check, and for obg it downloads the glibc build, which won't start there.All you need is a stable Rust toolchain (edition 2024).
git clone https://github.com/obelus-editor/obelus
cd obelus
# the window version, installed into ~/.cargo/bin as `obg`
cargo install --path crates/obelus-gui
# the terminal version, installed as `ob`
cargo install --path crates/obelus-cli
# or just build both: target/release/obg and target/release/ob
cargo build --releaserust-analyzer for Rust). Without one you can still read code; you just don't get go-to-definition, errors or an outline. Obelus starts none until you turn on language_servers in the settings.obg # no arguments: the welcome screen for this directory
obg src/main.rs # open a file; its repository is the project
obg ../another-repo # open a directory; that is the project
ob src/main.rs # the same file, in the terminalopen-settings for colours, wrapping and tab width; choose-theme for the theme.Every key, command and setting is in the reference.
This is the main way to use Obelus: from an idea to a merged change. The agent works in its own worktree, so the code you're looking at never moves under you, and it stops to ask whenever there's a decision for you to make.
Write a note, or just start talking.
See a line that looks wrong? Press Alt+t on it and write a sentence. For something that isn't about one line, write it on the notes page (Ctrl+t). Or skip the note: F4 starts a new conversation straight away.
Work out what you want with the agent.
Pick a note on the notes page and press Alt+a to open a conversation about it. The agent already knows what the note says. Once you've agreed on the steps, it asks before writing them under the note.
The agent makes a worktree and gets to work.
Before changing anything, it creates a worktree and a branch under .worktree/, builds it and runs the tests once, so it knows everything worked before it started. Every change after that happens over there, and not a character changes on your side. The top of the conversation shows which branch it's on.
Look in on it whenever you like.
You don't have to wait until it's done. F2, then Tab, pick the worktree, and you're on that tree. Changes it hasn't committed yet are marked in the margin, and F3 lists the files it has touched. For changes it has committed, F9 lists the commits to the file, and choosing one opens the file as that commit left it, with what the commit did marked in the margin.
When it's done, it tells you where to try it, and waits.
It runs the tests again and tells you the directory, the branch, what it ran and what happened. That's the actual result, not "this should work". Then it waits. It won't go any further until you've tried it.
Once you're happy, it reviews the change.
When you say it works, it asks whether to review the code first. Where it can, it starts a fresh context so it doesn't review with the same assumptions it wrote the code with. It lists what it found by how much it matters, you tick what to fix, and it fixes them one at a time.
A pull request, followed all the way to merged.
Then it asks how you want to land it: merge it directly, open a pull request, or keep it for later. For a pull request it uses gh. It watches CI, tells you why a check failed, fixes it if you say so, and merges once everything passes. If gh isn't installed or signed in, it pushes the branch and gives you the link.
Then it cleans up.
After the merge it asks whether to bring your local branch up to date, whether to remove the worktree, whether to tick the note off, and whether to close the conversation.
Every one of those decisions shows up as a card in the conversation: arrow keys to choose, Enter to answer. The agent never pushes, merges, deletes or ticks anything off on its own say-so.
This workflow is the default. If you'd rather the agent edited the files in front of you, set workflow to in-place in the settings. The steps are the same but there's no worktree, and every change can be undone with Ctrl+z. Set it to none and the agent works however it likes. Obelus itself never runs git: every git command above is run by the agent.
Obelus has no split panes. To see two pieces of code side by side, you open two windows. So it's normal to have several Obelus windows on one project, each on its own worktree. F2 then Tab lists every worktree of the repository, and under each tree a row for every Obelus on it, saying what it's reading. Moving this Obelus onto another tree asks first about anything unsaved, and reopens what you had open there last time.
In the terminal version, ob, that's Enter on the tree, and it's the only key there is: ob can't open a new terminal for you or bring another terminal window to the front. In the window version, obg, it's Ctrl+Enter, because Enter goes to another window instead: on a tree it opens a new one there, and on a window it brings that one to the front.
The rest of what happens with several windows open is in the reference.
Obelus has no model of its own. It talks to the agent you already use over ACP, the Agent Client Protocol. If you don't have one yet, press F4, start a new conversation, and install one from the agents page.
Press Alt+t on a line to write a note about it; Ctrl+t opens them all. A note can be about a line or the whole project, and notes can sit under other notes. A note remembers the commit it was written at, so a note from last week still finds its line however much the file has changed. Notes live in Obelus's own directory, not in your repository, so every worktree sees them and they never end up in your commits.
Whether the agent made a change or you did, you read it in the file: the margin marks which lines changed, Alt+d opens the old code in place, and pressing it again closes it.
git diffgit for youobg is the window version and ob the terminal version, like gvim and vim: the same screens and the same keysThere's no insert mode to get into before you can type. It works like VS Code or Emacs, not like vim or helix. The pattern is simple: function keys open something to look at, Ctrl does something to the current file, and Alt asks about what's under the cursor. Can't remember a key? Ctrl+p finds any command by name, and wherever a list has keys of its own, the row along the bottom says what they do. The full table is in the reference.
Those are the parts that make Obelus different. This is everything it has, and each row goes to where the features page explains it, key by key.
Obelus is built for one particular way of working. If most of this sounds like you, it should suit you:
These are left out on purpose, not because nobody got round to them.
If one of those is exactly why you'd pick an editor, Obelus probably isn't for you. That's fine: it wasn't built for that.
The rules trade-offs are checked against. Most were written down after getting something wrong once.
Built for a way of working, not a feature list.
A feature is here because the work actually needs it, not because other editors have it.
You can see what the agent does, and undo it.
When the agent edits a file, it's like you editing it: Ctrl+z undoes it. A command it runs can't be undone, so the command is shown exactly as it was run, with all of its output, and the key that stops the agent stops the command too.
Done changes are in the file; requested ones are in the conversation.
Once the agent has changed a file, the margin already shows the difference, so the conversation doesn't show it again. What it's still asking to do stays in the conversation.
Files change while you read them. That's normal.
The agent edits a file, a formatter runs, the branch switches. Obelus reloads on its own and keeps your place. If a file is deleted, it's marked [stale] and its contents stay on screen.
Honestly, I wrote it for myself. Every trade-off asks "does this work for me?" before "will someone skip it for lack of feature X?" — so the habits on this page are mine.
I never got used to vim. Modes, hjkl, colon commands: muscle memory for the people who have it, and something I had to think about every single time. I wanted to open it and read: arrow keys are arrow keys, Ctrl+c copies, and there's no mode to get out of first.
And the way I write code has changed. Most of it is written by Claude Code and Codex sessions now. What I do at the screen is read, check, mark what looks wrong and decide what's next, and I want my to-do list right beside the code. The terminal editors compete on features. Obelus is an editor too, but it goes another way: the syntax tree, Git history, the language server and the agent, put together the way I work.
And the name: an obelus (÷, †) is the mark scholars put in a manuscript's margin beside a line they doubted. It's a mark a reader makes while reading.