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

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

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

Why Use ThinkFan?

ThinkFan gives you:

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

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

Prerequisites

Before starting, make sure:

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

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

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

cat /proc/acpi/ibm/fan

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

Configuring ThinkFan

Create or edit your config file:

sudo nano /etc/thinkfan.conf

Paste the following Malaysia-optimized config:

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

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

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

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

Starting ThinkFan

Enable and start the ThinkFan service:

sudo systemctl enable --now thinkfan

Monitor its activity:

sudo journalctl -u thinkfan -f

You should see logs like this:

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

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

Tips for Stability

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

Optional: Use ThinkFan-UI for a GUI Experience

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

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

Final Thoughts

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

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

For more info, visit:

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

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

Backing up an Android device can be a complicated task, especially if you’re looking for a clean, rootless method that doesn’t involve proprietary cloud services or bloated apps. Open Android Backup offers a breath of fresh air for privacy-conscious users, particularly those who prefer open-source tools and full control over their data.

For users of Arch Linux and its derivatives like EndeavourOS, Manjaro, or CachyOS, the AUR package open-android-backup makes it easy to install and use this tool right from your system.

What Is Open Android Backup?

Open Android Backup is a cross-platform tool that leverages Android’s adb backup functionality to create and restore full application data backups — without requiring root access. It’s written in Python and uses a simple graphical user interface (GUI) built on PyQt5.

This tool aims to bridge the gap between power users and casual users who simply want a reliable way to save their app data, settings, and system preferences without rooting their phone or relying on Google.

Key Features

• No root required
  Works with stock Android devices using standard ADB tools.
• Cross-platform
  Runs on Linux, Windows, and macOS — anywhere Python and ADB are available.
• User-friendly GUI
  The PyQt-based interface makes backup and restore straightforward even for less technical users.
• Local backups
  Your data stays on your machine. No cloud, no remote servers, no hidden data sharing.
• App-by-app control
  Select specific apps to back up or restore, rather than dumping the whole device image.

Installation on Arch-based Systems

If you’re running an Arch-based distro, installing Open Android Backup is simple:

yay -S open-android-backup

Alternatively, use any other AUR helper like paru, or manually download and build the PKGBUILD.

Dependencies

Make sure you have ADB installed:

sudo pacman -S android-tools

Once installed, plug in your Android device with USB debugging enabled, and launch the application:

open-android-backup

You’ll be able to select what apps or data you want to back up, and start the process with just a few clicks.

For Other Linux, Windows, or macOS Users

Not on Arch? No problem.

You can download the tool or clone the repository directly from GitHub:

GitHub – mrrfv/open-android-backup

Follow the instructions in the README to set it up in your environment. The project is open-source under the MIT license, so you’re free to modify, inspect, and contribute to it.

Final Thoughts

Open Android Backup is a practical, lightweight, and privacy-respecting tool that fills a critical gap in Android device management. Whether you’re a developer, power user, or simply someone who wants more control over their data, it’s worth exploring.

Users of Arch-based Linux systems have the convenience of AUR packaging, while users on other platforms can build and run it manually from the GitHub source.

In a world increasingly dominated by proprietary backup solutions and cloud sync, tools like Open Android Backup remind us of the power and flexibility of open source — and the importance of data sovereignty.

The post Open Android Backup: A Clean, Rootless Backup Solution for Android Devices appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

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

What Is TLP?

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

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

Why ThinkPads + TLP Just Work

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

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

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

My Current Setup

Battery Management

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

START_CHARGE_THRESH_BAT0=75
STOP_CHARGE_THRESH_BAT0=80

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

TLP also supports force discharge and recalibration if needed.

Fan + Cooling

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

How to Check If acpi_call-dkms Is Needed

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

sudo tlp-stat -b

Look for:

Driver usage:
* natacpi (thinkpad_acpi) = active

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

sudo pacman -Rns acpi_call-dkms

Final Thoughts

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

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

Bonus Tip

Want to see TLP in action?

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

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

TL;DR

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

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

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

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

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

What is CachyOS?

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

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

Why Use CachyOS?

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

1. Performance-Tuned Kernels

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

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

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

2. Compiler Optimizations for Modern CPUs

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

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

3. Intelligent Memory and CPU Handling

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

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

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

4. A Gamer’s Delight

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

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

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

5. Cachy-Browser: A Faster Firefox

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

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

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

6. Desktop Environments and Themes

CachyOS supports multiple desktop environments including:

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

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

7. GUI Tools and Kernel Manager

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

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

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

Things to Keep in Mind

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

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

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

Real-World Performance

Many users have reported:

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

CachyOS for Amateur Radio Enthusiasts

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

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

Conclusion

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

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

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

Website: https://cachyos.org

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

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

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

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

My Setup Goals

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

Finding the RTSP Port with Nmap

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

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

sudo pacman -S nmap

2. Scan for common video streaming ports:

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

Replace 192.168.0.11 with your camera’s actual IP address.

Example output:

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

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

Testing the Stream with ffplay

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

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

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

Daily Viewing with MPV

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

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

Create a Desktop Shortcut

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

1. Create the launcher:

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

2. Paste this:

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

3. Make it executable:

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

Wrap-up

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

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

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

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

What is aprsc?

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

Highlights:

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

About aprsc-9m2pju-git

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

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

Installation

To install via your favorite AUR helper:

yay -S aprsc-9m2pju-git

Or manually:

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

What Gets Installed?

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

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

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

Running aprsc

After installation, start the service with:

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

Check logs:

journalctl -u aprsc.service -f

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

Things to Know

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

Thanks & Credits

Big shout-out to:

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

Maintainer

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

Resources

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

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

73 de 9M2PJU

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

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

That’s where Nerd Fonts comes in.

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

What Is Nerd Fonts?

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

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

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

Why You’ll Love Nerd Fonts

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

Want to Patch Your Own Fonts?

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

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

Try It Yourself

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

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

Download & Get Started

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

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

Open Source & Growing

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

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

Final Thoughts

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

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

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

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

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

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

How This Changed QSO Confirmations Forever

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

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

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

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

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

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

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

Prerequisites

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

• yay
• paru

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

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

Installing TrustedQSL from AUR

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

paru -S trustedqsl-git

Or with yay:

yay -S trustedqsl-git

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

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

Launching TQSL

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

tqsl

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

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

Why Use trustedqsl-git?

Using trustedqsl-git has its benefits:

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

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

Updating TQSL

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

paru -Syu

Or specifically:

paru -S trustedqsl-git

This will rebuild TQSL from the latest commit.

Final Thoughts

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

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

If you’re a licensed ham radio operator exploring digital modes or remote communication, there’s a good chance you’ve heard of EchoLink. It’s one of the easiest ways to connect with other hams worldwide—without needing a transceiver, tower, or even an antenna.

But what if you’re on Arch Linux (or a distro like CachysOS, Manjaro, EndeavourOS, or ArcoLinux)? There’s no official EchoLink client packaged for Arch. Fortunately, thanks to the Arch User Repository (AUR), we now have an actively maintained build of Qtel, the graphical EchoLink client from the SvxLink project.

This guide shows how to install qtel-svxlink-git from the AUR using paru or yay—two of the most popular AUR helpers.

What is EchoLink?

EchoLink is a system that allows licensed amateur radio operators to connect with each other using the internet as a bridge between radios. It works through:

• RF nodes (like a repeater or simplex radio with a computer running EchoLink software)
• PC and smartphone clients (for operators who want to connect via the internet)

That means you can:

• Join a repeater in another country
• Talk to someone over RF from your laptop or phone
• Access conference rooms where multiple hams chat together
• Even control a remote station or node

EchoLink is especially useful for:

• Hams in apartment buildings or RF-restricted areas
• Emergency comms backups
• Quick check-ins while traveling

What is Qtel?

Qtel is the official graphical EchoLink client that’s part of the SvxLink suite. It supports:

• Direct connections to other EchoLink nodes
• Simple, clean UI for managing connections
• EchoLink directory lookups
• Voice-over-IP through your computer mic/speakers

Unlike the full SvxLink server setup (which supports linking RF radios), Qtel is just the GUI EchoLink client—perfect if you don’t want the full suite.

Installing Qtel on Arch Linux via AUR

There’s no official Arch package for Qtel—but the qtel-svxlink-git AUR package makes it easy to build the latest Qtel client from the official GitHub repo.

Install with paru

paru -S qtel-svxlink-git

This will clone the source, compile it, and install it automatically. You may be asked about optional dependencies or PKGBUILD changes—just follow the prompts.

Install with yay

yay -S qtel-svxlink-git

yay works very similarly and will guide you through the process with a clean terminal UI.

What You Get

• Only the Qtel client, not the full SvxLink system.
• Pulled and built from the latest code on the official GitHub: sm0svx/svxlink
• Conflicts cleanly with older qtel or qtel-git packages
• Installs dependencies like qt5-base, alsa-lib, libsamplerate, gsm, and others

Running Qtel

After install, launch it:

qtel

You’ll be greeted with a clean UI where you can:

• Log in with your callsign and EchoLink credentials
• Search the station directory
• Connect to nodes, repeaters, or conferences
• Use your mic/speaker to talk, just like on any EchoLink client

Audio Troubleshooting

Having trouble with your mic or audio output?

• Run pavucontrol (PulseAudio volume control)
• Make sure Qtel is using the correct input/output devices
• Try switching from PulseAudio to PipeWire or ALSA if needed

Final Thoughts

EchoLink is a great bridge between the analog world of amateur radio and the digital world of the internet. Whether you’re on the go or stuck in a noisy apartment block with no antenna, Qtel gives you a clean and simple way to connect with hams worldwide.

Now that Qtel is available via the AUR as qtel-svxlink-git, it’s never been easier for Arch Linux users to get on the EchoLink network.

Visit https://aur.archlinux.org/packages/qtel-svxlink-git

The post Installing Qtel from AUR on Arch Based Linux Using paru or yay appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

Prerequisites

Before starting, ensure you have:

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

Step 1: Install rclone

Ubuntu/Debian

sudo apt update
sudo apt install rclone

CentOS/RHEL/Fedora

# For CentOS/RHEL
sudo yum install rclone

# For Fedora
sudo dnf install rclone

Arch Linux

sudo pacman -S rclone

Install from Official Script

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

Verify the installation:

rclone version

Step 2: Install FUSE

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

Ubuntu/Debian

sudo apt install fuse

CentOS/RHEL/Fedora

# For CentOS/RHEL
sudo yum install fuse

# For Fedora
sudo dnf install fuse

Arch Linux

sudo pacman -S fuse2

Step 3: Configure Google Drive Remote

Start the rclone configuration process:

rclone config

Follow these steps in the interactive setup:

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

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

Step 4: Test the Configuration

Verify that rclone can access your Google Drive:

# List directories in your Google Drive
rclone lsd gdrive:

# List all files
rclone ls gdrive:

# List files with details
rclone lsl gdrive:

Step 5: Create Mount Point

Create a directory where you want to mount Google Drive:

mkdir ~/GoogleDrive

Step 6: Mount Google Drive

Basic Mount Command

rclone mount gdrive: ~/GoogleDrive --daemon

Recommended Mount Command with Options

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

Mount Options Explained

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

Alternative: Mount with GUI Support

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

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

Step 7: Verify the Mount

Check if the mount is successful:

# List mounted filesystems
df -h | grep GoogleDrive

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

Step 8: Unmount Google Drive

To unmount the drive:

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

# Method 2: Using umount
sudo umount ~/GoogleDrive

# Method 3: Kill rclone process
killall rclone

Step 9: Auto-Mount on Boot (Optional)

Using systemd Service

Create a systemd service file:

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

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

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

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

[Install]
WantedBy=default.target

Enable and start the service:

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

Check service status:

sudo systemctl status rclone-gdrive.service

Using /etc/fstab

Add the following line to /etc/fstab:

sudo nano /etc/fstab

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

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

Performance Tips

Optimize for Your Use Case

For frequent small file access:

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

For streaming large files:

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

Troubleshooting

Common Issues and Solutions

Issue: Permission denied

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

Issue: Mount point is busy

# Force unmount
sudo umount -l ~/GoogleDrive

Issue: Slow performance

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

Issue: Files not showing immediately

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

Check rclone Logs

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

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

Security Considerations

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

Conclusion

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

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

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

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

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

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

HAMRS is exactly that.

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

Why HAMRS Matters for Portable Ham Radio

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

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

Install HAMRS on Arch Linux (and Derivatives)

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

yay -S hamrs-appimage

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

Perfect for:

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

Exporting and Uploading Logs

Once you’re done operating, you can:

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

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

Support the Developer

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

Support the project via:

• Patreon
• Merch
• Direct donation

Final Key Point

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

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

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

The post A Better Logger for Hams: HAMRS appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

Basic Concept: Think in Categories

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

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

Turns out, pacman follows this logic really well.

Install & Update Packages

Install a package:

pacman -S <package>

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

Update everything (the Arch way):

pacman -Syu

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

You’ll use this more than anything else.

Remove Packages (Cleanly!)

Remove a package:

pacman -R <package>

Just deletes the program—not configs or dependencies.

Full, squeaky-clean removal:

pacman -Rns <package>

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

Searching for Packages

Search available packages (online repo):

pacman -Ss <keyword>

Ss = Search Store

Search only installed packages:

pacman -Qs <keyword>

Qs = Query System

Package Information

Get info about a package in the repo:

pacman -Si <package>

Get info about an installed package:

pacman -Qi <package>

List all files a package installed:

pacman -Ql <package>

Find out what package owns a file:

pacman -Qo /path/to/file

Cleanups & Maintenance

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

Remove orphaned packages (leftovers):

pacman -Rns $(pacman -Qdtq)

Clean the package cache (but keep most recent):

pacman -Sc

Clean EVERYTHING in the cache:

pacman -Scc

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

Bonus: Troubleshooting Tools

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

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

Trick to Memorize Them All

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

Final Cheat Sheet

Here’s a quick reference:

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

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

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

Why This Matters

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

1. Clean Up Any Existing Broken Setup

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

2. Create a New Swap Subvolume

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

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

findmnt -no UUID /

3. Mount the Subvolume via /etc/fstab

Add this line to /etc/fstab:

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

Then:

sudo mkdir /swap
sudo mount -a

4. Create the Swap File

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

Make sure it appears with:

swapon --show

5. Get the Resume Offset

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

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

6. Update Kernel Parameters (GRUB)

Edit /etc/default/grub:

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

Then regenerate GRUB config:

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

7. mkinitcpio Hooks

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

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

Then:

sudo mkinitcpio -P

8. Test Hibernation

sudo systemctl hibernate

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

Final Notes

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

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

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

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

What is 0 A.D.?

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

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

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

Why It’s Perfect for Linux Users

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

Native Linux Support

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

For example:

# On Debian/Ubuntu
sudo apt install 0ad

# On Arch Linux
sudo pacman -S 0ad

# On Fedora
sudo dnf install 0ad

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

Vulkan Renderer and FSR Support

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

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

Rolling Updates and Dev Engagement

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

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

What Makes the Gameplay So Good?

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

Realistic Economy and Base Building

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

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

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

Intense Tactical Combat

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

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

Endless Map Variety and Mod Support

0 A.D. includes:

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

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

Multiplayer and Replays

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

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

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

Community and Contribution

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

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

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

How to Install on Linux

Here’s a quick reference:

Option 1: Package Manager (Recommended)

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

Option 2: Compile from Source

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

Final Thoughts

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

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

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

The post 0 A.D. on Linux: A Stunning, Free RTS Experience That Rivals the Best appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

What is Plank?

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

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

Key Features

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

How to Install Plank on Debian/Ubuntu

To install Plank on Debian-based distributions:

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

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

Customization with Themes

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

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

Final Thoughts

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

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

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

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.

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.

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.

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.

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.

In the world of Linux and Unix-based systems, text editors play a vital role in editing system configurations, writing scripts, and handling various programming tasks. Whether you are a system administrator, developer, or simply working on a server, choosing the right text editor can impact your productivity and workflow. Today, we will take a look at some of the most popular text editors: vi, vim, nano, edit, and pico. Each of these editors has its own strengths, weaknesses, and use cases.

1. vi: The Classic Workhorse

vi is one of the oldest and most basic text editors available on Unix systems. Released in 1976, it has remained a cornerstone for many Linux users. One of the key reasons for its popularity is that vi comes pre-installed in almost every Unix-based operating system, making it an editor that you can always rely on to be available.

• Ease of Use: Intermediate
• Key Features: Minimalist, with basic functionality like modal editing (command and insert modes).
• Pros:
• Lightweight and consumes very few resources.
• Always available by default on Unix systems.
• Cons:
• Steep learning curve, as vi relies heavily on keyboard shortcuts, and its modal nature can be confusing for beginners.

vi is perfect for users who prefer something lightweight and don’t need advanced features. It’s especially handy in situations where only a command-line interface is available, and graphical editors are not an option.

2. vim: Vi Improved

vim, released in 1991, stands for “Vi IMproved.” As its name suggests, vim is an enhanced version of vi that offers a wealth of additional features. It retains the same modal nature as vi but includes many conveniences for modern programmers and power users, such as syntax highlighting, multi-level undo, and plugin support.

• Ease of Use: Intermediate to Advanced
• Key Features: Extensive customization, syntax highlighting, and support for plugins and scripting.
• Pros:
• Highly configurable and ideal for coding and scripting.
• Large community support with a variety of plugins for specific programming languages.
• Cons:
• The learning curve is steep for new users due to its complexity.

vim is a go-to editor for developers and system administrators who need the power and flexibility to work efficiently. Once you master its commands and keybindings, it becomes a highly efficient tool.

3. nano: Simplicity at Its Best

For users looking for an easy-to-learn and intuitive text editor, nano is a great choice. It was released in 1999 as a free replacement for pico and has become widely popular due to its simplicity. Unlike vi or vim, nano does not have modes, and all the available commands are clearly listed at the bottom of the screen, making it very approachable for beginners.

• Ease of Use: Beginner-friendly
• Key Features: No modes, simple interface, and basic commands visible on-screen.
• Pros:
• Easy to use and available on most Linux distributions.
• Perfect for beginners or users who just want to make quick edits.
• Cons:
• Lacks advanced features like syntax highlighting, plugins, or scripting capabilities.

If you’re new to the Linux environment and need a no-frills editor to get things done, nano is likely your best bet.

4. edit: A DOS Throwback

edit was originally released in 1981 for the MS-DOS environment and became the default editor for many DOS and early Windows users. While it was simple and effective for its time, edit is largely outdated and rarely seen in modern Unix or Linux systems.

• Ease of Use: Beginner-friendly (for DOS/Windows users)
• Key Features: Classic DOS-style interface, simple for basic text editing.
• Pros:
• Lightweight and familiar to users who have worked in DOS environments.
• Cons:
• Very outdated, with limited functionality compared to modern text editors.
• Irrelevant in most modern Unix/Linux systems.

edit might evoke nostalgia for users who spent time on early DOS-based systems, but it’s not a practical choice in today’s Linux environment.

5. pico: The Original Simplicity

pico, released in 1989, was originally bundled with the Pine email client. Like nano, it is designed for simplicity, with a focus on ease of use. In fact, nano was created as a free clone of pico. While pico was once popular, it has largely been replaced by nano in most Linux systems.

• Ease of Use: Beginner-friendly
• Key Features: Simple navigation, basic functionality, no modes.
• Pros:
• Straightforward and easy to use.
• Best for quick text editing without the need for advanced features.
• Cons:
• Lacks many features, including plugins, syntax highlighting, and scripting.

While pico has fallen out of favor compared to nano, it still serves its purpose as a simple, lightweight editor for users who value ease of use over advanced features.

Choosing the Right Text Editor

So which one should you use? The answer depends on your needs and experience level:

• For Beginners: If you’re new to Linux or Unix, start with nano or pico. They are simple, intuitive, and get the job done without much hassle.
• For Intermediate Users: vim is a powerful tool with a large feature set. If you’re willing to invest time in learning it, vim will reward you with faster editing and more customization.
• For Minimalists: Stick with vi if you want a light, quick-to-open editor that’s always available.
• For DOS Fans: If you’re feeling nostalgic, you can still give edit a try, but it’s mostly a relic of the past.

Each text editor has its place in the Linux/Unix world, and the right one for you depends on how comfortable you are with the system and what features you need.

Final Thoughts

While text editors like vi, vim, and nano have different strengths, it’s important to remember that there is no “best” text editor. The best one is the one that fits your workflow and comfort level. Whether you’re just getting started or are a seasoned sysadmin, knowing the right tool for the job will make your life easier.

Which text editor do you use? Share your thoughts in the comments!

The post A Comparison of Text Editors – vi, vim, nano, edit, and pico appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Ubuntu, a name synonymous with ease of use and accessibility in the Linux world, has been a gateway for many into the realm of open-source operating systems. Its popularity stems from its user-friendly interface, robust community support, and extensive documentation, making it an ideal starting point for newcomers. However, as users gain more experience and develop specific needs or preferences, some choose to migrate to other Linux distributions. This blog post delves into the myriad reasons why Ubuntu users might explore new horizons and switch to different Linux operating systems.

Desire for More Control and Customization

One of the most compelling reasons for migrating from Ubuntu is the desire for greater control and customization. While Ubuntu provides a streamlined and user-friendly experience, some users crave the ability to tailor their system more intricately to their preferences.

Arch Linux: The Minimalist’s Dream

Arch Linux epitomizes the philosophy of simplicity and user control. Unlike Ubuntu, which comes pre-packaged with a range of software and services, Arch Linux starts as a bare-bones system, allowing users to build their environment from the ground up. This approach is highly appealing to advanced users who want to fine-tune their systems to meet their exact needs.

With Arch Linux, users have complete control over what software is installed, which services are running, and how their system is configured. This level of customization extends to the kernel itself, enabling users to compile and optimize it for their specific hardware. The Arch User Repository (AUR) further enhances this experience by providing a vast collection of community-maintained packages, making it easy to install and manage software that might not be available in official repositories.

Gentoo: The Ultimate in Flexibility

For those who crave even more control, Gentoo offers a source-based package management system that allows users to compile software directly from source code. This not only provides the ability to optimize software for specific hardware but also ensures that users can customize every aspect of their system.

Gentoo’s Portage system, inspired by the BSD ports collection, offers unparalleled flexibility. Users can choose compile-time options, enabling or disabling features as needed. This granularity of control can lead to a more efficient and responsive system, tailored precisely to the user’s requirements.

Different Package Management Systems

Package management is a crucial aspect of any Linux distribution, influencing how software is installed, updated, and maintained. While Ubuntu’s APT (Advanced Package Tool) is renowned for its simplicity and reliability, some users prefer alternatives that offer different features or efficiencies.

Fedora: The Cutting-Edge Innovator

Fedora, backed by Red Hat, is known for its commitment to providing the latest in free and open-source software. It uses the DNF package manager, which some users find faster and more efficient than APT. DNF’s advanced dependency resolution and transaction support make it a powerful tool for managing software on a Fedora system.

Fedora also serves as a proving ground for new technologies that eventually make their way into Red Hat Enterprise Linux (RHEL). This makes it an attractive option for users who want to stay on the cutting edge of software development and enjoy early access to the latest innovations in the Linux world.

openSUSE: A Powerhouse of Stability and Innovation

openSUSE offers two main distributions: Leap and Tumbleweed. Leap provides a stable, fixed-release cycle suitable for enterprise use, while Tumbleweed offers a rolling release model for those who want continuous updates.

openSUSE uses the Zypper package manager, which is known for its speed and efficiency. Zypper’s powerful command-line interface and integration with YaST (Yet another Setup Tool) provide a versatile and user-friendly package management experience. This makes openSUSE an appealing choice for users who value both stability and the ability to experiment with new software.

Performance and Resource Efficiency

As hardware ages or users seek to maximize performance on their systems, the efficiency of their operating system becomes a critical factor. Some users migrate from Ubuntu to distributions that offer lighter, faster experiences, especially on older hardware.

Linux Mint: A Traditional Desktop Experience

Linux Mint, based on Ubuntu, is designed to provide a more traditional desktop experience. It offers several desktop environments, including Cinnamon, MATE, and Xfce, each optimized for performance and ease of use. Linux Mint’s focus on a familiar interface and efficient resource usage makes it a popular choice for users who want a fast and responsive system, especially on older or less powerful hardware.

The distribution’s emphasis on out-of-the-box usability, with codecs, drivers, and essential software pre-installed, ensures a smooth transition for users moving from Ubuntu. This makes Linux Mint an attractive option for those who appreciate the stability and compatibility of Ubuntu but desire a more refined and efficient desktop experience.

Manjaro: The User-Friendly Arch Alternative

Manjaro is an Arch-based distribution that aims to provide the power and flexibility of Arch Linux with a user-friendly interface and simplified installation process. It offers several desktop environments, including Xfce, KDE, and GNOME, each tailored to provide a smooth and efficient user experience.

Manjaro’s rolling release model ensures that users always have access to the latest software and features without needing to perform major version upgrades. This continuous update cycle, combined with Manjaro’s focus on ease of use and performance optimization, makes it an appealing choice for users who want a fast and up-to-date system.

Pop!_OS: A Distro for Power Users

Pop!_OS, developed by System76, is designed with power users in mind. It is based on Ubuntu but features a number of enhancements aimed at improving productivity and performance. Pop!_OS includes tiling window management out of the box, making it easier for users to manage multiple windows and workspaces efficiently.

Additionally, Pop!_OS offers specialized versions for different hardware, including a version optimized for Nvidia graphics cards. This focus on hardware compatibility and performance optimization makes Pop!_OS a great choice for users who need a high-performance system for tasks like gaming, development, and content creation.

Rolling Release vs. Fixed Release

The release model of a Linux distribution significantly impacts its update cycle, stability, and user experience. While Ubuntu follows a fixed release model with long-term support (LTS) versions, some users prefer the continuous updates provided by rolling release distributions.

Rolling Release: Arch and Manjaro

Rolling release distributions like Arch Linux and Manjaro continuously update software packages and system components. This model ensures that users always have the latest features, bug fixes, and security updates without needing to perform major upgrades.

For users who prioritize having the most up-to-date software and enjoy experimenting with new features, a rolling release distribution can be an exciting and rewarding choice. However, it also requires a willingness to deal with potential instability and the need for regular maintenance to keep the system running smoothly.

Fixed Release: Debian and CentOS

Fixed release distributions like Debian and CentOS provide stability and long-term support, making them ideal for enterprise environments and users who prioritize reliability over the latest features. These distributions release major updates on a predictable schedule, ensuring a stable and consistent experience.

Debian, the upstream source for Ubuntu, offers a robust and stable environment with a vast repository of software packages. CentOS, derived from Red Hat Enterprise Linux, provides enterprise-level stability and support, making it a popular choice for servers and production environments.

Specific Use Cases and Preferences

Different Linux distributions cater to specific use cases and user preferences, offering specialized tools and environments for various tasks.

Kali Linux: The Security Professional’s Toolkit

Kali Linux, developed by Offensive Security, is designed for penetration testing and security research. It comes pre-installed with a comprehensive suite of security tools, making it a preferred choice for cybersecurity professionals and enthusiasts.

Kali Linux’s focus on security and ethical hacking distinguishes it from general-purpose distributions like Ubuntu. Users who require a specialized environment for penetration testing and vulnerability assessment will find Kali Linux an indispensable tool.

Elementary OS: A Beautiful and Intuitive Experience

Elementary OS is renowned for its elegant and intuitive design, inspired by macOS. It offers a cohesive and visually appealing user interface, with a focus on simplicity and ease of use. Elementary OS’s Pantheon desktop environment provides a clean and minimalist experience, making it an attractive option for users who value aesthetics and usability.

For users transitioning from macOS or those who appreciate a polished and consistent user interface, Elementary OS offers a refreshing alternative to Ubuntu’s GNOME desktop environment.

Philosophical and Ethical Reasons

Some users migrate to different Linux distributions based on philosophical and ethical considerations, seeking systems that align with their values regarding software freedom and open-source principles.

Trisquel: Embracing Software Freedom

Trisquel is a fully free software distribution that adheres strictly to the Free Software Foundation’s guidelines. It includes only free software, avoiding proprietary drivers and non-free firmware. This commitment to software freedom appeals to users who prioritize ethical considerations and want to support the principles of the free software movement.

For users who believe in the importance of software freedom and want to use a system that aligns with their values, Trisquel offers a compelling alternative to Ubuntu.

System Init Choices

The choice of init system can be a significant factor for some users, influencing system performance, complexity, and compatibility. While Ubuntu uses systemd, some users prefer alternatives that offer different features or philosophies.

Void Linux: A Different Approach with Runit

Void Linux uses runit as its init system instead of systemd. Runit is known for its simplicity, speed, and reliability, offering a straightforward approach to service management. Void Linux’s use of runit appeals to users who prefer a minimal and efficient init system and want to avoid the complexity associated with systemd.

For users who value simplicity and efficiency in their system initialization process, Void Linux provides a refreshing alternative to the systemd-based approach of Ubuntu.

Learning and Experimentation

The Linux ecosystem’s diversity provides a rich playground for learning and experimentation. Many users migrate from Ubuntu to

other distributions simply to expand their knowledge and experience with different systems.

Exploring the Linux Landscape

Trying out different distributions can be an educational journey, helping users understand the strengths and weaknesses of various systems and gain a broader perspective on the Linux ecosystem. Whether it’s experimenting with different desktop environments, package managers, or system architectures, migrating to a new distribution can be a valuable learning experience.

Gaining Specialized Skills

By using distributions tailored for specific tasks, such as security testing with Kali Linux or software development with Fedora, users can develop specialized skills and expertise. This hands-on experience can be particularly valuable for professionals looking to deepen their knowledge in certain areas or prepare for specific career paths.

Community and Support

The community and support structure of a Linux distribution can significantly impact the user experience. Different distributions foster unique communities, each with its own culture, communication style, and resources.

Finding the Right Fit

Some users migrate from Ubuntu to find a community that better fits their preferences for communication, support, and collaboration. Whether it’s the vibrant and active Arch Linux community, the welcoming and user-focused Linux Mint forums, or the professional and enterprise-oriented Fedora Project, each distribution offers a distinct community experience.

Contributing and Giving Back

Users who are passionate about contributing to open-source projects may find opportunities to get involved in different ways within various communities. Whether it’s contributing code, writing documentation, or providing support to other users, engaging with a new distribution can offer fresh opportunities to give back to the community.

Conclusion

Migrating from Ubuntu to another Linux distribution is a personal journey driven by a variety of factors. Whether it’s the desire for more control and customization, the need for different package management systems, the quest for performance and resource efficiency, or philosophical and ethical considerations, each user has unique reasons for exploring new horizons.

The Linux ecosystem’s diversity is one of its greatest strengths, offering a plethora of options to suit every need and preference. By experimenting with different distributions, users can find the perfect fit for their requirements and continue to enjoy the freedom and flexibility that Linux provides.

As you embark on your own journey of exploration and discovery, remember that the ultimate goal is to find a system that empowers you and enhances your computing experience.

The post Exploring New Horizons: Why Some Ubuntu Users Migrate to Other Linux Distributions appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the world of Linux distributions, two popular options stand out with distinct approaches to software releases: Ubuntu and Arch Linux. While both offer robust and feature-rich operating systems, their release models differ significantly, catering to the needs of various user communities.

Ubuntu: Predictable and Stable Releases

Ubuntu, developed by Canonical, follows a time-based release model, with new versions arriving every six months. This model provides users with a predictable and stable release schedule, making it easier for both individuals and organizations to plan their system upgrades and deployments.

Each Ubuntu release is supported for 9 months for the standard editions and 5 years for the Long-Term Support (LTS) editions. The LTS releases, occurring every two years, are particularly popular among enterprise users and those who value long-term stability and support.

The release cycle for Ubuntu is as follows:

• New versions are released in April and October each year.
• LTS releases are published in April, with the next LTS release coming two years later.
• Security and critical bug fixes are provided for the supported release versions.

This predictable and controlled release model ensures that Ubuntu users can plan their system upgrades and enjoy a reliable and consistent experience across multiple versions.

Arch Linux: Rolling Release and Bleeding Edge

In contrast, Arch Linux follows a rolling release model, where the distribution is continually updated, rather than releasing new versions at fixed intervals. This approach allows Arch users to always have the latest software packages and security updates, without the need to perform a full system upgrade.

The Arch Linux release model is often described as “bleeding edge,” as it provides users with the most up-to-date software versions as soon as they are available upstream. This appeals to users who value the latest features and improvements, and are comfortable with the potential for occasional instability or the need to manually handle system upgrades.

Arch Linux does not have a formal release schedule or a predetermined support timeline. Instead, the distribution is continuously updated through the pacman package manager, which allows users to keep their systems up-to-date on a daily or even hourly basis.

This rolling release model offers Arch Linux users the flexibility to customize their systems and stay on the cutting edge of software development. However, it also requires a higher degree of technical expertise and user involvement, as users are responsible for managing system upgrades and resolving any potential compatibility issues.

Key Differences

1. Release Cycle: Ubuntu follows a predictable six-month release cycle, while Arch Linux uses a rolling release model with continuous updates.
2. Stability: Ubuntu LTS releases prioritize long-term stability and reliability, making them a popular choice for enterprise environments and users who value consistency. Arch Linux, on the other hand, is often considered more bleeding edge and may experience occasional instability.
3. Software Versions: Arch Linux users always have access to the latest software versions, while Ubuntu’s releases are more conservative, focusing on stability over the latest features.
4. User Involvement: Arch Linux requires a higher level of user involvement, as users are responsible for managing system upgrades and resolving any potential issues. Ubuntu’s release model is more user-friendly, with Canonical handling the majority of the maintenance and upgrade processes.
5. Target Audience: Ubuntu caters to a broader user base, including beginners and those who value ease of use, while Arch Linux appeals more to experienced Linux users who prefer a high degree of control and customization.

In summary, the choice between Ubuntu and Arch Linux largely depends on the user’s priorities, technical expertise, and preferred level of control over their operating system. Ubuntu’s predictable release cycle and focus on stability make it a popular choice for mainstream users and enterprise environments, while Arch Linux’s rolling release model and bleeding-edge software attract experienced Linux enthusiasts who value the latest features and a high degree of customization.

The post Ubuntu vs Arch Linux: A Comparison of Release Models appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Unveiling BlackArch

BlackArch shares its roots with Arch Linux, renowned for its simplicity, versatility, and DIY ethos. However, BlackArch pivots its focus squarely towards security, crafting a specialized environment tailored for penetration testing endeavors. Unlike its counterparts like Kali Linux and Parrot OS, BlackArch distinguishes itself by its Arch Linux underpinnings, offering a unique flavor for security enthusiasts.

Installation and Interface

The installation process of BlackArch mirrors that of Arch Linux, ensuring a streamlined experience for seasoned Linux users. Users have the option to either deploy BlackArch as a standalone distribution or integrate it seamlessly as an extension to an existing Arch Linux setup. The slim ISO provides the Xfce desktop environment, while the full ISO offers a plethora of preconfigured window managers, catering to diverse user preferences.

A Cornucopia of Tools

What truly sets BlackArch apart is its expansive arsenal of security tools meticulously curated to address a myriad of cybersecurity challenges. From vulnerability assessment to network reconnaissance, BlackArch encompasses tools spanning various domains, ensuring comprehensive coverage for penetration testing endeavors. The repository boasts tools categorized across a spectrum of functionalities, enabling users to navigate and harness the appropriate tools with ease.

Diving into the Toolbox

Delving deeper, one encounters a rich tapestry of tool categories within BlackArch, each catering to distinct facets of cybersecurity assessment and exploitation. Whether it’s automating tasks, cracking passwords, analyzing firmware, or probing wireless networks, BlackArch provides a dedicated toolkit for every conceivable scenario. Notably, the repository is continuously evolving, with cybersecurity specialists and researchers diligently adding new tools and updates to bolster the platform’s efficacy.

Conclusion: Empowering the Cyber Guardians

In an era dominated by digital threats and vulnerabilities, BlackArch emerges as a beacon of resilience, equipping cybersecurity practitioners with the requisite instruments to navigate the labyrinth of modern-day security challenges. Its commitment to open-source principles fosters a collaborative ecosystem where knowledge proliferates, and defenses are fortified. As we traverse the digital landscape fraught with perils, BlackArch stands as a testament to the indomitable spirit of innovation driving the cybersecurity community forward.

In essence, BlackArch isn’t just a distribution; it’s a testament to the relentless pursuit of security excellence, empowering users to safeguard digital domains and preserve the integrity of the digital realm. With BlackArch at their disposal, cyber guardians stand poised to confront adversities head-on, ensuring a safer and more resilient digital future for all.

The post Exploring BlackArch: The Penetration Tester’s Arsenal appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

It has innovative design that allows maximum user customization with three banks of F keys for fast mode switching.

User can also use it as a CW keyboard keyer and set their preferable CW speed.

eepKeyer was developer by Mike K6EEP. Try it today, source code available here http://www.hamsoftware.org/

The post eepKeyer – Amateur Radio Contest CW Keyer For Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Demonstration of CW keying and radio control using cqrlog and rutblaster interface.

rutblaster supports cw, ssb and digital operation. radio control using CAT and DATA port. brewed by weerut 9w2rut.

cqrlog uses hamlib to control transceiver, cwdaemon for cw keying and fldigi for digital operation.

you can install cqrlog and hamlib on any linux distro you like. 100% free opensource software.

• http://www.cqrlog.com
• http://sourceforge.net/apps/mediawiki/hamlib/index.php?title=Main_Page
• http://sourceforge.net/projects/cwdaemon/
• http://www.w1hkj.com/Fldigi.html

The post Yaesu FT857D, CQRLOG and RUTBlaster on Debian Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Linux is new anymore, there are many custom Linux operating system that was designed for ham radio operators. Here are the list of famous Linux operating system for ham radio usage

1. KB1OIQ – Andy’s Ham Radio Linux DVD – This is a remastered version of Ubuntu Linux. As of version 13, there are 32-bit and 64-bit versions available.

2. hamOS – A Debian based Live and Installable operating system for radio amateurs.
hamOS contains many preinstalled ham radio applications as well as a
custom menu. This respin is geared toward the newer linux user. hamOS
uses the lightweight LXDE desktop environment and is therefore suitable
for older hardware.
Check out the GetExtras folder on the desktop to run some custom
scripts that will automatically grab flash, codecs, and other non-libre
software.

3. Ar-knoppix

4. Harv’s Hamshack Hack

5.  Digipup – based on puppylinux (lightweight linux distribution)

6. Shackbox – Shackbox provide linux AND windows software like the famous ham radio
deluxe, trunking software and a lot of other software related to
electronics, antenna design and else.

7.  Hamux – CentOS based repository with ham radio software.

However, you can choose any linux distro you like and install any ham radio applications that you desired. Since linux is opensource operating system, you can hack the source to suit your taste. Google, Yahoo also powered by linux operating system and small hardware such as switch, routers, acces point also powered by linux nowadays. Most of websites running on linux webservers. Happy Hamlinux-ing!

The post List Of Linux Operating System For Ham Radio Operator appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

1. add this to /etc/fstab, cache-chromium /home/your_user/.cache/chromium tmpfs defaults,noatime,mode=1777 0 0
2. then rm -r /home/your_user/.cache/chromium (to delete everything you had cached)
3. and mkdir /home/your_user/.cache/chromium (to create an empty directory).

After reboot, the cache will be mounted in ram and you won’t need to modify the launcher.

Why dont use ramfs ?

Primarily both ramfs and tmpfs does the same thing with few minor differences.

Ramfs will grow dynamically.  So, you need control the process that writes the data to make sure ramfs doesn’t go above the available RAM size in the system. Let us say you have 2GB of RAM on your system and created a 1 GB ramfs and mounted as /tmp/ram. When the total size of the /tmp/ram crosses 1GB, you can still write data to it.  System will not stop you from writing data more than 1GB. However, when it goes above total RAM size of 2GB, the system may hang, as there is no place in the RAM to keep the data.

Tmpfs will not grow dynamically. It would not allow you to write more than the size you’ve specified while mounting the tmpfs. So, you don’t need to worry about controlling the process that writes the data to make sure tmpfs doesn’t go above the specified limit. It may give errors similar to “No space left on device”.

Tmpfs uses swap.

Ramfs does not use swap.

The post Using TMPFS For Chromium Browser appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.