Most Linux users benefit from GNU Readline without realizing it. It is the library responsible for Bash's interactive command-line editing, providing familiar features like cursor movement, command history, and basic tab completion.
While Readline is highly configurable, Readline's completion remains relatively simple out of the box.
I came across a new tool called Flyline that takes Bash command completion to an entirely different level. No special configuration is required.
For anyone who has control over their shell environment, Flyline could become a must-have terminal tool.
Flyline takes a different approach entirely. Instead of layering on top of Readline, it replaces it outright. It is built in Rust and ratatui to render richer, more interactive terminal interfaces than Readline.
Exploring Flyline features
When I installed Flyline for the first time and started using it, the difference was immediately noticeable. Command suggestions appeared as I typed, making it quicker to complete commands and move through my workflow. It makes working in the terminal noticeably faster.
IntelliSense style autosuggestion
As soon as you start typing, Flyline displays a completion popup right next to the cursor with matching suggestions. This keeps the suggestions close to where you're working, making it easy to complete commands without breaking your typing flow.
Flyline IntelliSense Suggestion
You can cycle through the available suggestions by pressing the Tab key, with the selected entry being updated on the command line in real time. If you prefer, the Up and Down arrow keys work just as well, and the completion list can also be navigated using the mouse.
For longer lists, Flyline includes a functional scrollbar that lets you quickly jump through the available suggestions. Personally, I found it faster to keep typing and narrow down the results rather than reaching for the mouse, but it's nice to have the option.
Once you've found the suggestion you want, press Enter to insert it into the command line and close the completion popup.
Fuzzy search and path completion
Traditional command completion usually expects you to type characters in the correct order. For example, typing pamc won't normally suggest pacman, since the entered characters don't match the expected sequence.
Fuzzy Search
Flyline addresses this with fuzzy search support. Instead of requiring an exact character order, it tolerates minor typos and partial matches, making it much easier to find the command you're looking for. This means you can type a bit more naturally without worrying about getting every character in the right place.
The same fuzzy matching also works for file and directory paths. As you type, Flyline presents matching paths based on your input, allowing you to navigate deep directory structures with fewer keystrokes. I found this particularly useful when working with long or nested paths, where a small typo would normally require me to backtrack and start over.
Automatic completion synthesis (a lifesaver)
Not every command line tool ships with a completion script. Install a new CLI tool and you keep on pressing tab, and nothing happens. No suggestions appear.
When that's the case, Flyline can generate one automatically by parsing the command's --help output and available man pages.
I noticed this while trying ffmpeg, which didn't have a completion script on my system. When I typed:
ffmpeg --<Tab>
Flyline prompted me to generate a completion script for the command. After confirming, it analyzed the available documentation and created a completion definition on the fly. From that point onward, option completion for ffmpeg worked as expected.
Synthesize Suggestions
This is also useful for commands with dozens, or even hundreds, of available options. Instead of repeatedly opening the man page or running --help to look up an argument, I could simply rely on the generated completions and discover the available options as I typed.
It makes working with feature-rich command-line tools much more convenient.
Customize the cursor (for vanity)
This isn't exactly a productivity feature, but it does make the terminal feel a bit more lively.
If you've used the Kitty terminal emulator, you might be familiar with its cursor animations. Flyline brings similar effects to virtually any terminal emulator, letting you customize how the cursor looks and behaves.
To explore the available cursor options, run:
flyline set-cursor --help
This displays the various settings you can tweak, including cursor style and animation effects.
For example, the following command adds a cursor trail that closely resembles Kitty's animated cursor, even if your terminal emulator doesn't support it natively.
flyline set-cursor \
--backend flyline \
--style "#33ccff" \
--interpolate 1.5 \
--interpolate-easing out-elastic \
--effect fade \
--effect-easing in-out-sine \
--effect-speed 2.0
Cursor Trail Emulation
A refined shell history
Flyline also gives Bash's reverse history search a much nicer interface. Instead of the traditional incremental search prompt, it presents your command history in a dedicated view where you can see each command in full, search through previous entries, and even check when a command was executed.
Refined History
Just like command completion, history search also supports fuzzy matching. This makes it easier to find an older typed command, even if you don't remember the exact sequence of characters.
What impressed me the most, though, was the Canceled Commands feature. The first time I pressed Alt+R, the list was empty. However, every command I subsequently interrupted with Ctrl+C, was automatically added there.
Cancelled Commands
Remember, it is the commands that are interrupted without executing are added to the cancelled list, and not those commands that are executed and then pressed CTRL+C.
This list is kept separate from your regular shell history, so searching your normal command history with Ctrl+R remains unaffected, while cancelled commands are available through Alt+R. The only limitation is that the list is maintained per terminal session, so it is cleared once you close or reset the terminal.
Working with AI agents
Flyline can also work with your favorite AI assistant to turn plain English into executable Bash commands. Once you've configured an AI agent, you can simply describe what you want to do in natural language, and Flyline will ask the agent to generate the corresponding command.
For example, you could type something like:
ai: list files older than three days
Pressing Alt+Enter, or simply Enter if you've configured a trigger prefix such as ai:, sends the prompt to the configured AI agent. Flyline then displays the generated command with syntax highlighting before you decide whether to run it. If the agent returns additional information in Markdown, Flyline renders that as well.
I didn't test this feature personally. I will let you try and comment your experience with it.
Prompt customization
Flyline doesn't just enhance command editing, it also offers extensive prompt customization. You can build rich prompts with dynamic widgets, animations, left and right prompts, transient prompts, live time displays, and even your own custom widgets that run shell commands in the background.
The project's documentation goes into great detail, complete with examples and screenshots for the various customization options. Rather than covering each one here, I've put together a sample configuration that combines several of these features, including a subtle animation. Simply append the following to your ~/.bashrc to give it a try.
# 1. Create the animation widgets
flyline create-prompt-widget animation \
--name "SPINNER" \
--fps 12 \
'\e[38;2;137;180;250m⠋\e[0m' \
'\e[38;2;137;180;250m⠙\e[0m' \
'\e[38;2;137;180;250m⠹\e[0m' \
'\e[38;2;137;180;250m⠸\e[0m' \
'\e[38;2;137;180;250m⠼\e[0m' \
'\e[38;2;137;180;250m⠴\e[0m' \
'\e[38;2;137;180;250m⠦\e[0m' \
'\e[38;2;137;180;250m⠧\e[0m' \
'\e[38;2;137;180;250m⠇\e[0m' \
'\e[38;2;137;180;250m⠏\e[0m'
flyline create-prompt-widget animation \
--name "PULSE" \
--fps 6 \
--ping-pong \
'\e[38;2;166;227;161m●\e[0m' \
'\e[38;2;116;199;236m●\e[0m' \
'\e[38;2;203;166;247m●\e[0m'
# 2. Set prompt variables
PS1='\e[1;32m\u@\h\e[0m:\e[1;34m\w\e[0m\nSPINNER PULSE \e[1;35m❯\e[0m '
PS1_FILL='─'
RPS1='\e[38;2;249;226;175m\t\e[0m'
PS2='\e[2mFLYLINE_PROMPT_LINE_NUMBER ›\e[0m '
# 3. Set transient history cleanup
PS1_FINAL='\e[38;2;166;227;161m✔\e[0m \e[1;34m\w\e[0m \e[1;30m❯\e[0m '
RPS1_FINAL=''
PS1_FILL_FINAL=''
# 4. Enable cursor trail & motion
flyline set-cursor \
--backend flyline \
--style "#cba6f7" \
--interpolate 1.5 \
--interpolate-easing out-elastic \
--effect fade \
--effect-easing in-out-sine \
--effect-speed 2.0
Restart your terminal and enjoy the effects.
Custom animated Prompt
Install Flyline
The easiest way to install Flyline is by using the official installation script. Open a terminal and run:
curl -sSfL https://github.com/HalFrgrd/flyline/releases/latest/download/install.sh | sh
The installer downloads the latest release and automatically updates your ~/.bashrc to load Flyline, so there's no need to perform any additional setup manually.
Once the installation is complete, launch the interactive tutorial with:
flyline run-tutorial
I recommend going through the tutorial before you start using Flyline. It walks you through onboarding, making it much easier to get comfortable with the enhanced editing experience.
Is there anything similar for ZSH?
When I started using Flyline, apart from its intellisense style completion, I can't say it felt like a first in a lifetime moment, because I kind of used a similar functionality in ZSH for some time.
Flyline is designed exclusively for Bash, so you can't use it with Zsh.
But, the combination of zsh-syntax-highlighting, zsh-autosuggestions, and zsh-autocomplete covers many of the features you'd expect from an IntelliSense-like command-line interface.
Together, they offer inline suggestions, syntax highlighting, and interactive command completion that make working in the terminal much more comfortable.
ZSH Autosuggestion, Syntax Highlighting and Auto Complete
If you pair these plugins with a prompt framework like Starship or a Powerline-style prompt, you can build a polished and highly productive terminal environment.
Wrapping Up
Flyline is one of the new breed of terminal tools that are built in rust to be faster and provide features that either require too much config effort or not possible in classic GNU tools at all.
From intelligent command completion and fuzzy search to AI-assisted command writing and prompt customization, Flyline adds plenty of quality-of-life improvements without changing the shell you've grown accustomed to.
Give Flyline a try. It's already a capable tool, and with active development, it'll be interesting to see how it evolves in the future.
from It's FOSS https://ift.tt/69RLNWq
via IFTTT
