What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
A shell script is a plain-text file containing commands. On Ubuntu, you can create one with nano, make it executable with chmod, and run it from Terminal with ./script.sh.
mkdir -p ~/scripts
cd ~/scripts
nano hello.shEnter the following, save it, then run:
#!/usr/bin/env bash
echo "Hello from Ubuntu"chmod u+x hello.sh
./hello.shExpected output:
Hello from UbuntuThe quickest way to create and run a script
These instructions work in Ubuntu Desktop and Ubuntu Server. You do not need a compiler or special runtime for basic Bash scripts. Create the file in a directory you own rather than in /usr, /bin, or another system directory.
- Open Terminal.
- Create a personal scripts directory and enter it:
mkdir -p ~/scripts cd ~/scripts - Open a new file in
nano:nano hello.sh - Enter:
#!/usr/bin/env bash echo "Hello from Ubuntu" - Save with Ctrl+O, press Enter to confirm the filename, and exit with Ctrl+X.
- Add execute permission and run it:
chmod u+x hello.sh ./hello.sh
The .sh suffix is a useful naming convention, but it does not make a file executable. The file is simply a text file until you give it execute permission or explicitly pass it to an interpreter.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsWhat the shebang means
The first line, #!/usr/bin/env bash, is called a shebang. When you launch the file directly with ./hello.sh, it tells the operating system to find and use Bash. Bash’s documentation covers script files, shebangs, permissions, and positional parameters in its shell-script documentation.
#1 Best Overall
#!/bin/bash is another conventional form. The fixed path is explicit, while /usr/bin/env bash searches for Bash through PATH. Use a Bash shebang when the script contains Bash-specific syntax. A script beginning with #!/bin/sh should use POSIX sh syntax instead.
The blank line is optional. echo prints text to standard output. Lines beginning with # are comments, except for the first-line shebang, which has interpreter significance. Quoting affects variables, spaces, metacharacters, and expansions; see the GNU Bash references for shell syntax and quoting.
Create a script without an editor
On a minimal server or SSH session, you can create the same file with a here-document:
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →cat > hello.sh <<'EOF'
#!/usr/bin/env bash
echo "Hello from Ubuntu"
EOFThis creates or replaces hello.sh. The > operator overwrites an existing file, so check the filename before running the command.
You can also use vim, emacs, Visual Studio Code, or a graphical text editor. The editor does not determine whether the script works; its contents, interpreter, line endings, and permissions do.
Make the script executable
chmod u+x hello.shchmod changes file permissions. The u+x form adds execute permission for the file’s owner, which is usually the smallest change needed for a personal script. You can also use:
chmod +x hello.shThis adds execute permission for applicable permission classes according to the existing mode. Verify the result with:
Recommended Free Tools
Rank #2
ls -l hello.shA result might include -rwxr--r--; the exact owner, group, date, and permissions vary. Direct execution requires the execute bit, but bash hello.sh does not.
Do not use chmod 777 as a general fix. It grants read, write, and execute permissions broadly. Likewise, do not use sudo to create or run an ordinary user-owned script unless a specific command genuinely needs elevated privileges.
Three ways to run a script
| Command | Execute permission? | Interpreter |
|---|---|---|
./hello.sh |
Yes | The interpreter in the shebang |
bash hello.sh |
No | Bash explicitly |
sh hello.sh |
No | sh explicitly |
Direct execution: ./hello.sh
The ./ means “the file named hello.sh in the current directory.” Ubuntu generally does not search the current directory for commands, so typing only hello.sh commonly produces command not found. Direct execution tests both the file’s execute permission and its shebang.
Explicitly use Bash: bash hello.sh
Bash opens and executes the file, so the execute bit is unnecessary and the shebang is not used to select the interpreter. This is useful for testing or for a script whose executable metadata was lost. Bash’s invocation behavior is documented in the Bash manual.
Use sh only for POSIX shell scripts
sh does not necessarily mean Bash. A Bash script using arrays, [[ ... ]], associative arrays, mapfile, process substitution, or other Bash-only features may fail when run with sh. Choose one interpreter and write syntax compatible with it.
Pass arguments to a script
Save this as show-args.sh:
#!/usr/bin/env bash
echo "Script name: $0"
echo "First argument: $1"
echo "All arguments: $@"
for item in "$@"; do
printf 'Item: %sn' "$item"
doneRun it with:
chmod u+x show-args.sh
./show-args.sh apple "red banana"$0 is the name used to invoke the script, $1 is the first argument, and $2 is the second. Use "$@", rather than unquoted $@, when you need to preserve each argument as a separate item. Quoted variables also protect filenames and values containing spaces from unintended word splitting and filename expansion.
A practical system-information script
This Bash example uses variables, command substitution, printf, and multiple commands:
Rank #3
#!/usr/bin/env bash
printf 'User: %sn' "$USER"
printf 'Home: %sn' "$HOME"
printf 'Working directory: %sn' "$PWD"
printf 'Date: %sn' "$(date)"
printf 'Kernel: %sn' "$(uname -sr)"Save it as system-info.sh, then run:
chmod u+x system-info.sh
./system-info.shCheck and debug a script
Check Bash syntax without executing the script:
bash -n hello.shTrace commands as Bash executes them:
bash -x hello.shYou can also temporarily place set -x in the script. For additional static analysis, install or use ShellCheck if it is available:
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →shellcheck hello.shShellCheck can identify many quoting and syntax problems, but it is not a substitute for understanding what a script will do.
Exit statuses
Commands conventionally return status 0 for success and a nonzero value for failure. For example:
#!/usr/bin/env bash
echo "Task completed"
exit 0After running the script, inspect the status immediately:
./hello.sh
echo $?If a script does not explicitly call exit, Bash normally returns the status of its last command. Bash documents invocation and exit-status behavior in its invocation reference.
A simple failure check might look like this:
#!/usr/bin/env bash
if [[ ! -f "$1" ]]; then
printf 'Error: file not found: %sn' "$1" >&2
exit 1
fi
printf 'File exists: %sn' "$1"Understand the working directory
A script normally starts in the caller’s current working directory. It does not automatically run from the directory where it is stored. Check the current directory with:
pwdIf a Bash script needs files located beside the script itself, calculate that directory explicitly:
#!/usr/bin/env bash
script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
printf 'Script directory: %sn' "$script_dir"This is Bash-specific. Alternatively, use carefully constructed absolute paths.
Run a script from another directory
Use a relative or absolute path:
~/scripts/hello.sh
bash ~/scripts/hello.sh
bash "$HOME/My Scripts/hello.sh"Spaces are valid in filenames, but the path must be quoted. For command-line simplicity, names without spaces are usually easier to manage.
Make a personal script available as a command
Once the script works, place a copy in your personal executable directory:
mkdir -p ~/.local/bin
cp hello.sh ~/.local/bin/hello
chmod u+x ~/.local/bin/helloIf that directory is in PATH, run:
hello
command -v helloFor a temporary test when it is not already in PATH:
export PATH="$HOME/.local/bin:$PATH"
helloCommand lookup uses the directories in PATH when the command name does not contain a slash. Shell startup files differ by shell and setup, so do not blindly edit .bashrc without checking which shell you use. Inspect the current setting with:
echo "$PATH"Fix common errors
Permission denied
Check permissions and add execute permission for the owner:
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchls -l script.sh
chmod u+x script.shIf it still fails, check ownership and whether the file is on a mounted filesystem with execution disabled, such as some Windows or shared filesystems. You can test the contents with bash script.sh, but that does not fix direct-execution permissions.
Best Value
command not found
You may have omitted ./, used a misspelled command, or called a program that is not installed or is absent from PATH. Check:
command -v command-name
echo "$PATH"bad interpreter: No such file or directory
The shebang may point to an unavailable interpreter, or the file may have Windows CRLF line endings. Inspect it with:
head -n 1 script.sh
file script.shIf the file has Windows line endings, remove carriage returns with:
sed -i 's/r$//' script.shNo such file or directory
Check the filename, spelling, location, and current directory:
pwd
ls -lsyntax error
The script may contain Bash syntax but have been run with sh, or it may contain an unmatched quote, bracket, or command substitution. Try:
bash -n script.sh
bash script.shThe script cannot find its files
Relative paths are based on the caller’s current directory, not necessarily the script’s directory. Use pwd, absolute paths, or the Bash script-directory pattern shown above.
Different behavior with sudo
sudo changes the effective user and may change the home directory, environment, PATH, and ownership of files created by the script. Use it only for the specific operation that genuinely needs elevated privileges. Running the entire script as root is not a general permission fix.
Free tools Windows power users keep installed
One-click scans. No signup required.
The script appears to do nothing
Trace it and inspect its exit status:
bash -x script.sh
echo $?Also check for redirected output, skipped conditional branches, commands waiting for input, and invalid line endings.
Safe shell-script habits
- Read and understand a script before running it, especially with
sudo. - Inspect downloaded scripts with
less downloaded-script.sh. - Pay particular attention to
rm,dd,mkfs, recursivechmodorchown, writes to/dev, and changes to/etc, boot files, or package configuration. - Avoid blindly pasting commands from untrusted websites.
- Test unfamiliar scripts in a disposable directory or virtual machine.
- Quote variables and use
"$@"when preserving argument boundaries matters. - Use the narrowest permissions necessary, normally
chmod u+x. - Do not assume
set -emakes a script safe; Bash has exceptions to when it exits on errors. Design error handling deliberately, as described in the Bashsetreference.
Further reading
The exact Bash features available depend on the Ubuntu release and installed Bash version. Ubuntu’s Noble reference lists Bash package version 5.2.21-2ubuntu4, while the current GNU Bash manual documents Bash 5.3; these are not claims that every Ubuntu installation uses the same version. See the Ubuntu Bash manpage and the GNU Bash manual.
Automatic startup, cron jobs, systemd services, and desktop autostart are separate topics. First make sure the script works manually, has the intended interpreter, and returns a sensible exit status.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
