7 Ways to Make Your Linux Terminal Look Awesome

If you spend hours in the Linux terminal, it deserves to look and feel great. The default one gets the job done, but it’s not exactly inspiring or efficient. Over time, I’ve found that with a few clever tweaks, your terminal can look amazing and make you faster at everything you do.

Making your Linux terminal look awesome means upgrading to a modern emulator, using better colors and fonts, switching to a feature-rich shell like Zsh, and adding tools and plugins that boost both appearance and productivity.

In this article, I’ll show you how to build a clean, powerful terminal setup — one that looks sharp, runs fast, and actually helps you get more done. Whether you code, manage servers, or love a polished setup, this guide will transform your workspace.

Install a Modern Terminal Emulator

The first step to make the rest of our tasks easier is to install a good terminal emulator. By default, Ubuntu comes with Gnome Terminal. It is a good terminal emulator. However, there are better alternatives available.

Modern terminal emulators like Alacritty, Kitty, Tilix, WizTerm, Terminator, or Warp support GPU rendering, ligatures, transparency, and fast performance.

For this guide, we will be using Kitty. It’s a fast, customizable, open-source GPU-based terminal emulator with excellent documentation.

Before installing anything, let us first ensure our system is up to date. You can do so on Ubuntu, using the command:
sudo apt update && sudo apt upgrade -y

Now we can install Kitty using the command:
sudo apt install kitty

By default, when you launch Kitty, it might seem like a downgrade from the Gnome Terminal. But worry not—we will modify and theme it to make it more aesthetically pleasing and more productive than Gnome Terminal.

Even out of the box, Kitty offers a ton of improvements over the default terminal emulators. For example, you can open multiple tabs and split each tab into various windows (like a tiling window manager).

Kitty is primarily a keyboard-centric terminal emulator that offers a wide range of keyboard shortcuts. You can read more about them on their documentation page.

Having installed Kitty as the terminal emulator, we are now ready to configure and customize it.

Related: 11 Little-Known Terminal Tricks Every Linux User Should Try

Customize Colors and Fonts

The first step in customizing our terminal emulator is to change colors and font settings to make it more aesthetically pleasing. Appropriate font and color choices significantly enhance the visual appeal of your terminal.

Suppose you are using the default terminal emulator and have not installed Kitty. In that case, you can follow this tutorial on how to edit the font and other appearance settings in a Linux terminal.

To change the color theme of Kitty, you can run this command in your Kitty terminal:
kitten theme

I chose Adwaita’s darker theme, but you can choose whatever theme is the most aesthetically pleasing to you.

Press M to modify the configuration files to reflect the changed themes.

Next, we need to change the font used in our terminal emulator. For this, we need to manually make changes to the configuration files. To do so, open ~/.config/kitty/kitty.conf in any text editor (e.g., Nano).

Change the following settings as per your preference:

In addition to these changes, I recommend the following changes as well:

There are numerous configuration and theming options available through the Kitty configuration file. You can consult their documentation to explore all available options.

Once you have made the configuration changes, reload Kitty to preview them.

As you can see, our terminal emulator already looks much more aesthetically pleasing. You can tweak and tune these customizations as per your preference to achieve the desired result.

Upgrade Your Shell

Your shell is the program that sits between your computer and you. When you type in a command, it is the shell that interprets these commands and instructs the computer to carry out the requisite instructions. It then provides the computer’s response.

The default shell in most Linux distributions is Bash. While Bash is good enough for most tasks. However, it hasn’t changed in many years. It is plain (no colors, no smart suggestions, etc.).

There are two main alternatives to Bash: Zsh or Fish. The following is a brief comparison of the three shell options:

Feature	Bash	Zsh	Fish
Ease of Use	Basic, no visual feedback	Familiar, but more powerful	Very beginner-friendly
Autocomplete	Basic (Tab cycles options)	Smart + history-based suggestions	Context-aware + inline suggestions
Syntax Highlighting	❌ No	✅ With plugin (zsh-syntax-highlighting)	✅ Built-in
Autosuggestion	❌ No	✅ With plugin (zsh-autosuggestions)	✅ Built-in
Plugin Ecosystem	Sparse	Huge community (themes, plugins)	Smaller, but simpler
Scripting Compatibility	Most scripts are Bash-based	Fully compatible with Bash	Mostly compatible, but the syntax differs
Out-of-the-Box Experience	Plain	Plain (needs setup)	Beautiful defaults
Best For	Legacy setups, scripting	Power users, developers	Casual users, newcomers

Related: Bash vs Python on Raspberry Pi: When to Use One or the Other

For this tutorial, we will be using Zsh.

Installing Shell (Zsh)

You can install Zsh using this command:
sudo apt install zsh

Once installed, you can change your default shell using the command:
chsh -s $(which zsh)

On first start, zsh will automatically detect that you don’t have a .zshrc file and offer options to create one.

You can opt to customize your Zsh setup using this menu. However, since we plan to use a custom framework and theme (which will override these configurations), we chose 0.

Installing the Shell Framework (Oh My Zsh)

Zsh, with its default configuration, is an upgrade on Bash. However, we can take it one step further by installing the custom framework Oh My Zsh (OMZ). OMZ adds a ton of new features and also makes the zsh configuration much more straightforward.

You can install OMZ using the command (make sure curl and git are installed):
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

OMZ adds a ton of aliases to improve productivity. You can see all the available aliases using the command:
alias

Your Zsh is now initialized with optimal defaults, and you can verify its features and functionality to see the differences between Bash and Zsh (try auto-completing a half-typed command).

Installing the Shell Theme (Powerlevel10k)

To complete the setup of our shell, we need to install an appropriate theme. OMZ comes prepacked with a bunch of themes; you can check all the available themes on their GitHub page.

You can also download and install other themes. For example, we went with Powerlevel10k.

To do so, first clone their git repository using the command:
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ~/.oh-my-zsh/custom/themes/powerlevel10k

Now, to change the theme to Powerlevel10k, change these lines in ~/.zshrc file:

Restart your terminal emulator.

On first start, you will be greeted with this configuration screen:

Follow the prompts based on what is displayed on your screen.

The configuration will guide you through the various available customization options. Choose based on your preference.

You can redo this configuration at any time later as well, using the command: p10k configure

Once the configuration is complete, you will be welcomed to your very aesthetic and functional Zsh prompt.

Before:

After:

Congratulations —you have changed your shell from Bash to Zsh and configured it with optimal defaults and a beautiful theme. Now we can continue adding tools to improve productivity.

Add Useful Plugins & Tools

The true potential of using a custom shell like Zsh is unlocked when you install custom plugins. There are numerous plugins you can install to improve your productivity. Here, we will discuss two plugins that I think are must-haves.

zsh-autosuggestion

This plugin provides real-time suggestions as you are typing. If you agree with the suggestion, you can press the → key to accept the suggestion.

To install zsh-autosuggestion, clone it from its Git repository using the command:
git clone https://github.com/zsh-users/zsh-autosuggestions.git "$ZSH_CUSTOM/plugins/zsh-autosuggestions"

Now you can enable this plugin by editing the ~/.zshrc file to add the following lines.

Now restart your Zsh session and try typing a command to see the autosuggestion.

zsh-syntax-highlight

This is another plugin that can help you improve your Linux terminal experience. It identifies and indicates syntax errors in your commands. This can be an excellent tool for both beginners and experts.

To install zsh-syntax-highlight, clone from their Git repository using the command:
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git "$ZSH_CUSTOM/plugins/zsh-syntax-highlighting"

Now follow the same procedure as before and edit the ~/.zshrc file to add this plugin as well.

With this plugin installed, whenever you make a syntax error in your command, it will turn that command red (commands with correct syntax are shown in green).

These two plugins can significantly enhance your terminal experience. Instead of making typos and pressing enter to realize that you have made a syntax error, you can catch and correct your mistake promptly, and using autosuggestions, you no longer need to remember or type long commands.

There are numerous other plugins for Zsh + OMZ that you can explore. You can explore all the available plugins on their GitHub page. You can install any plugin that you fancy using the same steps.

Upgrade Core CLI Tools

Now that we have Zsh fully set up and learned how to install plugins, we can move on to other commonly used CLI Tools. CLI Tools such as cat, ls, grep, etc, form the core Linux Terminal experience.

However, there are better alternatives to these tools that can significantly improve your productivity and experience. Let us walk through them one by one:

bat → a better cat

bat is a cat clone with added features: syntax highlighting, Git integration, and line numbers. It makes reading code and config files far more pleasant.

You can install bat using the command:
sudo apt install bat

Before:

After:

From the screenshots above, you can clearly see that the bat is a significant upgrade over the conventional cat.

To avoid having to remember a separate command for this, you can add this alias to your ~/.zshrc file.
echo "alias cat='batcat --style=plain --paging=never'" >> ~/.zshrc

You can read more about other command-line parameters and styling options available on their GitHub page.

eza→ a better ls

eza is a fork of exa that can replace ls with color, icons, and Git-aware directory listings. You can install eza using the command:
sudo apt install eza

Now you can install eza for a better and more informative alternative to ls.

To replace the default ls, you can add this alias to your ~/.zshrc file.
echo "alias ls='eza --icons=always --group-directories-first'" >> ~/.zshrc

Other Alternatives

As above, there are several alternatives to standard CLI tools that can significantly enhance your experience. To avoid repetition, here is a tabulated list of all the other options:

Default Tool	Alternative	Demo Image
grep	ripgrep(rg)
find	fd (fdfind on Debian)
top	btop
df	duf
ping	gping

You can install these programs with apt, then set aliases in ~/.zshrc to avoid having to remember alternate commands.

Related Article: 50 Most Useful Linux Commands You Need To Know (Cheat Sheet)

These tools can supercharge your terminal experience. While aesthetically pleasing and eye-catching, these tools often improve productivity and are more user-friendly than their default counterparts.

Supercharge Navigation & Search

One key nuance of using the Linux terminal is that searching and navigating require you to name and spell directories and file names correctly. It can feel a bit clunky at times and is not very intuitive.

However, we can change this by installing a handful of innovative tools and integrating them into our shell.

First, install these packages:
sudo apt install -y fzf zoxide ripgrep fd-find bat

Now we can combine these tools to supercharge our navigation and search behavior in our terminal.

Smart Navigation (Jump Anywhere)

Zoxide allows us to improve our navigation method. It memorizes our navigation history and, based on that, jumps directly to a directory (you no longer need to add the full path).

To integrate it into our Zsh, we can add this configuration to the end of our ~/.zshrc file and reload the Zsh:

eval "$(zoxide init zsh)"
alias cd='z'        # optional
alias ..='z ..'     # optional

Now, the behavior of our cd command will change. It will automatically remember the directories we have visited and jump to them directly without requiring the complete path.

Instant Fuzzy Lists for Files/Directories

fzf, when combined with fd-find, lets us build a smart file and directory finder with fuzzy search. To implement it, add this configuration to the end of your ~/.zshrc file:

export FZF_DEFAULT_COMMAND='fdfind --type f --hidden --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"
export FZF_ALT_C_COMMAND='fdfind --type d --hidden --exclude .git'

This gives us two keyboard shortcuts:

Alt + C to do a fuzzy search of all directories and jump to it.

Ctrl + T to do a fuzzy search of all files and directories, and insert it into the command that you are typing.

Fuzzy Command Search & Auto Completion

We can also use fzf for auto-completion and command search functions in our Zsh terminal. We can integrate it into our ~/.zshrc file by adding these lines towards the end of the configuration:

if [[ -f /usr/share/doc/fzf/examples/key-bindings.zsh ]]; then
  source /usr/share/doc/fzf/examples/key-bindings.zsh
fi
if [[ -f /usr/share/doc/fzf/examples/completion.zsh ]]; then
  source /usr/share/doc/fzf/examples/completion.zsh
fi

Now, when we reload our terminal and press Ctrl + R, we get a fuzzy search for command history.

Fuzzy Search Inside Files

We can also combine fzf, ripgrep, and batcat to create a script that performs a fuzzy search for keywords across all files, allowing us to choose which file to open to the line where the keyword was found.

It can be handy if you do a lot of code editing on your Linux machine.

To implement it, add this function to your ~/.zshrc file:

rgf() {
  [[ -z "$*" ]] && { echo "Usage: rgf <pattern>"; return 1; }
  local sel file line
  sel="$(
    rg --no-heading --line-number --color=never \
       --hidden --no-messages \
       --glob '!.git/*' \
       "$@" . \
    | fzf --ansi --delimiter=: \
          --preview 'sh -c '"'"'
            file="$1"; line="$2"; before=15; after=200
            start=$(( line - before )); [ "$start" -lt 1 ] && start=1
            end=$(( line + after ))
            if command -v batcat >/dev/null 2>&1; then
              batcat --style=numbers --color=always --line-range="${start}:${end}" --highlight-line "${line}" "$file"
            else
              sed -n "${start},${end}p" "$file"
            fi
          '"'"' sh {1} {2}' \
          --preview-window='right,60%,border-left'
  )" || return
  file="${sel%%:*}"
  line="${sel#*:}"; line="${line%%:*}"
  "${EDITOR:-nano}" "+${line}" "$file"
}

Now, when you enter the command rgf, you will get a fancy fuzzy search with previews and the option to open the file at exactly the line where the keyword was found.

In fact, these are only a few examples; if you know your way around scripting, then you can create numerous similar functions tailored to your personal use case scenario. For example, read this guide for more ideas on how to improve the file-finding capability of your terminal using fuzzy find.

Install and Configure Tmux

One significant nuance of the default Linux terminal is that if you accidentally or intentionally kill a terminal, you lose its history and control over all the processes running in it. This has happened to me many times when I ran an apt command and accidentally killed the terminal.

Tmux is a terminal multiplexer — a program that runs between your shell and your terminal emulator.

It allows you to manage multiple terminal panes and sessions inside a single window. When you close your terminal emulator, the tmux session continues running in the background, and you can later reattach to it — even from a different terminal or over SSH.

You can install tmux using the command:
sudo apt install tmux

Now you can start a new tmux session using the command:
tmux

At any time, you can see what tmux sessions are running and which session is currently attached using the command:
tmux list-sessions

And you can switch to a different session using the command:
tmux switch -t <Session Name or Number>

We can integrate it into our Zsh shell so that whenever we start our terminal emulator, it automatically creates a session named “main” and if this session already exists, it only attaches to that session.

To do so, you can add the following lines to your ~/.zshrc file:

# Auto-start or attach to a tmux session when launching a terminal
if command -v tmux &> /dev/null; then
  # Skip if already inside tmux
  if [ -z "$TMUX" ]; then
    tmux attach -t main 2>/dev/null || tmux new -s main
  fi
fi

Now, using this, we can close and open our terminal whenever we want, and the running processes and history will be maintained.

You can also use the resurrect and continuum plugins for tmux to make this persistent across reboots.

Tmux is a powerful program, and the functionality we demonstrated only scratches the surface of what it can do. For example, you can create multiple sessions for each working environment — e.g., working, studying, etc. — and smoothly switch between them.

Tmux creates a separation between your terminal emulator and the actual shell, making it a must-have tool for all power Linux terminal users.

Bonus Tip: Add a Lightweight Terminal Dashboard

If you have followed the above steps, you have successfully configured your Linux terminal to look awesome while also increasing its productivity. One additional thing we can do for our terminal is to display a nice landing screen whenever it loads.

We can do this using the software fastfetch.

First, install fastfetch using the command:
sudo apt install -y fastfetch

Generate the default config of fastfetch using the command:
fastfetch --gen-config

This command will generate a default configuration at ~/.config/fastfetch/config.jsonc. You can open and edit it as you prefer. I edited my configuration as shown below:

Finally, we can add this configuration to the bottom of our ~/.zshrc file:

# --- Dashboard on interactive shells ---
show_dashboard() {
  # Prefer fastfetch; fallback to neofetch; fail silently if neither exists
  if command -v fastfetch >/dev/null 2>&1; then
    fastfetch
  elif command -v neofetch >/dev/null 2>&1; then
    neofetch
  fi
}

# Only run on interactive shells, not within scripts/cron
if [[ $- == *i* ]]; then
  # Avoid spamming in tmux: show only on the first window/pane
  if [[ -z "$TMUX" ]]; then
    show_dashboard
  else
    # inside tmux: only show on window 0, pane 0
    if tmux display -p '#{window_index}-#{pane_index}' 2>/dev/null | grep -qx '0-0'; then
      show_dashboard
    fi
  fi
fi

Now every time you start your terminal, you will be greeted with this welcome dashboard.

Related: 13 Linux Terminal Shortcuts You’ll Wish You Knew Earlier

With a modern emulator, tuned colors/fonts, Zsh + plugins, smarter search/navigation, upgraded CLI tools, tmux persistence, and a fastfetch dashboard, your terminal now looks sharp and works faster. Start with the pieces you’ll use every day and iterate.

Minor tweaks add up; soon, the terminal becomes a place you actually enjoy opening.

Whenever you're ready, here are other ways I can help you:

Master Linux Commands: Overwhelmed with Linux commands? This book is your essential guide to mastering the terminal. It includes practical tips, real-world examples, and a bonus cheat sheet to keep by your side.

The RaspberryTips Community: Need help with Linux or want to chat with people who actually get it? Join the RaspberryTips Community and get access to private forums, exclusive lessons, and direct support (try it for just $1).

You can also find all my recommendations for tools and hardware on this page.