# IntelliShell, a searchable command library instead of a shell history

> IntelliShell is a Rust program that turns the commands you have run into a structured, searchable library with templates, aliases and tags, and it hooks into Bash, Zsh, Fish, Nushell and PowerShell alike. It can also ask a local or remote language model to write or repair a command, which is the part worth thinking about before you enable it.

**lasantosr/intelli-shell** — Like IntelliSense, but for shells

- Repository: https://github.com/lasantosr/intelli-shell
- Website: https://lasantosr.github.io/intelli-shell/
- Stars: 1,299 · Forks: 25
- Language: Rust
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/lasantosr-intelli-shell

## Beyond history search, a library you can browse

IntelliShell is described as a command template and snippet manager for your shell, and the README is explicit that it goes far beyond a simple history search, transforming the terminal into a structured, searchable and intelligent library of your commands. That framing matters, because history search answers the question of what you typed, while a library answers the question of what you want to run now, including the version of it with a different path or a different flag. The supported shells are Bash, Zsh, Fish, Nushell and PowerShell, with standalone binaries for Linux, macOS and Windows, so the tool does not assume you are on one operating system or one shell. The implementation is Rust, and the documentation is written as a book hosted alongside the project rather than as a README, which tells you the project expects a lot of configuration surface. The audience is a developer whose history has become a library of useful commands that nobody, including themselves, can hold in their head.

## Four hotkeys do the work in the shell line

The shell integration is deliberately small, and the four bindings in the command line are the whole interface. ctrl+space searches for a command, ctrl+b bookmarks the command currently typed, ctrl+l replaces the variables in the current command, and ctrl+x diagnoses and tries to fix a failing command, which requires the AI features to be enabled. Escape clears the current line, and that binding can be skipped by setting INTELLI_SKIP_ESC_BIND to 1, which matters for anyone who uses escape inside a heredoc or a line editor. The bookmarking binding is the entry point to the whole system, since the README's quick start has you type a command and press ctrl+b as the second step. The keybindings are configurable, and the documentation points at a page on shell hotkeys for the details, so the defaults are a starting point rather than a constraint.

## Inside the interface, and the choice between inline and full screen

Once an interface is open, the keys change, and they are worth memorising because the whole tool is used through them. Escape quits without making a selection or goes back, F2 with ctrl+u and ctrl+e edit the highlighted item, ctrl+d deletes it, enter and tab confirm a selection or move to the next step, ctrl+enter and ctrl+r execute the highlighted command immediately, and ctrl+x and ctrl+i prompt the AI when searching or creating commands. The immediate execution bindings are the sharp edge, since a highlighted command can be run without being typed out and reviewed, so a library that contains a destructive command becomes a hazard. The project answers that with a feature called visual destructive feedback, which highlights potentially destructive commands, configurable through tags or custom regular expressions. The interface itself is a choice between a non-intrusive inline mode and an immersive full screen TUI, and the configuration goes from themes to search ranking algorithms.

## Templates, aliases and the tricks that make it worth the setup

The value of the tool is in the small behaviours the README documents under tips. A command template carries variables written as double braces, so you bookmark cd with a path variable and fill it in on the fly, and the smart completion pulls variable suggestions from any command rather than a fixed list. Aliases are the multiplier, because you can pin different sets of favourite values for the same command, so a cd alias can hold your pinned folders and the search shows exactly those. Two more behaviours are genuinely clever. If your search query matches an alias it is autocompleted instantly, although the variable replacement UI still appears if the command has variables. And recalling the last command with the up arrow and then pressing ctrl+space brings back the original template rather than the literal string, ready for new values. A destructive command can be tagged or matched by a regular expression and the tool will flag it before it runs.

## Where the library comes from: tldr, gists, files and HTTP

A command library is only useful if it has content, and IntelliShell has several ways to get it. The first is TLDR integration, which fetches command examples from tldr pages and imports them; the Cargo manifest shows the tldr feature depends on git2. The second is import and export, which the README says can share your command library using files, HTTP endpoints or even gists, and the gists route is what a team uses to share a set of commands across people. The library is also workspace aware, automatically discovering and loading commands from the directory of the project you are in, which is a different model from a global list and quietly the more useful one for day to day work. Everything is Rust with the tldr and extra-features options on by default, and the vendored option groups a statically linked SQLite, OpenSSL and libgit2 so the binary carries its own dependencies.

## The AI features are the part to evaluate on privacy

The AI features are described as generating, fixing and importing commands with local or remote LLMs, and the README treats them as an optional extra you enable separately. Two paths lead there. With ctrl+x while searching, you describe what you want in natural language and the model writes the command, and with ctrl+x on a command that failed, the model analyses the command and the error message to suggest a working version. The local and remote distinction is the one that matters. A local model keeps the command text on the machine, while a remote one sends it somewhere, and for a shell tool whose library may contain credentials, hostnames and internal paths, that is a decision your organisation has to make rather than one to discover later. The feature set around it is broader than generation, since completions can also be drawn from imported commands, and the destructive command highlighting exists precisely because the tool can now propose commands you did not write yourself.

## Installing on Linux, macOS and Windows

The install step is a script fetched over the network, and the README gives one per platform family. For sh compatible shells on Linux, macOS and Windows, including Bash, Zsh, Fish, Nu and Git Bash, the command pipes the install script into sh.

```sh
curl -sSf https://raw.githubusercontent.com/lasantosr/intelli-shell/main/install.sh | sh
```

On Windows with PowerShell the script is a separate one, and the execution policy may need relaxing first, which the README marks as optional and only needed if scripts are disabled.

```powershell
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
irm https://raw.githubusercontent.com/lasantosr/intelli-shell/main/install.ps1 | iex
```

Windows also needs the Microsoft Visual C++ Redistributable for the application to run, and the README notes it as a requirement rather than an option. On every platform the installer updates your shell profile, and to skip that you set the INTELLI_SKIP_PROFILE environment variable to 1 before installing. The project is published to crates.io as intelli-shell with standalone binaries for the three operating systems, and the release history is steady, with v3.4.4 on 2026-06-23, v3.4.5 on 2026-06-26 and v3.4.6 on 2026-10-08, and the last push on 2026-10-15. The licence is Apache-2.0.

## Conclusion

IntelliShell fits a developer with a long command history and a lot of similar commands with different arguments, since the alias and template features turn those into one entry, and it fits a team that wants to share a command library through files, an HTTP endpoint or gists. It does not fit a shell user who wants nothing installed, and it does not fit an environment where a shell plugin that can rewrite and execute a command is unwelcome, because the AI features and the immediate execution bindings are opt in but present. Verify three things first: that your shell is one of the five supported and that the install script's profile edit is acceptable in your setup, since the installer rewrites shell profiles unless you set INTELLI_SKIP_PROFILE, and which language model the AI features talk to, because the project supports both local and remote models and the difference matters for what leaves your machine.

## FAQ

### What is IntelliShell?

It is a command template and snippet manager for your shell, written in Rust, that goes beyond history search by turning the commands you run into a structured, searchable library. It works on Bash, Zsh, Fish, Nushell and PowerShell, with binaries for Linux, macOS and Windows.

### How do I install IntelliShell?

On sh compatible shells run curl -sSf https://raw.githubusercontent.com/lasantosr/intelli-shell/main/install.sh | sh, and on Windows PowerShell run irm https://raw.githubusercontent.com/lasantosr/intelli-shell/main/install.ps1 | iex, possibly after Set-ExecutionPolicy RemoteSigned -Scope CurrentUser. Windows also needs the Microsoft Visual C++ Redistributable.

### What can IntelliShell do with AI features?

With the AI features enabled you can describe a command in natural language and have it written for you while searching, and you can have a failing command and its error message analysed so a working version is suggested. The README states the models can be local or remote, and the AI features have to be enabled separately from the installation.

### How does IntelliShell share a command library between people?

Import and export work with files, HTTP endpoints and gists, and the TLDR integration fetches command examples from tldr pages. The library is also workspace aware, discovering and loading commands from the directory of the project you are working in.

## Sources

- [lasantosr/intelli-shell on GitHub](https://github.com/lasantosr/intelli-shell)
- [License: Apache-2.0](https://github.com/lasantosr/intelli-shell/blob/main/LICENSE)
- [Project website](https://lasantosr.github.io/intelli-shell/)
- [README](https://github.com/lasantosr/intelli-shell/blob/main/README.md)
- [Releases](https://github.com/lasantosr/intelli-shell/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lasantosr-intelli-shell