atuin.sh

What is Atuin?

Atuin is a shell-history tool that makes your terminal searchable and portable. It records the commands you run across machines, syncs them (optionally), and lets you search by rich context instead of scrolling through a flat history file. Atuin

What it actually does

• Better history search. Instead of plain reverse-search, you can find commands by text, directory, exit code, duration, or hostname. Useful when you remember where you ran something but not the exact wording.
• Sync across machines. Your history follows you between laptops and servers, so a command you figured out on one box is available on another.
• Encryption and self-hosting. History is encrypted on the client before syncing, and the sync server is open source if you'd rather run your own infrastructure.
• AI in the prompt. Atuin AI ships with the normal install and is opened by typing ? on an empty prompt. It can read shell context (recent commands, exit codes, directories) and suggest commands you can insert or run. It's described as free during testing.

It installs via a shell script and supports macOS, Linux, and Windows, with bash, zsh, fish, and others.

Who benefits most

If you mostly work on one machine with a short history, the gains are smaller; the sync and search features matter most at scale.

A practical next step

Install it, run a few commands, then try searching by directory — for example, find the last command you ran in a specific project folder. That single test tells you quickly whether contextual search fits how you work. If you want AI help, type ? on an empty prompt and ask why a recent command failed.

How does Atuin keep my shell history private and secure?

Atuin keeps shell history private by encrypting it on your machine before it ever leaves your computer. The sync service stores encrypted data it cannot read, and if you would rather not use the hosted service at all, the sync server is open source and can be self-hosted on your own infrastructure.

What that means in practice

• Client-side encryption: History is encrypted locally, so the remote copy is not plain text. This matters if you sync across a work laptop, a home desktop and a server, because a breach of the sync service would not directly expose your commands.
• Self-hosting option: If your threat model or compliance rules require it, you can run the sync server yourself and keep history entirely within your own network.
• Search stays useful: Encryption does not prevent rich local search. Atuin lets you find commands by text, directory, exit code, duration and hostname, so the privacy design does not cost you the main convenience.
• AI context is a separate consideration: Atuin AI can use shell history, command output, exit codes and directories as context. That is powerful for debugging, but it means deciding whether you are comfortable sending that context to an AI service, especially if your history contains secrets or proprietary paths.

A practical decision rule

If your history is mostly personal projects, the default encrypted sync is a reasonable balance of convenience and privacy. If your history regularly contains credentials, customer names or internal hostnames, self-hosting the sync server is the safer default, and you should review whether AI features need access to that same context.

Next step

Install Atuin once and test sync between two machines with a throwaway set of commands. Then check whether your shell history contains anything you would not want a third party to process, and choose hosted sync or self-hosting based on that answer.

For background on the project, see Atuin.

Can I sync my shell history across multiple machines with Atuin?

Yes. Atuin's core purpose is syncing, searching and backing up shell history across machines, with history encrypted on your side before it leaves the machine. Install it on each computer, sign in to the same account, and your command history follows you between them. The project also says the sync server is open source, so you can self-host if you would rather keep the infrastructure in-house.

It works on macOS, Linux and Windows, and supports common shells including bash, zsh and fish.

What syncing actually gives you

• Cross-machine recall: a command you ran on a work laptop is searchable on a home desktop.
• Richer search than Ctrl+R: filter by text, directory, exit code, duration or hostname, not just a fuzzy string match.
• Backup: history survives a wiped or replaced machine once it has synced.
• Privacy by default: encryption happens client-side, so the sync service stores ciphertext rather than readable commands.

A concrete scenario

You debug a failing container on your desktop, then move to a laptop. Instead of retyping the command, you search your history for the directory you were in and the non-zero exit code, find the exact invocation, and rerun it. That is the workflow the feature is built around.

Trade-offs to weigh

• Syncing means your command history exists somewhere beyond the local machine, even if encrypted. If your history contains secrets typed inline, treat that as a real risk.
• Search is only as good as your history; noisy, repetitive commands can make results harder to scan.
• If you want full control, self-hosting adds setup and maintenance work.

Next step

Install Atuin on one machine, confirm that search behaves the way you want, then add a second machine and check that a command run on the first appears on the second. If it does, roll it out to the rest of your machines. For an alternative approach, compare with Fig, though Atuin's focus is history sync rather than terminal autocomplete.

How do I search my shell history in Atuin?

Atuin replaces the standard reverse-search with a full-screen, context-rich history browser. Press Ctrl+R in your shell to open it, type any part of a command, and you get a list you can arrow through. Unlike the bare Ctrl+R built into bash or zsh, the results carry metadata — the directory you ran the command in, its exit code, how long it took, and which host it came from — so you can tell two similar-looking commands apart.

Ways to narrow a search

• Text matching: type a fragment of the command; the list filters as you type.
• Filters: restrict by directory, exit code, duration, or hostname when you want only commands that ran in a particular project folder, or only the ones that failed.
• Context display: each entry shows the working directory and timestamp, which is what makes the filter-by-directory approach practical rather than guesswork.

Once you have found the command, you can edit it before running rather than executing it blind — useful when the command is almost right but the branch, tag, or path has changed.

A concrete workflow

You are in ~/src/api and half-remember the exact kubectl invocation you used to tail logs last week. Open Ctrl+R, type kubectl logs, then filter to this directory. The matching entry shows the deploy name and how long ago it ran, so you confirm it is the right one and press the key to insert it. You adjust the pod name and run it.

What to weigh

The search only helps if your history is actually there. If you work across several machines, syncing is what makes the same history searchable everywhere, and Atuin encrypts history client-side before it leaves the machine, with a self-hostable sync server if you would rather run your own. If you never leave one computer and only ever search for the last few commands, the built-in Ctrl+R is already sufficient and Atuin adds a layer you may not need. Atuin is available for macOS, Linux, and Windows and supports bash, zsh, fish, and others, so the install path is short if you decide to try it.

What can Atuin AI do inside my terminal?

Atuin AI is a helper that lives inside the shell you already use, rather than a separate chat app or browser tab. According to the Atuin site, it ships with the normal Atuin install, and you open it by typing ? on an empty prompt. It can then use your shell context — command output, exit codes, directories and shell history — to answer questions, suggest commands, and let you run or insert a suggestion with a single key. Atuin's page also says it can run bash for context and flags dangerous commands before they run.

H3 Practical example You run docker compose up and get bind: address already in use. Instead of copying the error into a search engine, you type ? and ask why it failed. Atuin AI reads the failed command, its exit code and the error text, then explains that a local Postgres is holding the port and suggests stopping it before retrying. You can execute the suggested command or insert it into the prompt to edit first.

H3 Where it fits and where it doesn't

• Good fit: debugging a failed command, recalling how you ran something before, turning a vague goal into a concrete command, or working on a remote machine over SSH where opening a browser is awkward.
• Weaker fit: tasks needing a full editor, large file diffs, or long multi-step project work. A terminal prompt is a narrow surface, and the page describes quick, context-aware help rather than a full coding environment.
• Watch the trade-off: letting a tool read shell history and command output is powerful but sensitive. Atuin says history is encrypted client-side and can be self-hosted, but any AI feature that reads context is worth reviewing against your own rules about secrets, tokens and production output.

H3 Next step Install Atuin, run a command that fails, then type ? on an empty prompt and ask about that specific failure. If the answers are useful, decide whether you are comfortable with the context it reads; if not, keep Atuin for encrypted history sync and skip the AI prompt. You can start at Atuin.

Can I self-host the Atuin sync server?

Yes. Atuin's sync server is open source, and the site explicitly points people to self-hosting as the alternative to using the hosted sync service. Your shell history is still encrypted client-side before it leaves a machine, so a self-hosted server stores ciphertext rather than readable commands.

H3 What self-hosting changes

• Where history lives: on infrastructure you control, instead of Atuin's servers.
• Who operates it: you, including updates, backups, TLS and availability. A self-hosted server that goes down means no syncing between machines until it's back.
• What stays the same: the local client experience — searching history by text, directory, exit code, duration or hostname, and the keyboard-driven recall shown on the site.
• Encryption model: client-side encryption is described as the default, so the server is not a place to read or mine your history. Still treat your encryption key as the thing that actually protects the data.

H3 A practical scenario

Say you work across a laptop and a remote build box and don't want command history — which can contain hostnames, internal paths or tokens pasted by mistake — sitting with a third party. You run the sync server on a small VPS or a home machine, point each Atuin client at it, and get cross-machine history search without changing your shell workflow. The trade-off is real: you now own uptime and backups, and if you lose the server and your key material, recovery is on you.

H3 Deciding

• Choose hosted sync if you want zero maintenance and are comfortable with encrypted data on someone else's infrastructure.
• Choose self-hosting if policy, residency or preference requires your own server, and you can maintain it.
• Check the official docs for current server setup steps and client configuration before committing: Atuin.

One caution worth applying generally: encryption protects the contents, but metadata such as timestamps, hostnames and record counts may still be visible to whoever runs the server. If that matters, self-hosting is the stronger option.