Set Environment Variables in Linux Permanent and System-wide

In Linux, an environment variable is a value that can be used to provide configuration and data across different parts of a system.

These variables act as placeholders for data, allowing applications and the shell to interact with each other more smoothly.
One primary advantage of environment variables is that they facilitate the sharing of values between processes, enabling centralized control over aspects of system behavior.



Scope (Local vs Global)

Environment variables in Linux can be classified into two main categories based on their scope: Local and Global.

Local Variables

Local variables are limited to the current shell session. Any sub-shell or program initiated within that session can access these variables, but they are not available in other sessions.
Here’s how you can create a local variable:

variable_name="local value"
echo $variable_name


local value

In this code, you are declaring a variable named variable_name and assigning it the value “local value.” When using the echo command to print the variable, it returns the assigned value.

This variable is available only within the current shell and will not be recognized in new terminal windows or other sessions.

Global Variables

Global variables, also known as environment variables, are accessible to all sessions and users on the system.

They provide a way to share configuration settings between different applications and shell sessions.
You can create a global variable using the export command:

export GLOBAL_VARIABLE="global value"


global value

By prefixing the declaration with export, you are making the variable GLOBAL_VARIABLE accessible to all sessions and users on the system.

Unlike local variables, global variables retain their value across different terminal sessions.


Listing Environment Variables

In Linux, you have various methods to list environment variables. Here, we will explore different ways to do that.

Using printenv

The printenv command can list all environment variables or display the value of a specific variable.




By simply running printenv, you get a list of all environment variables. If you want to view a specific variable, such as HOME, use:

printenv HOME



The above command specifically displays the HOME variable.

Using env

Similar to printenv, the env command can also list all the environment variables.




It returns a comprehensive list of all the environment variables active on the system.

Using echo

To print the value of a specific environment variable, you can use the echo command with the variable name prefixed by $.

echo $USER



This returns the value of the USER variable, showing the current logged-in username.

Using /etc/environment

In some Linux distributions, the /etc/environment file holds global environment variables. You can view its contents with a text editor or the cat command.

cat /etc/environment



This will display the contents of the file, including any defined global environment variables.


Setting Environment Variables (Permanent variables)

When you want to make environment variables permanently available across all sessions and after reboots, you’ll need to add them to one of the shell configuration files.

Editing .bashrc

The .bashrc file is a script that runs every time you open a new terminal window. You can add your environment variables here.
Open .bashrc with a text editor like nano:

nano ~/.bashrc

Add your export line at the end of the file:

export NEW_VARIABLE="value"

Save and exit the file.
Now, apply the changes with:

source ~/.bashrc

Or you can restart the terminal.
Verify with:




The variable NEW_VARIABLE is now permanently set and won’t disappear after reboot.

Editing .bash_profile or .profile

Some systems use .bash_profile or .profile for login shells. The process is the same as with .bashrc.

Just replace .bashrc with .bash_profile or .profile in the above instructions.
The choice between these files depends on your system and personal preferences.

Generally, .bashrc is used for non-login shells, and .bash_profile or .profile for login shells. Environment variables can be placed in any of them, depending on your specific needs.
By adding environment variables to these configuration files, you ensure they are globally accessible across different terminal sessions and after system restarts.


Setting Environment Variables (System-wide)

System-wide environment variables are accessible to all users on the system. These variables can be set in specific files that are read during the system boot or user login.


The /etc/environment file is a simple text file containing key-value pairs. You can add an environment variable here:

sudo echo 'GLOBAL_PATH="/new/path"' | sudo tee -a /etc/environment

Then, you’ll need to log out and log back in, or restart the system.
Verify with:

printenv GLOBAL_PATH



The GLOBAL_PATH variable has now been set for all users on the system.


Alternatively, you can use the /etc/profile file to set system-wide environment variables. Open the file:

sudo nano /etc/profile

Add your export line:

export SYSTEM_VARIABLE="system value"

Save and exit.
To apply the changes, either restart the system or run:

source /etc/profile

Verify with:



system value

The SYSTEM_VARIABLE is now set globally for all users.
Both methods allow you to set environment variables that are accessible by all users, ensuring a consistent environment across the system.


/etc/environment vs. bashrc

Aspect /etc/environment ~/.bashrc
Scope System-wide (all users) User-specific
Type of sessions All types (including GUI like KDE and GNOME) Interactive non-login shells
Syntax key=value pairs only Shell scripting syntax
Effect Variables loaded upon login Variables loaded on new shell
Suitable for Setting environment variables for all users and sessions Setting user-specific aliases, functions, and shell variables
Impact on GUI applications Variables available Variables are not be available
Requires shell restart No (changes apply at next login) Yes (for changes to take effect in current session)
Accepts scripting No Yes


Unsetting Environment Variables

There may be times when you want to remove an environment variable, either for testing purposes or to clear an unnecessary or incorrect setting.

The unset command allows you to do just that.
Here’s how to unset an environment variable:

export VARIABLE_TO_UNSET="value"



The above code first sets a variable named VARIABLE_TO_UNSET with the value “value.” Now, you’ll unset it:



(blank line)

The variable has been removed, so attempting to echo it returns a blank line.
If the variable was set in one of the shell configuration files or system-wide files, you would need to remove the corresponding line from the file and reload the file with source or restart the session.


Special Environment Variables

Linux defines several special environment variables that control various aspects of the system’s behavior. Understanding these can help you in system configuration and scripting.


The PATH variable defines the directories where the system looks for executable files.

echo $PATH



This shows the directories that the system searches for executables, allowing you to run commands without specifying their full paths.


The HOME variable points to the current user’s home directory.

echo $HOME



This provides the path to the user’s home directory, useful in scripts or commands that need to reference user-specific files or directories.


This variable contains the current logged-in username.

echo $USER




The SHELL variable defines the default shell for the user.

echo $SHELL




This variable contains the system’s hostname.





The LANG variable sets the system’s language and locale.

echo $LANG




(Prompt String 1): This is the environment variable that defines the primary prompt string. It is the string of characters that are displayed when the terminal is waiting for input.

echo $PS1


[\u@\h \W]\$


(Prompt String 2): This is the secondary prompt that is displayed when a command needs more input to complete.

For example, if you type echo " without closing the quote and hit Enter, the secondary prompt (> by default) will appear on the next line.

This is to show you that the command is not yet complete, and it’s waiting for the closing quote.

echo $PS2




The PWD variable contains the current working directory.

echo $PWD



The PWD environment variable is not stored in a physical file but in the system’s memory when a shell session is created.


The HISTSIZE variable defines the size of the command history.





These variables can be set to define the default text editor and web browser.

echo $EDITOR




Using Environment Variables in Bash Scripting

Here’s a basic example of how you can use environment variables in a bash script:
Create a file called


export MY_OS="Linux"
echo "Hello, $MY_NAME. Welcome to $MY_OS!"

Now, make the script executable:

chmod +x

Run the script:



Hello, John. Welcome to Linux!

Here, MY_NAME and MY_OS are environment variables set within the script.

The export command makes MY_OS available to any subprocesses. They’re then used in an echo statement to print a welcome message.
You can even pass environment variables from the command line when running a script. This can be useful to change the script’s behavior based on input.

MY_NAME="Alice" ./


Hello, Alice. Welcome to Linux!

By prefixing the script run with MY_NAME="Alice", you’ve temporarily overridden the MY_NAME variable in the script, allowing for customizable output.
Utilizing environment variables in scripting allows you to write dynamic, reusable code.


Systemd and Environment Variables

systemd is an initialization system used to bootstrap the user space and manage all subsequent processes.

To set environment variables for a specific service using systemd, you will typically edit the service’s unit file.
Here’s an example:

sudo systemctl edit my-service.service

Add an [Environment] section:

Environment="MY_VARIABLE=my value"

Reload systemd and restart the service:

sudo systemctl daemon-reload
sudo systemctl restart my-service.service

The variable MY_VARIABLE is now available to the my-service service, with the value “my value.”
You can also use a dedicated environment file:

Create a file /etc/my-service.env with the content:

MY_VARIABLE=my value

Refer to this file in the service’s unit file:


Reload and restart as before.

This allows for a clean separation of configuration, which can be particularly useful with complex services.


Loading Environment Variables from Files

Here are two common ways to achieve that:

Using source

The source command reads and executes commands from the given filename in the current shell environment.
Create a file called with the following content:

export VAR1="value1"
export VAR2="value2"

To load these variables, run:


Verify with:

echo $VAR1
echo $VAR2



The variables are now available in your current shell.

Using dotenv

dotenv is a tool that can load variables from a .env file into the environment. You’ll need to install it first.
Create a file called .env with the following content:


Load these variables using dotenv:


Verify in the same way as before.




Q: How to use the export command to set the default editor?

A: To set the default editor using the export command, you need to modify the EDITOR environment variable. For example, if you want to set vim as your default editor, you can use the following command:

export EDITOR=vim

If you want to make it permanent, add the above line to your shell configuration file (~/.bashrc, ~/.bash_profile, or ~/.profile), then save and close the file. To make the changes take effect, you can use the source command:

source ~/.bashrc
Leave a Reply

Your email address will not be published. Required fields are marked *