Beginners Guide for Source Command in Linux

Linux TLDR
Last Updated:
Reading time: 4 minutes

The source is a built-in command-line tool that reads and executes the commands from the specified file (in order) as its argument in the current shell.

Each command from the specified file will be delivered to the TCL interpreter to be read and run, making it useful to load functions, variables, and configuration files.

Even when you modify the bash configuration (β€œ~/.bashrcβ€œ) file, it is recommended to load the changes in the current shell environment using the source command due to its nature of running the script in the current shell environment instead of creating a new shell environment as the bash command does.

Tutorial Details

Difficulty LevelLow
Root or Sudo PrivilegesNo
OS CompatibilityUbuntu, Manjaro, Fedora, etc.
Internet RequiredNo

Syntax of the Source Command

The source command takes two arguments: one is the filename (name or path of the file), and the other is the arguments (it will become the positional parameter for the file).

Note that the β€œ.” (period) is a synonym for the source command, so both work the same way.


And do not confuse between β€œ.” (period) and β€œ./” (relative positioning), because both are different.

  • The β€œ./” will run the script using bash by creating a new shell environment.
  • Whereas, β€œsource” or β€œ.” will read and execute the commands from the specified script or file into the current shell environment.

Evaluate the Contents of a Given File

Create a new text file with the name β€œcommands.txt” in your current working directory and add the following commands to it.


Use the file path as a source command argument.

$ source commands.txt 


Sourcing script file with series of commands

As you can see, the source command will read and execute the content of this file line by line in the current shell environment.

Specifying the Path of a Given File

In the previous example, the source command was able to read and execute the content of the file even without specifying the file’s absolute or relative path.

It is because if you do not specify them, the source command will search the β€œ$PATH” environment variable for files. If it does not exist, source will search for the file in the current directory.

To demonstrate, I have renamed the previous file from β€œcommands.txt” to β€œfile” name (there is already a command with file name) as shown.

$ mv commands.txt file

Now, if you specify the β€œfile” argument to the source command without specifying the absolute or relative path, it will search the β€œ$PATH” variable for the specified file.

$ source file 


running script file with sources command

As you can see above, there is a binary file with the name β€œfile” in the β€œ$PATH” variable that source found and tried to read and execute, but the file was a binary file, so source failed to read it.

To prevent this issue, you can specify the absolute or relative path for the specified file.

Example of an absolute path:

$ source /home/linuxtldr/file 


running script file with sources command by specifying full path

Example of a relative path:

$ source ./file 


running script file with sources command by relative path

Reading the Bash Configuration File

Using the source command, you can read variables from another file and load them into your existing file. To do that, you must declare the variables using the Bash β€œKEY=VALUE” syntax.

Create a text file in your current directory and copy the following content into it, then save the file with any name (ex: β€œenvβ€œ).

VAR1="value one"
VAR2="value two"
VAR3="value three"

Now, create a bash script in the same directory with the name β€œ” and add the following content.

#!/usr/bin/env bash

source ./env

echo "VAR1 is $VAR1"
echo "VAR2 is $VAR2"
echo "VAR3 is $VAR3"

If you run the β€œ” file using the source command, it will read the β€œVAR1β€œ, β€œVAR2β€œ, and β€œVAR3” variables defined in the β€œenv” file and execute the specified commands in your current shell environment as shown.

$ source


Running script with environment variables picked from env file

Sourcing Functions

If you have a block of commands or functions that you are using in multiple scripts, you can save them in a separate file and use the source command to refer to them when writing scripts.

For example, you can use the following β€œcheck_root” function to check whether the user running the script is a root user.

check_root() {
  if [[ $EUID -ne 0 ]]; then
    echo "You must run this script as root!"
    exit 1

Copy and save the above functions in the β€œ” file.

Than create a second script with the name β€œ” and simply use the source command to source the β€œ” function.

#!/usr/bin/env bash

source ./

echo "I am root"

If you run the above script as a non-root user, it will print β€œYou must run this script as root!” and exit.

You can source the β€œ” file into β€œ” to load the function into the current shell environment. However, if you try to execute β€œ” using the source command, your terminal window will close because source is not allowed to be run with sudo; instead, use the bash command.
$ bash 


Script created that will only run when executed as root

However, if you run your script as root or a sudo user, it will produce β€œI am root” and exit.

$ sudo bash 


Running a script with root privileges

The advantage of using this approach when creating scripts is that it will make the script smaller and more readable, reduce the repetition of codes, and make it easier to reflect changes in the file where the script is being used.

I hope this article makes it easier for you to understand the use of the source command.

If you have any questions regarding this topic, feel free to ask them in the comment section.

Join The Conversation

Users are always welcome to leave comments about the articles, whether they are questions, comments, constructive criticism, old information, or notices of typos. Please keep in mind that all comments are moderated according to our comment policy.