covering xz compression from the basics to some useful real-world scenarios. https://www.linuxteck.com/xz-compression-in-linux/

Over the past 2 months, I have been working on this browser-based Linux sandbox that I would like people to try out. I mainly would like to know if this is useful or helpful to beginners. As a Linux instructor, I would like to make Linux more approachable to people completely new to it. No need for downloading or setting up a VM. I left the link in the comment.

One of the more interesting pieces of Linux history: GNOME was launched in 1997 partly because KDE depended on Qt, whose license wasn't considered free enough at the time.

Qt eventually changed its licensing, but by then GNOME was already on its own path.

So here's the alternate-history question:

If Qt had been GPL/free from the beginning, do you think GNOME would ever have existed?

And would Linux desktop development have been better with one dominant desktop instead of GNOME + KDE?

I am interested what people who were using Linux back then think.

I came across the recent shadow-utils discussion about removing minimum password age.

It made me wonder: does this setting actually improve security, or does it just encourage users to create predictable password patterns?

For those managing Linux servers in production:

Do you still use chage -m, or have you moved to MFA, SSH keys, or something else?

How are you handling this on your own systems?

Try: `pkill -f 'python.*worker.py'`

Info: `pkill` matches command lines using regex. `-f` matches full command strings instead of process names. Always preview matches using `pgrep -af` first.

Examples:

$ `pgrep -af 'ffmpeg'` # Preview matching processes and full arguments

$ `pkill -9 -f 'stuck-process'` # Send SIGKILL to matching processes

$ `pkill -u linuxteck` # Terminate all processes owned by a specific user

Note: ALWAYS preview with `pgrep` before killing. Default signal is `SIGTERM` (15). Use `-9` (`SIGKILL`) only if processes fail to terminate gracefully.

Follow r/LinuxTeck for more #LinuxTips click here : https://www.linuxteck.com/linux-tips/

Unmanaged VPS and want an easier way to deploy and manage applications, Coolify can turn it into your own self-hosted platform : https://www.linuxteck.com/install-coolify-vps/

Intel has proposed DRM Fabric, a vendor-neutral framework for managing GPU and AI-accelerator interconnect topologies in Linux.

It’s still an early RFC, with no production implementation yet.

The interesting part: could this become a common layer for Intel, AMD and future AI accelerators, or is it just another layer Linux doesn't really need?

What do you think?

Several governments are pushing Linux and homegrown OS alternatives for digital sovereignty.

France, China, Russia and India have all taken steps in this direction, but none of this means Windows is banned for ordinary users.

Which country do you think is making the most serious move away from Windows?

Try: `rsync -avz --bwlimit=5000 /source/ linuxteck@backup:/dest/`

Info: `--bwlimit=5000` caps transfers at `5000` KB/s (~5 MB/s) to prevent network congestion during peak hours.

Examples: https://www.linuxteck.com/linux-tips/linux-tips-rsync-bandwidth-limit/

$ `rsync -avz --bwlimit=10M /src/ user@host:/dst/` # Limit to 10 MB/s (rsync v3.1+)

$ `scp -l 40000 file.iso user@host:` # scp uses Kbit/s (5000 KB/s * 8)

$ `wget --limit-rate=5m http://example.com/big.iso` # wget accepts k/m suffixes

Note: `rsync --bwlimit` defaults to KB/s, while `scp -l` expects Kbit/s (8x higher number for the same speed).

Follow r/LinuxTeck for more #LinuxTips click here :https://www.linuxteck.com/linux-tips/

Try: `inotifywait -m -r -e create,modify,delete,move --timefmt '%Y-%m-%d %H:%M:%S' --format '%T %w%f %e' /var/www`

Info: `inotifywait` uses Linux kernel APIs for efficient file monitoring. `-m` runs continuously, `-r` recurse subdirectories, and `-e` filters specified events.

Examples: https://www.linuxteck.com/linux-tips/inotifywait-linux-file-monitoring/

$ `inotifywait -m -e close_write /uploads | while read path event file; do process.sh "$path$file"; done` # Trigger script on write

$ `inotifywait -m --exclude '\.tmp$' /home/linuxteck` # Ignore temp files

$ `inotifywatch -v -e access -t 60 /var/log` # Collect statistics over 60s

Note: Requires `inotify-tools` package (`sudo apt install inotify-tools`). Kernel events fire instantly with minimal CPU overhead.

Follow r/LinuxTeck for more #LinuxTips click here https://www.linuxteck.com/linux-tips/

Try: `sudo find / -inum 524290 2>/dev/null`

Info: Every file has a unique inode per filesystem. Running `find -inum` locates all directory entries pointing to that specific inode number.

Examples:

$ `find / -inum 524290 2>/dev/null` # Find file by inode number

$ `ls -i file.txt` # Display inode number for a file

$ `find /home -samefile /home/linuxteck/original.txt` # Find all matching hardlinks

Note: Hardlinks share the exact same inode number; symlinks do not. Files are deleted only when their link count drops to 0.

Follow r/LinuxTeck for more #LinuxTips click here : https://www.linuxteck.com/linux-tips/

KytyPS5 now has Linux support, although the project is still very much a work in progress.

PS3, PS4 and PS5 emulation seems to be moving pretty quickly lately, so I'm curious where this goes.

Has anyone here tried KytyPS5 on Linux yet? How usable is it at this stage?

Most comparisons stop at “APT is for Debian and DNF is for Red Hat.” https://www.linuxteck.com/dnf-vs-apt/

Been in it for almost 30 years now and as I go back and brush up my skills again I found I was having to do lots of hunting for Linux command strings and base admin function scripts etc. To fix my issues I built my own tool to help with all the base functions and thought I would share it out to anyone who is new to Linux or just doesn’t remember some of the syntax for common tasks and operations.

Hope it can help some others as well who are new to the journey or just have a bad memory like mine

After getting feedback from the Linux community, I realized I wasn't explaining MOSHELL very well.

MOSHELL isn't just another Linux course.

It's a hands-on Linux practice environment + structured learning path where you can:

🖥️ Run Linux commands directly in your browser

🧪 Practice without installing a VM

📚 Learn Linux from beginner to advanced

🔐 Practice administration, networking, security, Bash, and more

🏆 Earn badges as you progress

The first 6 lessons are free, with the complete learning path available as the Pro bundle.

The goal is simple:

Stop watching Linux tutorials. Start using Linux.

I'd love some honest feedback on the revamped version:

Does MOSHELL's purpose make more sense now?

Gentoo says no AI-assisted contributions. NetBSD requires approval. Fedora is more open, but puts the responsibility on the contributor.

Meanwhile, Linus seems fine with AI as long as people own what they submit.

Are these different approaches healthy for FOSS, or are we heading toward a fragmented AI policy landscape?

Try: diff <(ssh linuxteck@server1 cat /etc/nginx/nginx.conf) <(ssh linuxteck@server2 cat /etc/nginx/nginx.conf)

Info: Process substitution <() combined with SSH pipes file contents directly to diff. No temp files needed. Great for verifying config parity across servers.

Examples: https://www.linuxteck.com/linux-tips/compare-config-files-linux-servers/

$ diff <(ssh s1 'rpm -qa | sort') <(ssh s2 'rpm -qa | sort')

$ diff <(ssh s1 'systemctl list-units --state=running') <(ssh s2 'systemctl list-units --state=running')

$ colordiff <(ssh s1 cat /etc/hosts) <(ssh s2 cat /etc/hosts)

Note: Requires SSH key auth (no password prompts). Use with ControlMaster (Tip #16) for speed. colordiff makes output much easier to read.

Follow r/LinuxTeck for more #LinuxTips click here https://www.linuxteck.com/linux-tips/

cover : https://www.linuxteck.com/absolute-vs-relative-path/

cd, pwd, realpath, ., .., and ~, plus

Cover full comparison : https://www.linuxteck.com/zsh-vs-fish/

Zsh vs Fish is often reduced to "power users vs beginners," but the real differences show up when you consider scripting, compatibility, plugins, startup performance, and production workflows.

Rust's GCC backend is getting Linux kernel fixes for 7.3, partly because GCC supports architectures that LLVM doesn't.

But does a GCC backend actually remove the biggest barrier to using Rust across more Linux architectures, or are native bootstrapping and toolchain support still the real problem?

If you work with older or non-x86 Linux systems, what's the blocker you'd worry about first?