Ants Terminal

A fast, modern terminal that makes Claude Code cheaper and easier to use.

What is this? • Why use it with Claude Code • Install • Getting started • Settings • For developers

Version 0.7.114 · What's new · What's planned

_{Recorded with demoreel on a private virtual screen.}

---

What is this?

A terminal is the window where you type commands to your computer. Ants Terminal is a fast, good-looking one for Linux — but its real party trick is that it works hand-in-hand with Claude Code, Anthropic's AI coding assistant, to save you money and make sessions smoother.

It's built from scratch, and the only thing it needs to run is Qt6 (a graphics toolkit most Linux desktops already have), so it's quick and light. Its tools for Claude run on your own machine — they send nothing anywhere.

Why use it with Claude Code

Claude Code charges by the token — think of a token as a small chunk of text it reads or writes. Every time Claude runs a command to look something up (checking what changed in your code, searching files, reading a long to-do list), it reads all that output, and you pay for it.

Ants Terminal answers a lot of those questions itself and hands Claude a short, tidy summary instead of a wall of text. Less text read means fewer tokens spent. Three things make that happen:

• A built-in toolkit Claude can use. 77 ready-made tools that answer Claude's common questions directly — often saving thousands of tokens per question (more below).
• A cheat-sheet for Claude. When a Claude session starts in an Ants tab, Ants hands Claude a short note pointing it at those tools, so it uses them instead of the expensive long-hand commands. (You can turn this off in Settings.)
• A live view of what Claude is doing. The bar along the bottom shows Claude's status (thinking, editing, searching…) at a glance, and you can browse and resume past Claude sessions without leaving the terminal.

The built-in toolkit, in plain terms

Each tool replaces a slow, token-hungry command with one quick answer:

Instead of Claude…	…it just asks for
scrolling back to re-read command output	the recent output, errors, or last command
searching your whole project with grep	matching lines, a file's outline, where a function is defined/used
running several git commands	your branch, recent commits, and changes in one go
reading a giant to-do / roadmap file	only the items it needs
re-running builds and tests to read the logs	the latest build/test results
running a pile of code-quality checkers by hand	one combined report
reading a whole spec to learn the rules	just that spec's checklist

You don't have to memorise any of this — Claude picks the right tool on its own once Ants Terminal is connected (see Getting started). A small counter in the bottom bar keeps a running total of what the tools have saved you this session.

Living alongside Claude

• See its status — the bottom bar shows what Claude is up to right now, plus how full its memory ("context") is getting.
• See which model it's using — a small badge shows the model (Haiku, Sonnet or Opus) and how hard it's set to think, for the tab you're looking at.
• Browse & resume sessions (Ctrl+Shift+J) — every Claude project and session, with a one-click resume, continue, or fork.
• Choose what Claude may run without asking (Ctrl+Shift+L) — edit the project's allowlist in a window instead of a settings file.
• See what changed before you keep it — a Review Changes button in the bottom bar shows what's changed in the project's files, in one coloured view.
• Paste a screenshot (Ctrl+Shift+V) — it's saved automatically and the file path is dropped into the prompt, so you can paste-and-send an image to Claude in one move.
• Follow the plan — when a project keeps a roadmap, a Roadmap button in the bottom bar opens it in a searchable window. Items line up in tidy columns, you can filter by status and kind of work, and it remembers which sections you had open in each project.
• See what Claude left running — a Background Tasks button in the bottom bar lists the commands Claude started in the background.

Power users: the tools are Model Context Protocol tools in the mcp__ants__* namespace. An optional extra set of Claude Code hooks installs with tools/install-hooks.sh — it needs jq, and only acts in folders that contain a .ants-project file. Details in CLAUDE.md.

It's also a great terminal

Even with Claude out of the picture, it's a fast, capable terminal:

• Opens your normal shell (bash, zsh, …) with full colour and Unicode, and handles full-screen programs like vim, htop, and less.
• Programming-font ligatures — pairs like != and => drawn as one neat symbol — plus italics, fancy underlines, and emoji.
• Inline images — show pictures and charts right in the terminal.
• Find things fast — search everything on screen and in scrollback (Ctrl+Shift+F), a command palette to run any action (Ctrl+Shift+P), and a "hint mode" that lets you open any link or file path on screen with a keypress (Ctrl+Shift+G).
• Click links and file paths to open them.
• Split a tab into panes (Split menu), and type into every pane of that tab at once with Broadcast Input (Ctrl+Shift+I).
• Work with past commands — jump between prompts (Ctrl+Shift+Up and Down), copy the last command's output (Ctrl+Alt+O), or run it again (Ctrl+Alt+R). This needs shell integration, which the welcome window sets up for bash or zsh.
• Tell tabs apart — View → Give Each Tab a Different Colour, or right-click a tab to rename it or pick its colour.
• Save your SSH connections — File → SSH Manager.
• Keep a record — record a session (Ctrl+Shift+R), log each tab to its own file, or export the scrollback as text or HTML (Settings menu).
• Handy editors — a pop-out box for writing long multi-line commands, and a saved-snippets library for ones you reuse.
• Remembers your session — your tabs and what was in them come back next time you open it.
• Looks the way you like — 11 built-in colour themes, adjustable see-through background, and optional automatic dark/light switching.
• Plugins — extend it with small Lua scripts (PLUGINS.md).
• Built-in code checker — Tools → Project Audit runs popular code-quality tools and shows the results in one place. Tools → Review adds a documentation review, a test-suite audit and an independent code review, run through the AI service you connect in Settings.

(Full keyboard shortcuts are in the command palette, Ctrl+Shift+P. The list of supported terminal codes is in docs/escape-sequences.md.)

Install

From your package manager

If you're on one of these, this is the best option — you get updates automatically, like any other program on your system. Add the repository once, then install:

# openSUSE Tumbleweed
sudo zypper ar https://download.opensuse.org/repositories/home:/milnet:/ants-terminal/openSUSE_Tumbleweed/ ants-terminal
sudo zypper in ants-terminal

# openSUSE Leap 16.0
sudo zypper ar https://download.opensuse.org/repositories/home:/milnet:/ants-terminal/openSUSE_Leap_16.0/ ants-terminal
sudo zypper in ants-terminal

# Fedora 44
sudo dnf config-manager addrepo --from-repofile=https://download.opensuse.org/repositories/home:milnet:ants-terminal/Fedora_44/home:milnet:ants-terminal.repo
sudo dnf install ants-terminal

# Mageia 10
sudo urpmi.addmedia ants-terminal https://download.opensuse.org/repositories/home:/milnet:/ants-terminal/Mageia_10/
sudo urpmi ants-terminal

The packages are built on openSUSE's own build servers. (Yes, Fedora and Mageia too — that service builds for more than openSUSE.)

The easy way (any Linux, 64-bit)

Not on one of the above? Grab the ready-to-run AppImage — one file, no installer. This link always gives you the newest version:

Download Ants Terminal (AppImage, 64-bit Linux)

Then make it executable and run it:

chmod +x Ants_Terminal-x86_64.AppImage
./Ants_Terminal-x86_64.AppImage

Or do the whole thing in one line:

curl -L -o Ants_Terminal-x86_64.AppImage \
  https://github.com/milnet01/ants-terminal/releases/latest/download/Ants_Terminal-x86_64.AppImage
chmod +x Ants_Terminal-x86_64.AppImage && ./Ants_Terminal-x86_64.AppImage

Prefer a specific version? Every release on the Releases page also carries the same build under its version number.

The AppImage keeps itself up to date. When a new version is out, Ants shows it on the menu bar. One click downloads it, checks it really came from this project, and swaps it in. Then restart now, or keep working and get the new version next time you open Ants. You can turn the startup check off in Settings → General.

It works on most recent Linux distributions and bundles everything it needs. Your settings live in ~/.config/ants-terminal/.

Build it yourself

You'll need a C++ compiler, Qt6, CMake, and (optionally) Lua 5.4:

# openSUSE:  sudo zypper install qt6-base-devel cmake gcc-c++ lua54-devel
# Ubuntu:    sudo apt install qt6-base-dev libqt6opengl6-dev cmake g++ liblua5.4-dev
# Fedora:    sudo dnf install qt6-qtbase-devel cmake gcc-c++ lua-devel
# Arch:      sudo pacman -S qt6-base cmake gcc lua

git clone https://github.com/milnet01/ants-terminal.git
cd ants-terminal
cmake -G Ninja -B build && cmake --build build
./build/ants-terminal

Use Ninja (as above), not plain make — it keeps the build from using too much memory. To install system-wide: sudo cmake --install build. More build options are in CONTRIBUTING.md.

Getting started

1. Open Ants Terminal. It works like any terminal straight away. The first time, a welcome window explains the features and offers one-click setup. Anything that would edit your own files shows the exact change first.

2. Connect Claude Code to it — once per computer. Claude Code talks to Ants through a small helper program, ants-mcpd. The welcome window that opens on first launch has a button that connects it; reopen that window any time from Help → Show Welcome. To connect by hand, run this from a source build's folder:

   claude mcp add --scope user ants -- "$PWD/build/ants-mcpd"

   With the AppImage, run claude mcp add --scope user ants -- /path/to/Ants.AppImage --mcpd.

   When ants-mcpd is rebuilt, reconnect Claude Code (/mcp) to pick it up. Ants itself keeps running, and so do your other sessions. The older connector, tools/mcp-bridge.py, is gone from 0.7.115. If Claude Code still points at it, run the command above again.

3. Start Claude Code in an Ants tab by typing claude. At the top of the session you should see a note that starts "Ants MCP is connected."

4. Watch the savings. Once Claude has used a few of the tools, a "↓ … saved" counter appears in the bottom bar. Hover over it for month, year and all-time totals.

If the tools don't show up, check that Settings → General → Enable Ants MCP integration is ticked, then close and reopen Ants.

Settings

Open Settings from the menu, or edit ~/.config/ants-terminal/config.json directly (it's saved so only you can read it). Common things to change:

Setting	What it does
Theme	Pick from 11 colour schemes (View → Themes)
Font size	4–48 points
Opacity	How see-through the background is
Scrollback	How much history to keep (up to 1,000,000 lines)
AI assistant	Connect a local or cloud AI for the built-in chat (Ctrl+Shift+A)

Privacy & security

• Your settings file and any saved keys are readable only by you.
• The built-in tools for Claude work entirely on your computer.
• When it opens, Ants asks GitHub whether a newer version exists (you can also check any time from Help → Check for Updates). If GitHub's gh command-line tool is installed and your project lives on GitHub, Ants also asks GitHub whether that project is public or private, to show it in the bottom bar.
• Nothing else goes online unless you set it up or ask for it: the optional AI features once you connect an AI service, SSH connections you open, updates you click, and links you follow.
• The private channel Claude Code talks to can only be reached by your own user account.
• Plugins run in a locked-down sandbox and can't freeze the terminal.
• Full details in SECURITY.md.

For developers

Ants Terminal is a from-scratch VT100/xterm terminal in C++/Qt6 with no terminal-library dependencies. The architecture, the per-subsystem map (also served live via the subsystem MCP tool), and the build/MCP authoring contracts live in CLAUDE.md and docs/standards/. Specs are in docs/specs/, decision records in docs/decisions/.

Before contributing, read CONTRIBUTING.md and CODE_OF_CONDUCT.md; report security issues via SECURITY.md.

cmake -G Ninja -B build && cmake --build build && ctest --test-dir build --output-on-failure

License

MIT License — Copyright (c) 2026 Ants Terminal Contributors