Do you have an old Raspberry Pi gathering dust? Instead of letting it go to waste, you can turn it into a dedicated smart home controller. By using DietPi, an ultra-lightweight Linux distribution, we can run Home Assistant even on older hardware with surprising efficiency.

In this guide, we’ll walk through the process of installing Home Assistant using the optimized DietPi software catalog.

Prerequisites

• A Raspberry Pi (all models supported, though RPi 3/4/5 are faster).
• A high-quality SD card (Class 10 or A1/A2 rated).
• An active internet connection.

Step 1: Access Your DietPi Terminal

First, log in to your DietPi via SSH or a local terminal. Make sure your system is fully updated before starting:

Bash

sudo apt update
sudo apt upgrade

Step 2: Open the DietPi Software Optimizer

DietPi comes with a built-in tool that automates the installation of complex software. To open it, run:

Bash

dietpi-software

Step 3: Select Home Assistant

1. Navigate to Browse Software.
2. Scroll down to the Home Automation category.
3. Find Home Assistant and press the Spacebar to select it (you will see an asterisk [*]).
4. Tab over to OK and press Enter.

Step 4: Run the Installation

Once back in the main menu, navigate down to Install and press Enter.

Technical Note: On older single-core devices (like the Pi 1 or Zero), this process can take a significant amount of time (20–40 minutes). DietPi is compiling dependencies and setting up a Python virtual environment to ensure the best performance. Do not interrupt the process.

Step 5: Final Configuration

Once the installation finishes, the system will likely prompt for a reboot. After it comes back online, Home Assistant will start automatically in the background.

You can access your new dashboard by opening a web browser on your PC or phone and typing:

http://your-pi-ip-address:8123

Pro-Tips for Peak Performance

• Logging to RAM: Since Home Assistant writes to its database frequently, go to dietpi-config > Advanced Options and ensure RAMlog is enabled. This extends the life of your SD card.
• External Storage: If you find the system slowing down as your database grows, consider using dietpi-drive_manager to move your user data to a USB SSD.
• Stay Minimal: On older armv6l hardware, keep your integrations simple. Avoid high-bandwidth tasks like live camera streaming to keep the interface snappy.

Conclusion

Installing Home Assistant on DietPi is the “pro-level” way to build a stable, lean smart home hub. You get the power of Home Assistant without the bloat of a standard operating system.

The post Transforming Your Old Raspberry Pi into a Smart Home Hub with DietPi appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re looking for a clean, stable WhatsApp experience on your Linux desktop, ElecWhat delivers exactly that—no bloat, no noise, just a focused tool that works.

Built with simplicity and performance in mind, ElecWhat runs quietly in the background, integrates nicely with your desktop environment, and offers just enough customization to fit your workflow.

Why Use ElecWhat?

ElecWhat is a lightweight desktop client for WhatsApp that prioritizes stability, customization, and Linux-first features. The codebase is tiny—under 600 lines—which makes it easy to audit and maintain. It’s been rock-solid in daily use, handling notifications, chats, and tray icon updates without issue.

If you want a client that respects your system resources and just works, this is it.

Features at a Glance

• Desktop Notifications – Stay up to date with incoming messages.
• Tray Icon with Unread Counter – Uses AppIndicator, works well with supported desktops.
• Custom Keyboard Shortcuts – Personalize your controls.
• CSS Styling Support – Tweak the interface your way—inline styles, external files, or remote stylesheets.
• Spellcheck – Enable or disable, with support for multiple languages.
• CLI and D-Bus Support – Useful for scripting, automation, or quick toggles.
• Remembers Window Position – Picks up exactly where you left it.

Installation

Ubuntu / Kubuntu

• Available as a Snap package
• .deb file (with --no-sandbox flag due to Electron security restrictions)
• AppImage option (also requires --no-sandbox)

Arch Linux

• Install via AUR: yay -S elecwhat-bin
• Or use the AppImage / prebuilt packages from the Releases section

Debian

• Grab the .deb from Releases or Buildkite
• AppImage option also available

Fedora

• RPM packages in Releases
• AppImage support included

Tip: For tray icon support on GNOME, install the AppIndicator extension.

Configuration Example

ElecWhat keeps your settings simple and flexible. Create or edit the config at:

• ~/.config/elecwhat/config.json
• (For Snap users: ~/snap/elecwhat/current/.config/elecwhat/config.json)

Here’s an example config:

{
  "notification-prefix": "elecwhat - ",
  "quit-on-close": false,
  "show-at-startup": false,
  "dbus": true,
  "menu-bar": true,
  "menu-bar-auto-hide": true,
  "keys": {
    "C ArrowDown": {
      "whatsappAction": "GO_TO_NEXT_CHAT"
    }
  },
  "css": [
    "span { font-size: small !important; }",
    "https://gist.githubusercontent.com/piec/3f9a198a7694f1df37895ee3faee9b6e/raw/whatsapp-test.css",
    "file://~/mysheet.css"
  ],
  "spellcheck": true,
  "spellcheck-languages": ["en-US", "fr"],
  "open-dev-tools": false
}

Design Philosophy

ElecWhat is not trying to be everything. It’s meant to be small, focused, and functional. You won’t find multi-account support or complex integrations here—just a clean interface that lets you use WhatsApp on your desktop without distractions.

If you’re someone who appreciates simplicity and reliability, ElecWhat will feel right at home in your setup.

Where to Get It

You can find builds for various distributions—including .deb, .rpm, and AppImage formats—on the project’s GitHub Releases.

Give it a shot. It might be the cleanest WhatsApp client you’ve ever used on Linux.

The post ElecWhat – A Minimalist, Reliable WhatsApp Desktop Client for Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

I’ve been looking for a good self-hosted media server, and after trying out a few, I landed on Jellyfin. It’s free, open-source, and doesn’t nag you with subscriptions or locked features. Exactly what I needed.

Instead of going the traditional apt install route, I decided to install Jellyfin using Flatpak — it keeps things clean and isolated, which I prefer on my Debian setup. Here’s how I got it up and running, including setting up access to my media folder.

Step 1: Installing Flatpak (if you don’t have it)

Flatpak wasn’t installed on my machine by default, so I ran:

sudo apt update
sudo apt install flatpak -y

After that, I added the Flathub repo:

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Quick tip: After setting up Flatpak, it’s best to log out and log back in — or just reboot — to make sure everything works smoothly.

Step 2: Installing Jellyfin Server via Flatpak

The Flatpak version of Jellyfin is available on Flathub, and installing it was simple:

flatpak install flathub org.jellyfin.JellyfinServer -y

To start the server, I ran:

flatpak run org.jellyfin.JellyfinServer

You’ll see some logs in the terminal, which means Jellyfin is doing its thing. Keep this terminal open for now — or later you can make it run in the background.

Step 3: Open It in Your Browser

Once it’s running, just go to:

http://localhost:8096

That’ll open the setup wizard where you pick a language, create your user, and set up your libraries.

If you’re running this on a different machine, just replace localhost with that machine’s IP.

Step 4: Giving Jellyfin Access to Your Media

Here’s where I got stuck for a minute: Jellyfin (via Flatpak) can’t see my media folders by default because of Flatpak’s sandboxing. Took me a second to figure this out.

Let’s say your movies are in /mnt/media/movies. You’ll need to give Jellyfin permission to see that folder:

flatpak override org.jellyfin.JellyfinServer --filesystem=/mnt/media:ro

The :ro part means read-only — safe if you don’t want Jellyfin messing with your files.

If you want it to write metadata, subtitles, etc., drop the :ro:

flatpak override org.jellyfin.JellyfinServer --filesystem=/mnt/media

Then just restart Jellyfin:

flatpak run org.jellyfin.JellyfinServer

Step 5: Add Media Libraries

Back in the web interface:

• Go to Dashboard > Libraries
• Click Add Media Library
• Pick what kind of content it is (Movies, TV, Music…)
• Point it to your folder, e.g., /mnt/media/movies
• Save and let Jellyfin do its magic

It’ll start scanning and building up your media library.

That’s It!

Jellyfin’s now up and running on my Debian system via Flatpak, and it’s happily indexing my media. The Flatpak approach keeps everything tidy, and it works great so far.

If you’re like me and prefer simple, no-nonsense tools that respect your setup, Jellyfin’s worth a try. And Flatpak makes it dead simple to install without touching your system packages.

The post How I Installed Jellyfin on Debian Using Flatpak appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the world of amateur radio, situational awareness and efficient communication are paramount. Enter FreeTAKServer (FTS), an open-source implementation of a Tactical Awareness Kit (TAK) server, designed to facilitate real-time data sharing and coordination among teams. Originally developed for military applications, FTS has found its way into civilian use, including amateur radio operations.

This guide will walk you through installing FreeTAKServer using Docker, a containerization platform that simplifies deployment and management of applications.

Official docs: FreeTAKServer Docker Setup

What You’ll Need

• A Linux server (preferred — Ubuntu, Debian, Fedora, etc.)
• Docker or Podman installed

Step 1: Choose Your Container Runtime

FreeTAKServer works with both Docker and Podman.

Check what’s installed:

docker --version
podman --version

Important: Pick one and stick with it for the whole setup.

Step 2: Create a Folder

Make a folder to keep everything organized:

mkdir ~/freetakserver
cd ~/freetakserver

Step 3: Get the Compose File

FreeTAKServer provides a pre-made file to launch everything easily.

Download it:

wget https://raw.githubusercontent.com/FreeTAKTeam/FreeTAKHub-Installation/refs/heads/main/containers/example-compose.yaml -O compose.yaml

Open it in your text editor:

nano compose.yaml

Look for a line like this:

FTS_IP: YOUR EXTERNAL URL HERE

Replace it with your server’s external IP address or domain name. Example:

FTS_IP: 123.45.67.89

Save and close.

Step 4: Start the Server

Now run the services in the background:

With Docker:

docker compose -f compose.yaml up -d

With Podman:

podman-compose -f compose.yaml up -d

Step 5: Check the Logs

Want to see if it’s working?

docker logs freetakserver
docker logs freetakserver-ui

Or with Podman:

podman logs freetakserver
podman logs freetakserver-ui

Step 6: Stop the Server

When you’re done or want to update:

docker compose -f compose.yaml down

Or:

podman-compose -f compose.yaml down

Where’s My Data Stored?

All your important FreeTAKServer data lives inside a Docker volume.

To find where it’s stored:

docker inspect freetakserver_free-tak-core-db

Look for the Mountpoint — that’s the full path to your data.

Example: /var/lib/docker/volumes/freetakserver_free-tak-core-db/_data

Ports to Know

The server uses default FreeTAKServer ports, but you can customize them with environment variables in the compose.yaml if needed.

Extra Settings (Optional)

Here are some useful environment variables:

Summary

• Simple Docker-based install
• Works on Linux with Docker or Podman
• Data is stored persistently using volumes
• UI and API included

Need Help?

Check the official FreeTAKServer Docker guide here:
https://freetakteam.github.io/FreeTAKServer-User-Docs/Installation/mechanism/Docker/overview/

The post How to Install FreeTAKServer Using Docker appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

I recently installed a SriHome SH025 IP camera and wanted to monitor the live stream from my Arch Linux desktop (CachyOS in my case). While the official app works, I prefer using local tools — no cloud, no mobile app, just clean video over my LAN.

After some digging, I got the RTSP stream working beautifully with mpv, and I even created a launcher icon for quick access.

Here’s exactly how I did it — plus how to find the right RTSP port using nmap.

My Setup Goals

• Watch the SriHome SH025 stream on my Linux desktop
• Skip the cloud and use direct RTSP
• Get working video (and ideally audio)
• Add a clickable desktop launcher
• Find the RTSP port if undocumented

Finding the RTSP Port with Nmap

SriHome cameras often don’t use the default RTSP port (554) — mine used 8554. If you don’t know your camera’s port, use nmap to scan for open ones:

1. Install nmap (if you don’t already have it):

sudo pacman -S nmap

2. Scan for common video streaming ports:

nmap -p 554,8554,10554,7070,6688 192.168.0.11

Replace 192.168.0.11 with your camera’s actual IP address.

Example output:

PORT      STATE  SERVICE
554/tcp   closed rtsp
8554/tcp  open   rtsp-alt
10554/tcp closed unknown
6688/tcp  open   unknown

In my case, port 8554 was open, which matched what ffplay and mpv needed.

Testing the Stream with ffplay

Before setting up anything fancy, I tested the RTSP stream with:

ffplay rtsp://admin:888888@192.168.0.11:8554/profile0

It worked! Full 1080p video and even audio came through. This confirmed the camera was broadcasting fine over RTSP.

Daily Viewing with MPV

After confirming the stream worked, I switched to mpv for daily use. It’s lightweight and integrates better with my desktop.

mpv rtsp://admin:888888@192.168.0.11:8554/profile0

Create a Desktop Shortcut

To make launching the camera easy from my app launcher, I made a .desktop file.

1. Create the launcher:

nano ~/.local/share/applications/sricam-view.desktop

2. Paste this:

[Desktop Entry]
Name=SriHome SH025 Viewer
Comment=Open SriHome IP Camera Stream in MPV
Exec=mpv rtsp://admin:888888@192.168.0.11:8554/profile0
Icon=camera-video
Terminal=false
Type=Application
Categories=Video;AudioVideo;Utility;

3. Make it executable:

chmod +x ~/.local/share/applications/sricam-view.desktop

Wrap-up

SriHome doesn’t document these RTSP settings well, but with a little effort — and tools like nmap, ffplay, mpv, and ffmpeg — you can get full, local access to your camera stream.

The post Viewing SriHome SH025 IP Camera on Linux with MPV appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’ve ever wanted to run your own APRS-IS server, especially on an Arch-based system, I’ve packaged a convenient way to do that: aprsc-9m2pju-git, an unofficial Arch Linux AUR package for aprsc, the high-performance APRS-IS core server daemon.

This project is aimed at amateur radio operators, APRS tinkerers, and sysadmins interested in experimenting with their own APRS infrastructure. I created this package to simplify the process of building and deploying the latest development version of aprsc on Arch Linux.

What is aprsc?

aprsc is a lightweight, multithreaded server daemon written in C that forms the backbone of the APRS-IS network. It relays packets between APRS clients, Internet Gateways (IGates), and RF repeaters. aprsc is widely used on the global APRS backbone due to its performance, reliability, and robust protocol support.

Highlights:

• Fully multithreaded and scalable
• Supports thousands of concurrent client connections
• Built-in APRS-IS filter support
• Web status interface
• TLS/SSL and SCTP support

About aprsc-9m2pju-git

This AUR package builds the latest git version of aprsc from upstream:
https://github.com/hessu/aprsc

It installs everything into /opt/aprsc, provides a working systemd service, sets up user permissions, and handles runtime directory creation. It’s tailored for custom or experimental setups without interfering with core system paths.

Installation

To install via your favorite AUR helper:

yay -S aprsc-9m2pju-git

Or manually:

git clone https://aur.archlinux.org/aprsc-9m2pju-git.git
cd aprsc-9m2pju-git
makepkg -si

What Gets Installed?

Here’s a quick breakdown of installed files and locations:

• Binary & Config: /opt/aprsc/
• Systemd Service: /usr/lib/systemd/system/aprsc.service

Log files live under /opt/aprsc/logs, and the default config file is at /opt/aprsc/etc/aprsc.conf.

Running aprsc

After installation, start the service with:

sudo systemctl --user enable --now aprsc.service

Check logs:

journalctl -u aprsc.service -f

Then open your browser and visit the web interface to verify it’s running!

Things to Know

• APRS-IS Authentication: You’ll need a valid callsign and APRS-IS passcode to allow client connections or gating.
• Customize Your Config: The default aprsc.conf is a minimal example. You should update it before exposing the server to the public.
• Development Version: This package tracks the latest commit from the main branch upstream. It’s great for testing, not necessarily for production unless you know what you’re doing.

Thanks & Credits

Big shout-out to:

• Heikki Hannikainen (hessu) – author and maintainer of aprsc
• Arch Linux & AUR community – for empowering users to package and share tools easily

Maintainer

• Callsign: 9M2PJU
• Email: 9m2pju@hamradio.my
• GitHub: @9M2PJU

Resources

• Upstream Project (hessu/aprsc)
• AUR Package: aprsc-9m2pju-git
• APRS-IS Technical Wiki

If you’re curious about APRS internals, want to run your own APRS-IS node, or just like experimenting with ham radio and Arch Linux, I hope this package makes it easier for you to get started.

73 de 9M2PJU

The post Building and Running aprsc on Arch Linux with aprsc-9m2pju-git appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re the kind of person who lives in the terminal—or just spends a lot of time in it—then you know how much the right font can change everything. Not just how things look, but how clearly and efficiently you can work.

That’s where Nerd Fonts comes in.

Nerd Fonts isn’t just another developer font. It’s a complete ecosystem of patched fonts, designed specifically for devs, sysadmins, and power users who want icon-rich, powerline-compatible, and beautiful fonts—right in their favorite terminal, editor, or tool.

What Is Nerd Fonts?

Nerd Fonts is a collection, patcher, and community-powered project that takes your favorite developer fonts (like FiraCode, Hack, Iosevka, Meslo, and many more) and supercharges them by adding thousands of extra glyphs from iconic fonts like:

• Font Awesome
• Devicons
• Octicons
• Material Design Icons
• Powerline and extra powerline symbols
• Codicons (like those used in VS Code)

These patched fonts are plug-and-play: ready for any terminal, editor, or shell prompt you throw at them.

Why You’ll Love Nerd Fonts

• 10,000+ icons: From development tools to popular tech logos, you’ll always have the right symbol.
• Powerline compatibility: Every font includes Powerline and extra symbols so your status lines and shell prompts look amazing.
• Cross-platform: Linux, macOS, Windows—Nerd Fonts works on all of them.
• Plug-and-play: Download, install, select your font, and go.
• Popular project support: Used and loved by tools like Powerlevel9k, colorls, LSD (LSDeluxe), Oh My Fish, and VimDevIcons.

Want to Patch Your Own Fonts?

If you’re feeling adventurous, Nerd Fonts even includes a Font Patcher script built with FontForge. It lets you take your favorite font and merge in icons from a symbol font of your choice. The combinations are practically endless.

Use the --custom option and make something truly unique that reflects your setup and style.

Try It Yourself

Want to see it in action? Fire up your terminal with a Nerd Font and watch your shell prompt transform. Or open Vim/Neovim and enjoy filetype icons with DevIcons. Customize your LS output, powerline prompt, or even your i3bar.

You’ll quickly wonder how you ever lived without it.

Download & Get Started

Getting started is easy. Just head to the Nerd Fonts Downloads page and grab a font that suits your workflow. They’re pre-patched and ready to use.

Whether you’re a hardcore Vim user, a Zsh customizer, or just want to make your terminal more intuitive, Nerd Fonts brings your setup to life.

Open Source & Growing

Nerd Fonts is open source, built and maintained by Ryan L McIntyre, with contributions from a passionate community. The project is growing fast and is supported by backers from all over the world.

Want to contribute? Head to github.com/ryanoasis/nerd-fonts and check out how you can help!

Final Thoughts

If you value clarity, efficiency, and a bit of flair in your development environment, you owe it to yourself to try Nerd Fonts. It’s one of those small changes that has a huge impact, both visually and practically.

The post Unlock Your Terminal’s True Potential with Nerd Fonts appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What Is code-server?

code-server is an open-source project developed by Coder that allows you to run VS Code on a remote server and access it through a web browser. This setup provides a consistent development environment that can be accessed from any device, be it a laptop, tablet, or even a smartphone. By leveraging the power of cloud servers, code-server enables faster tests, compilations, and downloads, all while preserving your local device’s resources.

Key Features of code-server

• VS Code in the Browser: Experience the full functionality of VS Code, including IntelliSense, debugging, and Git integration, all within your browser.
• Remote Development: Develop on powerful cloud servers, reducing the load on your local machine and enabling resource-intensive tasks.
• Consistent Environment: Maintain a uniform development setup across different devices, ensuring consistency and reducing the “it works on my machine” problem.
• Extension Support: Install and use most VS Code extensions, enhancing your development workflow.
• Secure Access: Access your development environment securely from anywhere, with options for HTTPS and authentication.

Installation Guide

Setting up code-server is straightforward. The easiest way to install code-server is to use the official install script, which automates most of the process. This script attempts to use the system package manager if possible.

For Linux, macOS, and FreeBSD:

Run the following command in your terminal:

curl -fsSL https://code-server.dev/install.sh | sh

After installation, you can start code-server by running:

code-server

By default, code-server will be accessible at http://127.0.0.1:8080, and your password will be stored in ~/.config/code-server/config.yaml.

For Docker Users:

You can also run code-server in a Docker container:

docker run -it --name code-server -p 127.0.0.1:8080:8080 \
  -v "$HOME/.local:/home/coder/.local" \
  -v "$HOME/.config:/home/coder/.config" \
  -v "$PWD:/home/coder/project" \
  -u "$(id -u):$(id -g)" \
  -e "DOCKER_USER=$USER" \
  codercom/code-server:latest

This command mounts your current directory into the container and forwards your UID/GID so that all file system operations occur as your user outside the container.

Securing Your code-server Instance

To expose code-server securely to the internet, consider the following methods:

• Port Forwarding via SSH: If you have an SSH server on your remote machine, you can forward local ports to access code-server securely.
• Using Let’s Encrypt with Caddy or NGINX: For a more robust solution, you can set up HTTPS using Let’s Encrypt with web servers like Caddy or NGINX.
• Self-Signed Certificates: For internal use or testing, you can generate and use self-signed certificates to enable HTTPS.

These methods ensure that your code-server instance is accessible securely from anywhere.

Keeping code-server Up-to-Date

To ensure you have the latest features and security patches, it’s important to keep code-server updated. You can check for the latest releases on the GitHub Releases Page. To update, simply run the install script again:

curl -fsSL https://code-server.dev/install.sh | sh

This will download and install the latest version of code-server.

Final Thoughts

code-server empowers developers by providing a powerful, browser-based development environment that can be accessed from anywhere. Whether you’re working from a laptop, tablet, or smartphone, code-server ensures that you have a consistent and secure development setup at your fingertips.

By leveraging cloud servers, code-server enables faster development cycles and reduces the load on local machines, making it an ideal solution for modern development workflows.

The post code-server: Unlocking the Power of VS Code in Your Browser appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the analog days of amateur radio, confirming a QSO (contact) often meant waiting weeks — or even months — for a paper QSL card to arrive via postal mail. These cards, beautifully designed and personally meaningful, were — and still are — treasured by hams around the world. But with the rise of digital logging, there came a need for something faster, more secure, and scalable for the modern era.

Enter Logbook of The World (LoTW), a game-changing system developed by the ARRL (American Radio Relay League). LoTW enables licensed amateur radio operators to submit and match QSO records electronically, eliminating the need for physical QSL cards while still offering a trusted confirmation process.

At the heart of this system is TrustedQSL (TQSL) — the official software used to digitally sign and upload your contacts to LoTW. It ensures that:

• Your identity and callsign are verified via a certificate issued by ARRL.
• Your log files (usually in ADIF format) are cryptographically signed, proving their authenticity.
• Confirmations happen automatically when your logged QSOs match with others in the system.

How This Changed QSO Confirmations Forever

Before LoTW, confirming a DXCC or WAS award required collecting and organizing piles of paper cards, often at considerable cost and effort. Now, with LoTW:

• Confirmations can happen within minutes, not months.
• There’s no postage or mailing involved.
• It’s globally accessible, 24/7.
• It reduces errors, fraud, and loss compared to traditional QSL methods.
• Operators can easily track award progress with automated tools.

While paper QSLs still have sentimental and collectible value, LoTW has become the de facto standard for official QSO confirmation in contests, awards (like DXCC, WAS, and VUCC), and everyday operating.

In short, LoTW and TrustedQSL have brought amateur radio into the digital age, without compromising trust, authenticity, or the sense of connection that makes this hobby special.

For amateur radio operators who log their QSOs digitally, the ARRL Logbook of the World (LoTW) is an essential service. To upload your logs securely to LoTW, you need a tool that signs them using a valid certificate, and that’s where TrustedQSL (TQSL) comes in.

If you’re using Arch Linux or an Arch-based distro like Manjaro, EndeavourOS, or CachyOS, you won’t find TrustedQSL in the official repositories, but thanks to the Arch User Repository (AUR), installing it is straightforward.

Here’s a step-by-step guide to installing the latest development version of TrustedQSL using the trustedqsl-git AUR package.

Prerequisites

Before you begin, ensure you have an AUR helper installed. The most common options are:

• yay
• paru

If you don’t have one yet, you can install yay with:

sudo pacman -S --needed base-devel git
git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si

Installing TrustedQSL from AUR

Now that your AUR helper is ready, you can install TrustedQSL:

paru -S trustedqsl-git

Or with yay:

yay -S trustedqsl-git

This package pulls the latest source code, compiles it, and installs it on your system.

Note: The -git suffix means this package builds the development version of TQSL from source.

Launching TQSL

Once installed, you can launch TrustedQSL from your application menu or by typing:

tqsl

The interface should feel familiar to those coming from Windows or macOS. You can now:

• Request or load your LoTW certificate
• Sign ADIF logs (e.g., from WSJT-X, Log4OM, CQRLOG, etc.)
• Upload signed logs directly to LoTW

Why Use trustedqsl-git?

Using trustedqsl-git has its benefits:

• You’re always running the latest version with the newest features and bug fixes.
• Great for testing upcoming features or contributing feedback upstream.
• Works well for those comfortable with the rolling-release nature of Arch.

However, keep in mind that development versions can occasionally introduce instability. If you prefer only stable releases, consider building from ARRL’s release tarballs.

Updating TQSL

Like any AUR package, updates trustedqsl-git won’t come via pacman -Syu. Instead, update it with your AUR helper:

paru -Syu

Or specifically:

paru -S trustedqsl-git

This will rebuild TQSL from the latest commit.

Final Thoughts

TrustedQSL is a crucial tool in the modern ham operator’s digital workflow, and it works beautifully on Arch-based systems with just a bit of help from the AUR. Whether you’re uploading FT8 contacts from WSJT-X or submitting your latest DXpedition logs, TQSL keeps your LoTW submissions valid and secure.

The post Installing TrustedQSL (TQSL) on Arch Linux Using AUR appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Mounting your Google Drive on Linux allows you to access your cloud storage as if it were a local directory. This guide will walk you through the complete process of setting up and mounting Google Drive using rclone, a powerful command-line tool for cloud storage management.

Prerequisites

Before starting, ensure you have:

• A Linux system with root or sudo access
• An active Google account with Google Drive
• Internet connection for authentication and file access
• Basic familiarity with the command line

Step 1: Install rclone

Ubuntu/Debian

sudo apt update
sudo apt install rclone

CentOS/RHEL/Fedora

# For CentOS/RHEL
sudo yum install rclone

# For Fedora
sudo dnf install rclone

Arch Linux

sudo pacman -S rclone

Install from Official Script

curl https://rclone.org/install.sh | sudo bash

Verify the installation:

rclone version

Step 2: Install FUSE

To mount filesystems, rclone requires FUSE (Filesystem in Userspace):

Ubuntu/Debian

sudo apt install fuse

CentOS/RHEL/Fedora

# For CentOS/RHEL
sudo yum install fuse

# For Fedora
sudo dnf install fuse

Arch Linux

sudo pacman -S fuse2

Step 3: Configure Google Drive Remote

Start the rclone configuration process:

rclone config

Follow these steps in the interactive setup:

1. Create a new remote: n) New remote
2. Name your remote: name> gdrive (You can use any name you prefer)
3. Select Google Drive: Storage> drive
4. Leave client ID and secret blank (unless you have your own): client_id> [Press Enter] client_secret> [Press Enter]
5. Choose scope (recommended: option 1 for full access): scope> 1 This gives full access to all files except the Application Data Folder.
6. Service Account file (leave blank for personal use): service_account_file> [Press Enter]
7. Enable web browser authentication: y) Yes
8. Browser authentication:
   • rclone will open your default browser
   • Log in to your Google account
   • Grant permissions to rclone
   • Copy the verification code back to the terminal
9. Shared Drive configuration: n) No (Unless you want to access a specific Shared Drive)
10. Confirm configuration: y) Yes this is OK

Read https://rclone.org/drive/#making-your-own-client-id

Step 4: Test the Configuration

Verify that rclone can access your Google Drive:

# List directories in your Google Drive
rclone lsd gdrive:

# List all files
rclone ls gdrive:

# List files with details
rclone lsl gdrive:

Step 5: Create Mount Point

Create a directory where you want to mount Google Drive:

mkdir ~/GoogleDrive

Step 6: Mount Google Drive

Basic Mount Command

rclone mount gdrive: ~/GoogleDrive --daemon

Recommended Mount Command with Options

rclone mount gdrive: ~/GoogleDrive \
  --vfs-cache-mode writes \
  --vfs-cache-max-age 100h \
  --vfs-cache-max-size 10G \
  --vfs-read-chunk-size 32M \
  --vfs-read-chunk-size-limit off \
  --buffer-size 32M \
  --daemon

Mount Options Explained

• --vfs-cache-mode writes: Cache file writes to improve performance
• --vfs-cache-max-age 100h: Keep cached files for 100 hours
• --vfs-cache-max-size 10G: Limit cache size to 10GB
• --vfs-read-chunk-size 32M: Read files in 32MB chunks
• --buffer-size 32M: Set buffer size for better performance
• --daemon: Run in background

Alternative: Mount with GUI Support

If you’re using a desktop environment and want the mount to appear in file managers:

rclone mount gdrive: ~/GoogleDrive \
  --vfs-cache-mode writes \
  --allow-other \
  --daemon

Step 7: Verify the Mount

Check if the mount is successful:

# List mounted filesystems
df -h | grep GoogleDrive

# Check if files are accessible
ls -la ~/GoogleDrive

Step 8: Unmount Google Drive

To unmount the drive:

# Method 1: Using fusermount
fusermount -u ~/GoogleDrive

# Method 2: Using umount
sudo umount ~/GoogleDrive

# Method 3: Kill rclone process
killall rclone

Step 9: Auto-Mount on Boot (Optional)

Using systemd Service

Create a systemd service file:

sudo nano /etc/systemd/system/rclone-gdrive.service

Add the following content (replace username with your actual username):

[Unit]
Description=rclone: Remote FUSE filesystem for Google Drive
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
User=username
Group=username
ExecStart=/usr/bin/rclone mount gdrive: /home/username/GoogleDrive \
  --config=/home/username/.config/rclone/rclone.conf \
  --vfs-cache-mode writes \
  --vfs-cache-max-age 100h \
  --vfs-cache-max-size 10G \
  --vfs-read-chunk-size 32M \
  --buffer-size 32M \
  --allow-other
ExecStop=/bin/fusermount -u /home/username/GoogleDrive
Restart=always
RestartSec=10

[Install]
WantedBy=default.target

Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable rclone-gdrive.service
sudo systemctl start rclone-gdrive.service

Check service status:

sudo systemctl status rclone-gdrive.service

Using /etc/fstab

Add the following line to /etc/fstab:

sudo nano /etc/fstab

Add this line (replace username with your actual username):

gdrive: /home/username/GoogleDrive rclone rw,noauto,nofail,_netdev,user,exec,allow_other 0 0

Performance Tips

Optimize for Your Use Case

For frequent small file access:

rclone mount gdrive: ~/GoogleDrive \
  --vfs-cache-mode full \
  --vfs-cache-max-size 10G \
  --vfs-read-ahead 256M \
  --daemon

For streaming large files:

rclone mount gdrive: ~/GoogleDrive \
  --vfs-cache-mode off \
  --vfs-read-chunk-size 128M \
  --vfs-read-chunk-size-limit 2G \
  --buffer-size 64M \
  --daemon

Troubleshooting

Common Issues and Solutions

Issue: Permission denied

# Add your user to the fuse group
sudo usermod -a -G fuse $USER
# Log out and log back in

Issue: Mount point is busy

# Force unmount
sudo umount -l ~/GoogleDrive

Issue: Slow performance

# Increase cache settings
rclone mount gdrive: ~/GoogleDrive \
  --vfs-cache-mode full \
  --vfs-cache-max-size 20G \
  --daemon

Issue: Files not showing immediately

# Add directory cache timeout
rclone mount gdrive: ~/GoogleDrive \
  --dir-cache-time 1000h \
  --daemon

Check rclone Logs

# View logs
rclone mount gdrive: ~/GoogleDrive --log-level INFO --log-file ~/rclone.log

# Or run in foreground for debugging
rclone mount gdrive: ~/GoogleDrive -v

Security Considerations

1. Token Security: Your authentication tokens are stored in ~/.config/rclone/rclone.conf. Protect this file with appropriate permissions: chmod 600 ~/.config/rclone/rclone.conf
2. Network Security: All communication with Google Drive is encrypted via HTTPS.
3. Local Access: Use --allow-other carefully as it allows other users to access the mount.

Conclusion

You now have Google Drive mounted on your Linux system! The mounted directory behaves like any other local directory, allowing you to:

• Copy files to and from Google Drive using standard commands
• Edit files directly in your preferred applications
• Access Google Drive through your file manager
• Use command-line tools on your cloud files

Remember that changes to files are synchronized with Google Drive, so always ensure you have a stable internet connection when working with important files.

For advanced usage and additional options, refer to the official rclone documentation.

The post How to Mount Google Drive using rclone on Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Developed by Louis Lam, the creator of Uptime Kuma, Dockge is a sleek, self-hosted solution for managing your docker-compose.yaml files in a user-friendly, modern web UI—directly from your own infrastructure.

What Is Dockge?

Dockge is a Docker Compose manager that acts as a control center for all your containerized applications. Unlike heavyweight orchestration platforms like Portainer or Rancher, Dockge doesn’t abstract away your Compose files—instead, it embraces them.

It runs in your browser, provides a beautiful and responsive interface, and gives you full control over managing, editing, and deploying Docker Compose stacks.

If you’ve been manually juggling docker-compose up, down, logs, and pull across multiple folders and terminals, Dockge will feel like a leap into the future.

Core Features That Make Dockge Shine

File-Centric Management

Dockge doesn’t lock you into a database or an internal config. Your compose.yaml files live on disk, exactly where you put them. Want to edit them outside Dockge? Go ahead. Dockge simply reflects and operates on your actual file structure.

Clean, Reactive UI

Built with modern web technologies (likely Vue/React), Dockge’s interface is snappy and beautiful. Navigating your projects, spinning containers up and down, and checking logs feels almost instantaneous.

Built-in YAML Editor

No need to SSH in or fumble through nano. Dockge provides an in-browser YAML editor with syntax highlighting, so you can tweak your Compose files in real-time, from any device.

Manage Container Lifecycle

With just a few clicks, you can:

• Start or stop containers
• Restart entire stacks
• Pull new images
• View live logs
• See environment variables

Multiple Project Support

Dockge supports multiple projects, each represented as a folder containing a Compose file. Think of it as a workspace manager—ideal for homelabbers running various self-hosted services like Home Assistant, Nextcloud, Pi-hole, Jellyfin, etc.

Web Terminal

Need to run a one-off command inside a container? The integrated web terminal gives you shell access right in the browser, without needing to docker exec manually.

Convert Docker Run to Compose

This underrated feature lets you paste a docker run command and convert it into a docker-compose.yaml file. It’s a brilliant way to transition your one-off containers to managed stacks.

Who Is Dockge For?

Dockge is tailor-made for:

• Developers who want more control over containerized environments.
• Self-hosting enthusiasts looking for clean, no-nonsense management of their homelab apps.
• Tech-savvy hobbyists who don’t want to learn Kubernetes or manage overkill dashboards.
• Minimalists who believe that good tools should be powerful and elegant.

Getting Started with Dockge

Setting up Dockge is incredibly simple—if you already use Docker Compose, you’re halfway there. Here’s a high-level overview:

1. Clone the Repository

git clone https://github.com/louislam/dockge /opt/dockge

2. Move Into the Directory

cd /opt/dockge

3. Start the Service

docker compose up -d

By default, Dockge runs a web server where you can start managing your Compose projects immediately. It reads your existing file structure, meaning there’s no database to configure and no vendor lock-in.

4. Optional: Add Auth and SSL

You can easily integrate it behind a reverse proxy with basic auth or OAuth (via Nginx, Traefik, etc.) to keep your setup secure.

Community & Support

Dockge is a growing open-source project with an active and supportive community. Here’s how to get involved:

• Join GitHub Discussions
• Report bugs and suggest features via GitHub Issues
• Contribute code or docs to help the project grow

Louis Lam has a reputation for responsiveness and quality (just look at Uptime Kuma’s success), so Dockge is in good hands.

Dockge vs Alternatives

Feature	Dockge	Portainer	Yacht
Compose-first design	Yes	No (UI-driven)	Yes
File-based	Yes	No	Yes
Lightweight UI	Blazing fast	Heavy	Moderate
Conversion Tools	docker run → compose	No	No
Terminal Access	Built-in		No
Multi-project	Excellent

Final Thoughts: Should You Use Dockge?

Absolutely—especially if you value clean interfaces and control.

Dockge bridges the gap between command-line flexibility and modern user interfaces. It’s the perfect tool for self-hosters and developers who want a non-intrusive, elegant, and functional way to manage Docker Compose environments.

Whether you’re managing a fleet of Raspberry Pis, running a mini data center at home, or just hosting your personal blog and media server, Dockge will make your life easier.

Explore More

GitHub: https://github.com/louislam/dockge

Try it, star it, and join the conversation. Your containers will thank you.

The post Dockge: The Ultimate Docker Compose Manager for Modern Self-Hosters appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re into amateur radio and love tinkering with Linux, you’ve probably heard of the Xiegu X6100—a portable HF transceiver that combines solid performance with an open, hackable platform. But what if you could take it further and run a full Armbian Linux system directly on it?

Thanks to the work by Links2004, it’s now possible.

Why Run Armbian on the X6100?

The X6100 runs on a Quad-Core Cortex-A7 SoC, originally intended for embedded systems and Android. Xiegu ships it with a custom Linux build, but it’s minimal, locked down, and missing common developer tools. For power users and developers, this is limiting.

By installing Armbian—a Debian-based lightweight Linux distro optimized for ARM devices—you can:

• Get full access to the system
• Use standard packages and development tools
• Enable remote access via SSH
• Customize the firmware environment

It essentially transforms your X6100 from just a radio into a mini portable Linux server.

What This Project Offers

The x6100-armbian project provides:

• A working Armbian image for the X6100’s internal eMMC or external SD card
• A ready-to-use u-boot bootloader configuration
• A tailored Linux kernel and device tree for X6100 hardware
• Instructions for flashing and booting Armbian
• Tools for creating your own image

The goal is to make your X6100 boot into Armbian like any SBC (think Raspberry Pi, but with a radio attached).

What Works (and What Doesn’t Yet)

According to the repo, here’s what works:

Serial console over USB
Ethernet over USB
WiFi
GPIO, I2C, SPI
Audio input/output
LCD panel
Battery status

This makes it possible to use the device for advanced scripting, monitoring, and even remote ham operations via the internet.

As with all bleeding-edge projects, some features may still need refinement—so treat this as experimental <– WARNING.

Getting Started

To try this out:

1. Clone the Repository
   Start by cloning the GitHub repo:
   git clone https://github.com/Links2004/x6100-armbian
2. Build or Download an Image
   You can either build the image from scratch using the Armbian build system, or download a prebuilt one (if available in the repo).
3. Flash to SD or eMMC
   Flash the image to an SD card using dd, Etcher, or your favorite tool. Boot it via the SD card first before flashing to internal storage.
4. Boot and Connect
   Connect to the serial console via USB or use the onboard Ethernet-over-USB to SSH in. You’ll be greeted with a full Armbian environment.

Use Cases

So what can you do once you’ve got Armbian running?

• Host a digital mode gateway (FT8, JS8Call, APRS)
• Develop custom X6100 tools using Python or C++
• Create a remote-controlled ham station over the web
• Run audio processing, logging software, or cloud sync scripts
• Harden and sandbox the radio for secure field deployment

The possibilities are only limited by your creativity—and your battery life!

Final Thoughts

Running Armbian on the X6100 breathes new life into an already impressive device. It opens up a playground for experimentation, automation, and integration, bridging the gap between the Linux SBC world and amateur radio.

Whether you’re a hacker, a maker, or a serious ham radio operator, this project is well worth a look. Just keep in mind: this is a community-driven effort, not an official Xiegu firmware, so proceed with care—and make backups! No warranty! This is not for normal users.

Credit:
All thanks and credit to Links2004 on GitHub for pioneering this project. You can view the full project and contribute at:
https://github.com/Links2004/x6100-armbian

The post Running Armbian on the Xiegu X6100 appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

But let’s be real: remembering all those -S, -R, -Q, and -Syu flags gets confusing fast. I used to look them up constantly (even for simple stuff), until I sat down and made a simple system to actually remember them.

Basic Concept: Think in Categories

Rather than memorizing every command individually, we grouped them by what we needed to do. Just like you’d do in real life:

• Install something
• Remove something
• Search for something
• Get information
• Clean things up

Turns out, pacman follows this logic really well.

Install & Update Packages

Install a package:

pacman -S <package>

Remember -S as “Send it to me” (Sync from the repository).

Update everything (the Arch way):

pacman -Syu

Mnemonic: “Sync, refresh the repos with y, and update everything.”

You’ll use this more than anything else.

Remove Packages (Cleanly!)

Remove a package:

pacman -R <package>

Just deletes the program—not configs or dependencies.

Full, squeaky-clean removal:

pacman -Rns <package>

Rns = Remove Neatly & Squeaky — it deletes the package, its unused dependencies, and leftover config files. I use this when I’m done testing something.

Searching for Packages

Search available packages (online repo):

pacman -Ss <keyword>

Ss = Search Store

Search only installed packages:

pacman -Qs <keyword>

Qs = Query System

Package Information

Get info about a package in the repo:

pacman -Si <package>

Get info about an installed package:

pacman -Qi <package>

List all files a package installed:

pacman -Ql <package>

Find out what package owns a file:

pacman -Qo /path/to/file

Cleanups & Maintenance

Arch doesn’t clean up after itself by default, so we run these occasionally:

Remove orphaned packages (leftovers):

pacman -Rns $(pacman -Qdtq)

Clean the package cache (but keep most recent):

pacman -Sc

Clean EVERYTHING in the cache:

pacman -Scc

Scc = Super clean cache (but be careful—you’ll need to re-download packages later).

Bonus: Troubleshooting Tools

These aren’t used often, but they’re lifesavers:

• Check missing files from installed packages: pacman -Qk
• Mark a package as explicitly installed: pacman -D --asexplicit <package>
• Mark it as a dependency instead: pacman -D --asdeps <package>

Trick to Memorize Them All

• We grouped all commands by action. Just ask yourself: Am I installing? Searching? Cleaning?
• Made up little mnemonics:
  • Syu = “Sync Your Universe”
  • Rns = “Remove Neatly & Squeaky”
  • Ss = “Search Store”
  • Qi = “Query Installed”
• Typed them often. Practice helps way more than reading.

Final Cheat Sheet

Here’s a quick reference:

The post Memorize Most Useful Pacman Commands appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re using CachyOS or any Arch-based distribution with Btrfs and want to enable hibernation, this guide will walk you through a clean and correct setup.

We’ll create a dedicated Btrfs subvolume for swap, configure the swap file correctly for compatibility, and set up everything needed for hibernation, including kernel parameters.

Why This Matters

Btrfs is great, but it introduces some complications when using swap files, especially for hibernation. The kernel needs to know the physical disk offset of the swap file, and that file must be non-compressed, non-COW, and stored in its own dedicated subvolume.

1. Clean Up Any Existing Broken Setup

sudo swapoff -a
sudo umount /swap 2>/dev/null || true
sudo btrfs subvolume delete /swap 2>/dev/null || true
sudo rm -rf /swap

2. Create a New Swap Subvolume

sudo mkdir -p /mnt/btrfs-root
sudo mount -o subvolid=5 /dev/disk/by-uuid/<YOUR_ROOT_UUID> /mnt/btrfs-root
sudo btrfs subvolume create /mnt/btrfs-root/swap
sudo umount /mnt/btrfs-root
sudo rmdir /mnt/btrfs-root

Replace <YOUR_ROOT_UUID> with the UUID of your Btrfs root. Find it using:

findmnt -no UUID /

3. Mount the Subvolume via /etc/fstab

Add this line to /etc/fstab:

UUID=<YOUR_ROOT_UUID> /swap btrfs subvol=swap,noatime,compress=no,space_cache=v2 0 0

Then:

sudo mkdir /swap
sudo mount -a

4. Create the Swap File

sudo chattr +C /swap
sudo fallocate -l 16G /swap/swapfile  # adjust size as needed
sudo chmod 600 /swap/swapfile
sudo mkswap /swap/swapfile
sudo swapon /swap/swapfile

Make sure it appears with:

swapon --show

5. Get the Resume Offset

sudo btrfs inspect-internal map-swapfile -r /swap/swapfile

You’ll get a number like 4546994. That is your resume_offset.

6. Update Kernel Parameters (GRUB)

Edit /etc/default/grub:

GRUB_CMDLINE_LINUX_DEFAULT="... resume=UUID=<YOUR_ROOT_UUID> resume_offset=4546994"

Then regenerate GRUB config:

sudo grub-mkconfig -o /boot/grub/grub.cfg

7. mkinitcpio Hooks

Edit /etc/mkinitcpio.conf and make sure resume is after udev:

HOOKS=(base udev autodetect microcode modconf kms keyboard keymap consolefont block filesystems resume fsck)

Then:

sudo mkinitcpio -P

8. Test Hibernation

sudo systemctl hibernate

After the system powers off, turn it on again. It should resume your session from swap.

Final Notes

• Don’t rely on /boot/efi/EFI/cachyos/grub.cfg; GRUB on EFI loads /boot/grub/grub.cfg.
• zram does not support hibernation; ensure your swapfile is active and recognized.
• Want to increase speed? Consider adding hibernate.compressor=lz4 to your kernel line.

Hibernation on Btrfs is not trivial, but once it’s done properly, it works just as well as with traditional setups. Good luck and happy hacking!

The post Setting Up a Btrfs-Compatible Swap File with Hibernation on CachyOS (or Any Arch-based System) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When setting up a Linux system—whether it’s a personal laptop, home server, or enterprise-grade machine—you eventually face this deceptively simple question:
“Which filesystem should I use?”

And while most people just stick with whatever the distro gives them (usually ext4), the truth is… there are better options out there—depending on what you’re doing.

In this post, I’ll walk you through the four main contenders: ext4, Btrfs, XFS, and ZFS. Each one has strengths and quirks. Let’s make sense of them.

ext4 – The Reliable Classic

If you’re running Linux, there’s a 90% chance you’re already using ext4. It’s the default for most distributions, and for good reason:

• It’s fast.
• It’s stable.
• It just works.

But here’s the thing: ext4 doesn’t do fancy stuff like snapshots, compression, or self-healing. If you don’t need those features, then it’s still a fantastic choice.

Use it if:
You’re setting up a general-purpose desktop or server and want maximum compatibility and no surprises.

Btrfs – The Smart All-Rounder

Btrfs (pronounced “butter-fs” or “bee-tree-fs”, pick your poison) is a modern filesystem built with cool features like:

• Snapshots (think instant backups)
• Transparent compression
• Built-in RAID support
• Checksums for data integrity

It’s a bit like ZFS but more lightweight and integrated into the Linux kernel.

Use it if:
You want modern features, better data safety, and don’t mind a little learning curve.

XFS – The Big File Specialist

XFS is a beast when it comes to large files and high-throughput storage. Originally developed by SGI, it’s now maintained by the Linux community and used heavily in environments like:

• Video editing
• Large-scale backups
• Databases with massive files

But it’s not great for small files or everyday desktop use.

Use it if:
You’re working with terabytes of video, raw photos, or large scientific datasets.

ZFS – The Data Guardian

ZFS is legendary. It’s basically a combination of a volume manager and a filesystem. It gives you:

• Extreme data integrity (self-healing)
• Snapshots, cloning, deduplication
• Built-in RAID (no more mdadm!)
• Compression, encryption—you name it

Sounds amazing, right? It is. But you’ll need a decent amount of RAM (8 GB+ is ideal), and it’s not included in the Linux kernel for licensing reasons—so you’ll need to install it manually.

Use it if:
You’re running a serious NAS or server and want the best protection against data loss.

So… Which One Should You Use?

Final Thoughts

The beauty of Linux is choice—but that also means doing a bit of homework. Fortunately, filesystems like ext4 and Btrfs make it hard to go wrong.

If you’re setting up a personal machine: ext4 is rock solid.
If you’re tinkering or want cool features: give Btrfs a go.
If you’re building a fortress for your data: ZFS is king.

Whichever route you take, just make sure to back up your data. Even the best filesystem won’t save you from rm -rf /

The post Choosing the Best Filesystem for Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Isn’t Linux supposed to be faster?

Yes… but “lighter” doesn’t always mean “faster” in daily use. There are several reasons why Ubuntu 25.04 might feel heavier than Windows 10 on the same hardware, and the good news is: you can fix most of them.

Let’s explore why this happens and how you can tweak Ubuntu for a smoother experience.

GNOME Desktop: Beautiful but Bulky

Ubuntu 25.04 ships with the GNOME desktop environment, which is modern and visually polished—but not lightweight.

Compared to Windows 10’s UI, GNOME:

• Uses more RAM and CPU
• Has animations and background daemons that run persistently
• May struggle on older or mid-range hardware

Fix: Install a lighter desktop environment like:

• Xfce: sudo apt install xubuntu-desktop
• MATE: sudo apt install ubuntu-mate-desktop
• LXQt: sudo apt install lubuntu-desktop

These will drastically improve responsiveness, especially on older systems.

Memory Handling: Different Philosophies

Windows 10 uses aggressive memory prefetching and caching to make apps launch quickly. Even if the system uses more RAM, it often feels snappier.

Ubuntu, on the other hand:

• Prioritizes minimal RAM usage at idle
• Loads apps on-demand rather than predicting

So Linux may feel slower to launch apps, but it’s actually using RAM more efficiently. The “snappiness” just needs a few tweaks.

Fix:

• Install preload: sudo apt install preload
• Enable zram swap: sudo apt install zram-tools && sudo systemctl enable --now zramswap.service

Drivers: Windows Has the Advantage

Most laptops come with OEM-optimized drivers for Windows. Linux often has to rely on:

• Generic open-source drivers
• Community-developed alternatives (e.g. Nouveau for NVIDIA)

This can affect:

• Graphics performance
• Battery life
• Touchpad gestures
• Wi-Fi stability

Fix:

• Use proprietary drivers where available: sudo ubuntu-drivers autoinstall
• Reboot and check with lshw -c video to confirm usage.

Power Management and CPU Scaling

On Windows, manufacturers preload power profiles, tuned firmware, and thermal governors.

Linux relies on the CPU governor, which may default to “powersave” or “ondemand”—making your laptop feel laggy.

Fix:

• View profiles: powerprofilesctl list
• Switch to performance: sudo apt install power-profiles-daemon powerprofilesctl set performance

For older systems, use cpufrequtils:

sudo apt install cpufrequtils
echo 'GOVERNOR="performance"' | sudo tee /etc/default/cpufrequtils
sudo systemctl restart cpufrequtils

Snap Packages and Startup Lag

Ubuntu ships many apps as Snap packages. These:

• Are isolated and more secure
• But launch slower and consume more disk I/O

Fix:

• Replace with .deb versions when possible: sudo snap remove firefox sudo add-apt-repository ppa:mozillateam/ppa sudo apt install firefox

You can also disable Snap entirely and switch to Flatpak or classic APT apps.

Optional Tips for a Faster Ubuntu

Here are a few more tweaks to make Ubuntu faster and lighter:

Disable Unused Services

Use systemd-analyze blame to see slow boot processes. Disable what you don’t need:

sudo systemctl disable <service>

Use a Lightweight File Manager

Replace Nautilus with something faster like:

sudo apt install thunar

Use a Lightweight Browser

Try Librewolf, Falkon, or GNOME Web instead of Firefox or Chrome.

Benchmark Comparison: Windows 10 vs Ubuntu 25.04 (GNOME)

With the above tweaks (especially desktop environment change and Snap removal), Ubuntu can outperform Windows 10 in real-world use.

Conclusion: Don’t Give Up on Ubuntu!

If Ubuntu 25.04 feels heavier than Windows 10, it’s not your hardware—it’s just that Ubuntu’s default setup is not optimized for every machine out-of-the-box.

The beauty of Linux is in its customizability. With a few simple tweaks, you can make Ubuntu faster, lighter, and tailored perfectly to your system.

Feel free to share this post with friends facing the same issue—or better yet, give them a hand tuning their Linux box.

The post Why Windows 10 Feels Lighter Than Ubuntu 25.04 (And How to Fix It) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In this post, we’ll explore the top 5 open-source NAS operating systems you can deploy today. Each one is suited to different needs—ranging from powerful enterprise-level setups to simple plug-and-play solutions for beginners.

1. TrueNAS CORE (formerly FreeNAS) – The ZFS King

Base OS: FreeBSD
Filesystem: ZFS
Best for: Power users, enterprises, and anyone who values data integrity

Why TrueNAS CORE?

TrueNAS CORE is the gold standard in open-source NAS software. Built on FreeBSD and leveraging the incredibly robust ZFS file system, it offers data protection features like checksumming, copy-on-write, and built-in snapshots.

It comes with a polished web UI, plugin support (e.g., Nextcloud, Plex, Transmission), replication tools, encryption, and advanced networking. It even supports virtual machines and Docker via its Linux counterpart, TrueNAS SCALE.

Recommended if you have 8GB+ RAM, preferably ECC, and want bulletproof storage with enterprise-level features.

https://www.truenas.com/truenas-core/

2. OpenMediaVault (OMV) – Best for Simplicity and Home Use

Base OS: Debian Linux
Filesystem: ext4, XFS, Btrfs, ZFS (via plugin)
Best for: Home servers, Raspberry Pi NAS builds, beginners

Why OpenMediaVault?

If you’re looking for something lightweight and easy to manage, OMV is your go-to. It’s perfect for home users or beginners wanting to set up a file server, media server, or even a Time Machine backup destination.

With Docker and Portainer integration, you can run containers effortlessly. It also has a large ecosystem of plugins and excellent community support.

Ideal for Raspberry Pi, mini PCs, or old laptops converted into a NAS.

https://www.openmediavault.org/

3. Rockstor – Linux-Based NAS with Btrfs Power

Base OS: openSUSE (newer versions)
Filesystem: Btrfs
Best for: Developers, Docker fans, modern Linux users

Why Rockstor?

Rockstor is a lesser-known but powerful NAS option that revolves around Btrfs, a modern copy-on-write file system with snapshot and compression capabilities. It features a clean web UI, Docker support, and great storage management features.

If you’re into Linux and want an alternative to ZFS, Rockstor’s Btrfs-first approach is worth trying.

Perfect for DIYers and devs looking to experiment with containers and Btrfs.

https://rockstor.com/

4. XigmaNAS (formerly NAS4Free) – Lightweight BSD NAS

Base OS: FreeBSD
Filesystem: ZFS, UFS
Best for: Legacy hardware, users who want a BSD NAS without bloat

Why XigmaNAS?

Think of XigmaNAS as the simpler cousin of TrueNAS. It’s BSD-based, supports ZFS, and runs well on older hardware. The UI is not as polished, but it gets the job done.

It supports all major sharing protocols (SMB, NFS, AFP, FTP, etc.) and can be configured for RAID, iSCSI, and rsync easily.

Great for repurposing older PCs into reliable NAS boxes.

https://www.xigmanas.com/

5. EasyNAS – Minimalist and Straightforward

Base OS: openSUSE
Filesystem: Btrfs
Best for: Total beginners, plug-and-play NAS setups

Why EasyNAS?

True to its name, EasyNAS is built for simplicity. It’s lightweight, quick to install, and has a minimal interface that lets you set up your file server in minutes. It lacks advanced features, but for basic use—like backing up files or sharing over the network—it’s more than capable.

Best if you want a “set it and forget it” NAS with minimal learning curve.

https://easynas.org/

Comparison at a Glance

Final Thoughts: Which NAS Should You Choose?

• Choose TrueNAS CORE if you want maximum reliability with ZFS, advanced features, and don’t mind the extra learning curve.
• Choose OpenMediaVault for ease of use, Raspberry Pi support, and excellent Docker integration.
• Choose Rockstor if you prefer Linux and want to explore Btrfs with Docker.
• Choose XigmaNAS for a light BSD-based NAS on old or underpowered hardware.
• Choose EasyNAS if you want a quick and easy local file server without the fluff.

Have questions or need help choosing the right NAS for your setup? Feel free to reach out or drop a comment below. Whether you’re running this on a recycled PC or a Raspberry Pi, there’s never been a better time to go open-source with your storage.

The post The Best Open Source NAS Operating Systems appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

As radio amateurs, integrating real-world sensor data into APRS can be both useful and fun. In this guide, I’ll show you how to use a Bash script to automatically fetch your local weather data from OpenWeatherMap and send it to the APRS-IS network.

This method is especially useful for stations that don’t have a dedicated weather station but want to share weather conditions based on their location.

What You’ll Need

• A Linux machine or server (I’m using Debian)
• Your APRS callsign and passcode
• An OpenWeatherMap API key (free)
• Coordinates of your QTH
• jq and netcat installed

Step 1: Get Your API Keys

APRS-IS Passcode

If you don’t already have a passcode, you can generate it based on your callsign. For example, you can use my free generator here:

https://pass.hamradio.my

OpenWeatherMap API Key

1. Go to https://openweathermap.org/api
2. Sign up for a free account.
3. Copy your API key from the dashboard.

Step 2: Determine Your Coordinates

You’ll need your latitude and longitude in decimal format.

Example for Kuala Lumpur:

• Latitude: 3.1390
• Longitude: 101.6869

Step 3: The Bash Script

Here’s the full script:

#!/bin/bash

# === USER CONFIGURATION ===
CALLSIGN="PJUWX-13"                   # Your APRS callsign (with SSID)
PASSCODE="12031"                      # Your APRS-IS passcode
LAT="3.1390"                          # Latitude (decimal format)
LON="101.6869"                        # Longitude (decimal format)
OPENWEATHER_API_KEY="your_api_key"   # Replace with your OpenWeatherMap API key
SERVER="rotate.aprs2.net"            # APRS-IS server
PORT="14580"                          # APRS-IS port
COMMENT="9M2PJU WX Station 🐧"       # Comment sent with weather data

# === FETCH WEATHER DATA ===
weather_json=$(curl -s "https://api.openweathermap.org/data/2.5/weather?lat=$LAT&lon=$LON&units=metric&appid=$OPENWEATHER_API_KEY")
temp=$(echo "$weather_json" | jq '.main.temp' | xargs printf "%.0f")
humidity=$(echo "$weather_json" | jq '.main.humidity')
pressure=$(echo "$weather_json" | jq '.main.pressure')

# === FORMAT WEATHER PACKET ===
lat_aprs=$(printf "%02d%05.2fN" "${LAT%.*}" "$(echo "${LAT#*.} * 60 / 1" | bc -l)")
lon_aprs=$(printf "%03d%05.2fE" "${LON%.*}" "$(echo "${LON#*.} * 60 / 1" | bc -l)")

WX_PACKET="${CALLSIGN}>APRS,TCPIP*:@$(date -u +%d%H%Mz)!${lat_aprs}/${lon_aprs}_.../...g...t$(printf "%03d" $temp)r...p...P...h${humidity}b$(printf "%05d" $((pressure * 10))) ${COMMENT}"

# === SEND TO APRS-IS ===
(
echo "user $CALLSIGN pass $PASSCODE vers PJUWX-Bash 1.0"
echo "$WX_PACKET"
sleep 1
) | nc "$SERVER" "$PORT"

echo "✅ Sent: $WX_PACKET"

Save this as send_weather_aprs.sh, and make it executable:

chmod +x send_weather_aprs.sh

What This Script Does

1. Fetches Weather Data from OpenWeatherMap using your coordinates and API key.
2. Extracts:
   • Temperature (°C)
   • Humidity (%)
   • Pressure (hPa)
3. Formats your position in APRS format (degrees and minutes).
4. Builds an APRS packet with a weather report.
5. Sends the packet using Netcat (nc) to the APRS-IS network.

Automate It with Cron (Optional)

To send updates every 20 minutes, add it to your crontab:

crontab -e

Then add:

*/20 * * * * /path/to/send_weather_aprs.sh

Example APRS Packet

PJUWX-13>APRS,TCPIP*:@220945z0313.14N/10141.21E_.../...g...t031r...p...P...h78b10032 9M2PJU WX Station 🐧

Things to Improve

This is a simple example to get you started. You could extend this by:

• Adding wind speed and direction
• Including rainfall (requires API with more data or sensors)
• Sending packets via RF using a TNC instead of APRS-IS
• Switching to Python for better formatting and error handling

Conclusion

This script is a lightweight, no-hardware solution to send real-time weather data to APRS using just Bash and a public API. Whether you’re setting up a portable station or just want to contribute environmental data from your QTH, this is a great way to get started.

Feel free to modify, share, or expand upon it!

The post Sending Weather Data to APRS-IS Using Bash and OpenWeatherMap API appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When you stream your favorite Netflix show without buffering, you’re witnessing the power of FreeBSD in action. Behind the scenes of every seamless streaming experience lies one of the most impressive FreeBSD deployments in the world – Netflix’s Open Connect CDN, which delivers terabits of data per second to millions of viewers across 190+ countries.

The Challenge: Scaling to Global Proportions

Netflix faced a monumental challenge as streaming demand exploded globally. They needed an operating system that could handle massive traffic volumes while maintaining rock-solid stability and performance. The solution had to be flexible enough for extensive customization and optimization to meet Netflix’s unique operational requirements.

The stakes were high. As Gleb Smirnoff, Netflix’s skilled FreeBSD engineer, puts it: “We are one of the biggest sources of traffic on the internet – sending terabits per second, powered by thousands of servers or appliances, all running FreeBSD.”

The FreeBSD Solution: Why Open Source Won

Netflix didn’t just adopt FreeBSD – they embraced it completely. Starting with a proof-of-concept CDN built on FreeBSD 9.0-RELEASE in 2012, Netflix quickly realized that achieving their ambitious growth targets required pushing beyond standard operating system capabilities.

Here’s the key insight that changed everything: Netflix discovered that even a single percentage point increase in CDN performance translates to hundreds of thousands of dollars in savings. This made investing in FreeBSD’s ongoing development not just worthwhile, but essential.

The Bold Decision: Tracking FreeBSD-CURRENT

While many organizations play it safe with stable releases, Netflix made a counterintuitive choice that paid off massively. Drew Gallatin, a FreeBSD veteran with over 25 years of experience, explains their strategy:

“We decided what we were doing was silly, and what we should do is track FreeBSD-CURRENT. It sounds crazy because that’s where everybody pushes all their stuff, but it’s actually the best thing in the world for us.”

This approach allows Netflix to catch regressions immediately rather than discovering problems years later. As Gallatin notes: “When we run FreeBSD-CURRENT, we catch things really fast. If there’s some regression, we catch it right away.”

Performance Breakthroughs: What FreeBSD Enabled

Netflix’s FreeBSD implementation has achieved remarkable performance milestones:

400 Gb/s Throughput: Netflix operates the world’s first 100+ gigabit per second production CDN servers, achieving 375 Gb/s at 53% CPU utilization.

Kernel TLS Innovation: By moving TLS processing from user applications to the kernel, Netflix eliminated memory bandwidth bottlenecks and preserved the efficient sendfile pipeline. This breakthrough enabled their record-breaking throughput.

RACK TCP Stack: Netflix contributed to developing RACK (Recent ACKnowledgment), improving TCP performance and reliability for high-volume data transmission.

Asynchronous Sendfile: Netflix’s optimizations enable non-blocking data transfers that dramatically improve network throughput.

The Open Source Advantage: Community Collaboration

What sets Netflix apart isn’t just their technical achievements – it’s their commitment to the FreeBSD community. Rather than keeping their innovations proprietary, Netflix actively contributes improvements upstream.

Smirnoff emphasizes this philosophy: “It’s crucial to reduce the divergence of your operating system to FreeBSD, which means that you need to upstream your changes.”

This approach creates a virtuous cycle:

• Netflix benefits from community development
• The FreeBSD community gains battle-tested improvements
• Everyone wins from enhanced performance and stability

Key community contributions include:

• Kernel TLS implementation (collaboration with Chelsio and Mellanox)
• Advanced VM page caching techniques
• Performance optimizations tested at massive scale
• Hardware acceleration support for various network cards

Why FreeBSD Was the Right Choice

Netflix’s success with FreeBSD demonstrates several key advantages of the operating system:

Scalability: Handles terabits per second of traffic across thousands of servers Performance: Enables record-breaking throughput with efficient resource utilization
Flexibility: Allows deep kernel-level customization and optimization Stability: Provides rock-solid reliability for mission-critical infrastructure Community: Benefits from active development and collaborative innovation Cost-Effectiveness: Open source licensing eliminates expensive per-server fees

Lessons for Your Organization

Netflix’s FreeBSD journey offers valuable insights for any organization considering FreeBSD:

Start Early: Engage with the FreeBSD community from the beginning to maximize benefits Test Rigorously: Implement comprehensive testing frameworks to catch issues quickly Contribute Back: Share improvements with the community to reduce technical debt Stay Current: Track recent developments to benefit from latest innovations Think Long-term: Strategic FreeBSD adoption pays dividends at scale

The Future is FreeBSD

Netflix’s success story is just the beginning. Their commitment to FreeBSD demonstrates that open source solutions can power the world’s most demanding applications. By choosing FreeBSD, Netflix didn’t just solve their CDN challenges – they helped advance the entire ecosystem.

As streaming continues to grow globally, Netflix’s FreeBSD-powered infrastructure stands ready to deliver. Every show you watch, every movie you stream, every seamless experience you enjoy is powered by the reliability, performance, and innovation that FreeBSD makes possible.

Ready to Experience FreeBSD’s Power?

Whether you’re building the next global CDN or optimizing your current infrastructure, FreeBSD offers the performance, stability, and community support to help you succeed. Netflix’s journey from a simple proof-of-concept to the world’s fastest CDN proves that FreeBSD scales with your ambitions.

Ready to get started? Download FreeBSD today and join the community that’s powering the future of high-performance computing.

The FreeBSD Foundation provides support for organizations adopting FreeBSD. Contact them for technical guidance, implementation assistance, and community connections that can accelerate your FreeBSD journey.

The post How Netflix Powers the World’s Fastest Content Delivery Network with FreeBSD appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Debian continues to be a powerful and versatile platform for amateur radio enthusiasts. One of its most valuable features is the Hamradio Blend, which includes a series of metapackages tailored specifically for amateur radio operations. These metapackages make it incredibly convenient to install and manage a full suite of ham radio tools and software in just a few commands.

What Are Metapackages?

Metapackages are essentially collections of related software grouped under a single package name. Installing one metapackage will automatically pull in all the recommended packages associated with a particular task. For ham radio operators, this means less time hunting for individual software packages and more time focusing on radio activities.

Available Hamradio Metapackages

Here’s a breakdown of the currently maintained metapackages in the Debian Hamradio Blend:

Installing Metapackages

To install any of these task-based collections, simply use the following format with your preferred package manager:

sudo apt-get install hamradio-<task>

Replace <task> with the specific area you’re interested in, for example:

sudo apt-get install hamradio-logging

If you’re looking for a full-featured ham radio setup, you can install the entire blend in one go:

sudo apt-get install hamradio-antenna hamradio-datamodes hamradio-digitalvoice hamradio-logging hamradio-morse hamradio-nonamateur hamradio-packetmodes hamradio-rigcontrol hamradio-satellite hamradio-sdr hamradio-tools hamradio-training

Final Thoughts

Whether you’re into CW, APRS, satellite work, or just learning the ropes, the Debian Hamradio Blend has something to offer. With metapackages, setting up a complete amateur radio environment has never been easier. This is a great way to turn your Debian machine into a powerful radio shack workstation.

If you’re running Debian, give these metapackages a try and take your ham radio experience to the next level.

Visit https://www.debian.org/blends/hamradio/get/metapackages

The post Boost Your Ham Radio Experience on Debian with the Hamradio Metapackages appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When it comes to customizing your shell experience, most people are familiar with Oh My Zsh, the popular Zsh configuration framework. But what if you’re a Bash user—loyal to the world’s most widely used shell? Enter Oh My BASH, a community-driven framework that brings power, flexibility, and style to Bash.

Whether you’re a casual Linux user, a seasoned sysadmin, or a developer who loves to tinker with terminal aesthetics and productivity tools, Oh My BASH might just be the productivity upgrade you’re looking for. In this post, we’ll dive deep into what Oh My BASH is, its origins, features, pros and cons, and who it’s best suited for.

What is Oh My BASH?

Oh My BASH is an open-source, community-maintained framework for managing your Bash shell configuration. Much like its inspiration, Oh My Zsh, this project aims to simplify the process of customizing and enhancing your Bash environment.

With features like themes, plugins, and modular configuration, Oh My BASH turns the plain, default Bash shell into a more vibrant, powerful, and efficient tool.

Origin and History

The project was created as a direct counterpart to Oh My Zsh, for users who prefer sticking with Bash rather than switching shells. Bash remains the default shell on many Unix-like systems, including most Linux distributions and macOS (until Catalina).

Oh My BASH started as a fork of Oh My Zsh and was adapted for Bash users by enthusiasts in the open-source community. Its development continues on GitHub:
https://github.com/ohmybash/oh-my-bash

Though not as widely adopted as Oh My Zsh, it has built a niche community of loyal users who appreciate what it offers without requiring them to abandon Bash.

Purpose of Oh My BASH

The primary goal of Oh My BASH is to:

• Make Bash customization easier.
• Provide a consistent and powerful shell experience.
• Add features like themes, aliases, and plugins without cluttering your .bashrc.

It acts as a productivity booster and aesthetic enhancer for your command-line interface, all while staying true to Bash’s simplicity and compatibility.

Advantages of Oh My BASH

Here are some of the standout benefits of using Oh My BASH:

1. Theming and Aesthetics

Oh My BASH includes a variety of prompt themes. These themes add colors, Git status indicators, timestamps, and other useful elements to your prompt, making it visually appealing and informative.

2. Modular Configuration

Rather than dumping all settings into a monolithic .bashrc, Oh My BASH supports a modular structure. You can organize custom aliases, environment variables, and plugin settings in separate files.

3. Plugin Support

It comes with a set of built-in plugins that extend Bash’s functionality. These include helpful aliases and functions for Git, Docker, system info, SSH, and more.

4. Predefined Aliases and Functions

Oh My BASH comes packed with smart defaults, including common aliases and shell functions that can save you typing time and reduce mistakes.

5. Community-Driven

It’s open-source and maintained by contributors around the world. You can create your own plugins or themes, or contribute back to the main repository.

6. Easy Installation and Reset

Installing Oh My BASH is straightforward and reversible. You can easily uninstall it if needed, reverting to your old .bashrc setup.

Disadvantages of Oh My BASH

While Oh My BASH offers many benefits, it’s not without drawbacks. Here are some things to consider:

1. Slower Shell Startup

As with many feature-rich shell frameworks, Oh My BASH can slightly increase your shell’s startup time, especially if you enable many plugins and themes.

2. Less Active than Oh My Zsh

Oh My BASH is not as actively maintained or as widely used as Oh My Zsh. You may find fewer themes, plugins, and community tutorials available.

3. Plugin Limitations

The plugin ecosystem is smaller compared to other frameworks. Some power users may find it limited for more advanced workflows.

4. Not Meant for Minimalists

If you prefer a minimalist setup or enjoy hand-tweaking your .bashrc, this framework might feel like overkill or too opinionated.

Who Should Use Oh My BASH?

Oh My BASH is ideal for:

• Bash Users Who Want More – If you like Bash and don’t want to switch to Zsh or Fish, but still want themes and productivity tools.
• Developers and Sysadmins – Who work heavily in the terminal and appreciate added Git info, aliases, and clear prompts.
• New Linux Users – Who want to make their terminal more approachable and user-friendly.
• Customizers – If you enjoy tweaking your environment but don’t want to write everything from scratch.

However, it may not be the best fit for:

• Hardcore Minimalists – Who prefer plain Bash with minimal external dependencies.
• Performance Purists – Who want the fastest shell startup time possible.
• Zsh/Fish Advocates – Users already invested in other modern shells with more robust ecosystems.

Getting Started with Oh My BASH

To install Oh My BASH, run this command in your terminal:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/ohmybash/oh-my-bash/master/tools/install.sh)"

This will back up your existing .bashrc and replace it with a new one using the Oh My BASH structure. You can start exploring themes by editing your .bashrc file and changing the OSH_THEME variable.

Example:

OSH_THEME="font"

To list available themes, check the themes/ directory in the cloned .oh-my-bash folder.

Tips and Tricks

• Use alias commands in your .bash_aliases.custom file.
• Create your own theme or modify existing ones for full control.
• Load additional scripts via the custom/ directory.
• Keep your .bashrc clean by leveraging modular files in .oh-my-bash/custom.

Final Thoughts

Oh My BASH is a solid choice for anyone looking to improve their Bash shell experience. It brings modern features, customization, and user-friendliness to a traditional and powerful shell without forcing you to switch ecosystems.

It may not have the flashiest bells and whistles of Oh My Zsh or Fish, but for many users, its blend of power and simplicity hits the sweet spot. If you’re someone who enjoys working in the terminal and wants a smoother, more expressive experience—give Oh My BASH a try.

Have you tried Oh My BASH? Got a favorite theme or plugin? Share your thoughts or custom setups in the comments below!

The post Exploring Oh My BASH: The Bash Framework You Might Be Missing Out On appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re looking for a sleek, lightweight, and no-nonsense dock for your Linux desktop, Plank might just be your perfect match. Built for simplicity and performance, Plank provides just what you need — and nothing you don’t.

What is Plank?

Plank is a minimalist dock designed for Linux desktop environments. Its goal is to be the simplest dock on the planet. It’s lightweight, visually clean, and designed to stay out of your way while still being highly functional.

Plank is also the core backend used by Docky (from version 3.0.0 onward), meaning it can be extended to create more feature-rich docks if needed — but Plank itself keeps things lean.

Key Features

• Ultra Lightweight: Uses minimal system resources — great for low-end or older hardware.
• Minimal UI: No clutter, no distractions — just a beautiful dock.
• Extensible: Acts as a backend library for more advanced dock implementations.
• Theming Support: Easily change its appearance with custom themes.

How to Install Plank on Debian/Ubuntu

To install Plank on Debian-based distributions:

sudo add-apt-repository ppa:ricotz/docky
sudo apt-get update
sudo apt-get install plank

Launch it by typing plank in a terminal or adding it to your startup applications.

Customization with Themes

You can tweak Plank’s appearance using community-made themes.

1. Download a theme from repositories like:
   • erikdubois/plankthemes
   • x64Bits/plank-themes
2. Copy the theme to:
   • ~/.local/share/plank/themes (per user)
   • or /usr/share/plank/themes (system-wide)
3. Open Plank settings by holding Ctrl + right-click on the dock, then choose your theme.

Final Thoughts

If you want a beautiful, no-frills dock for your Linux desktop, Plank nails the balance between functionality and simplicity. It just works — and looks good doing it.

Check out the source code or contribute at:
github.com/ricotz/plank

The post Plank: The Minimalist Dock for a Clean Linux Desktop appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When installing or managing a Linux system, one of the most debated topics is whether to use a swap partition or a swap file—or even use swap at all.

In this post, we’ll go back to the origin of swap, explore why swap was needed, how modern systems use (or avoid) it, and the advantages and disadvantages of both swap partitions and swap files.

What is Swap?

Swap is disk space used by the operating system when physical RAM is full. It acts as an extension of RAM to allow the system to offload memory pages that are not immediately needed, keeping critical applications running smoothly.

The Origin of Swap

Swap originated in the early days of computing, when:

• RAM was expensive and limited.
• Storage (although slower) was more plentiful.
• Systems needed a way to “extend” memory to run more processes than RAM allowed.

Unix systems implemented swap space as a way to avoid running out of memory entirely—this idea carried over to Linux.

Why You Might Still Need Swap Today

Even with modern hardware, swap still has roles:

1. Prevent Out of Memory (OOM) crashes: If your system runs out of RAM, swap provides a safety net.
2. Hibernation (suspend-to-disk): Requires swap equal to or greater than your RAM size.
3. Memory balancing: Swap allows the kernel to move idle pages out of RAM, freeing up space for active applications or disk cache.
4. Low-memory devices: On systems like Raspberry Pi or small VPS servers, swap helps compensate for limited RAM.

Why You Might Not Need Swap

On the other hand:

1. Lots of RAM: If your system rarely uses all available memory, swap may never be touched.
2. SSD wear concerns: Excessive swapping can reduce SSD lifespan (though this is largely exaggerated with modern SSDs).
3. Performance-critical applications: Swap is much slower than RAM. If you’re running performance-sensitive workloads, using swap can be a bottleneck.
4. Modern alternatives: Features like zram and zswap offer compressed RAM swap spaces, reducing or eliminating the need for disk-based swap.

Swap Partition

Advantages

• Stability: Less prone to fragmentation.
• Predictable performance: Constant location on disk can be slightly faster on spinning HDDs.
• Used by default in many legacy systems.
• Can be used even if root filesystem becomes read-only.

Disadvantages

• Inflexible size: Hard to resize without repartitioning.
• Occupies a dedicated partition: Not space-efficient, especially on SSDs.
• Inconvenient for virtualized or cloud instances.

Swap File

Advantages

• Flexible: Easy to resize or remove.
• No need for a separate partition.
• Supported by all modern Linux kernels (since 2.6).
• Works well with most filesystems including ext4, XFS, Btrfs (with limitations).

Disadvantages

• Can be slower on heavily fragmented file systems.
• Doesn’t work with hibernation on some setups.
• Needs correct permissions and configuration (e.g., no copy-on-write or compression with Btrfs unless configured properly).

Performance Considerations

Criteria	Swap Partition	Swap File
Resize Flexibility	Hard	Easy
Setup Complexity	Medium	Easy
Performance (HDD)	Slightly better	Slightly worse
Performance (SSD)	Similar	Similar
Works with Hibernate	Yes	Depends on setup
Dynamic Management	Manual	Resizable on-the-fly

When to Use What?

Use a Swap Partition if:

• You’re setting up a traditional desktop or dual-boot Linux system.
• You plan to use hibernation reliably.
• You prefer separating system components into strict partitions.

Use a Swap File if:

• You’re on a modern system with lots of RAM and SSD.
• You want to add swap after install easily.
• You’re using cloud or VPS environments with flexible resources.
• You don’t plan to use hibernation.

Bonus: zram and zswap

Modern Linux kernels support zram and zswap, which compress memory pages before swapping to disk:

• zram creates a compressed RAM-based block device as swap.
• zswap is a compressed cache for swap pages before writing to disk.

These are great for low-memory systems like Raspberry Pi or embedded devices.

Conclusion

Swap is not dead—it’s evolved.

Whether you choose a swap partition or a swap file depends on your needs:

• Flexibility? Go for swap file.
• Predictability and hibernation? Use a swap partition.
• Want better performance with low RAM? Consider zram.

As always with Linux, the choice is yours—and that’s the power of open systems.

TL;DR

• Swap partition: Reliable, but rigid.
• Swap file: Flexible and modern.
• No swap: Fine if you have lots of RAM and don’t use hibernation.
• zram/zswap: Smart memory compression alternatives.

The post Swap Partition vs Swap File on Linux: Everything You Need to Know appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the world of tech giants, custom tools and platforms are often developed in-house to meet unique needs at scale. One such example is gLinux, Google’s internal Linux distribution, tailored specifically for the company’s engineering workflows and infrastructure. While it’s not available to the public, gLinux plays a critical role in powering the work of thousands of Googlers worldwide.

Let’s dive deep into the origin, evolution, advantages, and usage of gLinux to understand why Google made the switch and how it leverages the power of open-source Linux in its operations.

Origin and History

Before gLinux, Google engineers used a Linux distribution called Goobuntu—a customized version of Ubuntu LTS (Long Term Support). Goobuntu was maintained internally and closely followed Ubuntu’s upstream releases, offering the stability and security required for large-scale engineering work. However, it had some limitations, particularly in terms of release cycles and package control.

In 2018, Google publicly revealed that it had begun transitioning from Goobuntu to a new internal distribution: gLinux. This new system was based on Debian Testing, chosen for its balance between cutting-edge features and system stability.

Timeline of Events:

• Pre-2010s: Google internally adopts Ubuntu LTS and customizes it into Goobuntu.
• 2012–2017: Goobuntu evolves with each new LTS release, but internal friction with Ubuntu’s release cadence begins to show.
• 2018: Google announces its shift to gLinux, built on Debian Testing.
• Post-2018: gLinux becomes the standard desktop OS for Google engineers, with updates and packages managed through a custom internal build system.

This move also reflected Google’s broader support for the Debian community and allowed greater control over updates, security, and tooling.

Why the Switch? Goobuntu vs. gLinux

Here are some of the core reasons why Google replaced Goobuntu with gLinux:

1. More Predictable Upgrade Path

Ubuntu’s release cycle meant that Google had to perform large-scale migrations every two years. Debian Testing, in contrast, allows for rolling updates, which are easier to manage incrementally.

2. Greater Flexibility and Control

Debian gives Google more control over its packages and dependencies. With gLinux, Google can apply custom patches, test packages internally, and push updates as needed—without waiting for upstream Ubuntu changes.

3. Security and Compliance

With a custom Debian base, gLinux could be tailored to meet strict internal security standards. This includes features like secure boot, sandboxed applications, and custom kernel modules.

4. Alignment with Upstream Open Source

Google has a long-standing relationship with open-source communities. Debian’s transparent development and packaging philosophy made it a better match for Google’s collaborative approach.

How gLinux Works Internally

While the exact details of gLinux’s architecture and infrastructure are proprietary, some high-level features are known:

• Based on Debian Testing: It pulls from the Debian Testing branch, allowing for a balance of new features and reasonable stability.
• Custom Internal Tooling: Google uses its own build systems to manage, test, and deploy gLinux packages.
• Tight Integration with Google’s Workspace: Everything from developer tools to secure network access is configured and maintained through gLinux-specific policies.
• Support for Internal Software Development: gLinux is optimized for Google’s software stack, including tools for coding, code reviews, builds, and containerization.

Advantages of gLinux

Here are some of the key benefits of gLinux as seen internally at Google:

Enhanced Security

gLinux is hardened to comply with Google’s internal security policies. This includes kernel-level protections, patch management, encryption, and advanced access controls.

Faster and Flexible Updates

By using Debian Testing and an internal update mechanism, gLinux allows Google to push out security patches and software upgrades quickly without being tied to third-party timelines.

Optimized Developer Experience

gLinux comes preloaded with Google’s development environment tools, code review systems, and internal APIs—ready to go out of the box.

Modular and Customizable

Google engineers can request and deploy specific packages, and gLinux supports modular installations for different roles—whether it’s frontend development, backend infrastructure, or machine learning research.

Open Source Friendly

Because Debian is a fully community-driven project, Google benefits from a robust and widely supported ecosystem—while also contributing fixes and enhancements back to Debian in some cases.

Usage and Deployment

gLinux is used across Google by thousands of employees, particularly software engineers and infrastructure developers. It powers:

• Workstations and laptops for developers.
• Build environments for large-scale codebases.
• Testing and automation frameworks for QA and CI/CD.
• Internal security scanning and policy enforcement systems.

It’s important to note that gLinux is not meant for production servers—Google uses other systems like gVisor, Borg, and containerized environments for running its services at scale.

Is gLinux Available to the Public?

No, gLinux is strictly an internal operating system. Unlike Ubuntu or Debian, you can’t download gLinux or install it on your own machine. It’s built to interface with Google’s internal tools and infrastructure, making it unsuitable for general use outside the company.

That said, Google’s choice to base it on Debian means that some of their contributions may benefit the wider Debian community over time.

Conclusion

While gLinux remains hidden behind Google’s walls, it represents a powerful example of how large organizations can adapt open-source software to meet enterprise-scale demands. By choosing Debian over Ubuntu, Google prioritized long-term flexibility, internal control, and deeper open-source alignment.

For Linux enthusiasts and enterprise IT architects, gLinux is a testament to the power of customizing open-source platforms for specific organizational needs. It might not be available to the public—but its influence on how Linux can scale in enterprise environments is undeniable.

The post Exploring gLinux: Google’s In-House Debian-Based Operating System appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

As a system administrator, mastering the command line is critical. Whether you’re maintaining servers, managing users, monitoring performance, or securing your system, knowing the right tools can make your job faster, easier, and more efficient.

Here’s a comprehensive list of the most important Linux commands every sysadmin should know — organized by category, explained in plain language, and ready to turn you into a command-line ninja .

System Monitoring & Performance

Keeping your system healthy starts with knowing what’s going on behind the scenes.

• top / htop
  View real-time system processes, CPU, and memory usage.
  htop is an enhanced version of top with a cleaner UI.
• uptime
  Shows how long the system has been running and the average load.
• vmstat
  Displays information about memory, processes, I/O, and CPU.
• iostat
  Useful for monitoring disk I/O stats and CPU load.
• free -h
  Human-readable memory usage summary (RAM + swap).
• sar
  Historical system activity reports — useful for spotting trends.
• ps aux
  List all running processes with their CPU and memory usage.
• lsof
  List open files. Great for checking what’s locking a file or port.
• strace
  Debugging tool to trace system calls and signals.

Filesystem & Disk Usage

Disk space issues are common — be ready to investigate and clean up.

• df -h
  Shows disk usage for all mounted filesystems in human-readable form.
• du -sh *
  Quickly estimate the size of directories/files in the current folder.
• lsblk
  Displays block devices and their mount points.
• mount / umount
  Mount or unmount filesystems.
• fdisk -l / parted -l
  Inspect disk partitions.
• blkid
  Shows UUIDs and labels of block devices — handy for /etc/fstab.
• find / -name filename
  Searches the entire system for a file.
• file
  Determines a file’s type — especially useful for unknown extensions.
• stat
  Displays detailed file metadata including timestamps and permissions.

User & Permission Management

Managing users and access rights is at the heart of system security.

• adduser / useradd
  Create new users (note: adduser is more user-friendly).
• passwd
  Set or change a user’s password.
• usermod
  Modify a user’s attributes, like group or shell.
• deluser / userdel
  Remove users from the system.
• groupadd, groupdel, gpasswd
  Manage user groups.
• chmod
  Change file permissions (e.g. chmod 755).
• chown / chgrp
  Change file owner or group.
• id
  Show a user’s UID, GID, and group memberships.
• who, w, last
  Show active users and login history.
• sudo
  Run commands with elevated (root) privileges.

Networking

Networking is critical on any server. These tools help diagnose and configure network connections.

• ip a / ip link
  Show all network interfaces and IP addresses.
• ip r
  View the routing table.
• ss -tuln / netstat -tuln
  Show open ports and listening services.
• ping / traceroute
  Test network connectivity and route paths.
• dig / nslookup
  Perform DNS lookups to debug name resolution.
• curl / wget
  Download files or make web/API requests from the command line.
• nmap
  Network scanner for discovering hosts and open ports.
• tcpdump
  Capture and inspect network packets.
• hostname
  View or set the system’s hostname.

Security & Access Control

Security is non-negotiable. These commands help you lock things down.

• ufw / iptables
  Configure and manage firewall rules.
• fail2ban-client
  Control Fail2Ban — protects against brute-force attacks.
• auditctl, ausearch
  View or search audit logs to monitor system access.
• getenforce, setenforce
  Manage SELinux modes.
• ssh / sshd
  Secure shell access and SSH server management.
• scp, rsync
  Securely copy files between systems.

Package Management

Installing and managing software is essential. Use the right tool based on your distro:

Debian/Ubuntu

• apt, dpkg, apt-cache

RedHat/CentOS

• yum, dnf, rpm

Arch Linux

• pacman

Universal

• snap, flatpak

Examples:

apt update && apt upgrade
dnf install nginx
pacman -S htop

System Maintenance & Logs

Keep your system running smoothly by managing services and watching logs.

• journalctl
  View systemd logs.
• dmesg
  Kernel ring buffer — shows hardware and boot messages.
• systemctl
  Manage services on systemd systems (start, stop, enable, etc.).
• service
  Older init-based service management.
• crontab -e
  Edit scheduled tasks (cron jobs).
• at
  Run one-off tasks at a specific time.
• logrotate
  Manages log file rotation to prevent disk overuse.
• shutdown, reboot
  Schedule or perform system reboots/shutdowns.

Backup & Automation

Protect data and automate your tasks for efficiency.

• rsync -avh
  Sync directories or backup data.
• tar -czf archive.tar.gz folder/
  Create compressed archive.
• scp user@host:file .
  Secure file copy over SSH.
• cron, anacron
  Automate repetitive tasks.
• bash / sh
  Write scripts to automate system administration tasks.

Bonus Tools & Utilities

• tmux / screen
  Terminal multiplexers — resume sessions, split terminals.
• ncdu
  Disk usage visualizer. Much better than du for quick inspection.
• glances
  Real-time monitoring of CPU, RAM, disk, and more.
• nc (netcat)
  Versatile networking tool — useful for debugging or testing.
• alias
  Create custom shortcuts for your most used commands.

Final Thoughts

These Linux commands are not just helpful — they’re the foundation of any good system administrator’s toolbox. Mastering them will give you confidence to manage, troubleshoot, and optimize Linux systems whether you’re working with a single server or an entire fleet of machines.

The post Essential Linux Commands Every System Administrator Should Know appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Whether you’re a seasoned sysadmin or just diving into Linux, understanding the boot process is key to mastering how your system starts up. The Linux boot process is a fascinating journey that transforms powered-off hardware into a fully operational system. In this post, we’ll walk through the entire boot sequence, breaking down each stage with technical clarity.

Stage 1: BIOS or UEFI – The System’s First Breath

The process begins the moment you press the power button.

BIOS (Legacy Systems)

• POST (Power-On Self Test) is triggered to check RAM, CPU, keyboard, and basic hardware.
• Searches for a bootable device by scanning the boot order (HDD, SSD, USB, etc.).
• Once a bootable device is found, BIOS reads the Master Boot Record (MBR), which contains the bootloader.

UEFI (Modern Systems)

• Replaces BIOS with a more advanced firmware interface.
• Reads the EFI System Partition (ESP), which contains EFI applications like GRUB.efi.
• Supports Secure Boot, GUID Partition Table (GPT), and faster booting.

Note: UEFI is now the standard for most modern hardware.

Stage 2: Bootloader – The Linux Gatekeeper

The bootloader is the program that loads and starts the Linux kernel.

Common Bootloaders:

• GRUB (GRand Unified Bootloader) – Most common in Linux systems.
• systemd-boot – Lightweight bootloader for UEFI systems.
• LILO (older systems) – Largely deprecated.

The bootloader:

• Loads the selected kernel image (e.g., /boot/vmlinuz-linux).
• Loads the initramfs/initrd – a temporary root filesystem used during early boot.
• Passes control and parameters (e.g., root device path, kernel options) to the kernel.

Example of GRUB config:

linux /boot/vmlinuz-6.1.0 root=/dev/sda2 ro quiet splash
initrd /boot/initrd.img-6.1.0

Stage 3: Kernel Initialization – The Heart of Linux

Now, the Linux kernel takes control.

What the Kernel Does:

• Sets up low-level system components: memory management, I/O scheduling, and CPU initialization.
• Loads drivers for essential hardware (from initramfs).
• Mounts the real root filesystem (e.g., from ext4, btrfs, XFS).
• Starts the init process (PID 1) – the first user-space program.

If anything goes wrong here (like missing root filesystem), you’ll see a kernel panic.

Stage 4: Init System – Orchestrating the System Startup

The init system is the “conductor” that starts all necessary services.

Common Init Systems:

• systemd (default on most modern distros like Debian, Ubuntu, Fedora)
• SysVinit (traditional)
• OpenRC (used in Alpine, Gentoo)

If using systemd, it:

• Reads unit files from /etc/systemd/system/ and /usr/lib/systemd/system/.
• Mounts local filesystems, activates swap, configures networking.
• Starts system services like sshd, NetworkManager, cron, and more.

You can inspect boot performance using:

systemd-analyze

Stage 5: Login Prompt – Ready for Action

Once all services are up and running:

• CLI systems: getty spawns login prompts on virtual terminals (e.g., tty1–tty6).
• GUI systems: A Display Manager (GDM, LightDM, SDDM) launches, leading to your graphical desktop environment (GNOME, KDE, etc.).

After login, the system is fully operational, ready for your commands or applications.

Visual Summary of the Linux Boot Flow

[ Power On ]
     ↓
[ BIOS / UEFI ]
     ↓
[ Bootloader (GRUB/systemd-boot) ]
     ↓
[ Kernel + initramfs ]
     ↓
[ Init system (systemd, etc.) ]
     ↓
[ System Services + Targets ]
     ↓
[ Login Prompt / GUI ]

Bonus: Useful Commands to Explore Boot

• View last boot duration: systemd-analyze
• See the breakdown of each service’s boot time: systemd-analyze blame
• Inspect boot logs: journalctl -b

Final Thoughts

The Linux boot process may seem complex, but each stage is logically structured to ensure a flexible, powerful, and modular startup system. Whether you’re debugging a failed boot or optimizing your boot time, understanding this process equips you with the tools to handle your system like a pro.

If you’re using Linux in embedded projects, servers, or even on low-power SBCs like Raspberry Pi, this knowledge becomes even more critical.

The post Understanding the Linux Boot Process: From Power On to Login appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re using Linux today — whether on a desktop, server, or embedded device — there’s a good chance the foundation of your system can be traced back to Debian. Debian is one of the oldest, most respected, and most influential GNU/Linux distributions ever created. It has quietly shaped the digital world around us — from powering large-scale web servers and scientific clusters to forming the basis of popular distributions like Ubuntu, Raspbian, and countless others.

But Debian is more than just a technical achievement. It is a social, ethical, and political project — one rooted in the ideals of freedom, transparency, and community governance.

This article takes a detailed journey through Debian’s origins, evolution, and its unique capabilities in desktop and server environments — and highlights why Debian is a perfect match for amateur radio operators.

The Origin of Debian: A Manifesto Becomes a Movement

In the early 1990s, the Linux kernel was still a new and evolving project. While Linus Torvalds was actively developing the kernel itself, various individuals and small groups were creating their own Linux distributions. These early distributions were often difficult to maintain, poorly documented, and inconsistent.

Enter Ian Murdock, a young computer science student at Purdue University. On August 16, 1993, he released the Debian Manifesto, which laid out a bold vision: a completely free, open, and community-developed operating system that adhered to the values of the Free Software Foundation.

He named it “Debian” — a portmanteau of his name and that of his then-girlfriend, Debra.

From the beginning, Debian sought to be different:

• It would not be controlled by a single person or company.
• It would emphasize openness, stability, and quality.
• It would be built by volunteers and for the community.

Debian was not only a software project — it was a social contract, a movement, and a model for how free software could be built cooperatively.

Historical Milestones: Debian Through the Years

1993–1995: The Early Days

Debian 0.91 was the first version that gained traction, introducing the .deb package format and the dpkg package manager. From the start, Debian aimed to be modular, reliable, and secure.

1996: The Birth of APT

One of Debian’s greatest innovations was the introduction of APT (Advanced Package Tool) — a front-end that made it easier to install, upgrade, and remove software while managing dependencies automatically. This was a huge leap over what other distributions offered at the time.

Late 1990s: A Social and Ethical Framework

Debian formalized its values through documents like:

• The Debian Social Contract
• The Debian Free Software Guidelines (DFSG)
• The Debian Constitution

These were radical moves. Debian became the first Linux distribution to explicitly define its governance, its commitment to users, and its ethical foundations.

2000s–2010s: Becoming a Foundation for the World

Debian’s popularity surged. It became the base for:

• Ubuntu
• Raspbian (now Raspberry Pi OS)
• Kali Linux
• Linux Mint (Debian Edition)
• Countless server deployments in enterprises and universities

Debian evolved to support multiple CPU architectures, introduced udev for dynamic device management, and transitioned to systemd in later years for improved boot and service handling.

Today, Debian is developed by over 1,000 active developers, with tens of thousands of contributors and mirror servers in almost every country on Earth.

Debian on the Desktop: A Powerhouse of Possibility

Although Debian has a reputation as a server distribution, it is equally capable as a desktop system, especially for users who value stability, freedom, and control.

Why Choose Debian for Desktop Computing?

1. Unmatched Stability

Debian’s “Stable” release is tested for months, sometimes years, before finalization. This makes it ideal for users who prioritize reliability over bleeding-edge features.

2. Custom Desktop Environments

Whether you prefer GNOME, KDE Plasma, XFCE, LXQt, Mate, Cinnamon, or even minimalist setups like i3wm, Debian allows full flexibility during installation.

3. Freedom From Bloatware

Unlike commercial operating systems that come pre-loaded with unnecessary software and background tracking, Debian installs only what you choose — nothing more.

4. Vast Software Library

With more than 59,000 precompiled packages, almost every piece of software you could need is available directly via apt. From graphic design and media editing to office work and development tools — Debian has it all.

5. Privacy and Security

Debian has no telemetry. It does not collect or transmit user data, ever. Plus, it receives security updates from a dedicated security team that supports each Stable release for five years or more.

6. Perfect for Developers and Hackers

Debian is an ideal workstation for programmers, sysadmins, researchers, and makers. It supports development tools in C, Python, Rust, Go, Java, and more — all easily installable through the package manager.

Debian as a Server: The Gold Standard of Stability

When it comes to deploying mission-critical applications, few operating systems are as trusted as Debian.

Why Debian Dominates Server Rooms

1. Long-Term Stability

Debian’s conservative release cycle ensures that servers can run for years without interruption, even through major upgrades.

2. Excellent Security Practices

Debian takes security seriously. With signed packages, trusted repositories, and an active security team, administrators can sleep better knowing their systems are protected.

3. Universal Hardware Support

From Raspberry Pis to enterprise-grade x86 servers, from old legacy boxes to modern ARM64 devices — Debian supports them all.

4. Container and Virtualization Ready

Debian is the default base image for Docker containers, is heavily used in cloud infrastructure, and runs perfectly on KVM, Xen, LXC, and VMware.

5. Flexible Roles

Debian can easily be configured as:

• Web server (Apache, NGINX)
• Mail server (Postfix, Dovecot)
• DNS server (BIND, Unbound)
• Database server (PostgreSQL, MySQL, MariaDB)
• File server (Samba, NFS)
• VPN (WireGuard, OpenVPN)

6. Efficient Resource Usage

Without bloated GUIs or unnecessary background services, Debian performs faster and lighter than most alternatives. It’s ideal for headless systems and energy-efficient servers.

Debian for Amateur Radio Operators: A Perfect Match

How Debian Enhances Ham Radio Operations

1. Wide Selection of Ham Software

Debian’s repository includes a treasure trove of amateur radio tools:

• AX.25 and APRS: ax25-tools, direwolf, xastir, aprx
• Digital Modes: flrig, fldigi, wsjtx, js8call, qsstv
• Logging and Contesting: tlf, xlog, cqrlog
• Packet Radio and Winlink: pat, linpac, soundmodem
• Satellite Tracking: gpredict

No need to compile from source — just install with apt.

2. Runs on Low-Power Devices

Debian is lightweight and can run on Raspberry Pi, Odroid, or old laptops — perfect for portable stations, field days, and emergency communications.

3. Custom Automation and Gateways

You can build your own:

• APRS iGate or Digipeater
• LoRa gateways
• Remote HF control stations
• Telemetry collection systems

With scripting and cron jobs, you can automate nearly everything.

4. Stable Uptime for Remote Stations

Need a node to run unattended in a rural area? Debian’s reputation for rock-solid uptime is exactly what hams need for off-grid repeaters, gateways, or remote logging setups.

5. Hackable and Modular

Debian doesn’t get in your way. You can build exactly the shack system you want — and even write your own software, drivers, or tools using Python, Bash, or C.

Conclusion: Why Debian Should Be Your OS of Choice

Whether you’re a sysadmin, hobbyist, student, ham radio operator, or casual Linux user, Debian has something for you.

• It’s ethically grounded, built by a global community, and entirely free.
• It powers desktops, laptops, servers, cloud platforms, and IoT devices with equal confidence.
• It respects your freedom, your time, and your intelligence.
• And for the amateur radio community, it is the perfect companion in the shack.

If you haven’t tried Debian yet, now’s the time. Download the ISO, write it to a USB drive, and join the movement that’s been quietly powering the internet, science, and innovation for over 30 years.

Debian isn’t just a Linux distro. It’s the soul of free software.

The post The Story of Debian: From Hacker Roots to Global Impact appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Self-hosting applications has become increasingly popular among developers, tech enthusiasts, and homelabbers. However, securely exposing internal services to the internet is often a complicated task. It involves:

• Opening firewall ports
• Dealing with dynamic IPs
• Managing TLS certificates
• Handling reverse proxies
• Setting up access control

This is where DockFlare comes in.

DockFlare is a lightweight, self-hosted Cloudflare Tunnel automation tool for Docker users. It simplifies the process of publishing your internal Docker services to the public internet through Cloudflare Tunnels, while providing optional Zero Trust security, DNS record automation, and a sleek web interface for real-time management.

Objectives of DockFlare

DockFlare was created to solve three key problems:

1. Simplicity: Configure secure public access to your Docker containers using just labels—no reverse proxy, SSL setup, or manual DNS records needed.
2. Security: Protect your services behind Cloudflare’s Zero Trust Access, supporting identity-based authentication (Google, GitHub, OTP, and more).
3. Automation: Automatically create tunnels, subdomains, and security policies based on your Docker service metadata. No scripting. No re-deploys.

Why Use DockFlare?

Here’s how DockFlare benefits its users:

• Quick Setup: Set up secure tunnels and expose services in seconds with Docker labels.
• Zero Trust Security: Enforce authentication for any service using Cloudflare Access.
• No Public IP Required: No need to forward ports or expose your home IP—perfect for CG-NAT and mobile ISPs.
• Safe by Default: TLS encryption, no open ports, and access rules built-in.
• User-Friendly UI: Visualize tunnels, view logs, and manage configurations in a web dashboard.
• DevOps Ready: Works seamlessly in CI/CD pipelines or home labs.

How to Install DockFlare

Requirements

• Docker and Docker Compose
• A Cloudflare account
• A domain connected to Cloudflare
• A Cloudflare API Token with:
  • Zone DNS edit
  • Zero Trust policy management
  • Tunnel management

Step 1: Create Your Project Directory

mkdir dockflare && cd dockflare

Step 2: Create .env File

Create a file named .env with the following contents:

CLOUDFLARE_API_TOKEN=your_token_here
CLOUDFLARE_ACCOUNT_ID=your_account_id
CLOUDFLARE_ZONE_ID=your_zone_id
TZ=Asia/Kuala_Lumpur

Keep this file private!

Step 3: Create docker-compose.yml

version: '3.8'

services:
  dockflare:
    image: alplat/dockflare:stable
    container_name: dockflare
    restart: unless-stopped
    env_file:
      - .env
    ports:
      - "5000:5000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - dockflare_data:/app/data
    labels:
      - cloudflare.tunnel.enable=true
      - cloudflare.tunnel.hostname=dockflare.yourdomain.com
      - cloudflare.tunnel.service=http://dockflare:5000

volumes:
  dockflare_data:

Step 4: Deploy DockFlare

docker compose up -d

Access the UI: http://localhost:5000

Exposing a Docker Service

Here’s an example of exposing a service like myapp running on port 8080:

services:
  myapp:
    image: myapp:latest
    labels:
      cloudflare.tunnel.enable: "true"
      cloudflare.tunnel.hostname: "app.yourdomain.com"
      cloudflare.tunnel.service: "http://myapp:8080"
      cloudflare.tunnel.access.policy: "authenticate"
      cloudflare.tunnel.access.allowed_idps: "your-idp-uuid"

This will automatically:

• Create a Cloudflare Tunnel
• Point your subdomain to it
• Enforce secure login

Add Non-Docker Services

Want to expose your home router or NAS?

1. Go to DockFlare UI.
2. Click “Add Hostname”.
3. Enter:
   • Hostname (e.g., nas.yourdomain.com)
   • Internal IP/port
   • Access policy (bypass/authenticate)
4. Done!

This works for any service, not just Docker.

Configuring Zero Trust Access

To secure your services:

• Go to Cloudflare Zero Trust dashboard
• Add an identity provider (Google, GitHub, etc.)
• Use the IDP UUID in your container labels
• Example:

cloudflare.tunnel.access.policy: authenticate
cloudflare.tunnel.access.allowed_idps: abc123-def456
cloudflare.tunnel.access.session_duration: 8h

Advanced Tips

• Expose multiple hostnames:
  cloudflare.tunnel.hostname=api.domain.com,admin.domain.com
• Customize session duration:
  cloudflare.tunnel.access.session_duration=12h
• Monitor logs via the web UI or docker logs dockflare

Resources

• GitHub: ChrispyBacon-dev/DockFlare
• Docker Compose Docs: docker.com/compose
• Cloudflare Tunnels Guide: developers.cloudflare.com

Conclusion

DockFlare is a game-changer for developers, sysadmins, and homelabbers who want an easy, secure, and automated way to expose their applications to the web. With support for Cloudflare Tunnels, Zero Trust Access, DNS automation, and a clean UI—it’s the only tool you’ll need to publish your services safely.

No more port forwarding. No more SSL headaches.

Just Docker + DockFlare + Cloudflare = Done.

The post DockFlare: Securely Expose Docker Services with Cloudflare Tunnels appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the digital age, accurate timekeeping is more critical than ever. From ensuring data consistency across global servers to enabling GPS navigation and military operations, the precision of our clocks underpins modern infrastructure. This post explores how Network Time Protocol (NTP), atomic clocks, and the Global Positioning System (GPS) work together to synchronize time around the world—and what stratum levels really mean in timekeeping hierarchy.

What Is Network Time Protocol (NTP)?

NTP (Network Time Protocol) is a protocol used to synchronize the clocks of computers and devices over a network. It allows systems to keep time within milliseconds of Coordinated Universal Time (UTC), which is the global time standard.

NTP works using a hierarchical structure of stratum levels, with each level representing the “distance” from the reference clock (usually an atomic clock or GPS-based source).

How NTP Works

Here’s a simplified overview of the process:

1. A client computer sends a request to an NTP server.
2. The NTP server responds with the current time along with information about when the request was received and replied to.
3. The client calculates the round-trip delay and clock offset.
4. The local clock is adjusted accordingly, either gradually or immediately.

This process often repeats at regular intervals to maintain synchronization.

Understanding NTP Stratum Levels

NTP servers are organized into strata based on how close they are to the original time source:

• Stratum 0: These are the reference clocks—usually atomic clocks, GPS receivers, or radio clocks. They don’t connect directly to the internet.
• Stratum 1: Servers directly connected to stratum 0 devices. These are often publicly available NTP servers and offer highly accurate time.
• Stratum 2: Servers that sync with stratum 1 servers. Most users rely on these.
• Stratum 3–15: Each additional level syncs from the level above, with increasing latency and reduced accuracy.
• Stratum 16: Designated for unsynchronized servers or devices.

Example:
If your Raspberry Pi is syncing from time.google.com (a stratum 1 server), your device becomes a stratum 2 client.

What Is an Atomic Clock?

An atomic clock is the most precise timekeeping device available. It uses the natural oscillations of atoms—commonly cesium-133 or rubidium—as a reference.

Key Characteristics:

• Accuracy: Can measure time with precision better than 1 second in millions of years.
• Stability: Remains extremely consistent over long periods.
• Use Cases: GPS satellites, NTP stratum 0 devices, scientific labs, telecom networks.

The international definition of one second is based on the radiation cycles of cesium-133:
9,192,631,770 transitions = 1 second

How GPS Provides Accurate Time

The Global Positioning System (GPS) is not just for navigation—it’s also a precise time distribution network. Each GPS satellite contains multiple atomic clocks. When your GPS receiver locks onto satellites, it can:

• Determine location using trilateration
• Calculate the exact time from satellite signals

GPS Time vs UTC:

• GPS time started in 1980 and does not account for leap seconds, unlike UTC.
• GPS receivers convert GPS time to UTC using data in the satellite’s almanac.

For time servers, GPS receivers act as Stratum 0 sources, making GPS-based NTP servers (Stratum 1) popular for time-critical systems.

Real-World Applications

When Accuracy Matters

A tiny time drift can cause:

• Log mismatch in security systems
• Transaction failures in banking
• Packet loss or desync in VoIP and online gaming
• Routing issues in network infrastructure

Thus, reliable NTP configuration, ideally syncing from multiple stratum 1 servers or running your own GPS-based server, is best practice for critical systems.

Summary

Together, atomic clocks, GPS, and NTP form a robust global timekeeping system that powers everything from Google’s servers to battlefield operations and your APRS messages.

Build Your Own Stratum 1 NTP Server (Raspberry Pi + GPS + Chrony)

Creating your own Stratum 1 NTP server is a rewarding project, especially for ham radio operators, makers, and sysadmins who want reliable, low-latency timekeeping without relying on the internet.

What You Need:

• Raspberry Pi (any model with GPIO, preferably Pi 3/4/5)
• GPS module with PPS (Pulse Per Second) output (e.g. u-blox NEO-6M or NEO-M8N)
• Serial connection to GPS (UART)
• Internet for installation (optional afterward)
• Linux with chrony, gpsd, and PPS support

Step 1: Hardware Setup

1. Connect the GPS module:
   • TX (GPS) to GPIO 15 (RXD) on the Pi
   • PPS pin to GPIO 18 (Pin 12)
   • VCC and GND appropriately
2. Enable UART and PPS on the Pi: sudo raspi-config
   • Interface Options → Enable Serial (disable console over serial, enable hardware UART)
   • Reboot when prompted.

Step 2: Install Required Packages

sudo apt update
sudo apt install gpsd gpsd-clients chrony pps-tools

Step 3: Enable and Test PPS

1. Add the PPS overlay:

Edit /boot/config.txt and add:

dtoverlay=pps-gpio,gpiopin=18

2. Reboot:

sudo reboot

3. Check if /dev/pps0 appears:

ls -l /dev/pps*

4. Test PPS signal:

sudo ppstest /dev/pps0

You should see output like:

source 0 - assert 1716165796.000000000, sequence: 1234 - clear 1716165796.000001234

Step 4: Configure GPSD

Edit /etc/default/gpsd:

START_DAEMON="true"
DEVICES="/dev/serial0"
GPSD_OPTIONS="-n"

Restart the service:

sudo systemctl restart gpsd

Verify:

cgps -s

You should see satellite data and GPS time.

Step 5: Configure Chrony for GPS + PPS

Edit /etc/chrony/chrony.conf and add these lines at the top:

refclock SHM 0 offset 0.5 delay 0.2 refid GPS
refclock PPS /dev/pps0 refid PPS lock GPS

Also, comment out any existing pool or server lines if you want it to be completely standalone.

Restart Chrony:

sudo systemctl restart chrony

Step 6: Verify Chrony Status

chronyc sources -v

You should see entries like:

#x  Name/IP address            Stratum  Poll Reach  LastRx Last sample
===============================================================================
#?  GPS                          0       4   377     10     -4ns[  +23ns] +/- 30us
#*  PPS                          0       4   377     9      -1ns[   -5ns] +/- 0.1us

The * next to PPS indicates it’s the preferred source.

🖧 Optional: Share NTP on Your Network

Edit /etc/chrony/chrony.conf to allow LAN clients:

allow 192.168.1.0/24

Replace with your local subnet. Restart Chrony to apply.

This allows you to sync your entire home lab or shack with millisecond precision without depending on the internet.

The post Understanding Network Time Protocol (NTP), Atomic Clocks, and GPS: How Precise Timekeeping Powers the Modern World appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In a local network where you want to keep your devices synchronized with accurate time, running a lightweight and efficient NTP server is essential. Chrony, a modern alternative to ntpd, is a great choice and in this guide, I’ll show you how to set it up inside a Docker container that fetches time from global sources and distributes it across your LAN.

Why Chrony?

Chrony is:

• More accurate than ntpd in many conditions (especially with intermittent connectivity)
• Lightweight and easy to configure
• Ideal for both clients and servers

What You’ll Set Up

• A Docker container running Chrony
• Configured to sync with global NTP servers
• Act as a time server for your LAN
• With optional logging and control access

Step 1: Create a Dockerfile for Chrony

Start by creating a simple Dockerfile to build a minimal Chrony container.

# Dockerfile
FROM debian:stable-slim

RUN apt-get update && \
    apt-get install -y chrony && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

COPY chrony.conf /etc/chrony/chrony.conf

EXPOSE 123/udp

CMD ["chronyd", "-d", "-f", "/etc/chrony/chrony.conf"]

Step 2: Create the chrony.conf

Here’s a sample chrony.conf tailored for local server use and syncing with global time sources:

# chrony.conf

# Time sources (use pool.ntp.org or your regional servers)
server 0.pool.ntp.org iburst
server 1.pool.ntp.org iburst
server 2.pool.ntp.org iburst

# Allow all clients on your LAN (edit this according to your subnet)
allow 192.168.1.0/24

# Local stratum fallback if Internet is down
local stratum 10

# Drift file to track clock error over time
driftfile /var/lib/chrony/chrony.drift

# Log tracking data
log tracking measurements statistics

# Log files location
logdir /var/log/chrony

# Optional: control access
cmdport 0  # Use 0 to disable remote control; use 323 if needed

Replace 192.168.1.0/24 with your actual LAN subnet.

Step 3: Build and Run the Docker Container

docker build -t chrony-server .

Now run the container with:

docker run -d \
  --name chrony \
  --restart unless-stopped \
  --network host \
  --cap-add=NET_BIND_SERVICE \
  chrony-server

Explanation:

• --network host allows the container to bind directly to port 123/UDP
• --cap-add=NET_BIND_SERVICE is required to bind to low-numbered ports like 123

Step 4: Test Your NTP Server

From a client machine on your LAN:

ntpdate -q <chrony-server-ip>

or

chronyc sources -a

You should see that the time is being served and synchronized.

Optional: Run as a Local Time Authority

If you want to run fully offline, or ensure internal time continuity even without internet:

1. Remove the server lines from chrony.conf
2. Set: local stratum 8
3. Start the server with a stable internal clock source

This makes your Chrony instance a local time authority for your network.

Firewall Notes

Make sure UDP port 123 is allowed inbound from your LAN on your Docker host:

sudo ufw allow proto udp from 192.168.1.0/24 to any port 123

Or for iptables:

iptables -A INPUT -p udp -s 192.168.1.0/24 --dport 123 -j ACCEPT

Conclusion

With this setup, you’ve created a portable, containerized NTP server using Chrony that:

• Syncs with global servers
• Serves accurate time to all local devices
• Works even if your external internet connection drops

Perfect for homelabs, IoT networks, or offline environments.

The post How to Set Up Chrony as a Local NTP Server Using Docker appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.