How To Change Shell in Linux

Linux offers users exceptional flexibility, including the ability to choose and customize your command-line interface. The shell—your primary interface for interacting with the operating system—can significantly impact your productivity and workflow. Whether you’re seeking more features, better customization options, or simply want to explore alternatives, changing your shell in Linux is a straightforward process with multiple approaches.

This guide walks you through everything you need to know about Linux shells—from understanding what they are to implementing advanced configurations. By the end, you’ll be equipped with the knowledge to confidently switch between different shells and optimize your command-line experience.

Understanding Linux Shells

The shell is a command interpreter that provides an interface between you and the Linux operating system. It accepts human-readable commands and translates them into instructions the kernel can understand and execute. Unlike graphical user interfaces (GUIs), shells offer text-based interaction through a terminal emulator.

What is a shell?

A shell is essentially a specialized program that processes commands and returns output. It serves as a command processor, allowing users to execute commands, run scripts, manage files, and interact with system components. The shell also provides programming constructs like loops, conditionals, and variables, making it a powerful tool for automation and scripting.

It’s important to distinguish between terminal emulators and shells. A terminal emulator (like GNOME Terminal, Konsole, or Xterm) is a program that provides the window interface where you type commands. The shell is the actual command interpreter running within that terminal window.

Popular shell options

While Bash (Bourne Again SHell) comes as the default on most Linux distributions, several alternatives offer unique features and advantages:

• Bash (Bourne Again SHell): The most common shell, offering solid functionality, good scripting capabilities, and widespread compatibility. Bash is the evolution of the original Bourne Shell (sh) with additional features.
• Zsh (Z Shell): Extends Bash with improved auto-completion, spelling correction, path expansion, and theming capabilities. The Oh My Zsh framework makes customization particularly approachable.
• Fish (Friendly Interactive SHell): Designed with user-friendliness in mind, featuring syntax highlighting, autosuggestions as you type, and web-based configuration. Fish prioritizes interactive use over strict POSIX compliance.
• Dash: A lightweight shell optimized for speed, often used as /bin/sh on Debian-based systems for running scripts.
• Ksh (KornShell): Combines features from the C shell and Bourne shell, popular in commercial Unix environments.
• Tcsh: An enhanced version of csh (C Shell) with command-line editing and programmable word completion.

Login shells vs. interactive shells

Linux distinguishes between different shell contexts:

Login shells are initiated when you log into a system, either remotely via SSH or at a local console. They typically read configuration files like .profile or .bash_profile to set up your environment.

Interactive shells are started when you open a terminal window in your desktop environment. They read configuration files like .bashrc (for Bash) to set up your working environment.

This distinction matters because changing your default shell affects which configuration files are read during startup, potentially altering your entire command-line experience.

Checking Your Current Shell Configuration

Before making any changes, it’s essential to understand your current shell configuration. Linux provides several ways to identify which shell you’re currently using.

Identifying your current shell

The most common method is using the echo $SHELL command, which displays the path to your default login shell:

echo $SHELL

This might output something like /bin/bash or /usr/bin/zsh, indicating your configured login shell.

Alternatively, you can use echo $0, which shows the name of the currently running shell process:

echo $0

For even more detailed information, use the ps command to check the process information:

ps -p $$

The $$ variable represents the current process ID, and this command will show which shell is actually running.

Viewing available shells

To see all shells available on your system, examine the /etc/shells file:

cat /etc/shells

This file lists all valid login shells on your system, typically including paths like:

/bin/bash
/bin/sh
/usr/bin/zsh
/usr/bin/fish

Verifying shell installation paths

To confirm the exact location of a shell executable, use the which command:

which bash
which zsh
which fish

These commands will return the full paths to these programs if they’re installed and in your PATH.

Temporary Shell Switching

Before permanently changing your shell, it’s wise to test alternatives temporarily. This allows you to experiment with different shells without committing to configuration changes.

Session-only shell changes

To switch shells temporarily for the current session only, simply type the name of the desired shell and press Enter:

fish

This launches the Fish shell within your current session. Any changes or customizations will only affect this temporary session and won’t persist after closing the terminal or logging out.

Examples of temporary switching

From Bash to Fish and back:

# Starting in Bash
fish
# Now in Fish shell
exit
# Back to Bash

From Bash to Zsh and back:

# Starting in Bash
zsh
# Now in Zsh shell
exit
# Back to Bash

Exiting temporary shells

To exit a temporary shell and return to your original shell, use the exit command or press Ctrl+D. This terminates the current shell process and returns you to the parent shell.

When switching shells temporarily, you’re creating a shell hierarchy. Each new shell runs as a child process of the previous one. Exiting a shell returns you to its parent.

Practical use cases for temporary switching

Temporary shell switching is particularly useful for:

• Testing shell-specific commands or syntax
• Trying out configurations before making permanent changes
• Using specialized features of a particular shell for specific tasks
• Demonstrating different shells to colleagues or students

Changing Your Default Shell with chsh

For a permanent change to your default shell, the chsh (change shell) command is the recommended approach. This updates your user account configuration in the system’s user database.

The chsh command explained

The chsh command modifies the shell field in the /etc/passwd file, which stores essential user account information. You’ll need proper permissions to make these changes—typically you can change your own shell, but changing another user’s shell requires administrative privileges.

Using chsh with no parameters

Running chsh with no parameters provides an interactive prompt:

chsh

The system will ask for your password for authentication, then prompt:

Changing the login shell for username
Enter the new value, or press ENTER for the default
Login Shell [/bin/bash]:

Type the full path to your desired shell (e.g., /usr/bin/zsh) and press Enter. The shell must be listed in /etc/shells to be accepted.

Using chsh with the -s option

For a more direct approach, use the -s option followed by the shell path:

chsh -s /usr/bin/zsh

This immediately sets Zsh as your default shell after password authentication.

Examples for different shells:

chsh -s /bin/bash    # Change to Bash
chsh -s /usr/bin/fish  # Change to Fish
chsh -s /usr/bin/zsh   # Change to Zsh

Changing shell for the current user

The process to change your own shell is straightforward:

1. Verify the shell is installed: which zsh
2. Confirm it’s in /etc/shells: cat /etc/shells | grep zsh
3. Change your shell: chsh -s /usr/bin/zsh
4. Enter your password when prompted
5. Log out and log back in for changes to take effect
6. Verify the change: echo $SHELL

Changing shell for other users

To change another user’s shell, you need root privileges:

sudo chsh -s /usr/bin/zsh username

Replace “username” with the actual username whose shell you’re changing. This is useful for system administrators managing multiple user accounts.

When changes take effect

Shell changes don’t take effect immediately in your current session. You need to log out and log back in for the changes to apply. This is because the login shell is determined when you start a new login session.

To verify your changes were applied correctly after logging back in, use:

echo $SHELL

Alternative Methods for Changing Shells

While chsh is the recommended approach, Linux offers alternative methods for changing the default shell.

Using usermod command

The usermod command is a general-purpose tool for modifying user accounts that can also change shells:

sudo usermod --shell /usr/bin/zsh username

This requires administrative privileges and works similarly to chsh but is typically used in system administration contexts or scripts that manage user accounts.

Examples:

sudo usermod --shell /bin/bash john    # Change john's shell to Bash
sudo usermod --shell /usr/bin/fish sarah  # Change sarah's shell to Fish

To verify the change, check the /etc/passwd file or use the getent command:

getent passwd username

Directly editing /etc/passwd

For advanced users, it’s possible to directly edit the /etc/passwd file, though this approach requires caution:

sudo nano /etc/passwd

The file contains one line per user, with fields separated by colons. The shell is specified in the last field:

username:x:1000:1000:Full Name:/home/username:/bin/bash

To change the shell, modify only the last field (e.g., change /bin/bash to /usr/bin/zsh).

Crucial precautions:

• Always create a backup first: sudo cp /etc/passwd /etc/passwd.backup
• Never delete or modify other fields
• Use vipw instead of regular editors when possible, as it includes file locking and validation

Using chsh with the -R option

For advanced scenarios involving chroot environments (isolated filesystem hierarchies), chsh offers the -R option:

sudo chsh -R /mnt/system -s /bin/zsh username

This changes the shell for a user in the system mounted at /mnt/system rather than the current system, useful for:

• Repairing systems booted from rescue media
• Setting up containers or virtual environments
• Configuring new system installations

Installing New Shells

Before changing to a different shell, you’ll need to install it if it’s not already available on your system.

Installation on Debian/Ubuntu

On Debian-based distributions (including Ubuntu and Linux Mint), use the apt package manager:

# Install Zsh
sudo apt update
sudo apt install zsh

# Install Fish
sudo apt update
sudo apt install fish

These commands refresh the package repository information and then install the respective shell packages.

Installation on RHEL/CentOS/Fedora

On Red Hat-based distributions, use dnf (or yum on older systems):

# Install Zsh
sudo dnf install zsh

# Install Fish
sudo dnf install fish

On some RHEL systems, you might need to enable additional repositories:

# For RHEL/CentOS
sudo dnf install epel-release
sudo dnf install fish

Installation on Arch Linux and derivatives

Arch Linux and its derivatives (like Manjaro) use the pacman package manager:

# Install Zsh
sudo pacman -S zsh

# Install Fish
sudo pacman -S fish

Compiling shells from source

For the latest versions or custom builds, you can compile shells from source code:

# Example for Fish shell
wget https://github.com/fish-shell/fish-shell/releases/download/3.5.1/fish-3.5.1.tar.xz
tar -xf fish-3.5.1.tar.xz
cd fish-3.5.1
./configure
make
sudo make install

Compiling from source is beneficial when:

• You need the latest features not yet available in package repositories
• Your distribution doesn’t provide the shell in its repositories
• You want to apply custom patches or modifications

Verifying successful installation

After installation, confirm the shell is properly installed:

# Check the binary location
which zsh
which fish

# Verify it can run
zsh --version
fish --version

# Ensure it's in /etc/shells
cat /etc/shells | grep fish

If the shell isn’t listed in /etc/shells, add it manually:

echo "$(which fish)" | sudo tee -a /etc/shells

Configuring Your New Shell

Installing and switching to a new shell is just the beginning. Proper configuration maximizes the benefits of your chosen shell.

Shell configuration files

Each shell uses different configuration files:

• Bash:
  • .bashrc: Configuration for interactive non-login shells
  • .bash_profile: Configuration for login shells
  • .profile: General settings read by login shells
• Zsh:
  • .zshrc: Main configuration file
  • .zprofile: Run for login shells
  • .zshenv: Environment variables for all shells
• Fish:
  • ~/.config/fish/config.fish: Main configuration file
  • Functions stored in ~/.config/fish/functions/

Essential configurations

Basic configurations common to most shells include:

Setting environment variables:

# Bash/Zsh
export PATH="$HOME/bin:$PATH"

# Fish
set -gx PATH $HOME/bin $PATH

Creating aliases:

# Bash/Zsh
alias ll='ls -la'
alias update='sudo apt update && sudo apt upgrade'

# Fish
alias ll 'ls -la'
alias update 'sudo apt update && sudo apt upgrade'

Configuring the prompt:

# Bash
PS1='\u@\h:\w\$ '

# Zsh
PROMPT='%n@%m:%~%# '

# Fish
function fish_prompt
    echo (whoami)@(hostname):(pwd)'$ '
end

Migrating settings between shells

When transitioning between shells, you’ll want to transfer your customizations:

From Bash to Zsh:

# Convert aliases
grep "^alias" ~/.bashrc >> ~/.zshrc

# Convert environment variables
grep "^export" ~/.bashrc >> ~/.zshrc

From Bash to Fish:

# Using the bass plugin for Bash compatibility
fisher install edc/bass

# Or manually converting syntax
# Bash: export VAR=value
# Fish: set -gx VAR value

Shell-specific enhancements

Each shell offers unique customization opportunities:

Zsh with Oh My Zsh:

# Install Oh My Zsh
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# Edit ~/.zshrc to set theme and plugins
# ZSH_THEME="robbyrussell"
# plugins=(git docker python)

Fish customizations:

# Install Fisher package manager
curl -sL https://git.io/fisher | source && fisher install jorgebucaran/fisher

# Install useful plugins
fisher install jorgebucaran/nvm.fish
fisher install PatrickF1/fzf.fish

Practical Examples and Use Cases

Different shells excel in different scenarios. Here are some practical configurations for specific use cases.

Setting up Zsh with Oh My Zsh

Oh My Zsh transforms Zsh with themes and plugins:

1. Install Zsh: sudo apt install zsh
2. Install Oh My Zsh: sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
3. Edit ~/.zshrc to activate plugins:

   ZSH_THEME="agnoster"
   plugins=(
     git
     docker
     composer
     npm
     sudo
     history
   )

4. Install Powerline fonts for advanced themes:

   apt install fonts-powerline

5. Restart your terminal or source the configuration: source ~/.zshrc

Configuring Fish for development

Fish provides an excellent development environment with minimal configuration:

1. Install Fish: sudo apt install fish
2. Set up autosuggestions (built-in) and syntax highlighting (built-in)
3. Create aliases for common git commands:

   # In ~/.config/fish/config.fish
   alias gs 'git status'
   alias gc 'git commit'
   alias gp 'git push'

4. Configure the Fish prompt for Git integration:

   fisher install pure-fish/pure

5. Add language-specific tools:

   # For Node.js
   fisher install jorgebucaran/nvm.fish

Creating a minimal Dash environment

For systems with limited resources or script execution:

1. Install Dash: sudo apt install dash
2. Create a minimal .profile for Dash:

   # ~/minimal_profile
   PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
   export PATH

3. Test with: dash --init-file ~/minimal_profile

User-specific shell environments

Different users can have different shells on the same system:

• Administrative users: Bash for compatibility with system scripts
• Developers: Zsh with Oh My Zsh or Fish for productivity features
• Script/automation users: Dash for speed and efficiency
• Support staff: Fish for user-friendliness and discoverability

Troubleshooting Common Issues

Changing shells occasionally leads to issues. Here are solutions to common problems.

Shell not changing after using chsh

If your shell doesn’t change after using chsh:

1. Verify the shell path is correct: which zsh
2. Ensure you’ve completely logged out and back in (not just closed the terminal)
3. Check if your display manager properly processes shell changes
4. For remote connections, ensure you’re using a full login session with ssh username@host
5. Verify the change was actually saved: getent passwd $USER

“Invalid shell” errors

If you receive “invalid shell” errors:

1. Confirm the shell is in /etc/shells: cat /etc/shells
2. Add the shell if missing: echo "$(which zsh)" | sudo tee -a /etc/shells
3. Verify the shell executable exists and is properly installed: ls -l $(which zsh)
4. Check permissions on the shell executable: ls -l $(which zsh)
5. Try using the absolute path: chsh -s $(which zsh)

Permission and authentication issues

For permission-related problems:

1. Ensure you have the correct password for chsh
2. Verify your user has permission to change shells
3. Check PAM configuration if authentication fails
4. Use sudo for changing other users’ shells: sudo chsh -s /bin/zsh username
5. Verify file permissions on /etc/passwd and /etc/shells: ls -l /etc/passwd /etc/shells

Recovery from incorrect shell configuration

If you’ve set an invalid or malfunctioning shell:

1. Log in to a virtual console (Ctrl+Alt+F3) using your username and password
2. Change your shell back: chsh -s /bin/bash
3. If you can’t log in, use recovery mode or a live CD
4. Mount your system and edit /etc/passwd to fix the shell entry
5. For emergency access without changing your shell permanently, use: ssh username@host -t /bin/bash

Advanced Shell Techniques

Beyond basic configuration, advanced techniques can further enhance your shell experience.

Shell scripting differences

Different shells have various scripting syntax:

Bash/Zsh variable assignment:

variable="value"
echo $variable

Fish variable assignment:

set variable "value"
echo $variable

Bash/Zsh for loop:

for i in {1..5}; do
    echo $i
done

Fish for loop:

for i in (seq 1 5)
    echo $i
end

Performance considerations

Shells vary in startup time and resource usage:

• Dash is fastest for script execution (typically 2-3x faster than Bash)
• Fish can be slower to start but offers better interactive performance
• Zsh with many plugins can have noticeable startup delay
• Bash offers a balanced approach

Benchmark your specific configuration:

time bash -i -c exit
time zsh -i -c exit
time fish -i -c exit

Security aspects

Different shells offer varying security features:

• Restricted shells (rbash, rzsh) limit what users can do
• Fish prevents some common security mistakes by design
• Setting a shell to /usr/sbin/nologin or /bin/false prevents interactive login
• Some shells offer better history protection and variable quoting

Best Practices

Follow these best practices for a smooth shell transition experience.

Testing before switching

Always test a shell before making it your default:

1. Run it temporarily: zsh or fish
2. Test your common workflows and commands
3. Try running your existing scripts and aliases
4. Check compatibility with tools you frequently use
5. Create a test user with the new shell: sudo useradd -m -s /usr/bin/zsh testuser

Backing up configurations

Before major changes:

1. Back up your current shell configuration:

   cp ~/.bashrc ~/.bashrc.backup
   cp ~/.bash_profile ~/.bash_profile.backup

2. Copy system files that might be modified:

   sudo cp /etc/passwd /etc/passwd.backup

3. Create a simple script to restore your previous shell if needed:

   echo 'chsh -s /bin/bash' > ~/restore_shell.sh
   chmod +x ~/restore_shell.sh