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

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

Why Use ElecWhat?

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

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

Features at a Glance

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

Installation

Ubuntu / Kubuntu

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

Arch Linux

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

Debian

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

Fedora

• RPM packages in Releases
• AppImage support included

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

Configuration Example

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

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

Here’s an example config:

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

Design Philosophy

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

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

Where to Get It

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

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

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

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

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

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

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

sudo apt update
sudo apt install flatpak -y

After that, I added the Flathub repo:

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

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

Step 2: Installing Jellyfin Server via Flatpak

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

flatpak install flathub org.jellyfin.JellyfinServer -y

To start the server, I ran:

flatpak run org.jellyfin.JellyfinServer

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

Step 3: Open It in Your Browser

Once it’s running, just go to:

http://localhost:8096

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

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

Step 4: Giving Jellyfin Access to Your Media

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

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

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

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

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

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

Then just restart Jellyfin:

flatpak run org.jellyfin.JellyfinServer

Step 5: Add Media Libraries

Back in the web interface:

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

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

That’s It!

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

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

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

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.

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

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

Why Run Armbian on the X6100?

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

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

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

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

What This Project Offers

The x6100-armbian project provides:

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

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

What Works (and What Doesn’t Yet)

According to the repo, here’s what works:

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

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

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

Getting Started

To try this out:

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

Use Cases

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

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

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

Final Thoughts

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

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

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

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

Back in the early 2000s, getting a stable internet connection in Malaysia was a real challenge. TM Net’s 56k dial-up was the standard option for most small businesses and homes, and broadband was still a distant dream for many of us. I was managing a small cyber café at the time, and I needed a way to share that single dial-up connection across multiple PCs — on a tight budget, with very limited hardware.

That’s when I discovered FREESCO — short for Free Cisco-style Router.

FREESCO was a tiny Linux-based operating system that ran entirely off a single 1.44MB floppy disk. Yes, just one floppy. No hard drive required. You just popped the disk into an old PC, booted it up, and you had yourself a fully functioning router, complete with PPP, NAT and DHCP. For someone managing a café with limited resources, it was nothing short of magic.

My setup was pretty typical for that time: a TM Net 56k dial-up connection, connected through a trusty US Robotics external modem. FREESCO took care of dialing in, managing the connection, and distributing internet access to all the café terminals. The PC running it was a hand-me-down — I believe it was a Pentium with 64MB of RAM — and yet it ran for days, even weeks, without needing a reboot.

One of the things that really impressed me was how reliable and lightweight FREESCO was. FREESCO was rock solid and had excellent support for dial-up modems, including the US Robotics model I was using.

For many café owners, tech hobbyists, and even small offices, FREESCO filled an important gap. It let us build functional, flexible network routers without spending a lot of money or relying on commercial solutions. It was a perfect example of open-source innovation meeting real-world needs.

Looking back, it’s amazing how much we were able to accomplish with so little. A single floppy disk, an old PC, and a dial-up line — and yet, FREESCO kept the whole shop online. It’s a piece of tech history I look back on fondly, and I know I’m not the only one.

Visit https://www.freesco.org/

The post How a Single Floppy Disk Kept Cyber Café Online in the Early 2000s appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

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

What You’ll Need

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

Step 1: Get Your API Keys

APRS-IS Passcode

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

https://pass.hamradio.my

OpenWeatherMap API Key

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

Step 2: Determine Your Coordinates

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

Example for Kuala Lumpur:

• Latitude: 3.1390
• Longitude: 101.6869

Step 3: The Bash Script

Here’s the full script:

#!/bin/bash

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

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

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

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

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

echo "✅ Sent: $WX_PACKET"

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

chmod +x send_weather_aprs.sh

What This Script Does

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

Automate It with Cron (Optional)

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

crontab -e

Then add:

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

Example APRS Packet

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

Things to Improve

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

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

Conclusion

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

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

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

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

What Are Metapackages?

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

Available Hamradio Metapackages

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

Installing Metapackages

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

sudo apt-get install hamradio-<task>

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

sudo apt-get install hamradio-logging

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

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

Final Thoughts

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

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

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

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

When 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.

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

Why Chrony?

Chrony is:

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

What You’ll Set Up

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

Step 1: Create a Dockerfile for Chrony

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

# Dockerfile
FROM debian:stable-slim

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

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

EXPOSE 123/udp

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

Step 2: Create the chrony.conf

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

# chrony.conf

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

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

# Local stratum fallback if Internet is down
local stratum 10

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

# Log tracking data
log tracking measurements statistics

# Log files location
logdir /var/log/chrony

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

Replace 192.168.1.0/24 with your actual LAN subnet.

Step 3: Build and Run the Docker Container

docker build -t chrony-server .

Now run the container with:

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

Explanation:

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

Step 4: Test Your NTP Server

From a client machine on your LAN:

ntpdate -q <chrony-server-ip>

or

chronyc sources -a

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

Optional: Run as a Local Time Authority

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

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

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

Firewall Notes

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

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

Or for iptables:

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

Conclusion

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

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

Perfect for homelabs, IoT networks, or offline environments.

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

In the ever-evolving world of amateur radio, digital voice modes have revolutionized how we communicate. Among the various software options available, DroidStar stands out as a versatile and powerful solution for digital voice communication. This comprehensive guide will walk you through everything you need to know about DroidStar, from its features to installation and configuration.

What is DroidStar?

DroidStar is an open-source application that connects to various digital voice systems including:

• M17 (with open-source Codec2 vocoder)
• Fusion (YSF/FCS, supporting both DN and VW modes)
• DMR (Digital Mobile Radio)
• P25 (Project 25)
• NXDN (Next Generation Digital Narrowband)
• D-STAR (REF/XRF/DCS reflectors)
• AllStar nodes (as an IAX2 client or using Web Transceiver mode)

Originally developed as two separate projects (DudeStar using Qt Widgets UI and DroidStar using Qt Quick UI), they have now been merged into a single entity under the DroidStar name.

Key Features

Cross-Platform Compatibility

Built with the Qt C++ library, DroidStar runs on multiple platforms:

• Linux
• Windows
• macOS
• Android
• iOS (without USB device support)
• Other POSIX platforms with Qt availability

Hardware Support

DroidStar is compatible with:

• AMBE USB devices (ThumbDV, DVstick 30, DVSI, etc.)
• MMDVM modems for hotspot functionality
• MMDVM_HS (hotspot) modems

MMDVM Support

DroidStar can function as:

• A hotspot/repeater when connecting to a digital mode reflector/DMR server with an MMDVM device
• A stand-alone transceiver when using ‘MMDVM Direct’ mode (currently M17 only)

Optional Features

• Flite Text-to-Speech: For testing without speaking (requires building with Flite TTS support)
• Software vocoder plugin API: For loading vocoder software (proper licensing required)

Installing DroidStar on Linux Using Flatpak

Flatpak makes it easy to install DroidStar on any Linux distribution. Here’s how:

Step 1: Install Flatpak (If Not Already Installed)

For Debian/Ubuntu-based distributions:

sudo apt update && sudo apt install flatpak -y

For Fedora:

sudo dnf install flatpak -y

For Arch Linux:

sudo pacman -S flatpak

Enable Flathub repository:

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

Step 2: Install DroidStar

Search for DroidStar:

flatpak search droidstar

You should see something like:

Name             Description                   Application ID                    Version          Branch        Remotes
DroidStar        A digital voice client        io.github.nostar.DroidStar        1.0.1-git        stable        flathub

Install DroidStar using:

flatpak install droidstar

When prompted with “Use this ref?”, type Y and press Enter.

Launch DroidStar with:

flatpak run io.github.nostar.DroidStar

Step 3: USB Device Permissions (Linux Users)

Linux users with USB AMBE and/or MMDVM dongles need to:

1. Add your user to the ‘dialout’ group
2. Disable the ModemManager service: sudo systemctl disable ModemManager.service
3. Reboot your system

Configuration Guide

Basic Setup

1. Enter Your Callsign: A valid amateur radio license is required
2. Choose Digital Mode: Select from DMR, D-STAR, YSF, NXDN, P25, or M17
3. Select Host/Module: Choose the desired reflector or server
4. Configure Mode-Specific Settings:
   • For DMR: Enter your DMR ID, latitude/longitude, location, and description
   • For D-STAR: Configure MYCALL, URCALL, RPTR1, and RPTR2 fields
   • For AllStar: Set up IAX client parameters or Web Transceiver details

Installing the Vocoder Plugin

DroidStar supports software vocoder plugins through its API. To install a vocoder:

Method 1: URL Download (Works on All Platforms)

1. Go to Settings tab
2. Enter the vocoder URL in the “Vocoder URL” field
3. Click “Download vocoder”

Method 2: Manual Installation (Linux/macOS/Windows)

1. Download the appropriate vocoder plugin matching your platform and architecture
2. Place the plugin in the system settings file location:
   • Linux: ~/.config/dudetronics/
   • Name format: vocoder_plugin.platform.arch
   • Example: vocoder_plugin.linux.x86_64

Note: The platform and architecture for your device are shown on the About tab. Remember that any vocoder plugin should be properly licensed by you if copyright patents apply.

Using DroidStar

For DMR Mode

1. Enter your DMR ID
2. Input the talkgroup ID number (e.g., 91 for Brandmeister Worldwide)
3. For DMR+ hosts, create your options string and check “Send DMR+ options on connect”

For D-STAR Mode

Enter the correct values for MYCALL, URCALL, RPTR1, and RPTR2 before transmitting.

For AllStar

DroidStar supports two methods for AllStar connectivity:

IAX Client Mode

1. Define IAX nodes on the Hosts tab
2. Select the node when IAX mode is chosen from the Main tab
3. Send DTMF commands like *3node, *1node, *70 in the IAX DTMF box

Web Transceiver Mode

1. Add a line in the Host tab with format: IAX 12345 wt 4569 allstar-public allstar
2. Add your ASL web portal password to “ASL password” under settings

Final Thoughts

DroidStar is a powerful tool for amateur radio enthusiasts looking to explore digital voice modes. Its cross-platform compatibility and support for various digital protocols make it a versatile option for both beginners and experienced operators.

While this software is provided as-is without official support, it benefits from the work of many open-source projects including MMDVMHost, MMDVM_CM, mvoice, and others. The vibrant amateur radio community continues to improve and expand DroidStar’s capabilities.

Whether you’re experimenting with digital modes or using it for emergency communications, DroidStar offers a flexible and accessible platform for digital voice communication.

Visit:

https://github.com/nostar/DroidStar

https://github.com/rohithzmoi/Droidstar-DMR

http://kapihan.net/connect/resources/files/droidstar-vocoders.php

The post DroidStar: The Ultimate Digital Voice Communication Tool for Amateur Radio appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

The dipole program is part of the Yagi-Uda project, a collection of tools designed for the analysis and optimization of Yagi-Uda antennas. This particular tool calculates the impedance of a single dipole, making it a useful utility for antenna engineers and amateur radio enthusiasts.

Installation on Ubuntu/Debian

To install the Yagi-Uda software suite, including dipole, run the following command:

sudo apt install yagiuda

This package includes several tools for Yagi-Uda antenna analysis and design, making it a valuable addition for those working with antennas.

Usage

To compute the impedance of a dipole, use the following command:

dipole <frequency> <length> <diameter>

For example, to calculate the impedance of a dipole at 7.1 MHz with a length of 20 meters and a diameter of 1.5 mm, run:

dipole 7.100mhz 20m 1.5mm

Example Output:

Self impedance of a dipole:
7.100000 MHz,  length 20.000000 m, diameter 1.500000 mm, is 
Z = 62.418686  -48.363233 jX Ohms

This output indicates:

• Frequency: 7.1 MHz
• Length: 20 meters
• Diameter: 1.5 mm
• Impedance (Z): 62.42 – j48.36 Ω

The negative reactance (-48.36 Ω) suggests the dipole is capacitive, meaning it is too long at this frequency. To achieve resonance (purely resistive impedance), the dipole length should be slightly reduced.

Related Tools

The Yagi-Uda project includes additional tools that help with various aspects of antenna design and optimization:

• first – Initial calculations for antenna design
• input – Processes input parameters for analysis
• output – Displays calculated results
• optimise – Helps refine antenna parameters for better performance

Each of these tools contributes to designing and analyzing Yagi-Uda antennas effectively.

Supported Platforms

The Yagi-Uda project was primarily developed for UNIX-based systems, including Linux distributions such as Ubuntu and Debian. While efforts were made to port it to other operating systems, its primary focus remains on UNIX environments.

Reporting Bugs

If you encounter any issues while using dipole or other Yagi-Uda tools, you can report them to Dr. David Kirkby (G8WRB) at david.kirkby@onetel.net. Providing clear, reproducible steps will help ensure that reported bugs are addressed efficiently.

Conclusion

For amateur radio operators and engineers working with Yagi-Uda antennas, the dipole program is a valuable tool for analyzing a single dipole’s impedance. With an easy installation process on Debian-based systems, it is an accessible and practical choice for antenna analysis.

The post Understanding Yagi-Uda’s dipole Program for Antenna Analysis appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Why MiniOS?

MiniOS is built on Debian, inheriting its renowned stability, security, and vast software repository. This makes it an excellent choice for users who need a reliable system that can be customized to their needs. Here are some of its core strengths:

Stability – Ensures a smooth and reliable user experience. Security – Benefits from Debian’s timely updates and patches. Compatibility – Supports a vast range of hardware and software. Community Support – Leverages the extensive Debian community knowledge.

Key Features of MiniOS

MiniOS is designed for portability and flexibility, offering unique features that set it apart from other Linux distributions:

Modularity – Customize the OS with different modules tailored to specific needs. USB Portability – Install MiniOS on a USB flash drive and use it on different machines. Broad Compatibility – Works on a variety of hardware, supporting both UEFI and legacy BIOS. Frequent Updates – Includes an updated kernel and essential tools for debugging and system management.

MiniOS Editions: Choose What Works Best for You

MiniOS offers different editions tailored to various user needs:

Standard Edition – The go-to version for everyday tasks, featuring a well-equipped and stable environment.

Toolbox Edition – A specialized version for power users, system administrators, and IT professionals. This edition includes essential utilities for disk partitioning, data recovery, and advanced system management.

Perfect for Every Use Case

MiniOS is a smart choice for:

Reviving old PCs with a lightweight yet feature-rich OS. Creating a portable workstation that you can carry anywhere. Running a reliable live system for diagnostics and system recovery. Experimenting with Linux in a flexible environment. Amateur radio operators looking to revive old PCs or laptops and use them as their main OS for logging.

Build Your Own MiniOS

MiniOS allows users to create their customized ISO images using two key tools:

minios-cmd – A command-line utility that simplifies the configuration and build process. Users can define system parameters such as architecture, desktop environment, and kernel options before generating a MiniOS ISO.

minios-live – A powerful script that automates the step-by-step process of building a MiniOS ISO. This tool manages tasks like base system installation, SquashFS filesystem creation, boot configuration, and final ISO generation.

Learn More About MiniOS

For more information on MiniOS, installation guides, customization tips, and community discussions, visit the official website:

MiniOS Official Website

MiniOS is a reliable, user-friendly, and modular Linux distribution that puts flexibility in your hands. Whether you’re looking for a portable operating system, a system rescue tool, or a lightweight Debian-based distro, MiniOS is the perfect solution!

The post Discover MiniOS: The Ultimate Portable Linux Experience appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you have spent time setting up a Raspberry Pi with your preferred applications, configurations, and settings, it makes sense to create a backup of your SD card. This is especially useful if you need to deploy the same setup to multiple Raspberry Pi devices or if you want a quick way to restore your system in case of failure.

By creating an image of your pre-configured Raspbian SD card, you can easily clone it onto other SD cards, saving time and effort. This guide will walk you through the process of making a full backup of your SD card and restoring it when needed.

Prerequisites

Before you begin, make sure you have:

• A Linux system (or a computer with a Linux-based OS like Debian, Ubuntu, or Raspberry Pi OS).
• A properly set up Raspberry Pi SD card that you want to clone.
• A second SD card for cloning.
• An SD card reader.

Step 1: Identify the SD Card Device

First, insert your Raspberry Pi SD card into your computer and identify its device name using the following command:

lsblk

You should see a list of storage devices. Look for the one corresponding to your SD card (e.g., /dev/mmcblk0 or /dev/sdb).

Important: Ensure you select the correct device, as using the wrong one may overwrite your system disk!

Step 2: Create an Image of the SD Card

Once you’ve identified the SD card, create an image file using the dd command:

sudo dd if=/dev/sdX of=~/raspbian_backup.img bs=4M status=progress

Replace /dev/sdX with your actual SD card device (e.g., /dev/mmcblk0). This command copies the entire SD card into a single .img file.

Step 3: Compress the Image (Optional)

Since SD card images can be large, you may want to compress them to save space:

xz -z -9 ~/raspbian_backup.img

This will create raspbian_backup.img.xz, which takes up significantly less space.

Step 4: Restore the Image to Another SD Card

To clone the image onto another SD card, insert a new SD card and use the following command:

sudo dd if=~/raspbian_backup.img of=/dev/sdX bs=4M status=progress

If you compressed the image, use:

xzcat ~/raspbian_backup.img.xz | sudo dd of=/dev/sdX bs=4M status=progress

Again, replace /dev/sdX with the correct device name.

Step 5: Expand the Filesystem (If Needed)

If the new SD card has more storage than the original, you may need to expand the filesystem to use the full capacity. Boot up the Raspberry Pi and run:

sudo raspi-config

Then go to Advanced Options > Expand Filesystem, and reboot when prompted.

By following these steps, you can easily back up and clone your Raspbian setup, ensuring you never lose your custom configurations. This method is perfect for setting up multiple Raspberry Pi devices quickly or having a ready-to-use backup for future use.

Whether you’re a developer, system administrator, or Raspberry Pi hobbyist, creating SD card images will save you time and effort in managing your devices.

The post How to Clone and Backup Your Raspbian SD Card for Easy Deployment appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Linux distributions come in two main release models: fixed release and rolling release. Each has its own advantages and drawbacks, making the choice between them dependent on user needs, preferences, and use cases. In this article, we’ll dive into the history of Linux releases, explain both models in detail, provide examples of each, and help you determine which one suits you best.

A Brief History of Linux Releases

The Linux operating system was first developed by Linus Torvalds in 1991, and soon after, various distributions (distros) began emerging to make Linux more accessible to users. Early distributions followed a fixed release cycle, similar to traditional commercial software, providing stable versions with long-term support.

As Linux usage grew, developers and power users sought an alternative release model that allowed them to receive continuous updates without waiting for major version upgrades. This led to the birth of the rolling release model, which delivers updates as soon as they are available, without the need for reinstalling or upgrading to a new version.

What is a Fixed Release Distribution?

A fixed release distribution follows a structured development cycle, with periodic major releases that bundle all updates, improvements, and new features into one package. These releases are well-tested before being distributed to users.

Examples of Fixed Release Distros:

• Ubuntu – Releases a new version every six months, with Long-Term Support (LTS) versions every two years.
• Debian – Has three main branches: Stable (fixed release), Testing, and Unstable.
• Fedora – Releases a new version approximately every six months.
• openSUSE Leap – A stable release that is synchronized with SUSE Linux Enterprise.
• Linux Mint – Based on Ubuntu LTS releases, focusing on stability and user-friendliness.

Pros of Fixed Release Distros:

Stable and reliable: Thoroughly tested before release.

Long-term support (LTS versions): Security updates for many years.

Predictable update cycles: Users know when a new version will be available.

Ideal for production environments and enterprises.

Cons of Fixed Release Distros:

Software can become outdated between releases.

Requires major upgrades to move to a new version.

May lack the latest features and improvements available in newer software.

What is a Rolling Release Distribution?

A rolling release distribution continuously updates packages as soon as they are available, rather than waiting for a scheduled release. This means that the operating system is always up to date without needing periodic major upgrades.

Examples of Rolling Release Distros:

• Arch Linux – A minimalist and highly customizable distribution.
• openSUSE Tumbleweed – A rolling release counterpart to openSUSE Leap.
• Gentoo Linux – Source-based rolling release with maximum flexibility.
• EndeavourOS – A user-friendly Arch-based distro.
• Manjaro – Based on Arch but with added stability and ease of use.

Pros of Rolling Release Distros:

Always up to date: No need to wait for major releases.

Access to the latest software and kernel versions.

No system reinstallation required to upgrade. Ideal for developers and enthusiasts who want cutting-edge software.

Cons of Rolling Release Distros:

Can be less stable due to frequent updates.

Updates may occasionally break the system if not managed carefully.

Requires more maintenance and troubleshooting knowledge.

Fixed vs. Rolling Release: Which One Should You Choose?

Choosing between a fixed release and a rolling release distribution depends on your needs:

If you prefer a stable and predictable system with fewer maintenance requirements, a fixed release distribution like Ubuntu LTS, Debian Stable, or Linux Mint is a great choice.

If you want cutting-edge software, continuous updates, and don’t mind occasional troubleshooting, a rolling release distribution like Arch Linux, Manjaro, or openSUSE Tumbleweed will suit you better.

Both fixed and rolling release distributions have their place in the Linux ecosystem. Understanding their differences allows you to make an informed choice based on your workflow, experience level, and expectations. Whether you prioritize stability or cutting-edge software, there’s a Linux distribution that fits your needs.

The post Linux Fixed Release vs. Rolling Release Distributions: Which One is Right for You? appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In today’s streaming landscape, music lovers often find themselves torn between subscription costs and accessibility. Enter Spotube – a game-changing open-source Spotify client that’s reshaping how we think about music streaming.

What Makes Spotube Special?

Spotube elegantly bridges the gap between Spotify’s extensive music library and free accessibility by utilizing Spotify’s data API while sourcing audio from YouTube, Piped.video, or JioSaavn. This innovative approach eliminates the need for a Spotify Premium subscription while delivering a premium experience.

And no – it’s not just another Electron app. Spotube is built with native performance in mind, resulting in a lightweight application that respects your system resources.

Standout Features That Users Love

Truly Ad-Free Experience

Unlike many alternatives, Spotube offers a completely ad-free listening experience thanks to its use of public Spotify and YouTube Music APIs.

Download Freedom

Freely download your favorite tracks for offline listening – perfect for travel or areas with spotty connectivity.

Cross-Platform Versatility

Whether you’re on Windows, macOS, Linux, Android, or iOS, Spotube has you covered with native applications for each platform.

Lightweight Champion

With its small footprint and minimal data usage, Spotube is ideal for users with limited storage or bandwidth constraints.

Privacy-Focused Design

Enjoy anonymous/guest login options and zero telemetry – Spotube collects no diagnostic or user data.

Enhanced Listening Experience

Time-synced lyrics let you follow along with your favorite songs, enhancing your connection to the music.

Local Control

All playback control happens locally on your device, not on remote servers, giving you greater control and privacy.

Supporting Artists While Using Spotube

While Spotube offers a free way to enjoy music, the developers emphasize the importance of supporting artists. They recommend engaging with creators by interacting with their YouTube channels and Spotify tracks, or preferably by purchasing merchandise, concert tickets, or physical media.

Getting Started Is Easy

Installation is straightforward across all platforms:

• Windows: Available via direct download, Chocolatey, Scoop, or WinGet
• macOS: Download directly or install via Homebrew
• Android: Get it on Google Play, F-Droid, or download the APK
• iOS: Download the IPA file (requires sideloading)
• Linux: Choose from Flatpak, Debian/Ubuntu, Arch/Manjaro, Fedora/OpenSuse packages, or a tarball

For those who like living on the bleeding edge, nightly builds are available directly from GitHub Releases.

The Team Behind the Magic

Spotube is maintained by a dedicated team of developers and community managers led by founder Kingkor Roy Tirtho, with contributors specializing in various platforms and aspects of the application.

The Open-Source Advantage

Licensed under the BSD-4-Clause License, Spotube represents the best of what open-source software can offer – transparency, community-driven development, and freedom from corporate restrictions.

What’s Not Included?

It’s worth noting that Spotube doesn’t support Spotify Shows & Podcasts (as these require Spotify Premium), though the team mentions that Spotify Listen Along functionality is coming soon.

Try Spotube Today

If you’ve been hesitant about music streaming costs or looking for a more lightweight, privacy-focused alternative to the official Spotify client, Spotube offers the perfect balance of functionality and freedom.

Visit Spotube’s website or join their Discord server to become part of this growing community of music lovers who value both great music and great software.

The future of music streaming is open-source, and Spotube is leading the way.

The post Spotube: The Ultimate Open-Source Spotify Experience Without Premium appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

The Linux kernel is the heart of any Linux-based operating system, managing hardware resources, scheduling tasks, and providing essential system functionality. While mainstream Linux distributions ship with a default kernel optimized for general-purpose usage, power users, gamers, and professionals in audio-visual production often seek better performance, lower latency, and enhanced responsiveness. This is where custom kernels like Liquorix come into play.

What is a Custom Kernel?

A custom Linux kernel is a modified version of the standard kernel, tweaked to improve specific aspects of system performance, compatibility, or functionality. Unlike stock kernels designed for broad hardware support and stability, custom kernels prioritize responsiveness, gaming performance, low-latency computing, or security enhancements.

Custom kernels often feature:

• Optimized CPU Scheduling: More efficient CPU scheduling algorithms help improve gaming, real-time applications, and overall system responsiveness.
• Reduced Latency: Tuning kernel parameters to minimize delays in task execution and system responsiveness.
• Enhanced I/O Performance: Custom schedulers like BFQ (Budget Fair Queueing) optimize disk operations for desktop and workstation use.
• Better Power Management: Custom tweaks for power efficiency, ideal for laptops and mobile devices.
• Specialized Features: Some kernels focus on security enhancements, overclocking support, or compatibility with specific hardware.

Introducing the Liquorix Kernel

One of the most popular custom kernels available today is Liquorix. Designed for high-performance interactive computing, Liquorix is widely favored by gamers, multimedia professionals, and anyone seeking a smoother and more responsive Linux experience.

Key Features of the Liquorix Kernel

Liquorix integrates several optimizations that set it apart from stock kernels. Here are some of the major features that make it a compelling choice:

1. Zen Interactive Tuning

• The Liquorix kernel is fine-tuned for responsiveness rather than raw throughput.
• Ideal for gaming, low-latency multimedia applications, and general desktop interactivity.

2. Improved Block Layer Performance

• Default I/O Scheduler: Switches from mq-deadline to BFQ, enhancing responsiveness for desktop usage.
• DM-Crypt Workqueues Disabled: Disabling workqueues for encrypted volumes can reduce unnecessary CPU overhead.

3. Enhanced Virtual Memory Management

• Background Reclaim for HugePages: Enabled for better memory management and lower latency.
• Multigenerational Least Recently Used (MG-LRU): Improves memory page management under heavy workloads.
• Compact Unevictable Disabled & Proactive Compaction Off: Reduces unnecessary background processing for a smoother experience.

4. Low-Latency CPU Scheduling

• PDS/BMQ CPU Scheduler: A fair process scheduler optimized for gaming, multimedia, and real-time applications.
• Lower Scheduling Timeslice (2ms instead of 4ms): Ensures finer task scheduling and responsiveness.

5. Optimized CPU Frequency Scaling

• Ondemand governor tweaks:
  • Sampling down factor increased from 1 to 5 for better CPU power efficiency.
  • Default up threshold lowered from 80% to 55%, making CPU frequency scaling more aggressive when needed.
  • Micro up threshold reduced from 95% to 60%, enabling quicker CPU bursts for better responsiveness.

6. High-Resolution Scheduling

• 1000Hz Tick Rate: Reduces jitter in task execution, beneficial for real-time workloads and gaming.

7. Hard Kernel Preemption

• One of the most aggressive preemption strategies short of full real-time patches.
• Guarantees system responsiveness even under heavy loads.

8. Optimized Disk Scheduling

• Uses Budget Fair Queueing (BFQ) as the default disk scheduler.
• Designed for desktop workloads, ensuring low-latency disk operations while maintaining high throughput.

9. TCP BBR2 Congestion Control

• Implements Google’s BBR2 algorithm for improved network speed and reduced congestion.
• Outperforms older congestion control algorithms like Cubic in maintaining stable high-speed connections.

10. Compressed Swap Support

• Uses Zswap with LZ4 compression, reducing disk swap overhead and improving system performance under memory pressure.

11. Easy Installation and Broad Compatibility

• Pre-built binaries available for Debian (Stable, Testing, and Unstable).
• Ubuntu builds available via Liquorix PPA.
• Functions as a drop-in replacement for stock kernels, supporting a wide range of hardware configurations.

Installing the Liquorix Kernel

Installing Liquorix on Debian, Ubuntu, or Arch-based distributions is simple. You can use the official installation script:

curl -s 'https://liquorix.net/install-liquorix.sh' | sudo bash

Alternatively, on Debian-based systems, you can manually install it using APT:

echo 'deb http://liquorix.net/debian $(lsb_release -cs) main' | sudo tee /etc/apt/sources.list.d/liquorix.list
sudo apt update
sudo apt install linux-image-liquorix-amd64 linux-headers-liquorix-amd64

For Arch Linux, Liquorix is available in the AUR and can be installed using an AUR helper like yay:

yay -S linux-lqx linux-lqx-headers

Who Should Use Liquorix?

The Liquorix kernel is an excellent choice for:

• Gamers who want reduced input lag and better frame time consistency.
• Content creators in music production, video editing, and 3D rendering needing low-latency processing.
• Developers and power users who demand the most responsive desktop experience.
• Users on modern hardware who want an optimized kernel without manually compiling custom patches.

However, Liquorix is not necessarily ideal for:

• Enterprise servers where stability and long-term support are prioritized over responsiveness.
• Users on very old hardware that may lack support for certain modern optimizations.
• Battery-conscious laptop users, as some optimizations trade power efficiency for speed.

Conclusion

The Linux kernel plays a crucial role in system performance, and using a custom kernel like Liquorix can provide noticeable improvements in gaming, multimedia production, and general system responsiveness. With optimizations for CPU scheduling, I/O operations, memory management, and networking, Liquorix offers a highly tuned experience for those seeking more than what stock kernels provide.

For enthusiasts looking to squeeze every bit of performance out of their Linux system, Liquorix is a powerful and easy-to-install alternative that delivers on its promise of reduced latency and enhanced interactivity.

If you’re ready to take your Linux experience to the next level, give Liquorix a try today!

Visit https://liquorix.net/

The post Unlocking Performance: The Power of Custom Linux Kernels and Liquorix appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the world of music players, finding a feature-rich, high-performance application that respects user privacy can be a challenge. Many modern music players are either bloated with unnecessary features, locked behind paywalls, or designed with intrusive data collection practices. But what if there was a player that offered the best of all worlds—high-quality playback, extensive format support, powerful music library management, and complete privacy? Enter Strawberry Music Player—a robust, open-source audio player that is tailored for audiophiles and music lovers alike.

What is Strawberry Music Player?

Strawberry is an advanced music player and music collection organizer built on Qt. It’s a continuation of the Clementine Music Player, developed to provide a modern, feature-packed alternative while staying true to its open-source roots. Designed with audiophiles in mind, Strawberry brings an intuitive interface, lossless audio support, and seamless music management.

Whether you’re a casual listener or someone who meticulously curates a massive library of high-fidelity audio, Strawberry provides an exceptional listening experience without unnecessary distractions.

Why Choose Strawberry Over Other Music Players?

Strawberry is not just another music player; it is a carefully designed piece of software that provides everything you need in a sleek and efficient package. Here are some reasons why it stands out:

1. Comprehensive Audio Format Support

Unlike many commercial music players that require additional plugins or paid upgrades, Strawberry supports a vast range of audio formats right out of the box. This includes:

• MP3
• FLAC (Free Lossless Audio Codec)
• WAV
• APE (Monkey’s Audio)
• M4A (AAC/ALAC)
• Opus, WavPack, and more

This ensures that whether you’re playing standard compressed files or high-resolution lossless tracks, Strawberry delivers pristine audio quality without compromises.

2. Audiophile-Grade Sound with Advanced Playback Features

Strawberry is engineered to provide high-quality audio playback, supporting a range of advanced features such as:

• ReplayGain: Normalize volume levels across tracks.
• Equalizer & DSP Effects: Fine-tune your music to match your preferences.
• Gapless Playback: Enjoy uninterrupted playback between songs.
• Crossfade Support: Smooth transitions between tracks.
• Streaming Support: Play online radio and integrate with services like Tidal.

3. Powerful Music Library Management

Strawberry goes beyond simple music playback by offering a comprehensive music library management system. Features include:

• Tag Editing: Easily edit metadata and organize your collection.
• Album Art Downloader: Fetch high-quality artwork automatically.
• Smart & Dynamic Playlists: Create playlists that update dynamically based on your listening habits.
• Fast Library Scanning: Quickly import and manage large music collections.

4. Seamless Device Integration

Strawberry allows you to transfer and sync music between different devices effortlessly. It supports:

• USB Storage & External Devices
• Android Device Synchronization
• MTP & iPod Support
• Last.fm & Libre.fm Integration for scrobbling and tracking your listening habits.

5. Built for Privacy-Conscious Users

One of Strawberry’s core principles is privacy. Unlike many commercial music players, Strawberry does not collect or share user data. There are no telemetry trackers, no analytics reporting, and no invasive advertisements. Your music library remains entirely private, ensuring a safe and secure listening experience.

6. Cross-Platform Availability

Strawberry is available for multiple operating systems, making it a great choice regardless of the platform you use. You can install Strawberry on:

• Linux (Debian, Ubuntu, Fedora, Arch, etc.)
• Windows (7, 8, 10, 11)
• macOS

How to Install Strawberry Music Player

Getting started with Strawberry is quick and easy. Follow the steps below to install it on your preferred operating system:

For Linux Users:

Most Linux distributions have Strawberry available in their official repositories. You can install it using:

• Debian/Ubuntu: sudo apt install strawberry
• Fedora: sudo dnf install strawberry
• Arch Linux: sudo pacman -S strawberry

For Windows Users:

1. Download the latest version from the official Strawberry website.
2. Run the installer and follow the on-screen instructions.
3. Launch Strawberry and start enjoying your music collection.

For macOS Users:

1. Download the latest macOS package from the official site.
2. Install the application by dragging it into the Applications folder.
3. Open Strawberry and set up your music library.

Final Thoughts: The Music Player You’ve Been Looking For

Strawberry Music Player is a breath of fresh air in the world of digital music. It is lightweight, powerful, privacy-focused, and completely free. Whether you’re an audiophile looking for the best lossless playback or a casual listener who just wants a clean and efficient music player, Strawberry delivers in every way.

Its commitment to open-source principles ensures that the software remains user-driven, free of bloatware, and continuously improved by a passionate community of developers. With extensive format support, advanced music library management, and a smooth, polished interface, Strawberry Music Player is the ultimate solution for music lovers who demand the best.

So why settle for less? Download Strawberry Music Player today and elevate your music experience to new heights!

Visit https://www.strawberrymusicplayer.org/

If you’ve already tried Strawberry, let us know in the comments what you think about it!

The post Experience the Ultimate Audio Player: Strawberry Music Player appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What is Mobian?

Mobian is a project that aims to bring Debian to mobile devices while minimizing its specific customizations by upstreaming changes to the original Debian project. The project is maintained by two teams:

1. The Mobian Team – Responsible for maintaining downstream packages and handling image generation and distribution.
2. The DebianOnMobile Team – Maintains packages that are already part of the Debian archive.

With Mobian, users can install a full Debian-based Linux operating system on their mobile devices, enabling them to use traditional Linux tools on the go. More information about Mobian can be found on the official website: Mobian Project.

Installing Mobian

Mobian supports various mobile devices, with installation instructions available on the official Mobian Supported Devices page. Users can either:

• Build Mobian images locally following the mobian-recipes documentation.
• Download official Mobian images from Mobian Project.

For security-conscious users, Mobian images come with signature verification options to ensure integrity.

Why Mobian is Ideal for Amateur Radio Operators

Amateur radio operators are always on the lookout for efficient and flexible solutions to enhance their portable radio communication setups. Here are some key reasons why Mobian is a great fit:

1. Full Linux Environment on Mobile Devices

With Mobian, radio enthusiasts can leverage the power of Debian’s vast repository of open-source tools, including:

• Xastir – An APRS (Automatic Packet Reporting System) client.
• Fldigi – A software modem for digital modes like PSK31, RTTY, and more.
• WSJT-X – For weak-signal communication using modes like FT8 and WSPR.
• GNU Radio – For SDR (Software-Defined Radio) applications.

2. Software-Defined Radio (SDR) Integration

Mobian enables seamless integration with SDR tools like RTL-SDR, HackRF, and LimeSDR, allowing hams to experiment with digital signal processing, spectrum monitoring, and remote radio control directly from their mobile devices.

3. Portable APRS and GPS Tracking

Using Mobian on a mobile device equipped with GPS, operators can:

• Run APRS software to report their location over RF or the internet.
• Use GPS-based logging software for SOTA (Summits on the Air) and POTA (Parks on the Air) activities.
• Track other amateur radio stations using APRS maps.

4. Customizable and Open-Source

Unlike proprietary mobile operating systems, Mobian provides full control over software, privacy, and system configurations. Hams can customize their setups for:

• Emergency communication (EmComm) applications.
• Mesh networking using protocols like AREDN and Meshtastic.
• Remote transceiver control via SSH or web-based interfaces.

5. Secure and Privacy-Focused

Many amateur radio operators value privacy. Mobian, being Debian-based, prioritizes security and transparency, making it a great alternative to proprietary mobile OS platforms that collect user data.

Expanding the Possibilities with Mobian

Beyond amateur radio applications, Mobian serves as a versatile mobile platform for general-purpose computing, hacking, and privacy-focused mobile usage. Some additional possibilities include:

• Running packet radio applications for digital communications.
• Using VoIP and SIP clients for secure voice communications.
• Experimenting with LoRa and Meshtastic networks for long-range data exchange.
• Implementing automation and remote control via MQTT and other IoT protocols.

Mobian users can keep up with the latest developments, features, and community discussions by following the Mobian Blog.

Challenges and Considerations

While Mobian is an excellent project for amateur radio, users should be aware of some challenges:

• Limited device support – Not all smartphones can run Mobian, so users must check compatibility.
• Battery life – Running a full Linux system on mobile hardware may drain batteries faster than optimized mobile OSes.
• Hardware access – Some mobile hardware components may not have full driver support.

Mobian represents a powerful shift in mobile computing, bringing the flexibility of Debian to handheld devices. For amateur radio enthusiasts, this opens up exciting possibilities for portable APRS stations, SDR experimentation, and on-the-go digital communication. With continued development and community support, Mobian has the potential to become a staple in the amateur radio toolkit.

For those interested in trying Mobian, visit the Mobian Wiki and join discussions on Matrix, IRC, or Telegram to connect with fellow users and developers.

Are you using Mobian for amateur radio? Share your experiences in the comments below!

The post Mobian: Bringing Debian to Mobile Devices and Its Benefits for Amateur Radio appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

As amateur radio enthusiasts, we’re always on the lookout for software that can enhance our operating experience. Today, I want to introduce you to QLog, a powerful open-source logging application that’s been gaining popularity in the ham radio community.

What is QLog?

QLog is a feature-rich amateur radio logging application available for Linux and Windows platforms (with experimental MacOS support for developers). Built on the Qt framework with an SQLite database backend, QLog strikes an impressive balance between simplicity and functionality.

The philosophy behind QLog is straightforward: be as simple as possible while providing all the essential features operators need. While it’s not primarily focused on contests, it does offer basic contest support among its many capabilities.

Key Features That Stand Out

QLog comes packed with features that make it a compelling choice for radio operators:

Station Integration

• Rig Control: Supports multiple interfaces including Hamlib, Omnirig v1 & v2 (Windows only), and TCI
• Rotator Control: Works with Hamlib and PSTRotator
• CW Keyer Support: Compatible with CWDaemon, FLDigi (all modes), Morse Over CAT, and WinKey V2 hardware

Online Services

• Callbook Integration: Connects with HamQTH and QRZ.com
• DX Cluster Integration: Stay updated on DX stations
• QSL Services: Integrates with LoTW, eQSL (including QSL pictures download), QRZ.com, Clublog, HRDLog.net, and ON4KST Chat
• Secure Password Storage: For all services with password or security token protection

Operating Features

• Customizable GUI: Adapt the interface to your preferences
• Online and Offline Maps: Visualize your contacts
• Club Member Lookup: Quickly identify fellow club members
• Bandmap and CW Console: Enhanced operating tools
• WSJT-X Integration: Seamless operation with digital modes
• Station Location Profiles: Support for multiple operating locations
• Various Statistics: Track your operating achievements
• Basic Awards Support: Keep tabs on your award progress

One of the most refreshing aspects of QLog is its commitment to user privacy and freedom. There are NO ads, NO user tracking, and NO hidden telemetry—it’s simply free and open-source.

Platform Support

QLog runs well on:

• Linux (with packages available for Ubuntu, Fedora, and as a Flatpak)
• Windows 10 (64-bit)
• MacOS (experimental support for developers)

The application supports a wide range of radio equipment through its compatibility with Hamlib, Omnirig, and TCI interfaces, making it versatile enough for most ham shacks.

Getting Started with QLog

For Linux Users

Ubuntu users can install QLog through the dedicated PPA:

sudo add-apt-repository ppa:foldyna/qlog
sudo apt update
sudo apt install qlog

Fedora users can download RPM packages from GitHub Releases, and a Flatpak package (which includes built-in TrustedQSL) is available via Flathub.

For Windows Users

Windows users need to install:

• Trusted QSL (optional)
• Omnirig v1 (optional)
• Omnirig v2 (optional)

The installation package is available through GitHub Releases.

My Experience with QLog

What I particularly appreciate about QLog is its clean, uncluttered interface combined with powerful features. The SQLite backend ensures your logging data is stored efficiently and can be backed up easily.

The integration with online services like LoTW and eQSL has streamlined my QSLing process, while the rig control features mean I spend less time manually entering frequency and mode information.

Final Thoughts

Whether you’re new to amateur radio logging or looking to switch from another application, QLog deserves your consideration. Its combination of simplicity, features, and open-source philosophy makes it a valuable tool for any ham radio operator.

QLog is actively maintained, with regular updates and a responsive community. If you encounter issues or have suggestions, you can report them through QLog Issues or join the QLog mailing list.

Give QLog a try—I think you’ll be impressed by what this free, open-source logging application has to offer to the amateur radio community.

Visit https://github.com/foldynl/QLog

QLog is licensed under the GNU General Public License v3.0. The project was started by Thomas Gatzweiler in 2020 and is currently maintained by Ladislav Foldyna (2021-2025).

The post QLog: A Comprehensive Amateur Radio Logging Application for the Modern Ham appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Linux users looking to fine-tune their audio experience often turn to EasyEffects, an advanced audio effects application designed for PipeWire. With EasyEffects, you can apply real-time audio processing to improve sound quality, including equalization, bass boosting, and noise reduction. Whether you’re using speakers or headphones, this tool offers extensive customization to suit your needs.

EasyEffects is the successor to PulseEffects, providing enhanced support for the modern PipeWire audio system, which is becoming the standard on many Linux distributions. PipeWire brings superior performance, lower latency, and better handling of audio and video streams compared to traditional PulseAudio setups.

If you’re looking for high-quality sound customization, installing and using EasyEffects Equalizer Presets is a great way to optimize your system’s audio. Below, we will guide you through installing and using a collection of curated presets for EasyEffects.

EasyEffects Presets Collection

A community-maintained repository provides a set of EasyEffects presets to enhance your listening experience. These presets help to optimize sound quality for different use cases, including bass enhancement, equalization, loudness control, and auto-gain adjustments.

Available Presets:

• Bass Enhancing + Perfect EQ – Combines Ziyad Nazem’s “Perfect EQ” settings with the Razor surround impulse response for enhanced bass.
• Perfect EQ – Enables Ziyad Nazem’s “Perfect EQ” without additional effects.
• Boosted – Uses Ziyad Nazem’s “Boosted” equalizer settings, with an emphasis on lower frequencies.
• Advanced Auto Gain – Designed for laptop speakers, improving both low and high frequencies while normalizing volume for speech and music.
• LoudnessEqualizer – Optimized for laptop speakers, ensuring clear vocal audio and preventing sound dimming when bass is played.

Installation Guide

There are two ways to install the EasyEffects presets: automatic installation using a script, or manual installation by copying the configuration files.

Automatic Installation

The easiest way to install the presets is by running the provided installation script:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/JackHack96/PulseEffects-Presets/master/install.sh)"

Note: The script requires curl to be installed. If your system does not have it, install it first:

sudo apt install curl  # For Debian/Ubuntu-based distros

After running the script, restart EasyEffects to apply the new presets.

Manual Installation

If you prefer manual installation, follow these steps:

1. Clone the preset repository: git clone https://github.com/JackHack96/PulseEffects-Presets.git
2. Copy the .json preset files to the EasyEffects configuration directory. For Flatpak installations: cp PulseEffects-Presets/*.json ~/.var/app/com.github.wwmm.easyeffects/config/easyeffects/output/ For native installations (via PPA or AUR): cp PulseEffects-Presets/*.json ~/.config/easyeffects/output/
3. Restart EasyEffects and select the desired preset from the interface.

Conclusion

EasyEffects is a powerful tool that allows Linux users to dramatically improve their audio experience. Whether you want deep bass, clear speech, or balanced sound, these presets provide a great starting point. By installing and experimenting with different configurations, you can find the perfect sound profile for your setup.

Try out these presets and enjoy superior audio on your Linux system!

For more details and updates, visit the official repository.

The post Enhance Your Audio Experience on Linux with EasyEffects Equalizer Presets appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

HamClock is a powerful tool designed for amateur radio operators, providing real-time propagation data, satellite tracking, and more. This guide will walk you through installing HamClock on various UNIX-like systems, including Raspberry Pi, macOS, Debian, Ubuntu, FreeBSD, and others. Whether you’re using HamClock for monitoring solar conditions, DX cluster spots, or tracking satellites, this step-by-step tutorial will help you get started.

Step 1: Install Required Dependencies

Before installing HamClock, ensure your system has the necessary dependencies installed. These dependencies vary by operating system:

For Raspberry Pi and Debian-based Systems:

sudo apt-get update
sudo apt-get -y install curl make g++ libx11-dev libgpiod-dev xdg-utils

For Ubuntu:

sudo apt install curl make g++ xorg-dev xdg-utils

For macOS:

First, install XQuartz and Xcode. Then, open “More developer tools” and install the command line tools. On macOS Sequoia, you may need to run:

xcode-select --install

For FreeBSD:

sudo pkg install gcc xorg gmake curl

Then, use gmake instead of make.

For NetBSD:

First, install pkgin, then run:

sudo pkgin install gmake curl

Use gmake instead of make.

For RedHat or Fedora:

sudo yum install gcc-c++ libX11-devel xdg-utils

For Alpine Linux:

setup-desktop
apk add g++ libx11-dev curl linux-headers

Step 2: Install HamClock

Once the dependencies are installed, proceed with downloading and installing HamClock. There are two methods depending on your operating system.

For Raspberry Pi (Automated Install):

cd
curl -O https://www.clearskyinstitute.com/ham/HamClock/install-hc-rpi
chmod u+x install-hc-rpi
./install-hc-rpi

Follow the prompts and answer y or n as needed. This script will automate the installation for you.

For Other UNIX-like Systems (Manual Install):

cd
rm -fr ESPHamClock
curl -O https://www.clearskyinstitute.com/ham/HamClock/ESPHamClock.zip
unzip ESPHamClock.zip
cd ESPHamClock
make -j 4 hamclock-800x480
sudo make install

This will install HamClock with a resolution of 800×480 pixels. If you need a different resolution, refer to Step 4.

Step 3: Run HamClock

After installation, you can start HamClock with the following command:

hamclock &

If everything is installed correctly, HamClock should open in a window displaying solar data, propagation info, and maps.

If you did not install a desktop icon, you can always launch HamClock from the terminal using the command above.

Step 4: Customize HamClock

HamClock supports different screen sizes. If you want to change the resolution, use the following commands:

cd ~/ESPHamClock
make clean
make -j 4 hamclock-2400x1440
sudo make install

Replace 2400x1440 with the desired resolution:

• hamclock-1600x960
• hamclock-2400x1440
• hamclock-3200x1920

If you want HamClock to fill the screen completely, navigate to Page 5 in the Setup menu and enable the full-screen option.

Step 5: Auto-start HamClock on Boot

To ensure HamClock starts automatically on system boot, you can create an autostart entry.

For XDG-compliant systems:

cd ~/ESPHamClock
mkdir -p ~/.config/autostart
cp hamclock.desktop ~/.config/autostart

For macOS (Create a Clickable App):

If you’re using macOS, you can create a clickable app on your Desktop:

cd ~/ESPHamClock
HCDIR=~/Desktop/HamClock.app
mkdir -p $HCDIR
echo '#!/bin/bash' > $HCDIR/HamClock
echo '/usr/local/bin/hamclock &' >> $HCDIR/HamClock
chmod u+x $HCDIR/HamClock

To assign a proper icon, follow these steps:

1. Open hamclock.png with Preview.
2. Click on the image.
3. Press ⌘-A to select the image, then ⌘-C to copy.
4. Right-click the new HamClock.app Desktop item and select Get Info.
5. Click the existing default icon in the top left corner.
6. Press ⌘-V to paste the new icon.

Conclusion

By following these steps, you’ll have HamClock running seamlessly for amateur radio use, helping you track propagation, monitor DX cluster spots, and track satellites. Whether you’re using a Raspberry Pi, macOS, or a UNIX-like system, HamClock is a great addition to any ham radio station. For more info, visit https://www.clearskyinstitute.com/ham/HamClock/

Enjoy using HamClock and 73!

The post Installing HamClock for Amateur Radio Use appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Why Remap Your Mouse Keys?

Before we dive into the how-to, let’s discuss why you might want to remap your mouse keys in the first place:

• Enhanced Control: Many games don’t utilize all the buttons on modern gaming mice. Re-mapping allows you to assign in-game actions to these unused buttons for quicker access to crucial commands.
• Macros and Combos: Execute complex sequences of keystrokes with a single button press. This is incredibly useful for MMOs or games with intricate combo systems.
• Accessibility: Remapping can make gaming more accessible for users with disabilities, allowing them to customize controls to suit their needs.
• Productivity Boost: Beyond gaming, remapping can streamline your workflow in other applications by assigning common tasks to your mouse buttons.
• Consistency Across Games: Create a unified control scheme for all your games, reducing the learning curve when switching between titles.

Installing Input-Remapper

Input-Remapper is available on various Linux distributions. The recommended method is usually through your distribution’s package manager. Here’s a general overview:

• Debian/Ubuntu-based distributions:

Bash

sudo apt update
sudo apt install input-remapper

• Fedora/RPM-based distributions:

Bash

sudo dnf install input-remapper

• Arch-based distributions:

Bash

sudo pacman -S input-remapper

If your distribution doesn’t have Input-Remapper in its repositories, you can usually build it from source. Refer to the official Input-Remapper GitHub page (https://github.com/sezanzeb/input-remapper) for detailed instructions.

Configuring Input-Remapper

Once installed, launch Input-Remapper. You’ll be greeted with a user-friendly interface. Here’s a breakdown of the key elements:

• Device Selection: Choose your gaming mouse from the list of connected devices. Make sure it’s properly detected.
• Button Mapping: This is where the magic happens. You’ll see a visual representation of your mouse with clickable buttons.
• Action Assignment: When you click a button, you can assign various actions to it:
  • Keypresses: Simulate pressing any key on your keyboard, including combinations (e.g., Ctrl+Shift+T).
  • Mouse Clicks: Simulate mouse clicks (left, right, middle, etc.).
  • Macros: Record and playback sequences of keystrokes and mouse clicks.
  • Special Actions: Input-Remapper also offers some special actions, like adjusting volume or launching applications.

Step-by-Step Guide to Remapping a Mouse Button

Let’s walk through a simple example of remapping a side button on your mouse to simulate the “G” keypress:

1. Select Your Mouse: Open Input-Remapper and select your gaming mouse from the device list.
2. Identify the Button: Click on the visual representation of your mouse to identify the button you want to remap. Input-Remapper should highlight the corresponding button on your physical mouse.
3. Assign the Action: Click on the selected button in Input-Remapper. A dialog box will appear allowing you to choose the action.
4. Choose “Keypress”: Select the “Keypress” option.
5. Enter the Key: Type “G” into the key input field.
6. Save the Configuration: Click “Save” to apply your changes.

Now, when you press the remapped button on your mouse, it will be as if you pressed the “G” key on your keyboard.

Creating Macros

Macros are where Input-Remapper truly shines. Here’s how to create one:

1. Select the Button: Choose the button you want to assign the macro to.
2. Choose “Macro”: Select the “Macro” option.
3. Record the Sequence: Click “Start Recording” and perform the sequence of keystrokes and mouse clicks you want to include in the macro.
4. Stop Recording: Click “Stop Recording” when you’re finished.
5. Save the Macro: Give your macro a name and save it.

Now, pressing the assigned button will execute the entire recorded sequence.

Tips and Tricks

• Profiles: Create different profiles for different games or applications. This allows you to quickly switch between control schemes.
• Modifiers: Use modifier keys (Ctrl, Shift, Alt) in your key mappings and macros for even more complex actions.
• Testing: Always test your remappings in-game to ensure they work as intended.
• Troubleshooting: If a button isn’t working, double-check that you’ve selected the correct device and button in Input-Remapper. Also, make sure the application has the necessary permissions to access your input devices. Restarting Input-Remapper or even your computer can sometimes resolve issues.
• Community Resources: The Input-Remapper GitHub page and community forums are excellent resources for finding help and sharing your configurations.

Beyond Gaming

While this guide focuses on gaming, remember that Input-Remapper can be used for a wide range of tasks. Think about how you can streamline your workflow in other applications by assigning common actions to your mouse buttons.

Conclusion

Input-Remapper is a powerful tool that can significantly enhance your gaming experience on Linux, especially on GNOME with Wayland. By following this guide, you can unlock the full potential of your gaming mouse and take your skills to the next level. So, go ahead, experiment, and customize your controls to dominate your favorite games!

The post Conquer Your Linux Games: A Guide to Binding Gaming Mouse Keys with Input-Remapper appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

The rtl8852cu Linux driver (version 1.19.2.1, updated as of May 10, 2024) supports USB WiFi adapters based on the RTL8832CU and RTL8852CU chipsets. While Realtek continues to develop this out-of-kernel driver, it is important to note that it is not fully compliant with Linux Wireless Standards. This makes it more suitable for specialized use cases, such as embedded systems, rather than general desktop or server environments.

For most users, adapters with in-kernel drivers are recommended due to their stability and ease of use. However, if you’re working with an adapter supported by this driver, here’s everything you need to know.

Key Features of the rtl8852cu Driver

• WiFi Standards: IEEE 802.11 b/g/n/ac/ax (WiFi 6)
• Security Protocols:
• WEP, WPA TKIP, WPA2 AES/Mixed mode (PSK and TLS)
• WPA3-SAE R2
• WPS (PIN and PBC methods)
• Modes Supported:
• Client mode
• AP mode (with DFS channel support)
• P2P-client and P2P-GO
• IBSS (not tested)
• Advanced Features:
• Miracast
• WiFi-Direct
• Wake on WLAN
• VHT and HE control (supports 160 MHz channel width in AP mode)

Note: Monitor mode is not supported. If you require monitor mode, consider adapters based on the mt7610u, mt7612u, or mt7921au chipsets.

Compatible Devices and Chipsets

This driver supports a variety of USB WiFi adapters, including:

• Edup AX5400 EP-AX1671 (single-state, no onboard Windows driver)
• Brostrend AX8
• TP-Link Archer TX50UH V1
• TP-Link Archer TXE70UH(EU) V1
• MSI AXE5400

Warning: Multi-state adapters (those with internal Windows drivers) may cause issues on Linux. For better compatibility, opt for single-state and single-function adapters. Avoid multi-function adapters (e.g., those combining WiFi and Bluetooth).

Supported CPU Architectures and Kernels

• CPU Architectures:
• x86, i386, i686
• x86-64, amd64
• armv6l, armv7l (arm)
• aarch64 (arm64)
• Kernel Versions:
• Officially tested: 5.4 to 6.6 (Realtek)
• Community-supported: 6.7 to 6.12

Tested Compilers: gcc 12, 13, and 14.

Installation Guide

Prerequisites

Before installing the driver, ensure your system is up-to-date and has the necessary development tools installed. You’ll also need internet access during installation.

1. Update Your System:

• For Debian-based distributions (e.g., Ubuntu, Kali):
  bash sudo apt update && sudo apt upgrade
• For Arch-based distributions (e.g., Manjaro):
  bash sudo pacman -Syu
• For Fedora:
  bash sudo dnf upgrade

1. Install Required Packages:

• Mandatory packages: gcc, make, bc, kernel-headers, build-essential, git
• Highly recommended: dkms, rfkill, iw, ip
• For Secure Boot: openssl, sign-file, mokutil Example for Ubuntu:

   sudo apt install -y build-essential dkms git iw

3. Download and Install the Driver:

   git clone https://github.com/morrownr/rtl8852cu-20240510.git
   cd rtl8852cu-20240510
   sudo ./install-driver.sh

4. Reboot Your System:
   After installation, reboot to ensure the driver loads correctly:

   sudo reboot

Troubleshooting Tips

• Adapter Turned To CD-ROM Mode: Visit https://github.com/morrownr/8821cu-20210916/issues/92
• Conflicting Drivers: Installing multiple out-of-kernel drivers for the same hardware can cause issues. Use sudo dkms status to check for conflicts.
• Secure Boot: If Secure Boot is enabled, follow the instructions in the FAQ to enroll the signing key.
• Manual Installation: If DKMS is unavailable, you can manually compile and install the driver using:

  make clean
  make -j$(nproc)
  sudo make install
  sudo reboot

Recommended Router/AP Settings

To optimize your WiFi performance:

1. Security: Use WPA2-AES or WPA3. Avoid mixed modes like WPA/WPA2.
2. Channel Width:

• 2.4 GHz: Set to 20 MHz fixed width.
• 5 GHz: Use channels 36–48 or 149–165 for compatibility.

1. Network Names: Avoid naming all bands (2.4 GHz, 5 GHz, 6 GHz) the same.
2. Router Placement: Position the router centrally, elevated, and away from walls.

Final Notes

While this driver provides robust support for RTL8832CU and RTL8852CU adapters, it is not without limitations. Users should weigh the trade-offs between stability, compatibility, and advanced features when choosing a WiFi adapter. For most desktop and server users, in-kernel drivers remain the best choice.

If you encounter issues or have questions, consult the FAQ or open an issue on the GitHub repository.

Happy networking!

The post Linux Driver for RTL8832CU and RTL8852CU USB WiFi Adapters appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When it comes to the Linux desktop experience, one thing remains constant: the occasional frustration with mouse scrolling. Whether you’re navigating through web pages, sifting through documents, or coding in your favorite editor, smooth and predictable scrolling is essential. Unfortunately, not all Linux desktop environments handle mouse scroll events gracefully. This is where imwheel steps in to save the day.

The Scrolling Conundrum on Linux

Despite the significant strides in Linux desktop environments like GNOME, KDE Plasma, and Xfce, inconsistencies in mouse scroll behavior persist. Users frequently encounter issues such as:

• Slow or Unresponsive Scrolling: Certain applications, particularly web browsers and terminal emulators, often exhibit sluggish scroll speeds that can make navigation a chore.
• Inconsistent Behavior Across Applications: Some programs adhere to the system-wide scroll settings, while others stubbornly ignore them, leading to an uneven user experience.
• Lack of Customization: The default settings provided by many desktop environments rarely offer the granular control needed to fine-tune scrolling to individual preferences.
• Hardware Compatibility Issues: High-DPI mice and those with tilt-scroll functions sometimes don’t play well with the underlying system, resulting in erratic or hyper-sensitive scrolling.

These issues can be a significant hindrance, especially for users who demand precision and efficiency in their workflow.

Enter imwheel

imwheel is a lightweight utility that intercepts and modifies mouse wheel input on the fly, giving users the power to adjust the scroll behavior at a granular level. Here’s why it remains an indispensable tool:

Customization at Your Fingertips

With imwheel, you can tailor your mouse scroll settings to perfectly suit your needs. Whether you need to ramp up the speed for faster navigation or dial it down for precision work, imwheel allows you to modify scroll sensitivity with ease. You can even set up custom scrolling profiles for different applications, ensuring that every piece of software behaves just the way you want it to.

Bridging the Gap

While modern desktop environments offer various settings to adjust scroll behavior, they often fall short of providing the detailed control that imwheel offers. Many of these environments have default configurations that may work well for most users but leave little room for customization when things go awry. imwheel bridges this gap by giving you a simple yet powerful way to tweak scroll acceleration and sensitivity, enhancing compatibility across a wide range of applications and hardware.

Wide-Ranging Compatibility

Even as Linux transitions toward newer display protocols like Wayland, a significant number of users still rely on X11. imwheel continues to be a vital tool for X11 users, ensuring that even on legacy systems, you can achieve consistent and smooth scrolling. Its ability to work across various distributions and desktop environments further cements its relevance.

Installing and Configuring imwheel

Getting started with imwheel is straightforward. Here’s a quick guide to installation and configuration on some popular Linux distributions:

Installation

• Debian/Ubuntu-based distros: sudo apt install imwheel
• Fedora: sudo dnf install imwheel
• Arch Linux: sudo pacman -S imwheel

Configuration

Once installed, you can customize imwheel by editing the ~/.imwheelrc file. Here’s an example configuration that increases vertical scroll speed:

".*"
None, Up, Button4, 4
None, Down, Button5, 4

In this configuration, the number 4 specifies the scroll acceleration. Adjusting this value allows you to fine-tune the scrolling speed to your liking. After updating the configuration, apply the changes by restarting imwheel:

imwheel -kill

For convenience, you can add the imwheel -kill command to your startup applications to ensure that imwheel is automatically launched when you log in.

Conclusion

In the ever-evolving landscape of Linux desktop environments, the need for precise control over hardware behavior remains paramount. imwheel continues to be a relevant and invaluable tool for those who find themselves frustrated by inconsistent mouse scroll behavior. By offering detailed customization options and bridging the gap left by default system settings, imwheel ensures that your scrolling experience is as smooth and responsive as it should be.

If you’ve ever found yourself fighting with your mouse scroll settings on Linux, give imwheel a try. It might just be the fix you need to enhance your workflow and reclaim the fluidity of your desktop experience.

The post Why imwheel Is Still Relevant for Linux Users in 2025 appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In this guide, we will explore power-profiles-daemon , TLP , Laptop-Mode-Tools , i7z , turbostat , cpupower , auto-cpufreq , and tuned . We’ll delve into their features, use cases, pros, and cons, and provide guidance on how to combine these tools for optimal results.

1. power-profiles-daemon

Overview:

power-profiles-daemon is a modern power management daemon developed by the GNOME project. It provides simple, high-level profiles (e.g., “Power Saver,” “Balanced,” “Performance”) for managing power consumption. It integrates well with GNOME desktop environments but can also be used in other environments.

Key Features:

• Simplicity : Provides easy-to-use power profiles without requiring deep technical knowledge.
• Integration : Works seamlessly with GNOME’s power settings and other desktop environments.
• Profiles : Offers predefined profiles like “Power Saver,” “Balanced,” and “Performance.”
• Systemd Integration : Uses systemd to manage power states and services.
• CPU Governor Management : Manages CPU governors (e.g., powersave, performance) based on the selected profile.
• Modern Approach : Designed for newer systems and works well with modern hardware.

Pros:

• Easy to use and configure.
• Good integration with GNOME and systemd-based systems.
• Minimal configuration required.
• Lightweight and efficient.

Cons:

• Limited customization compared to TLP.
• Primarily focused on high-level profiles rather than fine-grained control.
• Less suitable for advanced users who want granular control over power settings.

Use Case:

• Ideal for users who want a simple, out-of-the-box solution with minimal configuration, especially those using GNOME or other systemd-based desktop environments.

2. TLP (Tuned for Linux Power)

Overview:

TLP is a highly configurable power management tool designed to optimize battery life and performance on laptops. It offers a wide range of customizable settings for power management, including CPU frequency scaling, disk spindown, USB autosuspend, and more. TLP is independent of any specific desktop environment and works across various Linux distributions.

Key Features:

• Advanced Configuration : Allows fine-grained control over power settings, including CPU governor, disk spindown, USB autosuspend, and more.
• Automatic Tuning : Automatically applies power-saving settings when the laptop is running on battery and switches to performance mode when plugged in.
• Cross-Platform : Works with any Linux distribution and desktop environment.
• Extensive Documentation : Well-documented with a comprehensive configuration file (/etc/tlp.conf) that allows users to tweak every aspect of power management.
• Battery Health Management : Includes features like battery charge thresholds to prolong battery life.
• Wake-on-LAN and PCIe Power Management : Supports advanced features like Wake-on-LAN and PCIe ASPM (Active State Power Management).

Pros:

• Highly customizable and flexible.
• Works across all Linux distributions and desktop environments.
• Extensive feature set for both power saving and performance tuning.
• Automatic switching between battery and AC modes.
• Battery health management features.

Cons:

• Steeper learning curve due to the complexity of configuration.
• Requires manual editing of configuration files for advanced customization.
• May conflict with other power management tools if not configured properly.

Use Case:

• Ideal for advanced users who want granular control over power settings and are comfortable with manual configuration.
• Suitable for users who need to maximize battery life or performance depending on their usage scenario.

3. Laptop-Mode-Tools

Overview:

Laptop-Mode-Tools is an older power management tool that was widely used in the past but has seen less development in recent years. It focuses on extending battery life by enabling “laptop mode,” which reduces disk activity and optimizes power usage. It includes a variety of modules for managing different aspects of power consumption, such as CPU frequency scaling, disk spindown, and USB power management.

Key Features:

• Laptop Mode : Reduces disk activity by delaying writes to the hard drive, which helps conserve power.
• Modules : Includes a wide range of modules for managing CPU governors, disk spindown, USB power management, and more.
• Custom Scripts : Allows users to write custom scripts for additional power-saving tweaks.
• Legacy Support : Still supports older hardware and configurations.

Pros:

• Simple and effective for reducing disk activity and conserving power.
• Modular design allows users to enable or disable specific features.
• Works well on older systems where modern tools may not be fully supported.

Cons:

• Development has slowed down, and it may not be as actively maintained as TLP or power-profiles-daemon.
• Some features may be outdated or less relevant on modern hardware.
• Can be complex to configure, especially for beginners.
• May conflict with newer power management tools like TLP or power-profiles-daemon.

Use Case:

• Suitable for users with older hardware or those who prefer a simpler, module-based approach to power management.
• Best for users who want to extend battery life through reduced disk activity and are comfortable with older, less actively maintained software.

4. i7z

Overview:

i7z is a specialized tool designed to monitor Intel Core i3, i5, and i7 processors in real-time. It provides detailed information about CPU performance, including Turbo Boost states, core frequencies, temperatures, and power consumption.

Key Features:

• Real-Time Monitoring : Displays live data about CPU frequencies, Turbo Boost states, and thermal throttling.
• Turbo Boost Insights : Provides insights into how Turbo Boost is being utilized across cores.
• Temperature Tracking : Monitors CPU temperatures to help identify overheating issues.
• Power Consumption : Estimates power usage based on CPU activity and frequency.

Pros:

• Excellent for diagnosing CPU performance issues, especially on Intel processors.
• Provides granular details about Turbo Boost and per-core performance.
• Lightweight and easy to use for monitoring purposes.

Cons:

• Limited to Intel processors; does not support AMD CPUs.
• Primarily a diagnostic tool; does not actively manage power settings.
• Requires manual interpretation of data for actionable insights.

Use Case:

• Ideal for users with Intel processors who want to monitor CPU performance and Turbo Boost behavior.
• Useful for troubleshooting performance bottlenecks or thermal throttling issues.

5. turbostat

Overview:

turbostat is a command-line utility that reports processor topology, frequency, idle power-state statistics, temperature, and power usage on modern Intel and AMD processors. It is part of the linux-tools-common package and is widely used for analyzing CPU power efficiency.

Key Features:

• Processor Topology : Displays detailed information about CPU cores, threads, and cache hierarchy.
• Frequency Monitoring : Tracks CPU frequencies, including base, maximum, and current operating frequencies.
• Idle States (C-states) : Reports time spent in various idle states (e.g., C0, C1, C6) to assess power efficiency.
• Thermal and Power Data : Provides real-time data on CPU temperature, power consumption, and energy usage.

Pros:

• Highly detailed and accurate reporting of CPU performance and power metrics.
• Works on both Intel and AMD processors.
• Lightweight and runs directly from the terminal.

Cons:

• Primarily a diagnostic tool; does not actively manage power settings.
• Requires familiarity with CPU architecture and power management concepts to interpret the data effectively.

Use Case:

• Best suited for advanced users and developers who need to analyze CPU power efficiency and performance.
• Useful for diagnosing issues related to CPU idle states, frequency scaling, and thermal management.

6. cpupower

Overview:

cpupower is a collection of utilities for managing CPU frequency scaling and power-related settings. It allows users to query and set CPU governors, adjust minimum and maximum frequencies, and monitor CPU performance.

Key Features:

• CPU Governor Management : Supports setting CPU governors like powersave, performance, ondemand, and conservative.
• Frequency Scaling : Allows users to manually set minimum and maximum CPU frequencies.
• Monitoring : Provides real-time information about CPU frequencies, governor status, and idle states.
• Cross-Platform : Works on both Intel and AMD processors.

Pros:

• Simple and effective for managing CPU frequency scaling.
• Lightweight and easy to use for basic power management tasks.
• Compatible with a wide range of processors.

Cons:

• Limited to CPU-related optimizations; does not handle broader power management tasks like disk spindown or USB autosuspend.
• Requires manual configuration for advanced use cases.

Use Case:

• Ideal for users who want to manually control CPU governors and frequency scaling.
• Suitable for systems where other power management tools may not fully support CPU optimization.

7. auto-cpufreq

Overview:

auto-cpufreq is a lightweight, automatic CPU frequency scaling tool designed to optimize power consumption and performance based on system load and power source (AC or battery). It is particularly useful for laptops and portable devices.

Key Features:

• Automatic CPU Scaling : Dynamically adjusts CPU governors (e.g., powersave, performance) based on system load and power source.
• Power Profiles : Offers predefined profiles like “Battery,” “Performance,” and “Balanced.”
• Lightweight : Minimal resource usage and easy to install.
• Cross-Platform : Works across various Linux distributions and desktop environments.

Pros:

• Simple and easy to use with minimal configuration.
• Focuses on CPU optimization, which is critical for both battery life and performance.
• Lightweight and efficient, making it suitable for older hardware.

Cons:

• Limited to CPU-related optimizations; does not handle disk spindown, USB autosuspend, etc.
• Less feature-rich compared to TLP.

Use Case:

• Ideal for users who want automatic CPU frequency scaling without the complexity of TLP.
• Suitable for users who prioritize CPU performance and power savings but don’t need full-system power management.

8. tuned

Overview:

tuned is a dynamic system tuning daemon that optimizes system performance and power consumption based on predefined profiles. It is widely used in enterprise environments and is included by default in many Linux distributions.

Key Features:

• Predefined Profiles : Offers profiles like “balanced,” “powersave,” “throughput-performance,” and “latency-performance.”
• Custom Profiles : Allows users to create custom profiles tailored to specific workloads.
• Dynamic Tuning : Automatically adjusts settings based on system load and power source.
• Integration : Works well with systemd and other system services.

Pros:

• Easy to use with predefined profiles for common use cases.
• Highly customizable with support for custom profiles.
• Actively maintained and supported by major Linux distributions.

Cons:

• Limited customization compared to TLP for advanced users.
• May conflict with other power management tools if not configured properly.

Use Case:

• Ideal for users who want a balance between simplicity and customization.
• Suitable for enterprise environments where predefined profiles can be applied across multiple systems.

Combining Tools for Optimal Results

To achieve the best power management setup, you can combine several of these tools to address different aspects of system performance and power consumption:

1. For High-Level Profiles : Use power-profiles-daemon to manage high-level power profiles like “Power Saver,” “Balanced,” and “Performance.” This tool is ideal for users who want minimal configuration and seamless integration with modern desktop environments.
2. For Fine-Grained Control : Use TLP for comprehensive power management. TLP offers advanced customization options for CPU frequency scaling, disk spindown, USB autosuspend, and more. It is perfect for advanced users who want maximum control over their system’s power consumption.
3. For Disk Activity Reduction : If you’re particularly concerned about disk activity and want to reduce power consumption by delaying writes to the hard drive, you can enable laptop-mode-tools alongside TLP . This tool is especially useful for older systems with spinning hard drives.
4. For CPU Monitoring and Diagnostics : Use i7z and turbostat to monitor CPU performance and diagnose issues related to Turbo Boost, frequency scaling, and thermal management. These tools are invaluable for identifying inefficiencies and optimizing power usage.
5. For CPU Frequency Scaling : Use cpupower or auto-cpufreq to manage CPU governors and frequency scaling. These tools are lightweight and focus specifically on CPU performance and power savings.
6. For Predefined Profiles : Use tuned to apply predefined profiles for common use cases. Tuned is easy to use and highly customizable, making it suitable for both casual and advanced users.

Conclusion

Linux offers a rich ecosystem of power management tools, each catering to different needs and use cases. Whether you’re looking for simple, out-of-the-box solutions like power-profiles-daemon or advanced, customizable tools like TLP , there’s something for everyone.

The post Power Management on Linux: A Guide to power-profiles-daemon, TLP, Laptop-Mode-Tools, i7z, turbostat, cpupower, auto-cpufreq, and tuned appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When it comes to Linux software installation, Snap and Flatpak have become popular options for packaging and distributing applications. Both formats aim to simplify the process by providing a universal way of distributing applications across different distributions. However, despite their common goal, they have distinct differences, histories, and ecosystems. In this post, we’ll dive deep into the origins of Snap and Flatpak, compare their features, advantages, and disadvantages, and help you decide which one to use.

The Origins and History of Snap and Flatpak

Snap:

Snap was introduced by Canonical, the creators of Ubuntu, in 2016. Canonical wanted a solution to address the limitations of traditional Linux package managers like APT or YUM, especially when it came to distributing applications across multiple distributions. Snaps are designed to be distribution-agnostic and include all the dependencies an application needs, thus avoiding the problem of missing libraries or dependencies. They’re containerized, making them more secure and easier to manage.

Flatpak:

Flatpak has its roots in the Fedora project and was developed by Alex Larsson in 2015. Similar to Snap, Flatpak provides a way to bundle applications with their dependencies. The idea behind Flatpak was to allow applications to run consistently on different Linux distributions while maintaining a high level of security. While Fedora and Red Hat were the early adopters of Flatpak, it has since gained support from a wide range of distributions, including Ubuntu, Debian, and Arch Linux.

Key Differences Between Snap and Flatpak

1. Repositories:
   • Snap: Snap applications are hosted in the Snap Store, maintained by Canonical. The Snap Store is centralized, meaning Canonical manages the publishing, updating, and distribution of all snaps. This can make the process easier for developers, but it also means that there’s less diversity in where and how applications are hosted.
   • Flatpak: Flatpak uses a decentralized approach with multiple repositories available. The primary repository is called Flathub, which serves as a hub for most Flatpak applications. However, developers and organizations can host their own Flatpak repositories, giving them more control over their distribution. This decentralized model gives users more freedom in choosing their source of applications.
2. System Integration and Isolation:
   • Snap: Snaps are more integrated with the system, but they also come with some isolation features. They’re sandboxed, meaning that they run in a container with limited access to the system. However, they tend to be more “system” oriented, as Canonical has more control over the underlying system’s interaction with the apps.
   • Flatpak: Flatpak applications are more isolated and run in a more strict sandboxed environment. This isolation improves security, but it can sometimes cause issues with system integration, especially for applications that need to interact closely with the host OS. Flatpak uses a runtime system, meaning that Flatpak apps rely on a shared runtime for common dependencies.
3. Update Mechanism:
   • Snap: Snaps update automatically in the background, which can be both a blessing and a curse. Users don’t have to worry about manually updating their apps, but some users find automatic updates to be intrusive, especially if they’re not in control of the timing.
   • Flatpak: Flatpak also has an update system, but it’s more user-controlled. While Flatpak apps can update automatically, it depends on how the user configures their system. Flatpak updates tend to be more flexible and less frequent compared to Snap.
4. Size and Performance:
   • Snap: Since Snaps bundle all dependencies, they tend to be larger in size. While this guarantees that the app will work across different distributions, it also results in applications being bulkier and consuming more storage.
   • Flatpak: Flatpak applications tend to be smaller than Snap packages since they share common dependencies through the runtime. However, if an app requires multiple runtimes, it can still lead to a significant size overhead. Despite this, Flatpak apps generally perform better because they use shared runtimes, avoiding unnecessary redundancy.
5. Security and Sandboxing:
   • Snap: Snaps are sandboxed by design, and Canonical uses AppArmor for additional security. While this offers a good level of protection, some users feel that it’s not as strict as the Flatpak model, as Canonical’s more centralized control can mean less transparency.
   • Flatpak: Flatpak uses SELinux (Security-Enhanced Linux) or other similar security mechanisms for sandboxing. Flatpak has a more strict isolation model, meaning that Flatpak apps are more restricted in terms of what they can access on the host system.

Command Lists

Let’s take a quick look at the basic commands for using Snap and Flatpak.

Snap:

• Install a Snap package: sudo snap install <package-name>
• Search for Snap packages: snap find <package-name>
• List installed Snaps: snap list
• Remove a Snap package: sudo snap remove <package-name>
• Update Snap packages: sudo snap refresh

Flatpak:

• Install a Flatpak package: flatpak install flathub <package-name>
• Search for Flatpak packages: flatpak search <package-name>
• List installed Flatpak applications: flatpak list
• Remove a Flatpak package: flatpak uninstall <package-name>
• Update Flatpak packages: flatpak update

Advantages and Disadvantages

Snap Advantages:

• Centralized Snap Store simplifies distribution and management.
• Automatic updates reduce the need for user intervention.
• Works across many Linux distributions with minimal setup.
• Strong integration with Ubuntu and other Canonical-based systems.

Snap Disadvantages:

• Larger file sizes due to bundling all dependencies.
• Automatic updates can be intrusive for some users.
• More centralized control, meaning less transparency.
• Slower start-up times compared to native packages.

Flatpak Advantages:

• Strong security features with strict sandboxing.
• Smaller file sizes thanks to shared runtimes.
• Decentralized model gives more freedom and flexibility.
• Better integration with GNOME-based systems and other desktop environments.

Flatpak Disadvantages:

• Slightly more complex to set up due to multiple repositories.
• May require more storage if multiple runtimes are installed.
• Some apps may face compatibility issues in terms of system integration.
• Less integration with Ubuntu-based systems compared to Snap.

Which One to Choose?

Snap is a great choice if you’re using Ubuntu or a distribution based on it, as it is tightly integrated into the ecosystem. If you prefer a more centralized system with automatic updates and easy management, Snap might be the way to go. It’s also ideal if you need a quick and straightforward installation process across various distributions.

Flatpak is a better choice if you value security and sandboxing, or if you want to use a decentralized system with the freedom to pick your repository. Flatpak is more suited to users who appreciate flexibility and want smaller file sizes by leveraging shared runtimes.

Ultimately, the choice comes down to your preferences and your distribution. Both Snap and Flatpak have their strengths, and as Linux continues to evolve, the adoption of both formats will likely grow.

The post Snap vs Flatpak: A Detailed Comparison appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.