“My terminal looks really bad, while some people have a really cool CLI starting page with their name etc. What should I do so mine looks cool too?”

If you’re spending a lot of time in your terminal, why not make it a pleasant and productive environment? A well-customized terminal can not only look cool but also boost your productivity. This guide will walk you through various ways to transform your bland terminal into a powerful and visually appealing workspace on Linux and macOS.

1. The Shell Prompt (PS1)

The shell prompt is the first thing you see. Customizing it can provide useful information at a glance.

Basic Customization

You can customize your prompt by modifying the PS1 environment variable in your shell’s configuration file (~/.bashrc for Bash, ~/.zshrc for Zsh).

For example, to show your username, hostname, and current working directory, you can add this to your config file:

export PS1="\u@\h:\w\$ "

Advanced Prompt Customization with Starship

For a more powerful and visually rich prompt, you can use tools like Starship. Starship is a cross-shell prompt that is fast, customizable, and works on Linux, macOS, and Windows.

Installation:

• Linux (and macOS with Homebrew):

  brew install starship
  

• Other Linux:

  curl -sS https://starship.rs/install.sh | sh
  

Configuration:

Add the following to the end of your ~/.bashrc or ~/.zshrc:

eval "$(starship init bash)" # for Bash
eval "$(starship init zsh)"  # for Zsh

Starship is highly configurable. You can find more information in the official documentation.

2. Terminal Emulators

The terminal emulator is the application you use to interact with the shell. While the default terminal emulators on Linux and macOS are functional, there are better alternatives with more features and customization options.

• iTerm2 (macOS): A powerful replacement for the default Terminal app on macOS. It offers features like split panes, search, and extensive customization.
• Alacritty: A fast, cross-platform, OpenGL terminal emulator.
• Kitty: A feature-rich and hackable GPU-based terminal emulator.

3. Color Schemes

A good color scheme can reduce eye strain and make your terminal more readable.

• Dracula: A popular dark theme for many applications, including terminals.
• Solarized: A theme with both light and dark variants, designed for readability.
• Nord: A clean and elegant theme with a focus on clarity.

Most terminal emulators have built-in support for changing color schemes. You can also find collections of themes online, like iTerm2 Color Schemes.

4. Fonts with Ligatures

Using a font designed for programming can improve readability. Fonts with ligatures combine multiple characters into a single symbol, which can make your code look cleaner.

• Fira Code: A popular free monospaced font with programming ligatures.
• JetBrains Mono: A free and open-source font for developers.
• Cascadia Code: A fun, new monospaced font from Microsoft that includes programming ligatures.

After installing a font, you’ll need to configure your terminal emulator to use it.

5. Cool CLI Tools

Here are some tools that can make your terminal more informative and user-friendly:

• Neofetch: A command-line system information tool that displays a logo of your OS along with system information.

  # macOS
  brew install neofetch
  
  # Linux (Debian/Ubuntu)
  sudo apt-get install neofetch
  

  Add neofetch to the end of your ~/.bashrc or ~/.zshrc to see it every time you open a new terminal.

• lsd or exa: Modern replacements for the ls command with more features and better defaults.

  # lsd (macOS)
  brew install lsd
  
  # exa (macOS)
  brew install exa
  
  # lsd (Linux)
  sudo apt-get install lsd
  
  # exa (Linux)
  sudo apt-get install exa
  

  You can alias ls to lsd or exa in your shell’s configuration file:

  alias ls='lsd'
  # or
  alias ls='exa'
  

• bat: A cat clone with syntax highlighting and Git integration.

  # macOS
  brew install bat
  
  # Linux
  sudo apt-get install bat
  

  You can alias cat to bat:

  alias cat='bat'
  

• zoxide: A smarter cd command that learns your habits.

  # macOS
  brew install zoxide
  
  # Linux
  curl -sS https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | bash
  

  Add the following to your ~/.bashrc or ~/.zshrc:

  eval "$(zoxide init bash)" # for Bash
  eval "$(zoxide init zsh)"  # for Zsh
  

Conclusion

By combining these tools and techniques, you can create a terminal environment that is not only beautiful but also tailored to your workflow. Experiment with different tools and configurations to find what works best for you. A personalized terminal can make your command-line experience much more enjoyable and productive.

HomeBrew

Homebrew is a package manager for macOS (and Linux) that lets you easily install, update, and manage software and developer tools from the command line.

# Installation command
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After running the command, restart your terminal, and you’re good to go. Before we start installing, let’s understand the difference between a “formula” and a “cask” in Homebrew.

Formula: Command-line tools, libraries, and languages (e.g., Kotlin, Go). No special flags are needed when using brew commands with formulas. All Formulas

Cask: GUI applications like Chrome, VSCode, etc. These require a --cask flag for brew operations. Cask Directory

brew install git             # Installing a formula
brew install --cask firefox  # Installing a cask

brew uninstall foo           # Remove a package
brew upgrade foo             # Upgrade a specific package
brew list                    # See all installed packages
brew search foo              # Find available packages
brew info foo                # Get details about a package
brew update                  # Update Homebrew's package list
brew upgrade                 # Upgrade all outdated packages

🔗 HomeBrew-Official

Ollama - Local and OpenSource LLMs

This is an incredibly useful tool that I find myself using constantly. Local models are fantastic for answering general or timeless questions where you need accuracy without requiring up-to-the-minute data. They’re fast, private, work offline, and have another big advantage: 🌱 a reduced environmental impact.

Instructions:

1. Install Ollama by running the official script in your terminal. If you prefer, you can also download it manually from the official site.

   curl -fsSL https://ollama.com/install.sh | sh
   

2. Browse the Model Library to find a model. Keep an eye on the size, as some models can be several gigabytes.
3. Once you’ve picked a model, pull it using the pull command. For example, to get the Llama 3 model:

   ollama pull llama3
   

4. After the download is complete, you can run the model to start a chat session. To exit, just type /bye.

   ollama run llama3
   

That’s it! Now, anytime you have a question, you can just run ollama run <model_name> to interact with your local LLM.

Here is an example of how you can download and run another model in one line:

ollama pull mistral && ollama run mistral

🔗 Ollama

Gemini-cli

Gemini CLI is an open-source tool that brings the power of Google’s Gemini models directly into your terminal. It provides lightweight, direct access to the API, making it a versatile utility for a wide range of tasks, from coding and content generation to problem-solving and research.

Installation

1. Ensure you have Node.js (version 18+). You can check with node -v. If you don’t have it, install it with Homebrew:

   brew install node
   

2. Install the Gemini CLI globally using npm:

   npm install -g @google/gemini-cli
   

3. Run the setup and authentication command:

   gemini
   

   Follow the prompts to choose a theme and log in with your Google account.

Troubleshooting Tip: On some systems, the authentication flow in the terminal might not complete. If this happens, run gemini again, and then check your default web browser for the Google authentication page to complete the login.

⚠️ Unlike Ollama, only the tool is open-source, not the model. Your prompts and data will be processed by Google’s servers.

⚠️ The free tier has a rate limit (e.g., 60 requests per minute). You can upgrade to a paid plan to overcome this.

Common Commands

• /chat save <name>: Saves your current chat with a memorable name.
• /chat list: Lists all your saved chats.
• /chat resume <name>: Resumes a saved chat session.
• /compress: Replaces the current chat context with a summary to save tokens.
• /auth: Manages your authentication settings.
• /quit or /exit: Exits the tool.

Switching to Shell Mode

You can input ! to toggle shell mode. For example, type !pwd to see your current directory. The theme will change to indicate you’re in shell mode. To return to the chat, just input ! again.

Providing Context

Use the @ symbol to provide file or directory context for your prompts.

• @path/to/your/file.txt Explain this text file.
• @src/my_project/ Summarize the code in this directory.

You can find more commands in the official documentation.

Gemini CLI-Github repo

DuckDuckGo

Sometimes you just need to verify things quickly with a search engine. ddgr brings the DuckDuckGo search engine to your CLI, delivering fast results.

# Installation
brew install ddgr

Common Commands

These are the commands you’ll likely use most often:

navigation Commands

When results are displayed, you can use these keys to navigate:

Here’s an example I use extensively:

# Shows 5 results from GitHub for "awesome shell scripts"
ddgr -n 5 -w github.com "awesome shell scripts"

Profile Configuration

You can customize ddgr’s default behavior by editing the ~/.ddgrrc file (vi ~/.ddgrrc). Here are some of the options you can configure:

🔗 ddgr-Repo

Git CLI

brew install git

I’m sure you’re familiar with the basic git commands, but you can create powerful aliases to make your workflow faster. For example, you can run git st instead of git status.

1. Find your global git config file by running git config --list --show-origin.
2. Open that file (e.g., vi ~/.gitconfig) and add your aliases.

Here is an example ~/.gitconfig file:

[credential]
    helper = store
[user]
    name = Eganathan R
    email = md-email@gmail.com
[filter "lfs"]
    smudge = git-lfs smudge -- %f
    process = git-lfs filter-process
    required = true
    clean = git-lfs clean -- %f
[init]
    defaultBranch = master
[http]
    proxy = http://127.0.0.1:xxxx
[alias]
    st = status
    co = checkout
    br = branch
    ci = commit
    lg = log --oneline --graph --decorate # Pretty and compact log view

Podman (Optional)

Podman is a powerful, daemonless(It does not require a background service) container engine for developing, managing, and running containers. It provides a command-line interface that is compatible with Docker, making it an excellent alternative for container management without requiring a central daemon, i most use podman only for experimentation.

Installation

brew install podman

After installation, you may need to initialize a Podman machine, which is a lightweight virtual machine for running containers on macOS.

podman machine init
podman machine start

Common Commands

Many Podman commands are identical to their Docker counterparts, so you can often use podman as a drop-in replacement for docker.

🔗 Podman-Official

I’m certain this will help you. There are many other interesting command-line tools out there (like starship, tmux), but I consider them more for customization.

Thanks for reading, and have a great day ☺️