ATAC: a Postman-style API client that runs entirely in the terminal

What ATAC replaces, and for whom

Postman, Insomnia and Bruno all assume you want a windowed application, and in two of those cases an account tied to a hosted service. ATAC takes the opposite position. The README describes it as "Arguably a Terminal API Client" and states the philosophy plainly: free, account-less, and offline "for now and forever." That sentence is the whole product thesis, and it determines who the tool is for.

The target user is a backend or platform engineer who already works over SSH, keeps dotfiles in version control, and finds it irritating to switch to a browser or an Electron window to fire one request. ATAC manages collections and requests, ships an HTTP client, and covers the usual method set: GET, POST, PUT, PATCH and DELETE all appear as supported rows in the feature comparison table. Because collections live on disk rather than behind a login, a request definition can sit next to the code that serves it.

It is not for someone who wants to hand a collection to a colleague through a share link. There is no account, so there is no sharing layer, and the README does not describe one.

The TUI stack: ratatui, edtui and a tree widget

ATAC is a Rust binary built on ratatui, the terminal UI framework, with serde enabled so widgets can be serialized. Around that core the Cargo.toml pulls in a small set of specialised crates, and the split tells you how the interface is assembled.

tui-tree-widget renders the collections as a tree, which matches the nested folder-and-request structure these clients use. tui-scrollview handles scrollable panels, so response bodies and long headers do not need bespoke paging code. edtui supplies the text area used for editing the request URL, body, messages, payloads and scripts, which is the piece that makes ATAC more than a request sender: you edit inside the terminal rather than shelling out to an editor. crokey parses and applies key binding files, and tui-big-text is used only to draw the ATAC wordmark on the homepage, a detail the Cargo.toml comments confirm.

The request layer is reqwest with default features disabled and a hand-picked set: cookies, rustls, form, multipart, gzip, brotli, deflate and stream. rustls rather than native TLS means the binary does not link against the system OpenSSL. reqwest-middleware wraps the client to allow middleware chains, and reqwest_cookie_store plus cookie_store persist cookies between requests, which matters when you are walking through an authenticated flow by hand. Vim key bindings are documented, and there is a NeoVim integration section, so the editing model is aimed at people who already have muscle memory for it.

Installing ATAC and sending a first request

The README gives several install paths. The cargo route is the one that works everywhere Rust does, and it pins to the locked dependency set. Note the version floor: the README says your Rust version must be at least 1.82, while Cargo.toml declares rust-version 1.90, so treat 1.90 as the practical requirement.

cargo install atac --locked

On macOS or Linux with Homebrew the formula is shorter:

brew install atac

Windows users with Scoop get the same result:

scoop install atac

Arch and Fedora have native packages. The README documents pacman -S atac for Arch, and for Fedora copr the two-step enable-then-install sequence. There is also a Docker image at juliencaposiena/atac and prebuilt binaries on the releases page. The README warns that binaries must be run from a terminal with CLI arguments, because ATAC is not a graphical application; macOS users may need to clear the quarantine attribute with sudo xattr -rd com.apple.quarantine followed by the path to the binary.

Once installed, launching atac opens the TUI. From there you create a collection, add a request, set the method and URL, and send it. The repository ships an example_resources/ directory at the top level, which is the fastest way to see how a populated collection looks before you build your own. If you prefer to run from source, the README's compile instructions are cargo run and cargo run -- -h, with cargo build --release for a release build.

Where ATAC is the wrong tool

The feature table in the README is honest about scope, and the TODO sections are the most useful part of it. WebSocket and GraphQL support are listed under TODO v1.0.0, not under Current. If your work is mostly GraphQL, or you need to hold a WebSocket open and watch frames arrive, ATAC will not do it yet, and no amount of terminal enthusiasm changes that.

The account-less design cuts both ways. Because there is no server component, there is no team workspace, no environment sync across machines, and no hosted runner for scheduled requests. You get whatever you put in local files and whatever your own sync mechanism provides. Teams that currently rely on Postman's shared workspaces would be trading a managed feature for a git repository of request definitions, which is a real migration, not a drop-in swap.

There is also a packaging wrinkle worth knowing before you file a bug. The Cargo.toml exclude list contains "exemple_resources" while the repository directory is named example_resources. The exclude entry therefore does not match the actual path, which means the examples directory is not excluded from the published crate. It is a small inconsistency, but it is the kind of thing that surfaces when you inspect what cargo package actually bundles.

How ATAC differs from Bruno and from Postman

Bruno is the closest comparison, because it also positions itself against account-bound clients and stores collections locally. The difference is the interface: Bruno is a desktop application, ATAC is a TUI. If you work on a remote host over SSH, ATAC runs where the code runs and Bruno does not, unless you forward a display. If you want a window with a mouse, Bruno is the more direct answer.

Postman and Insomnia are the other reference points the README names. Both offer hosted collaboration and both are heavier: Postman is an Electron application, Insomnia likewise. ATAC's counter-argument is that a request is just an HTTP call, and an HTTP call does not need a browser engine. The README's comparison table marks ATAC as covering collection management and the standard HTTP methods, which is the overlap that matters for day-to-day use.

One practical distinction is the dependency posture. ATAC uses rustls rather than linking the system TLS stack, and it deliberately disables reqwest's default features in favour of an explicit list. That produces a self-contained binary, which is why the project can ship a musl-based Docker image built with cargo-zigbuild for both linux/amd64 and linux/arm64. A client that links fewer system libraries is easier to drop onto a stripped-down container or a remote box.

Licence, maintenance and the cost of upgrading

ATAC is MIT licensed, and the Cargo.toml declares the same. MIT is permissive: you can use, modify and redistribute it, including in commercial settings, provided the copyright notice and permission notice are preserved. That is the general shape of the licence, not legal advice for your situation; if you are vendoring the code into a product, have someone qualified read the actual LICENSE file in the repository.

The maintenance signal is straightforward. The repository is not archived, and the last push was on 2026-09-03, the same day v0.23.1 was released. The release cadence visible in the release history is uneven: v0.22.1 in October 2025, v0.23.0 in February 2026, then v0.23.1 in September 2026. The project is between 0.x and 1.0, and the README itself frames WebSocket and GraphQL as pre-1.0 work, so expect the interface and the feature set to keep moving.

Upgrade cost is low if you install through a package manager, since brew, scoop, pacman and dnf all handle the version bump. If you build from source, note that the crate pins exact dependency versions with = in Cargo.toml, for example reqwest = "=0.13.2" and ratatui = "=0.30.0". Exact pins make reproducible builds but mean you cannot pick up a transitive fix without the maintainer publishing a new release. With a Rust version floor of 1.90, an older toolchain will fail the build rather than warn.

Editorial conclusion

Adopt ATAC if you already live in a terminal and want request collections stored as local files with no account and no sync service. Skip it if your team depends on shared cloud workspaces, or if you need WebSocket and GraphQL support today, since the README places those under TODO v1.0.0. Before committing, install it with cargo install atac --locked, confirm your Rust toolchain is at least 1.82, and open an existing collection from example_resources/ to check that the tree and request panes behave the way your workflow needs.

Frequently asked questions

Official sources

1. Julien-cpsn/ATAC on GitHub
2. License: MIT
3. Project website
4. README
5. Releases