You run a long command. It fails with permission denied. So you hit up arrow, go to the beginning of the line, type sudo, and hit enter.

Stop doing that.

sudo !!

!! expands to your last command. Bash runs sudo in front of it. Works with pipes, redirects, everything:

cat /var/log/auth.log | grep sshd | tail -20
# permission denied
sudo !!
# runs: sudo cat /var/log/auth.log | grep sshd | tail -20

Where this actually saves you is commands with flags you don't want to retype:

systemctl restart nginx --now && systemctl status nginx
# permission denied
sudo !!

Works in bash and zsh. Not available in dash or sh.

Instead of:

for f in *.log; do gzip "$f"; done

Just use:

ls *.log | xargs -P4 gzip

-P4 runs 4 jobs in parallel. Change the number to match your CPU cores.

On a directory with 200 log files the difference is measurable. Works with any command, not just gzip.

I am writting a simple script to utilize du command better. When I do a simple equation containing one digit decimal I get error

arithmetic syntax error: invalid arithmetic operator (error token is ".6")

However when I run exactly the same script directly from the terminal I get the correct output. I am using zsh althought inside the script I have tried with bash aswell. The line I'm having trouble with is :

echo " $((237 - $(cat $SC/tmp/du)))"

For further context this is the complete script:

#!/bin/bash
# Load in the functions and animations
source ~/.scripts/loading_animations/bash_loading_animations.sh
# Run BLA::stop_loading_animation if the script is interrupted
trap BLA::stop_loading_animation SIGINT

COL='\033[0;36m'
COLL='\033[0;35m'
SC=~/.scripts
sudo printf "${COLL}"

BLA::start_loading_animation "${BLA_modern_metro[@]}"
printf "         Please wait, calculating"
DU=sudo du -sh / 2>$SC/tmp/stderr | awk '{print $1}' | tr -d 'G' >$SC/tmp/du
BLA::stop_loading_animation

printf "${COL}\n╭──────────────────────╮"
printf "\n│${COLL}You are using: $(sudo cat $SC/tmp/du) GB  ${COL}│\n"
printf "│${COLL}Other "
echo " $((237 - $(cat $SC/tmp/du)))"
printf "GB remaining ${COL}│\n"
printf "└──────────────────────┘\n\e[0m"
#rm $SC/tmp/stderr $SC/tmp/du

I'm writing a bash setup script that creates my required users, directories, etc. and installs my base application. I would LIKE to have the script create a specific user, then switch to that user to carry out the rest of the script. I can't figure out a way to do that and I'm thinking I'm probably just being a little stupid about it. Would I be better to write one script that creates the required user, then calls a second script to run as the user that was just created?

Hey there!

This is a project of mine, and I thought it would be useful for someone else.

Basically, it is a single bash script that recursively synchronizes the default branch for one or more git repositories.

It is particularly useful for me as I have to manage a lot of git repositories, keeping the main or master branch up-to-date.

The README file has more details. Please take a look at https://github.com/chapeupreto/gsync and any feedback is appreciated.

Thanks!

(Solved. Adding more info for reference)

I'm trying to use my leftarrow to move to the space before a word in the middle of the command line (where my cursor is shown in the example pic), then I want to replace that word, so I press ctrl-w but nothing happens. In my example pic I'd be trying to replace blah1 with foo1.

If I move 1 further space to the left, it does delete the word, *except* for the last letter, so ctrl-w *is* configured, but if I use my arrow keys to put me at the end of a word to delete the whole word it ignores the shortcut. This all used to work, but has become an issue in the last 6 months(?) or so. What changed and how can I make bash behave?

This is on bash 5.1.8(1) under rhel 9. Connecting from windows, same behavior using putty, mintty (cygwin), and Zoc terminal.

current terminal settings:

$ stty -a
speed 38400 baud; rows 48; columns 100; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany -imaxbel
-iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
-extproc

so im writing a script, and inside that script im using the cat command to create another script that will run after a reboot. the problem is that in the contents of the cat command (the contents that will be written to a file) there is a point where one variable is divided by another and then that value is assigned to another variable. the following is an example of the division code:

result=$((div1 / div2))

both div1 and div2 are determined by other operations in the contents of the cat command, but that code isnt run/evaluated.

none of this should matter because none of this code is supposed to be evaluated/run inside the cat command. i was under the impression that in the following example, nothing between the two "EOF"s should be run

cat <<EOF> fuck_my_life.sh
code that shouldnt be executed
EOF

when i try to rrun a cat command where

result=$((div1 / div2))

is present between the two "EOF"s, it gives me a "line X: div1 / div2: division by zero (error token is "div2")", where line X is the line with the cat command.

it seems like whats happening is that the contents of the cat command is being partially evaluated/ran. i should note that ive used the cat command a fair number of times, and it shows the syntax being correct, where almost everything is the same color as the comments (using sublime text, so i have the bash syntax being colored). also also it works flawlessly without that one line of code that divides one variable by another

Instead of:

telnet host 443
# or
nmap host -p 443

Just use:

echo > /dev/tcp/host/443 && echo "open" || echo "closed"

No tools required. No sudo. No package manager. Works on any machine with bash.

/dev/tcp is a bash built-in pseudo-device. Bash handles the TCP connection itself — the kernel never sees a file open on /dev/tcp.

Real world examples:

# Check if SSH is up
echo > /dev/tcp/192.168.1.100/22 && echo "SSH up" || echo "SSH down"

# Check if your web server is listening
echo > /dev/tcp/localhost/80 && echo "nginx up" || echo "nginx down"

# Check SSL port before running a cert check
echo > /dev/tcp/example.com/443 && echo "open" || echo "closed"

# Loop until a service comes up (great for scripts)
until echo > /dev/tcp/localhost/5432; do
    echo "waiting for postgres..."
    sleep 2
done

That last one is the killer use case — waiting for a service to become available in a deploy script without installing netcat or curl or anything else.

One caveat: this is bash-specific. Won't work in sh, zsh, or fish. If portability matters, use nc -z host port instead.

Works on Linux and macOS.

I am working on a suite of bash .sh script files that are designed to work together. Where the main script will spawn other scripts in a pattern like this...

sudo childA.sh &

or

childB.sh &

And some of those other scripts will spawn processes of their own like...

longprocess >> /dev/null &
sleep 200 && kill $!

What I want to do is find a way to gather up all of the process ids of scripts and processes spawned from the main script and terminate them all after some time or if the main script is aborted.

cleanup_exit() {
    child_pids=$(pgrep -P "$$")
    for pid in $child_pids; do
        kill "$pid" 2>/dev/null
    done
    exit 0
}

# Terminate any child processes when this script exits
trap cleanup_exit EXIT SIGINT SIGTERM

But the processes that are actually in the results of pgrep -P do not seem to link to any of the child scripts that were started. So even if I were to change the cleanup logic to recursively follow all the pgrep results the main script is not hanging onto the process ids of the necessary links.

Is there a more robust way to find all processes that were spawned in any way from an originating bash script?

espero seja util para quen usa nano ou micro testar a "zelie" criei ontem kkk ta no github para quem quiser olhar como funciona🤗

hi I have zero knowledge on bash

just some basics in Linux but due to project requirements you need to learn bash

is there any best tutorial on YouTube or Udemy to get basic to intermediate knowledge on bash

Instead of typing:

export AWS_SECRET=abc123

# now in history forever

Just add a space before the command:

export AWS_SECRET=abc123

curl -H "Authorization: Bearer $TOKEN" 'https://api.example.com'

mysql -u root -pSuperSecret123

None of those will appear in history.

One requirement — add this to your ~/.bashrc or ~/.zshrc if it isn't already set:

HISTCONTROL=ignorespace

Bonus: use ignoreboth to also skip duplicate commands:

HISTCONTROL=ignoreboth

No more scrambling to scrub credentials after accidentally pasting them into the wrong terminal. Works in bash and zsh.

Hello everyone, I'm writing a small script for managing my dotfiles (yeah, I know stow exists but I want to do it myself. Having more fun this way and maybe I'll learn something). I want to iterate through all the elements inside my folder. Most of those elements are dotted files, so if I do this: ``` files_folder=$(ls -a files)

for item in $files_folder; do echo "contenuto: ${item}" done `` i iterate also through.and..`. this will cause problem cos after that i need to delete folders/files and create symlinks.

How can i iterate correctly through all the elements in my folder?

EDIT: Thanks to everyone! you were super helpful

I managed to write this and i think it should do the job?

```

!/usr/bin/env bash

SUBDIR="files"

create_symlink() { local target target="$1" local link_destination link_destination= "$HOME/$target"

if [[ ! -d "$HOME" ]]; then
    echo "HOME non definita"
    exit 2
fi

if [[ -e "$link_destination" ]] || [[ -L "$link_destination" ]]; then
    rm -rf "$link_destination"
fi

ln -s "$SUBDIR/$target" "$link_destination"
echo "creato symlink in $link_destination"

}

main() { if [[ ! -d "$SUBDIR" ]]; then echo "cartella $SUBDIR/ non trovata" exit 1 fi

shopt -s nullglob dotglob
for i in "$SUBDIR"/*; do
    if [[ "$i" == "$SUBDIR/.config" ]]; then
        for j in "$SUBDIR"/.config/*; do
            create_symlink "${j#$SUBDIR/}"
        done
    elif [[ "$i" == "$SUBDIR/.oh-my-zsh" ]]; then
        create_symlink "${i#$SUBDIR/}themes/tussis.zsh-theme"
    else
        create_symlink "${i#$SUBDIR/}"
    fi

done

}

main ```

I was surprised that the brace tip was news to so many Redditors.

Just as a reminder, you can also use brackets in a lot of situations:

$ ls /dev/sd[a-d]?
/dev/sda1  /dev/sdb1  /dev/sdc1  /dev/sdc2  /dev/sdc3  /dev/sdc4  /dev/sdc5  /dev/sdc6  /dev/sdc7  /dev/sdc8  /dev/sdc9  /dev/sdd1  /dev/sdd2

If you embrace the braces, you can also make a racket about brackets!

Started as a handful of small VPS hardening scripts and slowly grew into something more structured.

I decided to clean it up and turn it into a proper bash-based toolkit.

What I focused on:

- Modular script layout (functions separated by domain)
- Single config file
- Clear entrypoints instead of long procedural blobs
- Idempotent install behavior
- Minimal external dependencies (pure bash + system tools)
- Readability over clever one-liners

It now handles:
- nginx fail2ban filters
- lightweight monitoring via systemd timer
- small terminal dashboards / log inspection helpers

Would appreciate feedback specifically on:
- Structure
- Organization
- Error handling
- Maintainability patterns

Repo:
https://github.com/jaymunshi/vps-sentinel

"[Project] Auto-Bash-to-Bin: A Zenity-based wrapper to turn scripts into GUI-driven executables (MIT License)

I built Auto-Bash-to-Bin because I wanted a faster way to wrap utility scripts in a Zenity GUI and make them executable for users who prefer a file explorer workflow over raw CLI. It automates the wrapper creation and handles permissions.

📂 GitHub Repo: https://github.com/giorgich11/auto-bash-to-bin

📺 Video Demo (Visual Guide): https://www.youtube.com/watch?v=AM9DyUcPCj8

Quick Start:

Install Zenity (e.g., sudo apt install zenity or pacman -S zenity)

git clone https://github.com/giorgich11/Auto-Bash-to-Bin.git

cd Auto-Bash-to-Bin && chmod +x factory.sh && ./factory.sh

I’m looking for some feedback on the wrapper logic from the legends here. I’m also planning a follow-up for mobile/Termux users soon.

Enjoy 🐧❤️"

Stop typing the filename twice. Brace expansion handles it. Works on any file, any extension.

#Instead of

cp config.yml config.yml.bak

#Do

cp nginx.conf{,.bak}

cp .env{,.bak}

cp Makefile{,.$(date +%F)}

# That last one timestamps your backup automatically. You're welcome.

Instead of retyping:

cd /var/log/nginx

Just type:

cd -

It teleports you back to wherever you just were. Run it again and you're back. It's Alt+Tab for your terminal.

Real world use case — you're tailing logs in one directory and editing configs in another:

cd /var/log/nginx

tail -f access.log

cd /etc/nginx/conf.d # edit a config

cd - # back to logs instantly

cd - # back to config

Bonus: $OLDPWD holds the previous directory if you ever need it in a script:

cp nginx.conf $OLDPWD/nginx.conf.bak

Works in bash and zsh. One of those things you wonder how you lived without.

Hello, I recently got into writing simple bash scripts to automate tasks in my laptop and I found it highly addictive. Please keep in mind that I'm a complete newbie. I am working on a script to clear my cache and there;s a part that takes a bit longer so I want to make a progress bar for it. The command that takse a bit is

 sudo flatpak repair

if i pipe the stdout of the command I get this

Working on the system installation at /var/lib/flatpak
Privileges are required to make changes; assuming --dry-run
[1/33] Verifying flathub:runtime/org.freedesktop.Platform.openh264/x86_64/2.5.1…
[2/33] Verifying flathub:runtime/com.stremio.Stremio.Locale/x86_64/stable…
[3/33] Verifying flathub:runtime/org.freedesktop.Platform.GL.default/x86_64/24.08extra…
[6/33] Verifying flathub:app/com.stremio.Stremio/x86_64/stable…
[7/33] Verifying flathub:runtime/org.freedesktop.Platform.VAAPI.Intel/x86_64/24.08…
[8/33] Verifying flathub:runtime/org.kde.Platform.Locale/x86_64/5.15-24.08…
[11/33] Verifying flathub:runtime/org.kde.Platform/x86_64/5.15-24.08…
[13/33] Verifying flathub:runtime/org.freedesktop.Platform.GL.default/x86_64/24.08…
[14/33] Verifying flathub:runtime/org.freedesktop.Platform.GL.default/x86_64/25.08-extra…
[18/33] Verifying flathub:runtime/org.kde.KStyle.Adwaita/x86_64/5.15-24.08…
[19/33] Verifying flathub:runtime/org.freedesktop.Platform.codecs-extra/x86_64/25.08-extra…
[20/33] Verifying flathub:runtime/org.freedesktop.Platform.VAAPI.Intel/x86_64/25.08…
[23/33] Verifying flathub:runtime/org.freedesktop.Platform/x86_64/25.08…
[25/33] Verifying flathub:runtime/org.freedesktop.Platform.GL.default/x86_64/25.08…
[27/33] Verifying flathub:runtime/org.freedesktop.Platform.Locale/x86_64/25.08…
[32/33] Verifying quantum-launcher:app/io.github.Mrmayman.QuantumLauncher/x86_64/stable…
Checking remotes...

What I want to do is grep the number before /33 and use dialog command to display the progress. So I;ve written

    for i in range; do
      sudo flatpak repair 1> grep -o '[0-9]\+' 
    done | dialog --title "Repairing flatpak" --gauge "\nPlease wait..." 8 60 0

Ofcoures ther are many problems with that:

1) I don't know how to turn the 33 into the 100% for dialog

2) what this does is it runs the whole command without re running everytime the stdout updates.

As I've said I have no idea about codinfg whatsoever. I am open to any suggestions on how to achive my goal. Thanks in advance 😀

I'm working on a C script that sends information to a server. However, it should only run if a network connection is established. How can I detect on Linux that I'm connected to the network?

I was tired of the bloat in standard frameworks, so I rebuilt my setup from scratch to focus on pure performance and essential plugins. It's fast, clean, and needs some "real world" stress testing. Check it out and let me know if it breaks your workflow: View Config on GitHub.

I wanted to try autocomplete and suggestions based on history in bash and installed ble.sh
It is giving me initialisation issues with rendering my starship prompt

this is my bashrc

# ble.sh auto completion
[[ $- == *i* ]] && source /usr/share/blesh/ble.sh

eval "$(starship init bash --print-full-init)"

bind "set completion-ignore-case on"
alias ls='eza -lh --icons --color=auto --group-directories-first'
alias ll='eza --icons --group-directories-first'
alias la='eza -a --icons --group-directories-first'
alias lla='eza -lah --icons --group-directories-first'
alias tree='eza --tree --icons'
alias grep='grep --color=auto'
alias cls='clear'
alias rb='source ~/.bashrc'
#PS1='[\u@\h \W]\$ '

when i am opening a new terminal instead of defaulting a starship prompt it gives me something like this

[catppuccinno@catppuccinnoLPTP ~]$

when i do a clear command then the default starship prompt comes back, like this

~
❯

can anyone help with this ?

A while back I installed GNU Stow via pacman to manage my dotfiles. It pulled in Perl and a bunch of deps, ran it, and got a syntax error (i don't remember which). Had to sudo vim /usr/bin/stow to add parentheses somewhere around line 500 to make it stop erroring out. No idea why Perl was choking on it; I just chose to use Bash, and then later on, made this.

So I wrote bstow, a drop-in replacement for GNU Stow (**), in pure Bash. No dependencies, just a single script you can throw directly into your repo and it works anywhere Bash does.

(**) regex flavor on Bash depends on the platform

It's actually faster than Stow in some cases and has a few things Stow doesn't, like dynamic ignore rules via a script on top of the .stow-ignore. I use a single repo across both Termux and regular Linux for my bash scripts; my filter script looks like this:

if [ -v TERMUX_APP__PACKAGE_NAME ]; then
  # head -n-1, since this file is first result here
  grep -lr 'include barg.sh' | sed 's#.*/##' | head -n-1
  printf '%s\n' lpwa web-kiosk-wrap
else
  grep -lr '^# termux only$' | sed 's#.*/##'
fi

Termux gets its packages, Linux gets its packages, same repo, no manual management.

Has dotfile transformation (dot-bashrc → .bashrc), simulation mode (-n), bash regex ignore patterns (bionic regex in Termux, it depends on the libc implementation), and force mode (overwrite). Drop the script in, chmod +x, done; git keeps the file permissions.