1.1 What Is Linux

Linux refers to a kernel created by Linus Torvalds and first released in 1991. The kernel manages hardware, memory, and processes. A complete operating system built around the Linux kernel is called a “Linux distribution”. Examples include Ubuntu, Fedora, Debian, and Arch Linux. A distribution combines the Linux kernel with userland tools, libraries, a package manager, and often a desktop environment.

License: The Linux kernel is licensed under GPL version 2. Most GNU utilities are GPL v3.
Development: The kernel has over 20,000 contributors as of 2024. Companies such as Red Hat, Intel, Google, and SUSE contribute code. Linus Torvalds manages releases.
Release cycle: The kernel releases a new version every 8 to 10 weeks. Distributions set their own release schedules. Ubuntu releases every 6 months with LTS versions every 2 years. Debian Stable releases roughly every 2 years. Fedora releases every 6 months.

1.2 What Is FreeBSD

FreeBSD is a complete operating system. It includes the kernel, userland utilities, C library, and documentation developed together in one source repository. The project derives from the Berkeley Software Distribution. Version 1.0 was released in 1993.

License: FreeBSD uses the BSD 2-Clause License. The license permits redistribution and use in source and binary forms, with or without modification, provided the copyright notice is kept.
Development: FreeBSD has a Core Team and around 400 active committers as of 2025.
Release cycle: Major releases occur every 18 to 24 months. Each major release receives support for 5 years. Minor releases occur every 3 to 4 months.

Key structural difference: Linux distributions combine components from multiple projects. FreeBSD ships a base system where all core components are versioned together.

2. Technical Components Compared

3. Factors That Affect Desktop Use

Desktop use requires hardware compatibility, application availability, and user interface polish. The following factors explain current adoption patterns.

3.1 Hardware Support for Consumer Devices

Linux distributions receive driver support from hardware vendors. Intel, AMD, and Nvidia contribute GPU drivers directly to the kernel or as loadable kernel modules. Kernel 6.10 includes drivers for Intel Arc GPUs, AMD RDNA 3, and Wi-Fi 6E chipsets such as Intel AX210 and MediaTek MT7921. Firmware is distributed in the linux-firmware package.

Vendor certification programs exist. Dell XPS, Lenovo ThinkPad, and Framework Laptop offer models preinstalled with Ubuntu or Fedora. These models are tested for suspend, backlight, and trackpad function.

FreeBSD supports many server NICs and storage controllers. Desktop hardware support is present but follows Linux. The AMDGPU driver was ported to FreeBSD in 2018 and updated periodically. Support for newer Wi-Fi chipsets arrives after Linux. As of FreeBSD 14.1, MediaTek MT7921 is supported. Some Realtek USB Wi-Fi devices require third party modules. Laptop suspend and resume works on some models but is not universal. The FreeBSD wiki maintains a laptop compatibility list.

3.2 Application Ecosystem

Desktop users expect browsers, office suites, media players, and communication tools.

Linux has native builds of Firefox, Chromium, Chrome, LibreOffice, VLC, GIMP, OBS Studio, Steam, VS Code, and JetBrains IDEs. Flatpak and Snap provide sandboxed versions of Spotify, Zoom, Slack, and Discord. Steam uses Proton to run many Windows games. ProtonDB reported in 2025 that 85 percent of the top 1000 Steam games run on Linux.

FreeBSD has Firefox, Chromium, LibreOffice, VLC, and GIMP via ports. There is no official Chrome build. There is no official Slack or Zoom client. Linux binary compatibility, called Linuxulator, can run some Linux applications, but GPU acceleration and audio for conferencing apps are limited. Steam is not supported natively. Wine can run some Windows applications on FreeBSD.

3.3 Desktop Environments

Linux distributions integrate GNOME, KDE Plasma, Xfce, and Cinnamon. GNOME 46 and KDE Plasma 6 support Wayland, fractional scaling, and touchscreens. Development is active. PipeWire provides audio and screen sharing for Wayland.

FreeBSD can install GNOME and KDE from packages. The FreeBSD desktop team ports these environments after Linux releases. Audio uses OSS by default. PipeWire and PulseAudio are available from ports but are not default. Configuration requires more manual steps compared to Ubuntu or Fedora.

3.4 Release and Update Model

Linux distributions vary. Ubuntu LTS provides 5 years of updates. Fedora provides 13 months. Arch Linux uses a rolling model with continuous updates. Kernel updates bring new drivers fast. This benefits new hardware.

FreeBSD releases a base system every 18 to 24 months. freebsd-update upgrades the kernel and userland together. The ABI is stable within a major version. This reduces unexpected changes but delays new hardware support.

4. Factors That Affect Server Use

Server use requires stability, network performance, storage reliability, and maintainability.

4.1 Base System Consistency

FreeBSD distributes the kernel, C library, compiler, and core utilities as one unit. The freebsd-update tool updates all base components. Documentation in the Handbook and man pages corresponds to the installed version. This reduces version mismatch.

Linux distributions combine components from separate projects. glibc, systemd, and the kernel have independent releases. An LTS distribution holds versions stable, but third party repositories can introduce newer libraries. Administrators must consider interaction between components.

4.2 ZFS Integration

ZFS is a filesystem with checksums, snapshots, compression, and send/receive replication. FreeBSD added ZFS in 2007. In FreeBSD 14, OpenZFS 2.2 is in the base system. The installer supports root on ZFS. Boot environments allow booting a previous snapshot if an upgrade fails.

On Linux, OpenZFS is available as a kernel module. Due to CDDL vs GPL licensing, it is not included in the main kernel. Ubuntu includes ZFS, but it is not default. RHEL removed ZFS packages. Administrators who require ZFS must manage the module separately.

Companies that use ZFS at scale include iXsystems for TrueNAS and Netflix for content delivery caches. Netflix published a talk in 2021 describing 200 Gb/s per server using FreeBSD and ZFS.

4.3 Networking Stack and Firewall

FreeBSD includes the pf packet filter from OpenBSD. pf uses a single configuration file and is used in pfSense and OPNsense firewall distributions. The FreeBSD network stack is used in appliances from Juniper and NetApp.

FreeBSD achieved 800 Gb/s of TLS encrypted traffic from a single host in 2023 using kernel TLS and sendfile, as documented by Netflix engineers.

Linux uses nftables and has a high performance network stack. Companies such as Cloudflare and Meta use Linux for edge networks. bpfilter, XDP, and DPDK provide high speed packet processing.

Both stacks are capable. pf is noted for simple syntax and auditability. Linux provides more features for container networking and eBPF.

4.4 Jails

FreeBSD Jails provide operating system level virtualization. A jail has its own filesystem, network address, and processes. Overhead is low because the kernel is shared. Jails have existed since FreeBSD 4.0 in 2000. Tools such as iocage and bastille manage jails. Jails integrate with ZFS for cloning and snapshots.

Linux provides LXC, Docker, and Podman. These tools use namespaces and cgroups. Docker is the industry standard for application containers. For system level containers, LXC is comparable to jails. Jails are part of the base system. Docker requires a daemon.

4.5 Long Term Support

FreeBSD provides 5 years of support for each major release. The ABI is stable within a major release. A binary compiled on FreeBSD 13.0 will run on 13.3 without recompilation.

Ubuntu LTS provides 5 years of standard support. Debian provides 5 years. RHEL provides 10 years. ABI stability is a goal, but glibc symbol versions can change and affect third party binaries.

4.6 License Considerations

The BSD license permits combining FreeBSD code with proprietary code and distributing the result without source. This is used in commercial products such as the Sony PlayStation operating system, which is based on FreeBSD, and Juniper JunOS.

The Linux kernel GPL requires that derivative works distributed in binary form must also provide source code. This requirement is acceptable for many companies but is a consideration for appliance vendors.

5. Deployment Statistics

Public data shows usage patterns.

Desktop: StatCounter reports Linux at 4.1 percent of desktop OS market share in May 2025. FreeBSD is below 0.1 percent. Steam Hardware Survey shows Linux at 2.3 percent in April 2025. FreeBSD is not listed.

Server: W3Techs survey of web servers in 2025 shows Unix at 70 percent. Within Unix, Linux distributions are the majority. FreeBSD is used by specific companies and in the firewall market. The pfSense project reported millions of installations.

Cloud: AWS, Google Cloud, and Azure provide Linux images by default. FreeBSD images are available but less common.

6. Summary of Differences

7. Conclusion

Linux distributions have broad hardware support, commercial application availability, and rapid driver updates. These characteristics align with desktop use where new GPUs, Wi-Fi, and consumer software are required. The large user base provides community help for desktop issues.

FreeBSD provides a single base system, integrated ZFS, the pf firewall, and jails. The release model emphasizes ABI stability for 5 years. The BSD license permits use in closed products. These characteristics align with server, storage, and appliance roles where consistency and long term maintenance are priorities.

Both systems are open source and technically capable. The choice depends on requirements for hardware, software, licensing, and administration model.

The post Linux and FreeBSD Operating Systems: Characteristics and Use Cases appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Are you tired of juggling countless SSH commands, remembering obscure IP addresses, or fumbling with scp for file transfers? If you’re managing a fleet of servers, whether for development, staging, or production, you know the pain. But what if there was a better way?

Inspired by the intuitive power of tools like lazydocker and k9s, Lazyssh emerges as your new best friend for navigating, connecting to, and managing your servers directly from the comfort of your terminal. Built with Go, Lazyssh transforms your ~/.ssh/config file into a dynamic, interactive dashboard, making server management a breeze.

What Makes Lazyssh a Game-Changer?

Lazyssh isn’t just another SSH client; it’s a comprehensive TUI (Terminal User Interface) wrapper that puts you in control with a clean, keyboard-driven interface.

Effortless Server Management

• See All Your Servers: Lazyssh reads and beautifully displays all entries from your ~/.ssh/config in a scrollable, easy-to-read list.
• Add & Edit with Ease: Forget manual file editing. Add new servers or modify existing ones directly from the UI with a comprehensive, tabbed interface for all your SSH configuration needs.
• Safety First: Delete server entries safely, knowing that Lazyssh handles your ssh_config with care, including automatic backups.
• Stay Organized: Pin your favorite servers to the top, tag them (e.g., prod, dev, test) for quick filtering, and sort them by alias or last SSH connection.
• Check Status: Ping servers to quickly ascertain their reachability.

Lightning-Fast Server Navigation

• Fuzzy Search: Find any server instantly by alias, IP, or tags with powerful fuzzy search.
• One-Key SSH: Hit Enter and you’re connected. It’s that simple.
• Clipboard Integration: Copy SSH commands to your clipboard with a single keypress.

Advanced SSH Configuration at Your Fingertips

Lazyssh brings the full power of OpenSSH to a user-friendly interface.

• Port Forwarding: Easily set up LocalForward, RemoteForward, and DynamicForward connections.
• Connection Multiplexing: Speed up subsequent connections with built-in multiplexing support.
• Comprehensive Authentication: Configure public key, password, and agent forwarding options.
• Security & Proxy Settings: Dive into ciphers, MACs, key exchange algorithms, and flexible ProxyJump or ProxyCommand configurations.
• Tabbed Interface: All these extensive options are neatly organized into intuitive tabs like Basic, Connection, Forwarding, Authentication, and Advanced.

Smart Key Management (Upcoming)

Future versions of Lazyssh promise even more powerful key management features, including:

• Copying files between local and remote servers with an easy picker UI.
• SSH Key Deployment: Automatically append public keys to ~/.ssh/authorized_keys, generate new keypairs, and support default local public keys.

Security You Can Trust

One of the most important aspects of any SSH tool is security, and Lazyssh excels here:

• No New Risks: Lazyssh is a UI/TUI wrapper around your existing ~/.ssh/config and leverages your system’s native ssh binary (OpenSSH) for all connections.
• Privacy Preserved: Private keys, passwords, and credentials are never stored, transmitted, or modified by Lazyssh itself.
• Config Safety: Lazyssh implements non-destructive writes, preserving your comments and formatting. It also creates atomic writes and robust backup mechanisms (one-time original backup and rolling timestamped backups) before any changes are made.

Get Started with Lazyssh Today!

Ready to streamline your SSH workflow? Installation is simple:

Option 1: Homebrew (macOS)

Bash

brew install Adembc/homebrew-tap/lazyssh

Option 2: Download Binary from Releases

Grab the latest version for your OS/ARCH from GitHub Releases. A convenient snippet is provided in the README to automate this process.

Option 3: Build from Source

If you prefer building from source:

Bash

git clone https://github.com/Adembc/lazyssh.git
cd lazyssh
make build
./bin/lazyssh
# Or run directly
make run

Master Lazyssh with Simple Key Bindings

Lazyssh is designed for keyboard efficiency. Here are some essential bindings:

• ↑↓/jk: Navigate servers
• Enter: SSH into selected server
• c: Copy SSH command to clipboard
• g: Ping selected server
• a: Add server
• e: Edit server
• d: Delete server
• p: Pin/Unpin servers
• q: Quit

(A hint bar at the top of the list provides context-aware shortcuts!)

Contribute and Support

Lazyssh is an open-source project, and contributions are highly welcome! Whether you spot a bug, have a feature request, or want to submit a pull request (following the semantic PR guidelines), your input helps make Lazyssh better.

Lazyssh is built with the excellent tview and tcell libraries, a testament to the power of the Go ecosystem for creating robust terminal applications. Say goodbye to SSH headaches and embrace the efficiency of Lazyssh.

https://github.com/Adembc/lazyssh

The post Lazyssh: Tame Your Server Farm with Terminal-Based SSH Management appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re using a ThinkPad in a hot and humid country like Malaysia, you probably already know how quickly your laptop can heat up. Whether you’re compiling code, editing videos, or just having too many browser tabs open — things can get toasty fast.

Most ThinkPads come with decent thermal design, but by default, the fan control is conservative. Enter ThinkFan — a lightweight, flexible fan control daemon that gives you full control over when and how your fan spins.

In this blog post, I’ll show you how to set up ThinkFan properly and optimize it for the Malaysian climate, where temperatures frequently exceed 30°C.

Why Use ThinkFan?

ThinkFan gives you:

• Manual control of fan levels based on actual temperature readings
• Better thermal management than default BIOS behavior
• Quieter system during light usage
• More aggressive cooling when needed

It’s especially useful for older ThinkPad models or systems that throttle too early or run too hot.

Prerequisites

Before starting, make sure:

1. You are using a ThinkPad.
2. You have installed ThinkFan (thinkfan) via your package manager.
3. The thinkpad_acpi module is loaded with fan control enabled:

echo "options thinkpad_acpi fan_control=1" | sudo tee /etc/modprobe.d/thinkfan.conf
sudo modprobe -r thinkpad_acpi
sudo modprobe thinkpad_acpi fan_control=1

4. Verify that /proc/acpi/ibm/fan exists:

cat /proc/acpi/ibm/fan

If you get a response, you’re good to go.

Configuring ThinkFan

Create or edit your config file:

sudo nano /etc/thinkfan.conf

Paste the following Malaysia-optimized config:

# Fan control interface for ThinkPad
tp_fan /proc/acpi/ibm/fan

# Temperature sensors (adjust if different on your system)
hwmon /sys/devices/platform/coretemp.0/hwmon/hwmon7/temp1_input
hwmon /sys/devices/platform/coretemp.0/hwmon/hwmon7/temp2_input
hwmon /sys/devices/platform/coretemp.0/hwmon/hwmon7/temp3_input

# Fan levels and temperature ranges (°C)
(1  0     48)      # Fan level 1 below 48°C
(2  48    58)      # Fan level 2 for light warmth
(3  58    65)      # Fan level 3 for typical usage
(4  65    72)      # Fan level 4 for medium load
(5  72    78)      # Fan level 5 for gaming or heavy usage
(6  78    83)      # Fan level 6 for high temps
(7  83  32767)     # Max fan speed for very high temps

This setup ensures that your fan stays quiet under light usage, but kicks in earlier and harder once temps climb — ideal for a warm country like Malaysia.

Starting ThinkFan

Enable and start the ThinkFan service:

sudo systemctl enable --now thinkfan

Monitor its activity:

sudo journalctl -u thinkfan -f

You should see logs like this:

Temperatures(bias): 50(0), 49(0), 50(0) -> Fans: level 2
Temperatures(bias): 66(0), 63(0), 67(0) -> Fans: level 3

This means it’s working and adjusting your fan dynamically.

Tips for Stability

• Don’t use thinkfan -n directly unless testing. Let systemd handle it.
• Avoid setting temperatures too low unless you’re okay with constant fan noise.
• If fan control stops working after suspend/resume, consider a udev or systemd resume hook to reload thinkpad_acpi.

Optional: Use ThinkFan-UI for a GUI Experience

If you prefer a graphical interface, check out ThinkFan-UI on GitHub. It lets you:

• View real-time temperatures
• Monitor fan levels visually
• Toggle daemon control manually
• Customize profiles easily

Final Thoughts

ThinkFan is a must-have for ThinkPad users who want quieter systems and better thermal performance. With a little configuration, you can make your laptop behave much better — and cooler, especially in Southeast Asia’s heat.

If you live in a climate like Malaysia, don’t settle for the default BIOS fan behavior. Take control — and give your laptop the cooling it deserves.

For more info, visit:

1. https://github.com/vmatare/thinkfan
2. https://github.com/zocker-160/thinkfan-ui

The post Keep Your ThinkPad Cool on Linux with ThinkFan appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re using a ThinkPad on Linux—especially an older model like the ThinkPad T460—you owe it to yourself to install TLP.

I’ve been tuning my T460 running CachyOS in Malaysia’s hot climate (no aircon, just a ceiling fan), and the difference with TLP is night and day. Let’s talk about how TLP works, how it makes your laptop smarter, and why it pairs beautifully with ThinkPads.

What Is TLP?

TLP is an advanced power management tool for Linux laptops. It automatically optimizes power usage depending on whether you’re plugged in or on battery, and offers a ton of ThinkPad-specific battery care features.

• On battery: Saves power, reduces heat
• On AC: Prioritizes performance
• On ThinkPads: Enables battery charge thresholds, recalibration, discharge, etc.

Why ThinkPads + TLP Just Work

ThinkPads are well-known for their Linux compatibility. TLP detects ThinkPad hardware via the thinkpad_acpi kernel module, enabling advanced features without needing extra modules like acpi_call-dkms.

On my T460, TLP uses natacpi (native ACPI) to:

Set charging thresholds
Prevent battery degradation
Reduce fan noise and overheating
Automatically stop charging at 80%
Keep things cool—even in a hot room

My Current Setup

Battery Management

I’m using these thresholds in /etc/tlp.conf:

START_CHARGE_THRESH_BAT0=75
STOP_CHARGE_THRESH_BAT0=80

That means charging only starts when my battery drops to 75%, and stops at 80%. This helps extend the battery’s lifespan—great if your laptop spends most of the time plugged in.

TLP also supports force discharge and recalibration if needed.

Fan + Cooling

Pairing TLP with ThinkFan gives full control of fan levels. I’m using an aggressive ThinkFan config to keep temps low. The fan spins up early to compensate for the Malaysian heat. Result? No thermal throttling.

How to Check If acpi_call-dkms Is Needed

TLP doesn’t need acpi_call-dkms if natacpi is active, which you can check with:

sudo tlp-stat -b

Look for:

Driver usage:
* natacpi (thinkpad_acpi) = active

If that’s active, you can uninstall acpi_call-dkms safely. I did!

sudo pacman -Rns acpi_call-dkms

Final Thoughts

TLP is a must-have for anyone running Linux on a ThinkPad. Combine it with ThinkFan and your old laptop will feel cooler, quieter, and smarter—even in hot climates like mine.

It’s free, open source, and incredibly effective.

Bonus Tip

Want to see TLP in action?

sudo tlp-stat -s    # See current power status
sudo tlp-stat -b    # Battery and charging status

Then just sit back and enjoy better thermals, longer battery life, and a cooler laptop.

TL;DR

• Install TLP on ThinkPads for power and battery management.
• Native support via thinkpad_acpi (no acpi_call-dkms needed).
• Works great with ThinkFan for thermal control.
• Set charge thresholds to extend battery health.
• Perfect for hot weather or 24/7 plugged-in laptops.

Want to automate thermal management and battery care like a pro? TLP is the answer.

The post TLP + ThinkPad: Ultimate Linux Battery & Thermal Management for Old Laptops appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re using an older laptop like the ThinkPad T460 in a hot, enclosed environment (like many of us in Malaysia), thermal management becomes crucial. Without proper cooling, your laptop will thermal throttle, overheat, or just feel uncomfortably warm during use.

This post walks through how I configured ThinkFan on CachyOS to provide aggressive, smart fan control — perfect for rooms without air conditioning.

Why ThinkFan?

ThinkFan is a lightweight daemon that adjusts your fan speed based on temperature readings. On ThinkPads, it interfaces with the system via the thinkpad_acpi module and /proc//sys interfaces.

Benefits:

• Auto-adjusts fan speeds based on real temps
• Lower idle temps
• Avoids overheating during heavy tasks
• Fully customizable fan curves

What You Need

• A ThinkPad laptop (in my case, a T460)
• CachyOS or any Arch-based distro
• Root access
• thinkfan and lm_sensors packages installed

Step 1: Install ThinkFan & lm_sensors

sudo pacman -S thinkfan lm_sensors

Step 2: Enable Kernel Modules

Ensure the ThinkPad ACPI module is loaded:

echo "options thinkpad_acpi fan_control=1" | sudo tee /etc/modprobe.d/thinkpad_acpi.conf

Then run:

sudo modprobe -r thinkpad_acpi
sudo modprobe thinkpad_acpi fan_control=1

To make it permanent across reboots, ensure the module is loaded:

echo thinkpad_acpi | sudo tee -a /etc/modules-load.d/thinkpad.conf

Step 3: Detect Sensors

sudo sensors-detect

Accept defaults. Then reboot.

Step 4: Identify Your Sensors

Run:

for i in /sys/class/hwmon/hwmon*/name; do echo "$i: $(cat $i)"; done

Example output:

/sys/class/hwmon/hwmon0/name: AC
/sys/class/hwmon/hwmon1/name: acpitz
/sys/class/hwmon/hwmon2/name: BAT0
/sys/class/hwmon/hwmon3/name: thinkpad
/sys/class/hwmon/hwmon4/name: pch_skylake
/sys/class/hwmon/hwmon5/name: iwlwifi_1
/sys/class/hwmon/hwmon6/name: coretemp

Step 5: Create the ThinkFan Config

Edit or create /etc/thinkfan.conf:

hwmon /sys/class/hwmon/hwmon6/temp1_input
hwmon /sys/class/hwmon/hwmon4/temp1_input
hwmon /sys/class/hwmon/hwmon3/temp1_input
hwmon /sys/class/hwmon/hwmon1/temp1_input

# Fan steps: (fan_level, temp_low, temp_high)
# Aggressive cooling - starts early and ramps fast

(0  0     48)
(1  45    52)
(2  50    56)
(3  54    60)
(4  57    65)
(5  60    70)
(6  65    75)
(7  70    80)

This fan curve is designed to start cooling early (as low as 45°C) and quickly reach max fan speed as temps rise — ideal for Malaysia’s hot climate.

Step 6: Enable and Start the Service

sudo systemctl enable --now thinkfan

Check its live logs:

sudo journalctl -u thinkfan -f

You should see output like:

Temperatures(bias): 51(0), 51(0), 45(0), 50(0), 50(0), 51(0) -> Fans: level 3

When things heat up:

Temperatures(bias): 55(0), 55(0), 46(0), 60(0), 58(0), 55(0) -> Fans: level 5

Final Result: Cool & Quiet(ish)

With this setup, my ThinkPad T460 stays cool even when:

• Browsing with multiple tabs
• In a room with no air-conditioning, no window, just a slow ceiling fan

Notes

• You can always tweak the fan curve for quieter behavior if needed.
• If you’re using KDE or GNOME, add a temp widget for real-time visuals.
• Don’t forget to clean your fans every few months — software can’t fix dust buildup.

The post Keeping Your ThinkPad Cool on CachyOS with ThinkFan 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.

In the ever-growing world of Linux distributions, there’s no shortage of choices. From beginner-friendly options like Ubuntu and Manjaro to bleeding-edge systems like Arch Linux, users can find a distro that suits nearly any use case. But what if you’re looking for raw performance, modern hardware optimization, and a smooth desktop experience out of the box?

Meet CachyOS — a lesser-known but rapidly rising Arch-based Linux distribution that’s built with one clear goal in mind: speed and responsiveness without sacrificing control or flexibility.

What is CachyOS?

CachyOS is an Arch-based Linux distribution that aims to provide an ultra-fast, responsive, and secure desktop environment tailored especially for modern CPUs and high-performance tasks, such as gaming, compiling, multitasking, and content creation.

What makes it different from other Arch-based distros like Manjaro, EndeavourOS, or Garuda? The answer lies in aggressive performance optimizations, custom-built kernels, and compiler-level tweaks designed to squeeze the most out of your system.

Why Use CachyOS?

Let’s break down the unique features that set CachyOS apart:

1. Performance-Tuned Kernels

CachyOS ships with multiple kernel options optimized for different workloads. These include:

• linux-cachyos: The default kernel tuned with custom CPU scheduling and responsiveness.
• linux-cachyos-bore: Includes the Bore scheduler for desktop fluidity.
• linux-cachyos-tt: The TT (Temporal Tasking) scheduler, offering ultra-low latency and gaming responsiveness.
• linux-cachyos-rc: A release-candidate kernel for those who want the absolute latest.

This variety allows users to test and select the best kernel for their hardware and needs.

2. Compiler Optimizations for Modern CPUs

CachyOS takes things further by building its packages using LLVM/Clang and custom compiler flags targeting x86-64-v3 or x86-64-v4 instruction sets — meaning if you have a newer CPU (2011 and beyond), you’re going to see noticeable speed gains in both daily tasks and heavy workloads.

This makes system updates and application launches faster than standard builds, especially compared to general-purpose distros.

3. Intelligent Memory and CPU Handling

CachyOS is tuned for desktop usage right out of the box:

• ZRAM enabled by default, allowing for better memory compression and management.
• Integrated systemd-oomd for handling low-memory situations gracefully.
• Intel P-State / AMD CPPC governor optimization for dynamic frequency scaling.
• Link-Time Optimization (LTO) enabled in many packages, improving runtime speed.

These tweaks result in faster application startup, lower input latency, and smoother multitasking, especially on systems with limited RAM or older SSDs.

4. A Gamer’s Delight

Gaming on Linux has improved drastically, and CachyOS embraces this shift:

• Preinstalled support for Steam, Proton, and Lutris.
• Comes with gamemode, MangoHud, vkBasalt, and other useful gaming tools.
• Native support for NVIDIA, AMD, and Intel drivers.
• Custom kernels improve FPS stability, input response, and frame pacing.

For competitive gamers or casual Linux users who love games, CachyOS offers an experience that rivals (or even beats) Windows in responsiveness.

5. Cachy-Browser: A Faster Firefox

One standout feature is Cachy-Browser, a custom fork of Firefox ESR. It includes:

• Performance patches
• Enhanced privacy settings
• Disabled telemetry
• Faster UI rendering

This browser is perfect for those who want a Firefox experience that’s faster and more private out of the box.

6. Desktop Environments and Themes

CachyOS supports multiple desktop environments including:

• KDE Plasma (default)
• GNOME
• XFCE
• Cinnamon
• LXQt
• Hyprland (Wayland tiling WM)

The KDE Plasma version comes with beautiful custom theming, blur effects, and system tweaks that make it look polished without being overdone.

7. GUI Tools and Kernel Manager

Even though CachyOS is performance-focused, it doesn’t leave usability behind. It provides:

• A GUI kernel switcher to easily change and install new kernels.
• Easy access to system tools via a control center-like panel.
• Full Calamares installer with support for Btrfs and auto partitioning.

You get the best of both worlds: raw power and ease of use.

Things to Keep in Mind

CachyOS is powerful, but it’s not for everyone.

• It assumes you have moderately new hardware (at least x86-64-v2+ support).
• Some features may break if you stray too far from its tooling (e.g., using other kernels).
• It’s not as “beginner-proof” as Ubuntu or Linux Mint.

However, if you have some Linux experience and you’re looking to push your system to its full potential, CachyOS is absolutely worth exploring.

Real-World Performance

Many users have reported:

• Faster boot times than Manjaro or EndeavourOS.
• Lower idle CPU usage and RAM footprint on Plasma.
• Better gaming performance with more consistent frame delivery.
• Snappier app launch times, thanks to LTO and compiler flags.

CachyOS for Amateur Radio Enthusiasts

CachyOS isn’t just built for speed and gaming—it’s also a great choice for amateur radio operators and digital communication enthusiasts. Thanks to its Arch-based foundation, CachyOS gives users access to both the official Arch repositories and the AUR (Arch User Repository), which hosts a vast collection of ham radio-related software. Whether you’re operating WSJT-X for FT8, fldigi for digital modes, GNU Radio for SDR experiments, or using Xastir and YAAC for APRS tracking, these tools are readily available with simple installation via pacman or AUR helpers like yay.

The high-performance nature of CachyOS makes it particularly suitable for real-time signal processing, SDR applications, and low-latency audio, which are critical for many amateur radio setups. Coupled with optimized kernels and better scheduling for CPU-bound tasks, operators can expect smoother and more stable performance—even on older hardware. If you’re looking for a Linux distribution that’s not only fast but also flexible and ham-radio friendly, CachyOS is well worth considering.

Conclusion

CachyOS is not just another Arch-based distribution — it’s a performance powerhouse tailored for those who want their system to work fast, feel smooth, and take full advantage of modern hardware.

Whether you’re a Linux gamer, a developer compiling massive codebases, or a daily user who just loves a snappy desktop, CachyOS offers an experience that’s hard to beat.

If you’re ready to explore a distro that blends bleeding-edge performance with user-centric design, give CachyOS a try.

Website: https://cachyos.org

The post CachyOS: A Fast and Modern Arch-Based Linux Distribution for Power Users and Gamers appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re a Linux user on a laptop—especially a ThinkPad (For Windows user, visit https://www.lenovo.com/us/en/software/vantage) —you owe it to yourself to install TLP. This brilliant power management tool doesn’t just improve battery runtime — it gives you real control over how your battery is treated, helping extend its lifespan through smart features like charge thresholds and battery recalibration.

Why TLP?

Out of the box, most laptops will charge your battery to 100% every time, even if you’re always plugged in. That’s not ideal. Repeatedly keeping a lithium-ion battery at full charge shortens its lifespan.

TLP changes the game. Once installed and configured, it helps you:

• Avoid unnecessary full charges
• Prevent overheating
• Preserve battery health over time

Let’s look at two of TLP’s most powerful features: charge thresholds and battery recalibration.

Set Smart Charge Thresholds

TLP allows you to limit how much your battery charges. On supported hardware (like ThinkPads), you can configure a start and stop percentage.

Here’s an example in /etc/tlp.conf:

START_CHARGE_THRESH_BAT0=75
STOP_CHARGE_THRESH_BAT0=80

What does this do?

• Your laptop will only start charging when the battery drops below 75%
• It will stop charging when it reaches 80%

This keeps your battery in a much healthier state — avoiding the constant 100% charge stress.

This is especially useful for users who work plugged in most of the time.

You can check your current threshold settings with:

sudo tlp-stat -b

Example output:

/sys/class/power_supply/BAT0/charge_control_start_threshold = 75 [%]
/sys/class/power_supply/BAT0/charge_control_end_threshold   = 80 [%]

If your battery is above the stop threshold, TLP will intentionally not charge it — exactly as it should.

Recalibrate to Restore Accuracy

Battery readings can become inaccurate over time. If your system shows 100% charge but you get very little runtime, it’s probably time to recalibrate.

TLP offers an easy way to do this:

sudo tlp recalibrate BAT0

What happens during recalibration:

1. Your laptop will fully discharge the battery
2. Then it will recharge it completely, recalibrating the battery controller

Important:

• Save your work! Your laptop will power off during the discharge phase.
• Don’t use this feature too frequently — once every few months (or when needed) is enough.

Check Battery Health

Want to see how worn your battery is? Use:

sudo tlp-stat -b

You’ll get output like:

energy_full_design = 23200 [mWh]
energy_full        = 14610 [mWh]

This tells you your battery only holds 63% of its original capacity — a sign of aging.

Why This Matters

TLP isn’t just another background tool — it gives power users real control over how their system manages energy. On ThinkPads and similar laptops, it unlocks features that were once limited to Windows-only tools.

By using:

• Charge thresholds to prevent unnecessary wear
• Recalibration to fix reporting errors
• Battery health stats to plan replacements

…you’re not just using Linux — you’re using it smarter.

Install TLP on Linux

TLP is available in most distro repositories:

Arch / Manjaro / CachyOS:

sudo pacman -S tlp

Ubuntu / Debian:

sudo apt install tlp

Then enable and start it:

sudo systemctl enable tlp --now

Optionally install extra tools:

sudo apt install tp-smapi-dkms acpi-call-dkms

Final Thoughts

If you care about your laptop’s health, TLP is a must-have. It’s free, lightweight, and gives you enterprise-grade control over your Linux system’s power management.

The post Extend Your Laptop Battery Life with TLP: Charge Thresholds & Recalibration on Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Have you ever dreamed of building and launching your own rockets? Whether you’re a student, educator, hobbyist, or aerospace enthusiast, there’s one tool that makes rocketry accessible, educational, and exciting: OpenRocket.

OpenRocket is a free, fully open-source model rocket simulator that helps you design, simulate, and optimize rockets in a virtual environment — all before a single part is printed or assembled.

And the best part? It’s completely free, runs on Windows, macOS, and Linux, and is trusted by thousands around the world — from classrooms to high-powered launch pads.

What is OpenRocket?

OpenRocket is a powerful simulation tool designed to make rocket science understandable and practical. It enables users to build virtual models of rockets, test their flight performance, and iterate on designs long before committing to physical builds. Whether you’re building a simple school project or a multi-stage high-powered model, OpenRocket is built to support you at every step.

Key Features

• Drag-and-Drop Rocket Design
  Build your rocket with ease using a graphical interface — choose body tubes, fins, nose cones, engines, recovery systems, and more.
• Accurate Flight Simulations
  Simulate flights in real-world conditions with detailed physics modeling, including wind, thrust curves, drag, gravity, and stability.
• Detailed Analysis Tools
  Visualize graphs for altitude, velocity, acceleration, angle of attack, and more — perfect for science fair projects and engineering analysis.
• Support for Multistage and Cluster Rockets
  Go beyond basic designs and experiment with multi-engine configurations, boosters, and complex recovery systems.
• Advanced Stability Calculations
  See real-time updates on your rocket’s center of pressure and center of gravity — helping ensure stable flights.
• Education-First Philosophy
  Built with educators and students in mind — great for teaching physics, aerodynamics, math, and engineering concepts.
• 100% Free and Open Source (GPLv3 License)
  Modify, contribute, or use it freely in academic and personal projects.

Perfect for Classrooms and Competitions

OpenRocket is a favorite in schools, universities, and STEM clubs. It’s ideal for:

• Physics and engineering lessons
• STEM competitions
• High school and university rocketry teams
• Maker clubs and hobbyist communities

With OpenRocket, students don’t just learn theory — they test it, visualize it, and bring it to life.

Cross-Platform and Easy to Use

OpenRocket runs smoothly on Windows, Linux, and macOS, with a lightweight footprint and no complex setup required. Just download, install, and launch.

Want to try the latest features? There are stable and experimental versions available, with an active community improving the project continuously.

Join a Global Community

OpenRocket is powered by passionate volunteers and used worldwide. With an active community on forums and GitHub, it’s easy to get help, share ideas, and even contribute your own code or simulations.

If you’re ready to explore the world of rocketry without burning through your budget, OpenRocket is your launchpad.

Ready for Liftoff?

Visit openrocket.info and start building your dream rocket today.

Design. Simulate. Launch. Learn. Repeat.

Welcome to the world of OpenRocket — where rocket science is for everyone.

The post OpenRocket: Design, Simulate, and Launch Your Own Rockets — Free and Open Source appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Have you ever dreamed of flying a Boeing 777 across continents, landing a Cessna on a grass strip, or navigating a helicopter through cityscapes — all from the comfort of your home? Meet FlightGear, a highly sophisticated, community-driven open-source flight simulator that puts the sky at your fingertips — and it’s completely free.

What is FlightGear?

FlightGear is an open-source flight simulator developed by a passionate global community of programmers, pilots, engineers, and aviation enthusiasts. Since its inception in 1997, FlightGear has grown into one of the most realistic and versatile flight simulators available — rivaling many commercial alternatives.

Whether you’re an aspiring pilot, a seasoned flight sim veteran, or a student of aerospace engineering, FlightGear offers something for everyone.

Realism that Soars

FlightGear prides itself on incredible realism — from its accurate flight dynamics and real-world weather modeling to true-to-life cockpit instrumentation and aircraft behavior. It supports:

• Over 400 aircraft — from gliders and airliners to helicopters and experimental planes.
• Worldwide scenery — leveraging global terrain data, airport layouts, and real-time weather.
• Accurate time-of-day and celestial modeling — fly under starlit skies or into a stunning sunset.
• Customizable systems — simulate electrical failures, instrument degradation, and more.

Cross-Platform Freedom

Available for Windows, macOS, and Linux, FlightGear ensures that everyone, regardless of their platform, can enjoy the thrill of flight. It also supports multi-monitor setups, networking for multi-player and instructor modes, and hardware such as yokes, pedals, and head tracking gear.

For Developers and Tinkerers

FlightGear isn’t just for pilots — it’s also a paradise for developers and modders. The source code is freely available, enabling anyone to contribute improvements, build new aircraft, create custom scenery, or integrate external hardware and software.

From hobbyist coders to university researchers, FlightGear is widely used for simulations, training, and experimentation.

Community-Driven Excellence

What truly sets FlightGear apart is its community. The project is driven by volunteers and supported by aviation lovers worldwide. Whether you’re looking for help, contributing code, or downloading new liveries, the FlightGear forums and mailing lists are full of helpful and passionate users.

How to Get Started

Getting airborne is easy:

1. Visit FlightGear.org.
2. Download the latest version for your operating system.
3. Choose your aircraft and preferred location.
4. Launch and take off into the open skies.

There’s no license fee, no DRM, and no limitations — just pure flight simulation freedom.

Final Thoughts

FlightGear proves that you don’t need to spend hundreds to enjoy a full-featured, high-quality flight simulator. It’s an amazing tool for learning, experimentation, and fun — built by the community, for the community.

Whether you’re chasing clouds or learning to navigate, FlightGear will help you spread your wings.

Download it. Fly it. Contribute to it. The sky is truly the limit.

The post Take to the Skies with FlightGear: The Ultimate Open-Source Flight Simulator appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

OpenWrt is not just firmware—it’s a complete Linux-based operating system purpose-built for routers and embedded devices. To understand how OpenWrt works, it helps to look at how it integrates with router hardware, manages networking tasks, and provides flexibility well beyond stock firmware.

In this post, we’ll explore how OpenWrt operates internally, from bootloader to network stack, and why it’s so much more powerful than vendor firmware.

1. The Boot Process: How OpenWrt Starts

OpenWrt uses the standard embedded Linux boot sequence:

1. Bootloader (e.g., U-Boot or CFE)
   • Executes first when the router powers on.
   • Initializes the CPU, memory, and peripherals.
   • Loads the OpenWrt kernel and passes control.
2. Linux Kernel
   • A highly customized and lightweight kernel compiled for the router’s architecture (e.g., MIPS, ARM, x86).
   • Initializes hardware drivers, network interfaces, file systems, and system services.
3. Init System (procd)
   • OpenWrt uses a custom init system called procd to manage services, boot order, hotplug events, and more.
   • It replaces classic sysvinit or systemd to keep things lightweight and fast.

2. Filesystem and Overlay

OpenWrt’s filesystem is built around SquashFS + OverlayFS:

• SquashFS is a compressed, read-only root filesystem containing the core OS.
• OverlayFS provides a writable layer on top of it, enabling persistent configuration and package installation without altering the base image.

This design allows:

• Fast boot times
• System resets (factory reset = wipe overlay)
• Minimal storage use (great for routers with low flash memory)

3. Networking Stack

OpenWrt’s real power lies in its networking flexibility. Here’s how it manages key components:

a. Interface Management (netifd)

Handles creation of logical interfaces (LAN, WAN, VLANs, bridges, tunnels).
Interfaces are defined in /etc/config/network and handled by netifd.

b. Firewall (nftables or iptables)

OpenWrt uses nftables (or iptables in older versions) for packet filtering, NAT, and port forwarding.
Firewall zones (e.g., LAN, WAN) are defined for easy rule management.

c. DHCP/DNS (dnsmasq)

A lightweight DNS and DHCP server (dnsmasq) serves local IP addresses and hostname resolution.

d. Wireless Stack (hostapd / wpad)

Wireless radios are configured using hostapd or wpad, managing SSID, encryption (WPA2/WPA3), and multiple interfaces.

e. Routing

Routing is handled by the Linux kernel’s routing table and can be extended with:

• Static routes
• Dynamic routing protocols (e.g., OSPF via quagga or bird)
• VPN routes (e.g., WireGuard or OpenVPN)

4. Package Management: How OpenWrt Is Modular

OpenWrt includes a package manager called opkg (Open Package Manager).

Users can install packages for:

• VPNs: wireguard, openvpn
• Ad-blocking: adblock, banIP
• Monitoring: collectd, luci-app-statistics
• Web servers, proxy servers, NAS functions, mesh routing (B.A.T.M.A.N., 802.11s)

Each package is a compressed archive with its own dependencies and can be installed with:

opkg update
opkg install luci-app-wireguard

5. Configuration System (UCI)

OpenWrt uses its own Unified Configuration Interface (UCI) for managing system settings. All configs are stored in:

/etc/config/

Examples:

• /etc/config/network – interfaces, VLANs, bridges
• /etc/config/wireless – radios, SSIDs
• /etc/config/firewall – zone policies, rules
• /etc/config/system – hostname, timezone

You can edit these directly or use UCI commands:

uci set wireless.@wifi-iface[0].ssid='OpenWrt'
uci commit wireless
wifi reload

6. Web Interface (LuCI)

LuCI is OpenWrt’s lightweight, modular web GUI:

• Runs on an embedded uhttpd or lighttpd web server
• Dynamic rendering via Lua + JavaScript
• Exposes all config options in a user-friendly form
• Extendable with modules (e.g., luci-app-sqm, luci-app-ddns)

You can install LuCI separately or use CLI-only setups for advanced users.

7. Remote Access & Automation

OpenWrt supports:

• SSH access out of the box
• Public key authentication
• Cron jobs for automation
• Remote syslog
• SNMP, Prometheus exporters
• MQTT for IoT applications

You can remotely manage it using APIs, CLI, or custom scripts.

8. System Resources and Performance

Because OpenWrt runs on devices with as little as 8MB flash and 64MB RAM, it is optimized for:

• Minimal memory usage
• Background service trimming
• Efficient caching and logging
• Graceful failure on low disk/memory

That said, OpenWrt can scale well to more powerful hardware (x86, ARM64), supporting multi-core load balancing, gigabit routing, and even containerization (via lxc or docker on x86 builds).

Final Thoughts

OpenWrt works by replacing the limited firmware on your router with a full-featured Linux OS, designed for performance, customization, and stability. It gives you access to capabilities usually reserved for enterprise-grade routers—at zero cost.

If you’re the kind of person who likes to control every part of your network, OpenWrt is the ultimate toolkit: flexible, modular, transparent, and endlessly powerful.

The post How OpenWrt Works: Inside the World’s Most Powerful Router Operating System appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re thinking of using Neovim as a modern, fast, and extensible text editor — but don’t want to configure everything from scratch — LazyVim can save you time and effort.

This guide walks you through installing Neovim, then setting up LazyVim — step by step, without skipping the basics.

Part 1: Install Neovim

LazyVim requires Neovim 0.9 or later, so first make sure you have the correct version.

Step 1: Check if Neovim is installed

Run:

nvim --version

If Neovim is not found or the version is older than 0.9, install or upgrade it.

Linux (Arch-based)

sudo pacman -S neovim

Or for bleeding-edge:

paru -S neovim-git

macOS (with Homebrew)

brew install neovim

Or upgrade:

brew upgrade neovim

Windows

Use scoop:

scoop install neovim

Or download prebuilt binaries from GitHub.

Part 2: Install Git (if not already installed)

LazyVim uses Git to clone plugins. On Linux:

sudo pacman -S git      # Arch
sudo apt install git    # Debian/Ubuntu

Part 3: Install LazyVim

LazyVim is not a plugin — it’s a full Neovim configuration. You’ll replace your existing config with LazyVim’s starter template.

Step 1: Backup your current config (if any)

mv ~/.config/nvim ~/.config/nvim.bak

Step 2: Clone the LazyVim starter template

git clone https://github.com/LazyVim/starter ~/.config/nvim

This gives you a minimal, clean LazyVim-based configuration.

Step 3: Start Neovim

nvim

This will trigger the initial setup. LazyVim will automatically install:

• lazy.nvim plugin manager
• Language Server Protocol (LSP) support
• Autocomplete, Treesitter, statusline, fuzzy finder, file tree, and more

Let it finish the install before doing anything else.

LazyVim File Structure Overview

Once installed, your config lives in:

~/.config/nvim/
├── init.lua             # Entry point
├── lua/
│   ├── config/          # Options and keybindings
│   ├── plugins/         # Add your own plugins here
│   └── lazyvim/         # Core LazyVim files

How to Add Plugins

Create a new file in lua/plugins/, like this:

-- ~/.config/nvim/lua/plugins/colorscheme.lua
return {
  "folke/tokyonight.nvim",
  priority = 1000,
  config = function()
    vim.cmd.colorscheme("tokyonight")
  end,
}

Then restart Neovim and run:

:Lazy sync

Summary

Final Thoughts

If you’re looking to switch to Neovim but don’t want to build everything from scratch, LazyVim is a reliable starting point. It gives you a modern editing experience with sane defaults, and a structure that you can extend as you learn.

You don’t need to become a Vim wizard overnight — but LazyVim can help you get productive today and grow at your own pace.

Resources

• LazyVim GitHub
• Neovim Homepage
• lazy.nvim plugin manager
• nvim-lua-guide

The post Guide to Neovim + LazyVim Setup 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.

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.

Logging QSOs shouldn’t feel like work — especially when you’re running portable. Whether you’re activating a POTA park, chasing summits for SOTA, joining Field Day, or just working HF from a hilltop, you need a logging app that’s fast, offline-ready, and built for real operators.

HAMRS is exactly that.

It’s built from the ground up for modern ham radio ops — simple UI, solid performance, and zero learning curve. Whether you run 100 watts or QRP, HAMRS gives you a clean, fast way to log contacts in the field, then export them for LoTW, QRZ, or your main shack log.

Why HAMRS Matters for Portable Ham Radio

• Offline logging with fast entry — no internet needed
• Templates for POTA, SOTA, Field Day, etc.
• Auto-fill grid squares, park info, and more
• ADIF import/export — seamless integration with Logbook of The World, QRZ, etc.
• FLRig support — auto-fill frequency/mode from your rig (Pro)
• Dark mode for visibility in all lighting conditions
• Built for speed — logs pileups without freezing or lagging

If you’re logging by hand or using bloated shack software on your laptop, HAMRS will feel like a breath of fresh air.

Install HAMRS on Arch Linux (and Derivatives)

On Arch, Manjaro, CachyOS, or any Arch-based distro, install it from the AUR with:

yay -S hamrs-appimage

This installs the latest AppImage version and sets up a launcher in your menu. Launch it, select your logging template, and you’re ready to go.

Perfect for:

• QRP operators
• HF/VHF/UHF field deployments
• Satellite logging (custom templates supported)
• EMCOMM / field exercises
• Club stations
• Quick home station logging without extra config

Exporting and Uploading Logs

Once you’re done operating, you can:

• Export logs in ADIF format
• Upload directly to QRZ (built-in feature)
• Import into TQSL for Logbook of The World
• Share logs with your club or contest team

HAMRS speaks the language of ham radio. No conversions, no weird formats.

Support the Developer

HAMRS is built by a fellow ham with optional Pro features like rig control and cloud sync.

Support the project via:

• Patreon
• Merch
• Direct donation

Final Key Point

You already care about radios, antennas, propagation, and signal reports — don’t let your logging app be the weakest part of your setup.

HAMRS was made for you — the operator in the field, in the car, in the club tent. If you value efficiency and simplicity while still hitting all the right ham features, this is your logger.

Every Day Is Field Day
https://www.hamrs.app

The post A Better Logger for Hams: HAMRS 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.

Winlink is an essential tool in emergency and portable amateur radio communications. It allows you to send and receive emails over RF using various modes like VHF, UHF, and HF. In this guide, I’ll walk you through setting up a Winlink client on a Raspberry Pi, turning your Pi into a lightweight and powerful messaging hub.

Whether you’re preparing for EmComm scenarios or operating in remote areas, this setup gives you email access without the internet.

What You’ll Need

• Raspberry Pi 3, 4, or Zero 2 W (running Raspberry Pi OS or Debian-based Linux)
• Internet access for installation
• Your amateur radio license
• A soundcard interface (e.g., Signalink, Digirig, or USB soundcard)
• A transceiver (VHF/UHF or HF)
• A Winlink account (free to register on first connect)

Optional but useful:

• USB GPS (for mobile use)
• Touchscreen or headless SSH setup

Step 1: Install Dependencies

First, update your Pi:

sudo apt update && sudo apt upgrade -y

Install required packages:

sudo apt install build-essential git cmake libhamlib-dev libwxgtk3.0-gtk3-dev libconfig++-dev libfftw3-dev libpulse-dev libusb-1.0-0-dev libudev-dev libasound2-dev

Step 2: Install pat — the Winlink Client

pat is a cross-platform Winlink client written in Go, ideal for headless or GUI-less systems like the Raspberry Pi.

Install Go (if not installed):

sudo apt install golang-go

Clone and build pat:

cd ~
git clone https://github.com/la5nta/pat.git
cd pat
go build
sudo cp pat /usr/local/bin/

Verify:

pat version

Step 3: Configure pat

Create config directory:

mkdir -p ~/.config/pat
nano ~/.config/pat/config.json

Paste and edit this basic configuration:

{
  "mycall": "9M2PJU",
  "secure_login_password": "your_winlink_password",
  "locator": "OJ03pa",
  "listen": ["http"],
  "http_addr": "0.0.0.0:8080"
}

Replace 9M2PJU with your callsign, and set your password. The locator can be your Maidenhead grid square.

Step 4: Connect Radio & Sound Interface

Connect your USB soundcard interface to the Pi and your transceiver. Make sure audio in/out is working (check with arecord and aplay).

Optional: Configure audio devices in ~/.asoundrc or set defaults with alsamixer.

Step 5: Install ardop or ax25 Modem

Install ARDOP (for VHF/UHF or HF soundcard modes)

Clone and build:

cd ~
git clone https://github.com/la5nta/ardop.git
cd ardop
go build
sudo cp ardop /usr/local/bin/

Step 6: Launch pat Web Interface

Run the client:

pat http

On your browser, navigate to:

http://<raspberrypi-ip>:8080

You’ll see the Winlink pat interface. You can compose messages, connect to gateways, and send emails over RF.

Step 7: Send and Receive Messages

To send a message:

1. Click Compose
2. Enter recipient (e.g., yourname@winlink.org)
3. Choose Winlink CMS Relay for direct messages or Packet/ARDOP for RF
4. Click Send

To send via RF (Packet or ARDOP), you’ll need to set up modems and gateway frequencies. Example (packet mode):

pat connect ax25 KLSAR-10

Or ARDOP:

pat connect ardop K4CJX

Tips and Tricks

• Use tmux or screen to keep pat running in the background
• Install ax25-tools if using hardware TNC
• Use direwolf for software packet TNC (AX.25 mode)
• Set up a cronjob to auto-launch on boot

Security Note

The web interface doesn’t use SSL by default. If you’re exposing this over a network, consider using SSH tunneling or a reverse proxy with HTTPS.

Final Thoughts

With just a Raspberry Pi and some ham radio gear, you now have a fully functional Winlink station capable of handling email over RF. This setup is portable, reliable, and an excellent asset for both casual and emergency use.

The post How to Set Up a Winlink Client on a Raspberry Pi appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

As WordPress powers over 40% of the web, it remains a prime target for hackers, bots, and automated malware attacks. If you’re running a WordPress site—whether it’s a blog, e-commerce store, or a landing page for your ham radio projects—securing it should be a top priority. One of the best security layers you can implement is a Web Application Firewall (WAF).

But not all WAFs are created equal. Some are cloud-based and block threats before they hit your server. Others work as WordPress plugins and offer deep integration and control.

In this post, I’ll break down the top WAF options for WordPress in 2025, comparing features, pros, cons, pricing, and real-world use cases—so you can make the right decision based on your needs.

What Is a Web Application Firewall?

A Web Application Firewall acts as a shield between your WordPress site and incoming traffic, inspecting requests and blocking malicious ones. Think of it as a digital bouncer checking each visitor for suspicious behavior before letting them in.

There are two main types of WAFs:

1. Cloud-based WAFs: Work at the DNS or CDN level (e.g., Cloudflare, Sucuri).
2. Plugin-based WAFs: Installed directly on your WordPress site (e.g., Wordfence, MalCare).

Each has its advantages, depending on your hosting, traffic level, and technical skill.

1. Cloudflare WAF – Fast, Reliable, and Cost-Effective

Cloudflare is widely known for its CDN and DNS services, but its WAF is equally powerful—especially for WordPress users.

Pros:

• Stops attacks before they reach your server
• Offers free plan with basic security rules
• Includes DDoS mitigation, CDN, and caching
• Seamless integration with WordPress
• Fast global delivery of your content

Cons:

• Advanced WAF rules require Pro plan ($20/month)
• Some setup required (changing DNS)

Best for:

Performance-oriented websites, WooCommerce stores, blogs with global audiences, and users who want minimal maintenance.

Pro Tip: Even the free plan includes rate limiting and bot protection, which stops most basic attacks. You can combine this with a WordPress security plugin for layered defense.

2. Sucuri Website Firewall – Best for Serious Security

Sucuri is a full-service website security platform that includes a WAF, malware scanning, cleanup, and performance optimization.

Pros:

• Cloud-based protection stops attacks upstream
• Excellent malware detection and auto-cleanup
• Includes global CDN and caching for performance
• 24/7 support included in higher tiers

Cons:

• No free plan – starts at $199.99/year
• Requires DNS changes, which may intimidate non-tech users

Best for:

High-risk websites, businesses, and anyone willing to pay for peace of mind.

Real-world scenario: If your site is already under attack or blacklisted, Sucuri can clean it up and restore it faster than most competitors.

3. Wordfence – WordPress-Specific and Feature-Rich

Wordfence is one of the most popular WordPress security plugins, offering a strong WAF that runs inside your WordPress site.

Pros:

• Easy to install and use
• Real-time firewall rules (in Pro version)
• Built-in malware scanner and brute-force protection
• Free version is very capable

Cons:

• Runs after traffic hits your web server (uses PHP resources)
• Can slow down sites on low-powered shared hosting

Best for:

Tech-savvy WordPress users, self-hosted blogs, or users who want to see detailed logs and control every setting.

Use Wordfence if you like to monitor every login attempt, block IPs manually, or receive email alerts when something goes wrong.

4. MalCare – Smart, Cloud-Based Malware Scanning

MalCare offers a smart mix of plugin-based control with cloud scanning. It focuses on simplicity and automation, making it beginner-friendly.

Pros:

• Cloud-based scanning doesn’t stress your server
• One-click malware removal (Premium)
• Brute-force protection and login hardening
• Beginner-friendly dashboard

Cons:

• WAF not as advanced as Cloudflare or Sucuri
• Free version limited in features

Best for:

Small business websites, freelancers, and non-technical WordPress users who want clean security with low overhead.

5. Astra Security – Sleek UI and Smart Protection

Astra Security is a newer player, offering a clean interface with comprehensive WAF, malware detection, and threat analytics.

Pros:

• Real-time WAF with machine learning
• Easy to use, great UI
• Also protects login pages, comment forms, and admin areas

Cons:

• No free version
• Not as widely battle-tested as Cloudflare or Wordfence

Best for:

Startups, agencies, and WooCommerce shops looking for smart security and good UX.

Comparison Table: At a Glance

WAF	Type	Free Plan	CDN	Malware Scan	Ideal For
Cloudflare	Cloud				Speed, DDoS, passive protection
Sucuri	Cloud				High-security, hacked sites
Wordfence	Plugin				Tech users, real-time visibility
MalCare	Hybrid			(cloud)	Beginners, low-maintenance sites
Astra Security	Cloud				Agencies, WooCommerce

My Personal Recommendation

After years of managing WordPress sites (including this one), my ideal setup for 2025 is:

Cloudflare Free + Wordfence Free

• Cloudflare blocks bad traffic before it hits your server
• Wordfence monitors everything inside your WordPress instance

It’s a layered defense, and the cost is zero, unless you upgrade either service.

For critical or business websites, I recommend upgrading to either:

• Cloudflare Pro ($20/mo) – adds more advanced firewall rules
• Sucuri Basic Plan ($199/year) – adds cleanup and expert support

Bonus Tips for Better WordPress Security

• Always keep WordPress, plugins, and themes updated
• Use strong passwords and 2FA for logins
• Disable XML-RPC unless needed
• Limit login attempts (Wordfence can help with this)
• Backup your site regularly (UpdraftPlus, JetBackup, etc.)

Final Thoughts

A good WAF is not a luxury—it’s a necessity. Whether you’re blogging about amateur radio, running an online shop, or managing a portfolio, your WordPress site is vulnerable by default. Don’t wait for an attack to realize the importance of security.

Choose a WAF that fits your needs and budget. Even a free combo like Cloudflare + Wordfence can make a world of difference.

Stay safe, secure your site, and keep creating awesome content.

The post Choosing the Best Web Application Firewall (WAF) for Your WordPress Site appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re a Linux user craving a real-time strategy (RTS) game with the polish of Age of Empires and the historical depth of a university textbook—yet entirely free and open source—then you need to try 0 A.D.. This epic project by Wildfire Games is not just an open-source alternative to mainstream RTS games—it’s a serious contender in its own right, crafted with passion, precision, and community spirit.

What is 0 A.D.?

0 A.D. (Zero Anno Domini) is a free, open-source, cross-platform RTS game that takes players deep into ancient history, allowing them to build and battle with civilizations from 500 B.C. to 500 A.D. The game is built using the custom Pyrogenesis engine, a modern 3D engine developed from scratch for this purpose, and available under the GPL license—yes, you can even tinker with the code yourself.

It’s not just a clone. 0 A.D. sets itself apart with:

• Historically accurate civilizations
• Dynamic and random map generation
• Tactical land and naval combat
• City-building with tech progression
• AI opponents and multiplayer support
• Modding tools and community-created content

Why It’s Perfect for Linux Users

Linux gamers often get the short end of the stick when it comes to big-name games—but 0 A.D. feels like it was made for us. Here’s why Linux users should care:

Native Linux Support

0 A.D. runs natively on Linux without the need for Wine, Proton, or compatibility layers. You can install it directly from your distro’s package manager or build it from source if you like full control.

For example:

# On Debian/Ubuntu
sudo apt install 0ad

# On Arch Linux
sudo pacman -S 0ad

# On Fedora
sudo dnf install 0ad

No weird dependencies. No workarounds. Just pure, native performance.

Vulkan Renderer and FSR Support

With Alpha 27 “Agni”, 0 A.D. now supports Vulkan, giving Linux users much better graphics performance, lower CPU overhead, and compatibility with modern GPU features. Plus, it includes AMD FidelityFX Super Resolution (FSR)—which boosts frame rates and visual quality even on low-end hardware.

This makes 0 A.D. one of the few FOSS games optimized for modern Linux graphics stacks like Mesa, Wayland, and PipeWire.

Rolling Updates and Dev Engagement

The development team and community are highly active, with new features, bug fixes, and optimizations arriving steadily. You don’t need to wait years for meaningful updates—0 A.D. grows with each alpha release, and Linux users are treated as first-class citizens.

Want to contribute a patch or translate the UI into Malay? You can. Everything is transparent and accessible.

What Makes the Gameplay So Good?

Let’s dive deeper into why the gameplay itself shines.

Realistic Economy and Base Building

Unlike many fast-paced arcade RTS games, 0 A.D. rewards planning and resource management. You’ll manage four resources—food, wood, stone, and metal—to construct buildings, raise armies, and advance through phases that represent a civilization’s growth. Advancing from village phase to town phase to city phase unlocks more units and structures.

Each civilization has unique architectural styles, tech trees, and military units. For example:

• Romans have disciplined legionaries and siege weapons.
• Persians boast fast cavalry and majestic palaces.
• Athenians excel in naval warfare.

Intense Tactical Combat

Units in 0 A.D. aren’t just damage sponges. There’s formation control, terrain advantage, flanking tactics, and unit counters. The AI behaves strategically, and in multiplayer, experienced players can pull off devastating maneuvers.

Naval combat has received significant improvements recently, with better ship handling and water pathfinding—something many commercial RTS games still struggle with.

Endless Map Variety and Mod Support

0 A.D. includes:

• Skirmish maps
• Random maps (with different biomes and elevation)
• Scenario maps (with scripted events)

And thanks to the integrated mod downloader, you can browse, install, and play with community mods in just a few clicks. Want to add new units, tweak balance, or add fantasy elements? You can.

Multiplayer and Replays

Play with friends over LAN, the Internet, or against the built-in AI. The game includes:

• Multiplayer save and resume support
• Observer tools (with flares, commands, and overlays)
• Replay functionality to study your tactics or cast tournaments

There’s even an in-game lobby where players coordinate matches across all platforms.

Community and Contribution

The 0 A.D. project thrives because of its community:

• Developers contribute code via GitHub.
• Artists create stunning 3D models and animations.
• Historians help ensure cultural accuracy.
• Translators localize the game into dozens of languages.
• Players write guides, tutorials, and strategy posts.

If you’re a Linux user and want to contribute to an ambitious FOSS project, this is the perfect gateway into game development, design, or open collaboration.

How to Install on Linux

Here’s a quick reference:

Option 1: Package Manager (Recommended)

• Debian/Ubuntu: sudo apt install 0ad
• Arch Linux: sudo pacman -S 0ad
• Fedora: sudo dnf install 0ad
• openSUSE: sudo zypper install 0ad

Option 2: Compile from Source

Follow the official instructions at https://trac.wildfiregames.com/wiki/BuildInstructions

Final Thoughts

0 A.D. is more than just a game—it’s a testament to what free and open-source software can achieve. For Linux gamers, it’s a rare gem: a game that respects your platform, performs well, and lets you own your experience entirely.

So whether you’re a seasoned general or a curious strategist, download 0 A.D. today and relive history—on your terms.

Visit https://play0ad.com to download and start playing.

The post 0 A.D. on Linux: A Stunning, Free RTS Experience That Rivals the Best 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.

What Is OpenRA?

OpenRA is a community-driven initiative that reimagines classic RTS games for contemporary platforms. It’s not just a remake; it’s a complete overhaul that introduces:

• Modernized Interfaces: Updated sidebars and controls for improved usability.
• Enhanced Gameplay Mechanics: Features like fog of war, unit veterancy, and attack-move commands.
• Cross-Platform Support: Runs seamlessly on Linux, Windows, macOS, and *BSD systems.
• Modding Capabilities: A built-in SDK allows for the creation of custom mods and maps.

These improvements ensure that both veterans and newcomers can enjoy a refined RTS experience.

Latest Features and Updates

The March 2025 release brought significant enhancements:

• New Missions: Two additional Red Alert missions with improved objectives.
• Persistent Skirmish Options: Settings now carry over between matches.
• Balance Tweaks: Refinements for Red Alert and Dune 2000 to ensure fair play.
• Asset Support: Compatibility with The Ultimate Collection and C&C Remastered Collection.
• Language Support: Progress towards multilingual capabilities.

These updates demonstrate OpenRA’s commitment to evolving and enhancing the RTS genre.

Installation on Linux

Installing OpenRA on Linux is straightforward:

1. Download AppImages: Visit the official download page to get the AppImage for your desired mod.
2. Make Executable: Right-click the AppImage, select ‘Properties,’ and enable execution permissions.
3. Launch: Double-click the AppImage to start the game.

Alternatively, you can install OpenRA via:

• Snap: sudo snap install openra
• Flatpak: flatpak install flathub net.openra.OpenRA

These methods ensure that OpenRA integrates smoothly with your system.

Why Choose OpenRA?

OpenRA stands out in the Linux gaming landscape due to:

• Community Engagement: Regular updates and active forums foster a vibrant player base.
• Modding Scene: A robust SDK encourages creativity and customization.
• Cross-Platform Play: Enjoy multiplayer matches with friends on different operating systems.
• Educational Value: An in-game encyclopedia provides insights into units and strategies.

These features make OpenRA not just a game but a platform for learning and community interaction.

See OpenRA in Action

For a visual overview, check out this review:

Other Notable Strategy Games for Linux

If you’re exploring more strategy titles, consider:

• 0 A.D.: A historical RTS focusing on ancient civilizations.
• The Battle for Wesnoth: A turn-based strategy game with a rich fantasy setting.
• Freeciv: A free Civilization-inspired game with extensive customization.

Each offers unique gameplay experiences and is well-supported on Linux platforms.

OpenRA exemplifies how classic games can be revitalized for modern audiences. Its blend of nostalgia and innovation makes it a standout choice for strategy enthusiasts on Linux.

The post Rediscover Classic RTS with OpenRA on Linux 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.

Before container technologies like Docker came into play, applications were typically run directly on the host operating system—either on bare metal hardware or inside virtual machines (VMs). While this method works, it often leads to frustrating issues, especially when trying to reproduce setups across different environments.

This becomes even more relevant in the amateur radio world, where we often experiment with digital tools, servers, logging software, APRS gateways, SDR applications, and more. Having a consistent and lightweight deployment method is key when tinkering with limited hardware like Raspberry Pi, small form factor PCs, or cloud VPS systems.

The Problem with Traditional Software Deployment

Let’s say you’ve set up an APRS iGate, or maybe you’re experimenting with WSJT-X for FT8, and everything runs flawlessly on your laptop. But the moment you try deploying the same setup on a Raspberry Pi or a remote server—suddenly things break.

Why?

Common culprits include:

• Different versions of the operating system
• Mismatched library versions
• Varying configurations
• Conflicting dependencies

These issues can be particularly painful in amateur radio projects, where specific software dependencies are critical, and stability matters for long-term operation.

You could solve this by running each setup inside a virtual machine, but VMs are often overkill—especially for ham radio gear with limited resources.

Enter Docker: The Ham’s Best Friend for Lightweight Deployment

Docker is an open-source platform that allows you to package applications along with everything they need—libraries, configurations, runtimes—into one neat, portable unit called a container.

Think of it like packaging up your entire ham radio setup (SDR software, packet tools, logging apps, etc.) into a container, then being able to deploy that same exact setup on:

• A Raspberry Pi
• A cloud server
• A homelab NUC
• Another ham’s machine

Why It’s Great for Hams:

• Lightweight – great for Raspberry Pi or low-power servers
• Fast startup – ideal for services that need to restart quickly
• Reproducible environments – makes sharing setups with fellow hams easier
• Isolation – keeps different radio tools from interfering with each other

Many amateur radio tools like Direwolf, Xastir, Pat (Winlink), and even JS8Call can be containerized, making experimentation safer and more efficient.

Virtual Machines: Still Relevant in the Shack

Virtual Machines (VMs) have been around much longer and still play a crucial role. Each VM acts like a complete computer, with its own OS and kernel, running on a hypervisor like:

• VirtualBox
• VMware
• KVM
• Hyper-V

With VMs, you can spin up an entire Windows or Linux machine, perfect for:

• Running legacy ham radio software (e.g., old Windows-only apps)
• Simulating different operating systems for testing
• Isolating potentially unstable setups from your main system

However, VMs require more horsepower. They’re heavy, boot slowly, and take up more disk space—often not ideal for small ham radio PCs or low-powered nodes deployed in the field.

Quick Comparison: Docker vs Virtual Machines for Hams

Ham Radio Use Cases for Docker

Here’s how Docker fits into amateur radio workflows:

• Run an APRS iGate with Direwolf and YAAC in isolated containers.
• Deploy SDR receivers like rtl_433, OpenWebRX, or CubicSDR as containerized services.
• Set up a Winlink gateway using Pat + ax25 tools, all in one container.
• Automate and scale your APRS bot, or APRS gateway using Docker + cron + scripts.

Docker makes it easier to test and share these setups with other hams—just export your Docker Compose file or image.

When to Use Docker, When to Use a VM

Use Docker if:

• You’re building or experimenting with modern ham radio apps
• You want to deploy quickly and repeatably
• You’re using Raspberry Pi, VPS, or low-power hardware
• You’re setting up CI/CD pipelines for your scripts or bots

Use VMs if:

• You need to run legacy apps (e.g., old Windows logging software)
• You want to simulate full system environments
• You’re working on something that could crash your main system

Final Thoughts

Both Docker and VMs are powerful tools that have a place in the modern ham shack. Docker offers speed, portability, and resource-efficiency—making it ideal for deploying SDR setups, APRS bots, or automation scripts. VMs, on the other hand, still shine when you need full system emulation or deeper isolation.

At the end of the day, being a ham means being an experimenter. And tools like Docker just give us more ways to explore, automate, and share our radio projects with the world.

The post Docker vs Virtual Machines: What Every Ham Should Know appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.