A terminal that knows
where each command ends.
Most terminals hand you a scrollback and wish you luck. eTerm knows which command produced which output — so you can fold a run to one line, diff two runs of the same command, hand one to the pane next door, or copy the whole session as a runbook. Ask a model for a command and approve it before it runs. Review a pull request without opening a browser. Written from scratch in Rust on gpui, the framework behind Zed.
Free to download and use. macOS on Apple Silicon, signed with a Developer ID and notarized by Apple, so it opens without warnings.
Blocks · failure strip · an approval waiting · a suggestion in grey
Download for macOS
One disk image. Open it, drag eTerm to Applications. The build is signed with a Developer ID and notarized by Apple, so Gatekeeper lets it through without a warning — and the checksum is beside it so you can check what you got.
macOS · Apple Silicon
eterm-0.8.12-arm64.dmg
6.0 MB
sha256 c2bdb8327a810b16c7df9d9fda685aa8b2097b5de3c41ca7468cedb6fc21b370
Apple Silicon only. An Intel build would need a second toolchain and a machine to test it on, and shipping one nobody has run is worse than shipping none. Where something has not been measured — a CJK input method, an Intel build, anything on Linux — the docs say so instead of guessing.
A shell that keeps
the receipts.
With shell integration on — and for zsh that means doing nothing — eTerm knows where every command's output begins and ends. Everything below follows from that one fact.
Command blocks
Every command and its output is a block. Fold one to a single line, jump between prompts, hand a block to the pane next door, diff two runs of the same command to see what changed, or copy the whole session as a runbook somebody else can follow. A strip down the edge shows where the failures are, so a red run three screens up is one glance away rather than a scroll.
AI mode that waits for you
Ask for a command over the session you are asking about. The model answers with one, you approve it, it runs, and what it printed becomes the next question. ⌘E asks why the last command failed. Nothing runs that you did not approve, and approval is per command — not per session, not once at setup — with no mode that turns it off, because the value of an approval is exactly the attention it takes. A command that looks destructive needs a different chord, so return does nothing at all.
Review a pull request in the terminal
Reading a pull request means leaving the terminal for a browser, and gh pr diff gives you somewhere to read one but nowhere to say anything. ⌘R opens a window on the repository your session is standing in: read the diff with the code coloured as code, comment on a line, reply in a thread, read the description and the conversation under it, and send the review with a verdict. No gh, no browser. The token lives in the login keychain, never in a config file.
A tab that wants you
When a long command finishes, or an agent rings the bell because it needs an answer, the tab says so and the Dock bounces if you are somewhere else. A build that finished four minutes ago should not be found by coming back to check.
The command line, coloured as you type
Green when the first word is a command that exists, and silence when eTerm is not sure — a colour that is sometimes wrong teaches you to ignore it, so it is only ever shown when it is known.
Suggestions and completions
Two different things, answering two different questions. A suggestion is the rest of a command you have run before, in grey after the cursor: what did I type last time? A completion is a list of ways to finish the word under the cursor — commands, options, paths: what are my options here?
A palette that knows your project
npm run dev, composer test, make deploy — read from the manifest in the directory you are standing in, so the scripts your project actually has are one keystroke away without remembering what they were called.
Secrets drawn as a bar
Tokens and keys on screen are hidden behind a bar until the pointer is over them, so a screenshot or a pair of eyes over your shoulder gets nothing. And before any output reaches a model, the value of a SOMETHING_SECRET= line is replaced with [redacted]. The screen is local either way.
Tabs and splits that come back
Tabs and splits with draggable dividers, restored between runs — the layout you left is the layout you return to, sessions and all.
Shell integration with nothing to install
zsh needs nothing done: eTerm starts every session with a ZDOTDIR of its own — four small files that source your own .zshenv, .zprofile, .zshrc and .zlogin and then hand ZDOTDIR back — so your configuration runs exactly as it would have, a shell started inside the session is an ordinary shell again, and nothing is written into your home directory.
22 palettes, eight on the GPU
Twenty-two colour palettes, eight of them drawn over a shader surface on the GPU. Pick one, or set your own in settings.toml.
PATH control, find, mouse, input methods
Tools stay reachable when eTerm is launched from the Dock rather than a shell, because PATH is under your control. Find in session, mouse reporting for the programs that use it, and input methods for the languages that need them.
Built with the decisions written down.
Three of them matter more than any feature, and they are the ones a terminal usually keeps to itself.
The core has no framework in it
The emulator, the key rules, settings, palettes and the AI client are plain Rust, and every line of gpui lives in one directory. gpui is young and moves fast — three of its APIs changed under this project in a single day — so the boundary keeps that cost in one place, where it can be paid once.
Nothing runs that you did not approve
AI mode shows the command and waits. Return runs it — unless it looks destructive, and then return does nothing at all and a different chord is required. A terminal often points at a machine reached over ssh, and the gap between proposing and running is where a person belongs. What that gap must not become is a habit.
The numbers were measured
A frame costs 0.15 ms of grid work against an 8.3 ms budget, 0.31 ms in the alternate screen. Where something has not been measured — a CJK input method, an Intel build, anything on Linux — the docs say so instead of guessing, because a number nobody measured is a number you will one day plan around.
The model is yours.
So is the bill.
AI mode talks to Anthropic or OpenAI with a key you paste in — there is no eTerm account and no proxy in the middle. Refresh asks the provider what your account actually serves today and lists that, rather than a model list that went stale the day it was written.
- The model key and the GitHub token go into the login keychain, never into settings.toml — that file is plain text and the first thing anyone attaches when asking for help
- Secrets on screen are replaced with [redacted] before any output reaches a model
- The model is told the exit code and up to forty lines of output — what it needs to answer, not your whole scrollback
- The screen itself is local either way; only what you ask about leaves the machine
Free to download.
Free to use. A licence is a thank-you.
Every feature in eTerm works without a licence, and always will. What a licence changes is one thing: now and then — not in the first twenty minutes of a session, and not more than once every three days — a strip appears under the session to say that eTerm is free, that a licence exists, and where. A licence turns that strip off. Nothing is held back from anyone who does not buy one.
The Licence pane arrived in 0.8.12. On 0.8.11 or earlier there is nothing to paste into yet — download the current build first; it updates itself from there.
A licence for eTerm
$49 one-time · never expires · no subscription
Pay once and a line of text beginning ETERM-
is emailed to you within a minute. Then ⌘,
→ Licence → Set key…, paste, return. The status row says who it is licensed to, and the
strip does not come back. You also get an account page where the key can always be found again.
Card payment by Stripe. No account is needed to buy; one is created for you so the key is never lost. Questions or a refund — reply to the licence email.
- Checked where
- On your machine, and nowhere else. Signed with a key only the shop has; eTerm carries the half that can verify and cannot sign.
- Phones home
- Never. A licence bought once works on a machine that has never been online. No account, no seat count, no activation server to go away.
- Kept where
- In the login keychain, beside the other secrets eTerm keeps — never in settings.toml.
Open a shell,
keep the receipts.
Download eTerm, open a project, and get a terminal that knows what each command did — with a model on a leash and a pull-request review one keystroke away.