1.1 What Is Linux

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

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

1.2 What Is FreeBSD

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

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

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

2. Technical Components Compared

3. Factors That Affect Desktop Use

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

3.1 Hardware Support for Consumer Devices

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

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

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

3.2 Application Ecosystem

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

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

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

3.3 Desktop Environments

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

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

3.4 Release and Update Model

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

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

4. Factors That Affect Server Use

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

4.1 Base System Consistency

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

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

4.2 ZFS Integration

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

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

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

4.3 Networking Stack and Firewall

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

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

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

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

4.4 Jails

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

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

4.5 Long Term Support

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

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

4.6 License Considerations

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

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

5. Deployment Statistics

Public data shows usage patterns.

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

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

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

6. Summary of Differences

7. Conclusion

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

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

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

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

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

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

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

What is OpenRocket?

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

Key Features

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

Perfect for Classrooms and Competitions

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

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

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

Cross-Platform and Easy to Use

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

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

Join a Global Community

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

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

Ready for Liftoff?

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

Design. Simulate. Launch. Learn. Repeat.

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

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

If you’ve ever wanted to dive into the world of digital electronics, whether as a student, educator, engineer, or hobbyist, you’re going to love this tool: Digital — a powerful, free, and open-source logic circuit simulator created by Helmut Neemann. Available on GitHub at hneemann/Digital, this Java-based application combines clarity, flexibility, and educational value in one sleek package.

What Is Digital?

Digital is a logic circuit simulator designed with a clear goal: to make the teaching, learning, and development of digital logic intuitive and visual. It lets you create, simulate, and analyze logic circuits ranging from basic gates to complex CPUs — all with a drag-and-drop interface and real-time simulation.

Unlike other bloated EDA software, Digital is refreshingly simple, elegant, and lightweight. But don’t let its simplicity fool you — it’s capable of simulating complex architectures with clocked components, finite state machines, memory modules, and even custom microprocessors.

Key Features

• Intuitive Interface
  Drag and drop components onto your canvas, connect wires, and see how your circuit behaves in real-time.
• Real-Time Simulation
  Changes are reflected immediately, with live logic levels and animations that bring your circuits to life.
• Modular Design
  Use subcircuits and hierarchical design to keep things organized, even in large-scale projects.
• Clocked Components
  Simulate registers, flip-flops, RAM, and sequential logic effortlessly.
• Built-in CPU & Assembler
  Digital includes a simple, yet powerful CPU with its own instruction set and assembler — ideal for teaching computer architecture.
• Made for Education
  Widely used in universities and schools. Perfect for explaining logic gates, truth tables, FSMs, and microprocessor fundamentals.
• Cross-platform (Java-based)
  Works on Windows, macOS, and Linux. Just download and run!
• Open Source (GPL-3.0 License)
  Actively maintained and completely free. Fork it, contribute, or adapt it to your own projects.

Who Is It For?

• Students: Learn digital logic step by step with instant feedback.
• Educators: Use it in the classroom to teach logic circuits and CPU architecture interactively.
• Makers & Hobbyists: Build and test your own logic-based inventions.
• Researchers & Developers: Prototype logic systems before implementing them in hardware.

Whether you’re building an ALU, a traffic light controller, or your own 8-bit CPU, Digital gives you the tools to simulate it with precision.

Get Started in Minutes

1. Head over to the Digital GitHub repository.
2. Download the latest release (JAR file).
3. Run it using Java (Java 8 or higher required).
4. Start building your first circuit with just a few clicks.

No complex installations. No licenses. No fees. Just pure learning and tinkering joy.

Final Thoughts

In a world of expensive and overly complex simulation tools, Digital shines as a free, open-source, and educator-friendly alternative. It’s ideal for classrooms, home labs, and anyone curious about what happens beneath the silicon.

So if you’re ready to master digital logic — from basic gates to building your own CPU — it’s time to download Digital and start creating.

Explore. Simulate. Learn. With Digital.

The post Digital – Design, Simulate, and Understand Logic Circuits Like Never Before appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

What is FlightGear?

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

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

Realism that Soars

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

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

Cross-Platform Freedom

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

For Developers and Tinkerers

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

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

Community-Driven Excellence

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

How to Get Started

Getting airborne is easy:

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

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

Final Thoughts

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

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

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

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

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

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

What is Oh My BASH?

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

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

Origin and History

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

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

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

Purpose of Oh My BASH

The primary goal of Oh My BASH is to:

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

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

Advantages of Oh My BASH

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

1. Theming and Aesthetics

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

2. Modular Configuration

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

3. Plugin Support

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

4. Predefined Aliases and Functions

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

5. Community-Driven

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

6. Easy Installation and Reset

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

Disadvantages of Oh My BASH

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

1. Slower Shell Startup

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

2. Less Active than Oh My Zsh

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

3. Plugin Limitations

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

4. Not Meant for Minimalists

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

Who Should Use Oh My BASH?

Oh My BASH is ideal for:

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

However, it may not be the best fit for:

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

Getting Started with Oh My BASH

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

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

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

Example:

OSH_THEME="font"

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

Tips and Tricks

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

Final Thoughts

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

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

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

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

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

What is Plank?

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

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

Key Features

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

How to Install Plank on Debian/Ubuntu

To install Plank on Debian-based distributions:

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

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

Customization with Themes

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

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

Final Thoughts

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

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

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

What Is OpenRA?

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

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

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

Latest Features and Updates

The March 2025 release brought significant enhancements:

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

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

Installation on Linux

Installing OpenRA on Linux is straightforward:

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

Alternatively, you can install OpenRA via:

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

These methods ensure that OpenRA integrates smoothly with your system.

Why Choose OpenRA?

OpenRA stands out in the Linux gaming landscape due to:

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

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

See OpenRA in Action

For a visual overview, check out this review:

Other Notable Strategy Games for Linux

If you’re exploring more strategy titles, consider:

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

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

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

The post Rediscover Classic RTS with OpenRA on Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Are you looking to learn more about servers but don’t know where to start? Ubuntu Server provides the perfect foundation for beginners and experienced users alike. With its reliability, security features, and extensive community support, Ubuntu Server makes it easy to create useful projects that enhance your home network or provide valuable skills for your career.

In this guide, I’ll walk you through 10 practical projects that anyone can set up using Ubuntu Server. Each project requires minimal hardware and provides real-world benefits. Let’s get started!

1. Network-Attached Storage (NAS) Server

What it is: A centralized location to store and access your files from any device on your network.

Why Ubuntu Server is perfect: Ubuntu’s stability ensures your data remains safe, while its lightweight nature means even older hardware can serve as a reliable NAS.

Setup overview:

1. Install Ubuntu Server on your hardware
2. Install and configure Samba for file sharing:

sudo apt update
sudo apt install samba -y

3. Create a directory for your shared files:

sudo mkdir -p /media/nas
sudo chmod 777 /media/nas

4. Configure Samba by editing its configuration file:

sudo nano /etc/samba/smb.conf

5. Add the following at the end of the file:

[NASShare]
path = /media/nas
browseable = yes
read only = no
force create mode = 0660
force directory mode = 2770
valid users = @users

6. Set a Samba password for your user:

sudo smbpasswd -a yourusername

7. Restart Samba:

sudo systemctl restart smbd

Benefits: Access your files from any device, centralize your backups, and stream media throughout your home.

2. Personal Cloud Storage (NextCloud)

What it is: Your own personal cloud storage solution similar to Dropbox or Google Drive but hosted on your own hardware.

Why Ubuntu Server is perfect: Ubuntu’s package management makes installing dependencies straightforward, while LTS releases ensure long-term stability.

Setup overview:

1. Install LAMP stack:

sudo apt update
sudo apt install apache2 mariadb-server libapache2-mod-php php-gd php-json php-mysql php-curl php-mbstring php-intl php-imagick php-xml php-zip -y

2. Secure your MariaDB installation:

sudo mysql_secure_installation

3. Create a database:

sudo mysql -u root -p
CREATE DATABASE nextcloud;
CREATE USER 'nextclouduser'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON nextcloud.* TO 'nextclouduser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

4. Download and install NextCloud:

cd /tmp
wget https://download.nextcloud.com/server/releases/latest.zip
unzip latest.zip
sudo mv nextcloud /var/www/html/
sudo chown -R www-data:www-data /var/www/html/nextcloud/

5. Configure Apache:

sudo nano /etc/apache2/sites-available/nextcloud.conf

6. Add the following configuration:

<VirtualHost *:80>
    DocumentRoot /var/www/html/nextcloud/
    ServerName your_domain_or_IP

    <Directory /var/www/html/nextcloud/>
        Options +FollowSymlinks
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

7. Enable the site and required modules:

sudo a2ensite nextcloud.conf
sudo a2enmod rewrite headers env dir mime
sudo systemctl restart apache2

8. Access NextCloud through your browser at http://your_server_IP_or_domain and complete the setup wizard.

Benefits: Maintain control over your data, avoid subscription fees, and get unlimited storage based on your hardware.

3. Media Server with Plex

What it is: A powerful media server that organizes your movies, TV shows, music, and photos, making them accessible from anywhere.

Why Ubuntu Server is perfect: Ubuntu’s efficiency means more resources are available for transcoding media, and its compatibility with Plex is excellent.

Setup overview:

1. Add the Plex repository:

sudo apt update
sudo apt install apt-transport-https curl -y
curl https://downloads.plex.tv/plex-keys/PlexSign.key | sudo apt-key add -
echo deb https://downloads.plex.tv/repo/deb public main | sudo tee /etc/apt/sources.list.d/plexmediaserver.list

2. Install Plex Media Server:

sudo apt update
sudo apt install plexmediaserver -y

3. Create directories for your media:

sudo mkdir -p /opt/plexmedia/{movies,tv,music,photos}
sudo chown -R plex:plex /opt/plexmedia

4. Access the Plex web interface at http://your_server_IP:32400/web and follow the setup wizard
5. Add your media libraries pointing to the directories you created

Benefits: Stream your media collection to any device, automatic metadata fetching, and smart organization of your content.

4. Home Automation Server with Home Assistant

What it is: A central hub to control and automate your smart home devices.

Why Ubuntu Server is perfect: Ubuntu’s reliability ensures your home automation stays running, while its hardware compatibility supports various IoT devices.

Setup overview:

1. Install Docker (the easiest way to run Home Assistant):

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce -y

2. Install Docker Compose:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

3. Create a Docker Compose file:

mkdir ~/homeassistant
cd ~/homeassistant
nano docker-compose.yml

4. Add the following content:

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    volumes:
      - ./config:/config
    environment:
      - TZ=YOUR_TIME_ZONE
    restart: always
    network_mode: host

5. Start Home Assistant:

sudo docker-compose up -d

6. Access Home Assistant through your browser at http://your_server_IP:8123

Benefits: Centralized control of all smart devices, powerful automation capabilities, and reduced dependence on cloud services.

5. Personal VPN Server with WireGuard

What it is: Your own VPN server that allows secure remote access to your home network and protects your privacy when using public Wi-Fi.

Why Ubuntu Server is perfect: Ubuntu’s security focus makes it ideal for VPN services, and recent kernels include built-in WireGuard support.

Setup overview:

1. Install WireGuard:

sudo apt update
sudo apt install wireguard -y

2. Generate private and public keys:

wg genkey | sudo tee /etc/wireguard/private.key
sudo chmod 600 /etc/wireguard/private.key
sudo cat /etc/wireguard/private.key | wg pubkey | sudo tee /etc/wireguard/public.key

3. Create a WireGuard configuration:

sudo nano /etc/wireguard/wg0.conf

4. Add the following (substituting your own values):

[Interface]
PrivateKey = YOUR_SERVER_PRIVATE_KEY
Address = 10.0.0.1/24
ListenPort = 51820
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

# Client configuration example
[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32

5. Enable IP forwarding:

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

6. Start and enable the WireGuard service:

sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

7. Generate configurations for your clients and distribute them securely

Benefits: Secure remote access to your home network, enhanced privacy on public networks, and better control over your internet connection.

6. Web Server for Hosting Your Own Website

What it is: A server to host your personal website, blog, or web application.

Why Ubuntu Server is perfect: Ubuntu’s robust LAMP stack support makes it the go-to choice for web hosting environments.

Setup overview:

1. Install LAMP stack:

sudo apt update
sudo apt install apache2 mariadb-server php libapache2-mod-php php-mysql -y

2. Secure MariaDB:

sudo mysql_secure_installation

3. Create a website directory:

sudo mkdir -p /var/www/yourwebsite
sudo chown -R $USER:$USER /var/www/yourwebsite

4. Create a simple index.php file:

echo '<?php phpinfo(); ?>' > /var/www/yourwebsite/index.php

5. Configure Apache virtual host:

sudo nano /etc/apache2/sites-available/yourwebsite.conf

6. Add the following configuration:

<VirtualHost *:80>
    ServerName yourwebsite.local
    ServerAlias www.yourwebsite.local
    DocumentRoot /var/www/yourwebsite
    ErrorLog ${APACHE_LOG_DIR}/yourwebsite_error.log
    CustomLog ${APACHE_LOG_DIR}/yourwebsite_access.log combined
</VirtualHost>

7. Enable the site and restart Apache:

sudo a2ensite yourwebsite.conf
sudo systemctl restart apache2

Benefits: Full control over your web presence, no monthly hosting fees, and valuable skills for web development.

7. Pi-hole Ad Blocker

What it is: A network-wide ad blocker that improves browsing speed and privacy by blocking ads at the DNS level.

Why Ubuntu Server is perfect: Ubuntu’s efficiency means Pi-hole can run alongside other services without issues, making it a perfect addition to any home server.

Setup overview:

1. Install required packages:

sudo apt update
sudo apt install curl -y

2. Run the Pi-hole installer:

curl -sSL https://install.pi-hole.net | bash

3. Follow the on-screen instructions (accept most defaults)
4. Note your admin password at the end of installation
5. Configure your router to use your Ubuntu Server as the DNS server, or configure individual devices
6. Access the Pi-hole admin interface at http://your_server_IP/admin

Benefits: Faster browsing, reduced bandwidth usage, enhanced privacy, and protection from malicious domains.

8. Git Server with Gitea

What it is: A lightweight, self-hosted Git service similar to GitHub but running on your own hardware.

Why Ubuntu Server is perfect: Ubuntu’s package management and system resource efficiency make it ideal for hosting developer tools like Git services.

Setup overview:

1. Install required packages:

sudo apt update
sudo apt install git curl sqlite3 -y

2. Create a user for Gitea:

sudo adduser --system --group --disabled-password --shell /bin/bash --home /home/git git

3. Download and install Gitea:

VERSION=$(curl -s https://api.github.com/repos/go-gitea/gitea/releases/latest | grep tag_name | cut -d '"' -f 4)
sudo wget -O /tmp/gitea https://dl.gitea.io/gitea/${VERSION}/gitea-${VERSION}-linux-amd64
sudo chmod +x /tmp/gitea
sudo mv /tmp/gitea /usr/local/bin/gitea

4. Create required directories:

sudo mkdir -p /var/lib/gitea/{custom,data,log}
sudo chown -R git:git /var/lib/gitea
sudo chmod -R 750 /var/lib/gitea
sudo mkdir /etc/gitea
sudo chown root:git /etc/gitea
sudo chmod 770 /etc/gitea

5. Create a systemd service:

sudo nano /etc/systemd/system/gitea.service

6. Add the following content:

[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea
ExecStart=/usr/local/bin/gitea web --config /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target

7. Start and enable Gitea:

sudo systemctl daemon-reload
sudo systemctl enable --now gitea

8. Access Gitea through your browser at http://your_server_IP:3000 and complete the initial setup

Benefits: Full control over your code repositories, no limitations on private repositories, and integrated issue tracking.

9. Game Server Host

What it is: A dedicated server for hosting multiplayer games like Minecraft, Terraria, or Counter-Strike.

Why Ubuntu Server is perfect: Ubuntu’s stability and resource efficiency allow game servers to run smoothly and consistently, even on modest hardware.

Setup overview for Minecraft Server:

1. Install required packages:

sudo apt update
sudo apt install openjdk-17-jre-headless screen -y

2. Create a minecraft user:

sudo adduser --system --home /opt/minecraft-server minecraft
sudo addgroup --system minecraft
sudo adduser minecraft minecraft

3. Switch to the minecraft user:

sudo su - minecraft

4. Download the Minecraft server:

mkdir -p ~/server
cd ~/server
wget https://piston-data.mojang.com/v1/objects/8f3112a1049751cc472ec13e397eade5336ca7ae/server.jar -O minecraft_server.jar

5. Accept the EULA:

echo "eula=true" > eula.txt

6. Create a start script:

echo '#!/bin/sh
cd /opt/minecraft-server/server
java -Xmx2G -Xms1G -jar minecraft_server.jar nogui' > start.sh
chmod +x start.sh

7. Exit the minecraft user and create a systemd service:

exit
sudo nano /etc/systemd/system/minecraft.service

8. Add the following content:

[Unit]
Description=Minecraft Server
After=network.target

[Service]
User=minecraft
Nice=5
KillMode=none
SuccessExitStatus=0 1
InaccessibleDirectories=/root /sys /srv /media -/lost+found
NoNewPrivileges=true
WorkingDirectory=/opt/minecraft-server/server
ReadWriteDirectories=/opt/minecraft-server/server
ExecStart=/opt/minecraft-server/server/start.sh
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "say SERVER SHUTTING DOWN IN 10 SECONDS. SAVING ALL MAPS..."\015'
ExecStop=/bin/sleep 10
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "save-all"\015'
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "stop"\015'

[Install]
WantedBy=multi-user.target

9. Enable and start the service:

sudo systemctl enable minecraft.service
sudo systemctl start minecraft.service

Benefits: Host your favorite games with friends without subscription fees, customize server settings, and install mods freely.

10. Docker Host for Containerized Applications

What it is: A platform for running containerized applications, making it easy to deploy and manage various services.

Why Ubuntu Server is perfect: Ubuntu has excellent Docker support, regular updates, and a well-maintained Docker repository.

Setup overview:

1. Install Docker:

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce -y

2. Install Docker Compose:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

3. Add your user to the Docker group (to avoid using sudo with Docker commands):

sudo usermod -aG docker $USER

4. Log out and back in for the changes to take effect
5. Test Docker:

docker run hello-world

6. Create a sample Docker Compose project:

mkdir ~/docker-test
cd ~/docker-test
nano docker-compose.yml

7. Add the following content for a simple web server:

version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: always

8. Create a test HTML file:

mkdir -p html
echo "<html><body><h1>My Docker Container is Working!</h1></body></html>" > html/index.html

9. Start the container:

docker-compose up -d

10. Access your test site at http://your_server_IP:8080

Benefits: Easily deploy complex applications, maintain isolated environments, and simplify updates and maintenance.

Why Ubuntu Server is the Perfect Choice

Throughout these projects, Ubuntu Server demonstrates its incredible versatility and power. Here’s why Ubuntu Server stands out from other options:

1. Stability: Ubuntu Server LTS releases are supported for 5 years, ensuring long-term reliability
2. Security: Regular security updates keep your server and data protected
3. Huge Community: Extensive documentation and community support make troubleshooting easy
4. Package Management: The APT package system simplifies software installation and updates
5. Resource Efficiency: Works well even on older or limited hardware
6. No License Fees: Completely free to use, even in commercial environments
7. Regular Updates: Stay current with the latest technologies and improvements

Getting Started with Ubuntu Server

Ready to begin? Here’s how to get started:

1. Download Ubuntu Server from ubuntu.com/download/server
2. Install it on your preferred hardware (old PC, Raspberry Pi, or virtual machine)
3. Choose one of the projects above and follow the step-by-step instructions
4. Join the Ubuntu community for support and to share your experiences

Remember, these projects are just the beginning. As you become more comfortable with Ubuntu Server, you’ll discover countless more possibilities for creating valuable services for your home or small business.

Have you built any interesting projects with Ubuntu Server? Share your experiences in the comments below!

This guide was created to help newcomers explore the capabilities of Ubuntu Server. For enterprise environments, consider Ubuntu’s commercial support options.

The post 10 Simple and Useful Projects Anyone Can Build with Ubuntu Server appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

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

What is Swap?

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

The Origin of Swap

Swap originated in the early days of computing, when:

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

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

Why You Might Still Need Swap Today

Even with modern hardware, swap still has roles:

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

Why You Might Not Need Swap

On the other hand:

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

Swap Partition

Advantages

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

Disadvantages

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

Swap File

Advantages

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

Disadvantages

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

Performance Considerations

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

When to Use What?

Use a Swap Partition if:

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

Use a Swap File if:

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

Bonus: zram and zswap

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

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

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

Conclusion

Swap is not dead—it’s evolved.

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

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

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

TL;DR

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

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

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

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

Origin and History

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

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

Timeline of Events:

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

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

Why the Switch? Goobuntu vs. gLinux

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

1. More Predictable Upgrade Path

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

2. Greater Flexibility and Control

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

3. Security and Compliance

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

4. Alignment with Upstream Open Source

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

How gLinux Works Internally

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

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

Advantages of gLinux

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

Enhanced Security

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

Faster and Flexible Updates

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

Optimized Developer Experience

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

Modular and Customizable

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

Open Source Friendly

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

Usage and Deployment

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

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

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

Is gLinux Available to the Public?

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

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

Conclusion

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

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

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

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

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

System Monitoring & Performance

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

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

Filesystem & Disk Usage

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

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

User & Permission Management

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

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

Networking

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

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

Security & Access Control

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

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

Package Management

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

Debian/Ubuntu

• apt, dpkg, apt-cache

RedHat/CentOS

• yum, dnf, rpm

Arch Linux

• pacman

Universal

• snap, flatpak

Examples:

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

System Maintenance & Logs

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

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

Backup & Automation

Protect data and automate your tasks for efficiency.

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

Bonus Tools & Utilities

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

Final Thoughts

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

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

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

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

The process begins the moment you press the power button.

BIOS (Legacy Systems)

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

UEFI (Modern Systems)

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

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

Stage 2: Bootloader – The Linux Gatekeeper

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

Common Bootloaders:

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

The bootloader:

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

Example of GRUB config:

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

Stage 3: Kernel Initialization – The Heart of Linux

Now, the Linux kernel takes control.

What the Kernel Does:

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

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

Stage 4: Init System – Orchestrating the System Startup

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

Common Init Systems:

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

If using systemd, it:

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

You can inspect boot performance using:

systemd-analyze

Stage 5: Login Prompt – Ready for Action

Once all services are up and running:

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

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

Visual Summary of the Linux Boot Flow

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

Bonus: Useful Commands to Explore Boot

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

Final Thoughts

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

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

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

Does your home or office internet feel sluggish, especially when multiple people are browsing? You might be surprised to learn that you can significantly improve your network’s performance by setting up a caching proxy server. In this guide, I’ll walk you through the process step-by-step.

What is a Caching Proxy Server?

A caching proxy server sits between your local network devices and the internet. It stores copies of resources (like web pages, images, and videos) that users request. When someone on your network visits a website that another user has already accessed, the proxy server delivers the cached content instead of downloading it again from the internet. This reduces bandwidth usage and improves loading times.

Benefits of Setting Up a Caching Proxy Server

• Faster browsing: Cached content loads much quicker than fresh downloads
• Reduced bandwidth consumption: The same content isn’t downloaded multiple times
• Lower latency: Local network access is always faster than internet requests
• Works for all devices: Benefits every device on your network without configuration
• Potential cost savings: If you have a metered connection, this reduces data usage

What You’ll Need

• A spare computer or Raspberry Pi (with at least 2GB RAM and 32GB storage)
• Basic networking knowledge
• 1-2 hours of setup time
• Squid proxy software (free and open-source)

Step 1: Choosing and Preparing Your Hardware

You don’t need powerful hardware for a home or small office caching proxy. A Raspberry Pi 4 works great for small networks (up to 10 devices), while a modest PC or old laptop can handle larger networks.

For this tutorial, I’ll use Ubuntu Server as the operating system, but you can use any Linux distribution.

1. Download Ubuntu Server from ubuntu.com/download/server
2. Install it on your device following the installation prompts
3. Make sure to set a static IP address during installation

Step 2: Installing Squid Proxy Server

Squid is the most popular caching proxy software. It’s powerful, reliable, and well-documented. Let’s install it:

1. Update your system:

sudo apt update
sudo apt upgrade -y

2. Install Squid:

sudo apt install squid -y

3. Verify the installation:

squid -v

This should display the Squid version information.

Step 3: Configuring Squid for Caching

The default Squid configuration works, but we need to optimize it for caching:

1. Back up the original configuration:

sudo cp /etc/squid/squid.conf /etc/squid/squid.conf.original

2. Edit the configuration file:

sudo nano /etc/squid/squid.conf

3. Find and modify these settings (or add them if not present):

# Define your local network
acl localnet src 192.168.1.0/24  # Change this to match your network

# Allow access from your local network
http_access allow localnet

# Cache settings
cache_mem 512 MB  # Adjust based on your server's RAM
maximum_object_size 50 MB  # Maximum size of objects to cache
cache_dir ufs /var/spool/squid 10000 16 256  # 10GB disk cache

# Refresh patterns for different content types
refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
refresh_pattern \.(gif|png|jpg|jpeg|ico)$ 10080 90% 43200 override-expire ignore-no-cache ignore-no-store
refresh_pattern \.(css|js)$     10080   90%     43200 override-expire ignore-no-cache ignore-no-store
refresh_pattern .               0       20%     4320

4. Save and close the file (Ctrl+X, then Y, then Enter in nano)
5. Create the cache directory:

sudo mkdir -p /var/spool/squid
sudo chown proxy:proxy /var/spool/squid

6. Initialize the cache:

sudo squid -z

7. Restart Squid:

sudo systemctl restart squid

Step 4: Setting Up Your Network to Use the Proxy

There are two ways to implement the proxy on your network:

Option 1: Configure Each Device (Manual Method)

Configure each device to use your proxy server:

• Proxy Address: Your server’s IP address (e.g., 192.168.1.10)
• Port: 3128 (Squid’s default port)

This approach requires setting up each device individually but gives you more control.

Option 2: Configure Your Router (Transparent Proxy)

This method automatically routes all web traffic through your proxy:

1. Install additional packages:

sudo apt install iptables-persistent -y

2. Add these lines to squid.conf:

# Transparent proxy settings
http_port 3128 transparent

3. Set up IP forwarding:

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

4. Create IPTables rules:

sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 3128

5. Save the rules:

sudo netfilter-persistent save

6. On your router, set the default gateway to your proxy server’s IP address

Step 5: Testing and Monitoring

1. Test basic functionality by browsing from a device on your network
2. Monitor cache performance:

tail -f /var/log/squid/access.log

3. Check cache hit rate:

squidclient mgr:info | grep "Hit Rate"

Advanced Optimizations

After you have the basic setup working, consider these optimizations:

Increase Cache Size

If you have extra storage, increase the cache size:

cache_dir ufs /var/spool/squid 20000 16 256  # 20GB disk cache

Enable HTTPS Caching

Modern websites use HTTPS. To cache this content:

1. Install SSL tools:

sudo apt install openssl -y

2. Generate certificates:

sudo mkdir -p /etc/squid/ssl_cert
sudo openssl req -new -newkey rsa:2048 -sha256 -days 365 -nodes -x509 -keyout /etc/squid/ssl_cert/myproxy.pem -out /etc/squid/ssl_cert/myproxy.pem
sudo chown proxy:proxy /etc/squid/ssl_cert/myproxy.pem

3. Add to squid.conf:

# HTTPS caching
https_port 3129 cert=/etc/squid/ssl_cert/myproxy.pem ssl-bump intercept
acl SSL_port port 443
acl CONNECT method CONNECT
http_access allow CONNECT SSL_port localnet
ssl_bump server-first all
sslcrtd_program /usr/lib/squid/security_file_certgen -s /var/lib/ssl_db -M 4MB
sslcrtd_children 5

4. Create the SSL database:

sudo mkdir -p /var/lib/ssl_db
sudo chown -R proxy:proxy /var/lib/ssl_db

5. Restart Squid:

sudo systemctl restart squid

6. Install the generated certificate on your devices as a trusted CA

Troubleshooting Common Issues

1. Squid not starting: Check logs with sudo journalctl -u squid
2. Slow performance: Verify disk cache is working with ls -la /var/spool/squid/
3. Websites not loading: Ensure your network configuration is correct
4. HTTPS issues: Check certificate installation

Conclusion

Setting up a caching proxy server can significantly improve your network’s browsing experience. While the initial setup requires some technical knowledge, the long-term benefits are substantial. Your internet will feel faster, especially for frequently visited sites, and you’ll save bandwidth in the process.

Have you set up a caching proxy server? Share your experience in the comments below!

Disclaimer: This setup is intended for home or small office networks. For enterprise environments, consider professional solutions with support contracts.

The post How to Set Up a Caching Proxy Server to Speed Up Your Local Network appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Maintaining multiple Ubuntu desktops in an office, school, or lab environment can become bandwidth-intensive if each machine downloads updates from the internet individually. A more efficient solution is to set up a local update server, which caches packages and distributes them to all local machines.

In this guide, we walk through how to set up a local Ubuntu package mirror using apt-cacher-ng, a lightweight and efficient caching proxy for Debian-based systems.

Prerequisites

• A dedicated Ubuntu server (or one of your desktops) that will act as the cache server.
• Internet access on the server.
• Static IP or reserved DHCP IP for the cache server.
• Ubuntu desktops configured to use the cache.

Step 1: Install apt-cacher-ng on the Server

sudo apt update
sudo apt install apt-cacher-ng

Once installed, the service starts automatically. You can check its status with:

sudo systemctl status apt-cacher-ng

Step 2: Configure apt-cacher-ng (Optional)

The default settings are usually fine for most use cases. But if you want to review or tweak the settings:

sudo nano /etc/apt-cacher-ng/acng.conf

Ensure this line is set (it usually is):

PassThroughPattern: .*ubuntu.com/.* 

To allow web access to the stats page, find and set:

ReportPage: acng-report.html

Then restart the service:

sudo systemctl restart apt-cacher-ng

Step 3: Allow Access Through Firewall (If Enabled)

If UFW is enabled:

sudo ufw allow 3142/tcp

Port 3142 is the default port used by apt-cacher-ng.

Step 4: Test the Server Locally

You can test the server by accessing this URL in a browser on another machine:

http://<cache-server-ip>:3142/acng-report.html

You should see the Apt-Cacher NG status page.

Step 5: Configure Ubuntu Clients

On each Ubuntu desktop, edit or create the file:

sudo nano /etc/apt/apt.conf.d/01proxy

Add this line (replace <cache-server-ip> with your server’s IP address):

Acquire::http::Proxy "http://<cache-server-ip>:3142";

Example:

Acquire::http::Proxy "http://192.168.1.10:3142";

Now, whenever you run:

sudo apt update && sudo apt upgrade

The desktop will fetch packages from your local cache server, downloading from the internet only if they’re not already cached.

Optional: Exclude Certain Packages or Repositories

You can fine-tune what gets cached in /etc/apt-cacher-ng/acng.conf. Look for directives like:

ExThreshold: 10

Or define blacklist patterns. See the man page for more advanced options:

man acng.conf

Monitor Usage

Check the cache statistics and logs via:

• Web UI: http://<cache-server-ip>:3142/acng-report.html
• Log file: /var/log/apt-cacher-ng/apt-cacher.log

Final Tips

• Regularly monitor disk space. Cache can grow over time.
• Use cron or logrotate to manage logs and old cached files.
• Works seamlessly for Ubuntu, Debian, and derivatives (Linux Mint, Pop!_OS).

Setting up a local update server is a smart move for environments with multiple machines. It reduces internet usage, speeds up updates, and improves reliability during high-traffic times. Once configured, it’s mostly maintenance-free.

The post How to Set Up a Local Update Server for Ubuntu Desktops appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

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

This is where DockFlare comes in.

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

Objectives of DockFlare

DockFlare was created to solve three key problems:

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

Why Use DockFlare?

Here’s how DockFlare benefits its users:

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

How to Install DockFlare

Requirements

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

Step 1: Create Your Project Directory

mkdir dockflare && cd dockflare

Step 2: Create .env File

Create a file named .env with the following contents:

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

Keep this file private!

Step 3: Create docker-compose.yml

version: '3.8'

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

volumes:
  dockflare_data:

Step 4: Deploy DockFlare

docker compose up -d

Access the UI: http://localhost:5000

Exposing a Docker Service

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

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

This will automatically:

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

Add Non-Docker Services

Want to expose your home router or NAS?

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

This works for any service, not just Docker.

Configuring Zero Trust Access

To secure your services:

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

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

Advanced Tips

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

Resources

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

Conclusion

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

No more port forwarding. No more SSL headaches.

Just Docker + DockFlare + Cloudflare = Done.

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

I’m pleased to introduce demimasa.mybsd.org.my, a public NTP server hosted on FreeBSD, serving as a Stratum 2 time source in Malaysia. This server synchronizes directly with the national Stratum 1 server mst.sirim.my, operated by SIRIM, ensuring highly accurate and trusted time data.

What is demimasa.mybsd.org.my?

• Stratum 2 NTP Server: It receives time from the primary Stratum 1 server (mst.sirim.my) and distributes it to other devices.
• Hosted on FreeBSD: Running on the stable and secure FreeBSD operating system, known for its robustness in networking and server applications.
• Open to the Public: Anyone in Malaysia (or nearby regions) can configure their devices to use this server as an alternative or backup NTP source.
• Ideal for Networks and IoT: Perfect for enterprise networks, small businesses, home users, or developers needing accurate local time without relying on overseas servers.

Why the Name “demimasa”?

The name “demimasa” is inspired by Surah Al-‘Asr from the Quran, which highlights the critical importance of time and how humans should value and utilize it wisely.

Surah Al-‘Asr (The Declining Day or The Time) is a short but profound chapter that reminds us:

“By time,
Indeed, mankind is in loss,
Except for those who have believed and done righteous deeds and advised each other to truth and advised each other to patience.”
(Quran 103:1-3)

This Surah emphasizes that time is a precious resource, and wasting it leads to loss. Only those who combine faith, good actions, truthfulness, and patience truly benefit from the gift of time.

In the context of this NTP server, demimasa symbolizes the value of precise timekeeping and reminds us how crucial accurate time is — whether for technology, communication, or daily life.

Why Use demimasa.mybsd.org.my?

• Reduced Latency: Since this server is physically located within Malaysia and linked to the national time source, devices sync faster compared to international servers.
• Improved Reliability: Having more local NTP servers strengthens the time infrastructure and avoids dependence on external global servers that may have connectivity issues.
• Free and Open: No restrictions or fees for using the server — just point your NTP client to demimasa.mybsd.org.my.
• Supports Various Devices: Compatible with any standard NTP client, including routers, switches, Linux/Windows servers, and embedded devices.

How to Use demimasa.mybsd.org.my on Common Operating Systems

Here’s how you can configure your device or server to sync time using demimasa.mybsd.org.my:

Windows 10/11

1. Open Settings > Time & Language > Date & Time.
2. Scroll down and click Additional date, time & regional settings.
3. Under Date and Time, click Set the time and date.
4. Go to the Internet Time tab and click Change settings.
5. Enter demimasa.mybsd.org.my in the server field.
6. Click Update now, then OK to save.

Linux (Debian/Ubuntu)

To change your NTP server on Ubuntu, the method depends on which NTP client you’re using:

For systemd-timesyncd (default on newer Ubuntu versions):

1. Edit the config file

sudo nano /etc/systemd/timesyncd.conf

2. Set your preferred NTP server

Uncomment and modify this line:

NTP=demimasa.mybsd.org.my

3. Restart the service

sudo systemctl restart systemd-timesyncd

4. Verify it’s using your NTP servers

timedatectl show-timesync --all

For chrony:

1. Edit the chrony config

sudo nano /etc/chrony/chrony.conf

2. Add or replace NTP servers

Look for lines like:

server demimasa.mybsd.org.my iburst

You can add multiple server or pool lines.

3. Restart chrony

sudo systemctl restart chrony

4. Check sources

chronyc sources -v

For ntpd:

1. Edit the ntp config

sudo nano /etc/ntp.conf

2. Change or add server entries

Replace existing lines like:

server demimasa.mybsd.org.my

3. Restart the service

sudo systemctl restart ntp

4. Verify

ntpq -p

macOS

1. Open System Preferences > Date & Time.
2. Click the lock icon and enter your password to make changes.
3. Check Set date and time automatically.
4. Enter demimasa.mybsd.org.my as the time server.
5. Close System Preferences.

Cisco Routers/Switches

Enter configuration mode:

conf t
ntp server demimasa.mybsd.org.my
end
write memory

Other Network Devices (Generic)

In your device’s NTP or time settings, simply add or replace the NTP server with:

demimasa.mybsd.org.my

About the Infrastructure

The time chain:

• Stratum 1: mst.sirim.my (official Malaysian national time server, synchronized with atomic clocks)
• Stratum 2: demimasa.mybsd.org.my (synchronizes from mst.sirim.my and serves the public)

This hierarchical setup follows best practices for NTP deployment to ensure both accuracy and scalability.

Final Thoughts

If you’re looking for a trustworthy, locally hosted NTP server to improve your network time accuracy, demimasa.mybsd.org.my is a great choice. It complements other public NTP servers and strengthens Malaysia’s overall timekeeping infrastructure.

The name reminds us all to value every second wisely — just like Surah Al-‘Asr teaches.

Feel free to share this resource with your colleagues, IT teams, and anyone who needs precise time synchronization in Malaysia.

The post Introducing demimasa.mybsd.org.my — A Reliable Public NTP Server in Malaysia appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

Why Chrony?

Chrony is:

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

What You’ll Set Up

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

Step 1: Create a Dockerfile for Chrony

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

# Dockerfile
FROM debian:stable-slim

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

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

EXPOSE 123/udp

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

Step 2: Create the chrony.conf

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

# chrony.conf

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

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

# Local stratum fallback if Internet is down
local stratum 10

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

# Log tracking data
log tracking measurements statistics

# Log files location
logdir /var/log/chrony

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

Replace 192.168.1.0/24 with your actual LAN subnet.

Step 3: Build and Run the Docker Container

docker build -t chrony-server .

Now run the container with:

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

Explanation:

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

Step 4: Test Your NTP Server

From a client machine on your LAN:

ntpdate -q <chrony-server-ip>

or

chronyc sources -a

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

Optional: Run as a Local Time Authority

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

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

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

Firewall Notes

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

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

Or for iptables:

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

Conclusion

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

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

Perfect for homelabs, IoT networks, or offline environments.

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

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

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

The Problem with Traditional Software Deployment

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

Why?

Common culprits include:

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

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

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

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

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

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

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

Why It’s Great for Hams:

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

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

Virtual Machines: Still Relevant in the Shack

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

• VirtualBox
• VMware
• KVM
• Hyper-V

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

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

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

Quick Comparison: Docker vs Virtual Machines for Hams

Ham Radio Use Cases for Docker

Here’s how Docker fits into amateur radio workflows:

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

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

When to Use Docker, When to Use a VM

Use Docker if:

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

Use VMs if:

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

Final Thoughts

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

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

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

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

Installation on Ubuntu/Debian

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

sudo apt install yagiuda

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

Usage

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

dipole <frequency> <length> <diameter>

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

dipole 7.100mhz 20m 1.5mm

Example Output:

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

This output indicates:

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

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

Related Tools

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

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

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

Supported Platforms

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

Reporting Bugs

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

Conclusion

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

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

CHIRP is a powerful open-source tool for programming amateur radios, supporting brands like Baofeng, Kenwood, and Yaesu. With the transition from chirp-daily to chirp-next, Ubuntu users need a new approach to install the latest version. This guide provides a step-by-step method to install CHIRP, configure dependencies, and troubleshoot common issues.

Step 1: Install Required Dependencies

Before installing CHIRP, ensure your system has the necessary dependencies. Open a terminal and execute:

sudo apt update && sudo apt install python3-wxgtk4.0 pipx

• python3-wxgtk4.0: Provides the graphical components for CHIRP.
• pipx: Ensures a clean and isolated installation of CHIRP.

Step 2: Download the Latest CHIRP Package

The latest CHIRP version is distributed as a Python wheel (.whl). Download it from the official CHIRP website:

1. Visit: https://archive.chirpmyradio.com/chirp_next
2. Download the most recent chirp-YYYYMMDD-py3-none-any.whl file.
3. Save it to your Downloads folder for easy access.

Alternatively, download it via wget:

cd ~/Downloads
wget https://archive.chirpmyradio.com/chirp_next/next-20250321/chirp-20250321-py3-none-any.whl

(Replace 20250321 with the latest available version.)

Step 3: Install CHIRP Using Pipx

With the .whl file downloaded, install CHIRP via pipx:

pipx install --system-site-packages ~/Downloads/chirp-20250321-py3-none-any.whl

(Ensure you use the correct file name for your version.)

After installation, CHIRP should be available system-wide.

To add a shortcut for CHIRP to your application menu after installing it via pipx, first create a desktop entry file in the ~/.local/share/applications/ directory. Open a terminal and run nano ~/.local/share/applications/chirp.desktop to create a new file. In this file, add the following content:

[Desktop Entry]
Name=CHIRP
Comment=Open-source radio programming software
Exec=/home/YOUR_USERNAME/.local/bin/chirp
Icon=chirp
Terminal=false
Type=Application
Categories=Utility;HamRadio;

Make sure to replace /home/YOUR_USERNAME/.local/bin/chirp with the correct path to the CHIRP executable. Once the file is created, save it and make it executable by running chmod +x ~/.local/share/applications/chirp.desktop. After that, refresh the application menu by running update-desktop-database ~/.local/share/applications or restarting your desktop environment. Your CHIRP application should now appear in the application menu, ready to launch with a custom shortcut.

Step 4: Ensure CHIRP Is in Your PATH

If CHIRP is not recognized as a command, update your PATH:

pipx ensurepath

Restart your terminal or log out and log back in. You can now run CHIRP using:

chirp

Step 5: Configure Serial Port Permissions

If CHIRP cannot detect your radio, you may need to grant serial port access.

1. Identify your radio’s device name: dmesg | grep ttyUSB This should return something like /dev/ttyUSB0.
2. Grant access to your user: sudo usermod -a -G $(stat -c %G /dev/ttyUSB0) $USER
3. Log out and back in or reboot your system for the changes to take effect.

Updating CHIRP

To update CHIRP in the future:

1. Download the latest .whl file.
2. Uninstall the current version: pipx uninstall chirp
3. Reinstall using the latest .whl following Step 3 above.

Troubleshooting Common Issues

CHIRP Doesn’t Start

• Ensure pipx ensurepath has been executed.
• Restart your terminal or log out and back in.

Serial Port Access Denied

• Check user group permissions with: ls -l /dev/ttyUSB0
• Add your user to the required group (e.g., dialout or uucp).

wxPython or Python Issues

• Verify Python version: python3 --version
• Check wxPython installation: python3 -c "import wx; print(wx.__version__)"
• If wxPython is missing or outdated, install it manually: pip3 install -U -f https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-20.04 wxPython

Final Thoughts

By following this guide, you’ll have the latest CHIRP version running smoothly on Ubuntu. Whether you’re programming Baofeng, Kenwood, or other compatible radios, CHIRP simplifies configuration and channel management.

Happy radio programming!

The post How to Install the Latest CHIRP on Ubuntu 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.

What is DragonOS?

DragonOS is a specialized Linux distribution designed for SDR enthusiasts, built on Lubuntu and packed with pre-installed open-source SDR software. Developed by Cema Xecuter, DragonOS aims to be for SDR what Kali Linux is for penetration testing—a comprehensive, plug-and-play environment that eliminates the hassle of setting up and configuring software from scratch.

With DragonOS, you no longer have to struggle with software dependencies, installation conflicts, or configuration headaches. Just boot it up, and you’re ready to explore the airwaves!

Why is DragonOS a Game-Changer for Amateur Radio Operators?

Amateur radio, also known as ham radio, has long been a playground for innovation. From emergency communications to satellite operations and digital modes, amateur radio operators are always at the cutting edge of wireless experimentation. DragonOS simplifies access to powerful SDR tools, allowing hams to:

• Monitor and Decode Signals – DragonOS supports tools like GQRX, SDR++, and CubicSDR, making it easy to listen to and analyze radio signals across various bands.
• Operate Digital Modes – With applications like WSJT-X, FLDigi, and Direwolf, you can engage in weak-signal communication, packet radio, and APRS (Automatic Packet Reporting System) right out of the box.
• Track and Communicate with Satellites – Use GPredict and SatNOGS to track amateur satellites and receive telemetry data.
• Experiment with RF Security – Tools such as GNU Radio, RTL_433, and HackRF utilities allow you to analyze and experiment with various wireless protocols.
• Set Up an APRS iGate or Repeater – With Direwolf and other tools, you can configure your system to receive and relay APRS packets to the global APRS-IS network.
• Decode Weather Satellites – With software like SatDump and WXtoIMG, you can receive real-time images from NOAA and Meteor satellites.

Supported SDR Hardware

DragonOS comes with built-in support for a variety of SDR devices, ensuring seamless compatibility with:

• RTL-SDR (one of the most affordable SDR receivers)
• HackRF One
• LimeSDR
• BladeRF
• Ettus USRP
• SDRPlay
• PlutoSDR
• Yardstick One
• Ubertooth
• And more!

Versatility and Ease of Use

DragonOS is designed to be flexible and user-friendly. You can run it as:

• A Live Bootable OS – Test it without installing anything.
• A Dual-Boot System – Install alongside Windows, macOS, or another Linux distribution.
• A Virtual Machine – Run it in VirtualBox or VMware for testing and development.

The pre-installed SDR tools are organized for convenience, so users of all experience levels can quickly get started. Whether you’re setting up a field station, testing antennas, or analyzing signals from the comfort of your shack, DragonOS makes it effortless.

Getting Started with DragonOS

Ready to dive into the world of SDR? Download DragonOS and follow the setup instructions at Cema Xecuter’s official website. The active community and ongoing development ensure that DragonOS remains cutting-edge, making it the go-to platform for SDR enthusiasts worldwide.

Embrace the future of radio with DragonOS—where software meets spectrum!

The post Unleashing the Power of Software Defined Radio with DragonOS appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

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

What Makes Spotube Special?

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

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

Standout Features That Users Love

Truly Ad-Free Experience

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

Download Freedom

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

Cross-Platform Versatility

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

Lightweight Champion

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

Privacy-Focused Design

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

Enhanced Listening Experience

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

Local Control

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

Supporting Artists While Using Spotube

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

Getting Started Is Easy

Installation is straightforward across all platforms:

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

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

The Team Behind the Magic

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

The Open-Source Advantage

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

What’s Not Included?

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

Try Spotube Today

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

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

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

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

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

What is a Custom Kernel?

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

Custom kernels often feature:

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

Introducing the Liquorix Kernel

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

Key Features of the Liquorix Kernel

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

1. Zen Interactive Tuning

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

2. Improved Block Layer Performance

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

3. Enhanced Virtual Memory Management

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

4. Low-Latency CPU Scheduling

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

5. Optimized CPU Frequency Scaling

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

6. High-Resolution Scheduling

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

7. Hard Kernel Preemption

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

8. Optimized Disk Scheduling

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

9. TCP BBR2 Congestion Control

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

10. Compressed Swap Support

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

11. Easy Installation and Broad Compatibility

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

Installing the Liquorix Kernel

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

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

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

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

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

yay -S linux-lqx linux-lqx-headers

Who Should Use Liquorix?

The Liquorix kernel is an excellent choice for:

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

However, Liquorix is not necessarily ideal for:

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

Conclusion

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

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

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

Visit https://liquorix.net/

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

Originally introduced in February 2018, GridTracker began as a simple tool designed to listen to traffic from WSJT-X and display it on a map. Over the years, it has evolved into a comprehensive and powerful amateur radio tool, extending beyond FT8 to serve a wide range of functions. From live traffic decodes and logbook management to real-time spot reports, weather conditions, and solar activity tracking, GridTracker has become an indispensable asset for radio enthusiasts.

Features of GridTracker

GridTracker offers a wealth of features that enhance the amateur radio experience. Here are some of its key capabilities:

1. Advanced Mapping & Real-Time Contact Tracking

GridTracker provides highly detailed and customizable maps that allow users to visualize both real-time and historical contacts. It supports multiple overlays, including Greyline, Moon position tracking, award tracking, and reception reports (Spots). Grid and county hunters will appreciate the instant access to detailed location data directly from the map interface.

2. Customizable Alerts

Users can set up personalized audio and visual alerts, ensuring they never miss an important signal, QSO opportunity, or propagation event.

3. Comprehensive Callsign Lookup

GridTracker integrates seamlessly with popular callsign databases, making it easy to retrieve detailed operator information quickly.

4. Call Roster for Live Activity Monitoring

The Call Roster is a table-based view of live activity, allowing users to track ongoing QSOs in a highly customizable format. This feature is particularly useful for award chasers and special event operators, enabling them to initiate contacts with a single click.

5. Seamless Logging Integration

GridTracker works with many popular logging programs and web-based logbook systems, providing up-to-the-minute tracking for awards such as DXCC and Worked All States.

6. Complete DXCC, Country, and Prefix Recognition

Whether you’re chasing DXCC or monitoring global activity, GridTracker offers comprehensive recognition for countries, prefixes, and DXCC entities.

7. Offline Mode for Portable Operations

Field-day, Parks on the Air (POTA), Summits on the Air (SOTA), Islands on the Air (IOTA), or mobile operators will appreciate GridTracker’s 100% offline mode, ensuring uninterrupted functionality even in remote locations.

8. Off-Air Messaging System

GridTracker allows users to send messages to potential QSO partners over the Internet, bridging communication gaps beyond traditional RF propagation.

9. Real-Time Spotting Integration

The software supports real-time spotting for other GridTracker and Log4OM users, enhancing situational awareness for radio operators.

Why Use GridTracker?

GridTracker is more than just a mapping tool—it is an all-in-one amateur radio companion that simplifies QSO tracking, enhances logging capabilities, and provides essential propagation data. Whether you are a DX chaser, an award hunter, or simply looking to optimize your radio experience, GridTracker offers the features and flexibility needed to take your operations to the next level.

Final Thoughts

For amateur radio operators looking for a feature-rich, intuitive, and powerful software tool, GridTracker is a must-have. It enhances the ability to track signals, visualize activity, and manage logbooks efficiently, making it a valuable asset in the modern ham radio landscape.

Visit https://gridtracker.org/

The post Unlocking the Power of GridTracker for Amateur Radio Operators appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In a world where digital communication is often subject to surveillance, censorship, and centralized control, Reticulum stands as a revolutionary solution. Designed as a cryptography-based networking stack, Reticulum empowers individuals and communities to build local and wide-area networks using readily available hardware. Unlike traditional networking technologies, Reticulum operates efficiently even under extreme conditions, such as high latency and ultra-low bandwidth.

Reticulum is more than just a network—it is a tool for creating thousands of independent and autonomous networks that interconnect seamlessly. These networks are designed to function without kill-switches, external control, or centralized oversight, allowing users to communicate freely and securely. Reticulum enables sovereign, censorship-resistant, and decentralized communication, making it a game-changer for those seeking privacy, security, and resilience in their networks.

Unlike conventional network stacks, Reticulum does not rely on the IP protocol or higher layers. However, it can still be encapsulated over IP networks, allowing users to tunnel Reticulum traffic through the Internet or private IP infrastructures when necessary. By eliminating dependencies on traditional networking protocols, Reticulum optimizes performance and security. The stack is built directly on cryptographic principles, ensuring stable and resilient functionality even in trustless and adversarial environments.

One of the most remarkable aspects of Reticulum is its ease of deployment. It requires no kernel modules or special drivers, making it incredibly lightweight and accessible. Running entirely in user space, Reticulum can be installed on virtually any system that supports Python 3, from personal computers and embedded devices to large-scale infrastructure. This versatility ensures that users can establish secure and sovereign communication networks without specialized or expensive hardware.

Reticulum: A New Era of Secure Networking

Reticulum is the cryptography-based networking stack for building local and wide-area networks with readily available hardware. It can operate even with very high latency and extremely low bandwidth. Reticulum allows you to build wide-area networks with off-the-shelf tools, and offers end-to-end encryption and connectivity, initiator anonymity, autoconfiguring cryptographically backed multi-hop transport, efficient addressing, unforgeable delivery acknowledgements and more.

The vision of Reticulum is to allow anyone to be their own network operator, and to make it cheap and easy to cover vast areas with a myriad of independent, inter-connectable and autonomous networks. Reticulum is not one network. It is a tool for building thousands of networks. Networks without kill-switches, surveillance, censorship and control. Networks that can freely interoperate, associate and disassociate with each other, and require no central oversight. Networks for human beings. Networks for the people.

Reticulum is a complete networking stack, and does not rely on IP or higher layers, but it is possible to use IP as the underlying carrier for Reticulum. It is therefore trivial to tunnel Reticulum over the Internet or private IP networks.

Having no dependencies on traditional networking stacks frees up overhead that has been used to implement a networking stack built directly on cryptographic principles, allowing resilience and stable functionality, even in open and trustless networks.

No kernel modules or drivers are required. Reticulum runs completely in userland, and can run on practically any system that runs Python 3.

Reticulum: The Unstoppable, Sovereign Networking Stack

A Vision for Sovereign Communication

Reticulum is more than just a network—it’s a framework for building thousands of independent networks. Unlike traditional systems, Reticulum eliminates the need for central control, allowing anyone to operate their own sovereign communication infrastructure. The key vision behind Reticulum is to empower individuals and communities to create networks that are free from surveillance, censorship, and external control.

With Reticulum, users can establish highly secure communication channels, ensuring that their data remains private and tamper-proof. This is particularly crucial in regions where communication restrictions are imposed, or in emergency scenarios where traditional networks fail.

What Makes Reticulum Different?

While Reticulum serves the same fundamental purpose as other networking stacks—moving data reliably from one point to another—it does so in a completely different way. Here are some notable characteristics that set Reticulum apart:

Privacy & Security by Default

• Reticulum does not use source addresses in transmitted packets, making it impossible to trace the origin of communication.
• All encryption keys are ephemeral and provide forward secrecy, ensuring that past communications remain secure even if future keys are compromised.
• It is impossible to send or receive unencrypted packets within Reticulum, eliminating vulnerabilities associated with unprotected data transmission.

Decentralization & Sovereignty

• There is no central authority controlling address allocations; users can create addresses as needed.
• Once an address is generated, it remains globally reachable and portable, meaning it can be moved across different locations in the network while staying accessible.
• Networks built on Reticulum are self-configuring and resilient, adapting to various communication mediums seamlessly.

Interconnectivity & Versatility

• Reticulum supports a wide range of communication hardware, including LoRa radios, AX.25 packet radio TNCs, WiFi, Ethernet, serial devices, and even free-space optical links.
• It allows seamless integration over existing IP networks (TCP/UDP), meaning it can function over wired and wireless infrastructure while maintaining security and decentralization.
• By combining multiple communication mediums, Reticulum enables the creation of dynamic, self-healing mesh networks that are highly resistant to disruptions.

Supported Hardware & Interfaces

Reticulum is designed to work over virtually any medium that can sustain a half-duplex connection with at least 500 bits per second throughput. Some of the supported hardware and interfaces include:

• Ethernet and WiFi devices
• LoRa radios using RNode
• Packet radio TNCs (AX.25 and KISS-compatible)
• Any serial-based communication device
• TCP and UDP over IP networks
• Custom hardware via standard input/output (stdio) and pipes

For example, a simple Raspberry Pi setup connected to a LoRa radio, a packet radio TNC, and a WiFi network would allow devices on each of these mediums to communicate seamlessly, thanks to Reticulum’s self-configuring architecture.

How to Get Started with Reticulum

Getting started with Reticulum depends on your intended use case. However, installation is straightforward using Python’s package manager:

pip install rns

Once installed, you can start Reticulum manually or set it up as a system service using the rnsd utility. The first time Reticulum runs, it automatically generates a configuration file that helps you connect with local peers and expand the network from there.

For more details, consult the Getting Started Fast section of the Reticulum Manual.

Included Utilities for Network Management

Reticulum comes with several built-in utilities to simplify network setup and maintenance:

• rnsd – Runs Reticulum as a background service.
• rnstatus – Displays real-time information about network interfaces.
• rnpath – Manages and views routing paths.
• rnprobe – Diagnoses connectivity to specific destinations.
• rncp – Transfers files securely between nodes.
• rnx – Executes remote commands over Reticulum networks.

These tools ensure that even networks operating over extremely low-bandwidth mediums, such as LoRa or packet radio, function efficiently and reliably.

Applications Built on Reticulum

Reticulum powers several innovative applications that demonstrate its capabilities:

• Nomad Network – An off-grid, encrypted, and resilient mesh communication platform.
• Sideband – A user-friendly graphical messaging app for Linux, Android, and macOS.
• LXMF – A distributed, delay-tolerant messaging protocol designed for asynchronous communication.

These projects showcase Reticulum’s ability to facilitate secure and decentralized digital interactions without reliance on traditional internet infrastructure.

Performance & Future Development

Reticulum is optimized for a broad range of performance scenarios, with speeds ranging from 150 bits per second to 40 megabits per second across different mediums. While development continues, the focus remains on expanding functionality for low-bandwidth networks, ensuring long-term resilience and adaptability.

Join the Reticulum Community

If you’re interested in exploring Reticulum, the community offers multiple channels for support and discussion:

• GitHub Discussions
• Matrix Channel: #reticulum
• Reticulum Subreddit

Since Reticulum is still in beta, users should be aware of potential bugs or security improvements in future releases. However, its current stability and effectiveness make it a compelling choice for those seeking secure, decentralized communication solutions.

Conclusion

Reticulum represents a paradigm shift in digital communication, offering a powerful, censorship-resistant alternative to traditional networking protocols. Whether you’re building an off-grid messaging system, a disaster-resilient infrastructure, or simply seeking an alternative to centralized networks, Reticulum provides the tools to create truly sovereign and unstoppable communication systems.

Are you ready to take control of your own network? Install Reticulum today and start building the future of decentralized, autonomous communication!

For more info, visit https://github.com/markqvist/Reticulum

The post Reticulum: The Future of Secure and Resilient Networking appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Why an RT Kernel and PipeWire?

• RT Kernel: Designed for time-critical applications, an RT kernel minimizes latency by prioritizing real-time tasks, crucial for audio processing.
• PipeWire: A modern multimedia framework that excels at handling audio and video streams, offering superior performance and flexibility compared to older solutions.

Step-by-Step Guide

1. Verify Your RT Kernel is Running:

Before anything else, confirm your RT kernel is active. Open your terminal and run:

Bash

uname -r

You should see “rt” in the output, indicating a successful installation (e.g., 5.15.0-xanmod1-rt).

2. Install PipeWire and Essential Packages:

Install PipeWire and its necessary components using your distribution’s package manager:

• Debian/Ubuntu:

Bash

sudo apt install pipewire pipewire-audio-client-libraries pipewire-pulse pipewire-jack wireplumber

• Fedora:

Bash

sudo dnf install pipewire pipewire-pulseaudio pipewire-jack-audio-connection-kit wireplumber

• Arch Linux:

Bash

sudo pacman -S pipewire pipewire-pulse pipewire-jack wireplumber

3. Grant Real-Time Privileges:

To allow PipeWire to operate in real-time, configure the audio group:

• Edit the limits file:

Bash

sudo nano /etc/security/limits.d/99-audio.conf

• Add these lines:

@audio   -  rtprio     95
@audio   -  memlock    unlimited

• Add your user to the audio group:

Bash

sudo usermod -aG audio $USER

• Log out and back in for the changes to apply.

4. Fine-Tune PipeWire Configuration:

• Create a custom configuration directory:

Bash

mkdir -p ~/.config/pipewire

• Copy default configurations:

Bash

cp /usr/share/pipewire/pipewire.conf ~/.config/pipewire/
cp /usr/share/pipewire/pipewire-pulse.conf ~/.config/pipewire/

• Edit ~/.config/pipewire/pipewire.conf:
  • Add desired sample rates to default.clock.allowed-rates (e.g., 44100, 48000, 96000).
  • Set default.clock.quantum to your preferred buffer size (e.g., 256 for low latency).
  • Set default.clock.min-quantum to your minimum buffer size (e.g., 32).

5. Optimize for Low Latency:

• Create a low-latency configuration file:

Bash

mkdir -p ~/.config/pipewire/pipewire.conf.d
nano ~/.config/pipewire/pipewire.conf.d/99-low-latency.conf

• Add these settings:

context.properties = {
    default.clock.rate = 48000
    default.clock.quantum = 256
    default.clock.min-quantum = 32
    default.clock.max-quantum = 8192
}

48000 Hz is perfectly adequate, 192000 Hz is generally only relevant in professional audio production or for audiophiles with very high-end equipment. Most people would not be able to tell the difference between the two.

6. Enable Real-Time Priority:

• Create a real-time priority file.

Bash

mkdir -p ~/.config/pipewire/pipewire.conf.d
nano ~/.config/pipewire/pipewire.conf.d/10-rt-priority.conf

• Add these setting.

context.modules = [
{   name = libpipewire-module-rt
    args = {
        nice.level = -11
        rt.prio = 88
        rt.time.soft = 200000
        rt.time.hard = 200000
    }
    flags = [ ifexists nofail ]
}
]

7. Restart PipeWire:

Apply the changes by restarting PipeWire:

Bash

systemctl --user restart pipewire pipewire-pulse

8. Verify Low-Latency Operation:

• Check latency settings:

Bash

pw-top

• Verify real-time priorities:

Bash

ps -eo pid,cls,pri,cmd | grep pipewire

Troubleshooting:

• Xruns (audio dropouts): Increase default.clock.quantum.
• High CPU usage: Use htop to identify problematic processes.
• CPU frequency scaling: Consider disabling it: sudo cpupower frequency-set -g performance.

Important Notes:

• Finding the optimal settings requires experimentation based on your hardware.
• For advanced usage, consider CPU core isolation, and the realtime-privileges package.

By following these steps, you’ll be well on your way to achieving exceptional audio performance with PipeWire and an RT kernel. Happy listening!

The post Unleash Sonic Perfection: Configuring PipeWire with an RT Kernel for Low Latency Audio appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

The pursuit of perfect audio reproduction leads enthusiasts down many paths. For Linux users, one promising avenue is the RT (Real-Time) kernel. Let’s explore how RT kernels can benefit audio workflows and take a specific look at the popular XanMod RT kernel.

What is an RT Kernel?

A real-time kernel is a modified version of the standard Linux kernel designed to handle time-sensitive tasks with greater precision and consistency. Unlike standard kernels that prioritize overall system throughput, RT kernels focus on minimizing latency and providing predictable response times.

The key differences in an RT kernel include:

• Preemption: RT kernels can interrupt (preempt) virtually any task to handle higher-priority processes
• Priority inheritance: Prevents priority inversion problems where low-priority tasks block high-priority ones
• Deterministic scheduling: Ensures time-critical tasks run when needed, not just when convenient

Why RT Kernels Matter for Audio

Audio processing is inherently time-sensitive. When your system processes audio, it needs to maintain consistent timing to avoid artifacts like:

• Clicks and pops (buffer underruns)
• Jitter (timing inconsistencies)
• Dropouts (missed audio data)

Standard kernels can introduce unpredictable latency spikes as the system juggles various tasks. These momentary hiccups may go unnoticed in everyday computing but can be disastrous for audio applications, especially during recording or professional mixing sessions.

Audiophile Benefits of RT Kernels

For serious audiophiles, the benefits of RT kernels extend beyond professional audio production:

• Lower latency for digital audio: Allows running at smaller buffer sizes without artifacts
• More consistent streaming: Fewer interruptions during high-resolution audio playback
• Reduced jitter: More precise timing for digital-to-analog conversion
• Better performance with USB DACs: More reliable handling of USB audio interfaces
• Smoother performance with DSP: Digital signal processing runs more reliably

Many audiophiles report subjective improvements in soundstage, detail retrieval, and overall listening experience when using RT kernels, though these effects can be difficult to measure objectively.

The XanMod RT Kernel: A Performance-Optimized Solution

Among the available RT kernel options, XanMod has gained significant popularity in the audio community. XanMod is a custom Linux kernel focusing on performance, responsiveness, and low latency.

What Makes XanMod Special?

XanMod builds upon the standard Linux kernel with:

• Extensive scheduler optimizations: Better handling of processor tasks
• Improved CPU frequency scaling: More responsive power management
• Enhanced I/O performance: Faster disk and peripheral operations
• Lower latency audio subsystem: Optimized specifically for audio tasks
• Compatibility with a wide range of hardware: Works well across different systems

The RT version of XanMod incorporates the PREEMPT_RT patch set, which transforms the kernel into a fully preemptible real-time system.

Key Features for Audiophile Use

XanMod RT offers several advantages specifically beneficial for audio enthusiasts:

• Low-latency scheduling: Better scheduling for real-time tasks, reducing latency for audio playback and recording
• CPU optimization: CPU cores are more efficiently utilized, allowing audio processes to run uninterrupted
• Real-time scheduling: Guarantees ultra-low latency for applications such as music production
• Optimized CPU scheduler: Uses advanced schedulers like CacULE or MuQSS, ensuring efficient CPU resource allocation
• Better handling of audio interrupts: Optimizes how the system deals with interrupts, ensuring audio processes remain unaffected

Measuring Audio Performance Improvements

To quantify the benefits of RT kernels, you can use several tools:

• rtapp: Tests the responsiveness of real-time applications
• cyclictest: Measures kernel latency and jitter
• jack_iodelay: Measures round-trip latency in JACK audio system
• JACK Latency Test: Built-in tool for measuring system latency

These tools can help you objectively measure the improvements in your system’s audio performance after switching to an RT kernel.

Setting Up Your System for Audiophile Use

Simply installing an RT kernel won’t automatically optimize your system for audio. You’ll want to:

1. Configure your audio settings with appropriate buffer sizes
2. Set up JACK or PipeWire with RT priorities
3. Add your user to the audio group for proper permissions
4. Configure CPU scaling to performance mode
5. Disable unnecessary system services that might interrupt audio

For PipeWire users, additional real-time scheduling tweaks can enhance its performance, making it a viable alternative to JACK for low-latency, high-quality audio.

Are There Downsides?

RT kernels aren’t without trade-offs:

• Slightly higher CPU usage: The scheduler requires more processing power
• Potentially reduced overall throughput: Optimizing for latency can reduce maximum throughput
• Not always necessary for casual listening: Benefits are most noticeable in demanding scenarios
• May require more power: Particularly relevant for laptop users concerned about battery life

For serious audio work or critical listening, these trade-offs are usually worth it. For casual usage, the benefits might be less noticeable.

Conclusion

For Linux audiophiles seeking the ultimate in audio performance, RT kernels like XanMod RT provide tangible benefits by ensuring audio processing receives the precise timing and priority it deserves. By fine-tuning your Linux system with an RT kernel and proper audio configurations, you can unlock the best possible sound experience.

Whether you’re recording a masterpiece, mixing a soundtrack, or simply enjoying your carefully curated music collection, the consistent low-latency performance of an RT kernel might be the upgrade your audio system needs to reach its full potential. The improvements in timing precision, reduced jitter, and overall system responsiveness can elevate your listening experience to new heights.

The post RT Kernels for Audiophiles: Enhanced Audio Performance on Linux appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

The Origin and History of NTP

NTP was designed by Dr. David L. Mills in 1985, making it one of the oldest Internet protocols still in use today. Developed at the University of Delaware, it was created to address the need for precise timekeeping in early computer networks. Over the decades, NTP has evolved, with various enhancements improving its accuracy, security, and resilience. Today, it is widely used in industries ranging from finance to telecommunications and even space exploration.

How NTP Works

NTP operates using a hierarchical structure, where highly accurate Stratum 1 servers (directly synchronized with atomic clocks or GPS time sources) provide time to Stratum 2 servers, which in turn distribute the time to lower-tier systems. This cascading model ensures minimal load on primary time sources while maintaining high accuracy.

NTP uses the UDP protocol on port 123 to communicate and follows a complex algorithm to measure and correct time discrepancies. It continuously adjusts system clocks by calculating round-trip delays and clock offsets, ensuring highly accurate synchronization over a network. Modern NTP implementations also support security features like NTS (Network Time Security) to prevent tampering and spoofing attacks.

Practical Uses of NTP

NTP serves a critical role in various fields, including:

• Computer Networks: Synchronizing timestamps in distributed systems to prevent errors in transaction logging and event tracking.
• Financial Transactions: Ensuring accurate timestamps for stock exchanges, banking operations, and digital payments.
• Telecommunications: Keeping voice and data networks in sync to prevent latency and synchronization issues.
• Cybersecurity: Validating cryptographic timestamps to enhance security and integrity.
• Space and Scientific Research: Ensuring precision timing in astronomical observations and experiments.
• Amateur Radio: Essential for digital modes, log synchronization, and accurate APRS positioning.

List of Top Public NTP Servers

There are many public NTP servers available for worldwide use. Some of the most reliable include:

1. pool.ntp.org – A global cluster of NTP servers providing redundancy and availability.
2. time.google.com – Google’s high-accuracy NTP service.
3. time.windows.com – Microsoft’s default NTP service.
4. time.apple.com – Apple’s time synchronization service.
5. time.nist.gov – The U.S. National Institute of Standards and Technology’s official time server.
6. ntp.ubuntu.com – Canonical’s NTP server for Ubuntu users.
7. time.cloudflare.com – Cloudflare’s secure and highly accurate NTP service.
8. time.macos.apple.com – Apple’s macOS-specific NTP service.

These servers ensure that users worldwide have access to precise and reliable time synchronization.

Best NTP Server Software

For those looking to set up their own NTP servers, here are some of the best available NTP server software solutions:

1. ntpd (Network Time Protocol Daemon) – The most widely used NTP implementation, included in most Linux and Unix distributions.
2. Chrony – A lightweight and highly accurate alternative to ntpd, ideal for systems with intermittent network connectivity.
3. OpenNTPD – A simpler and more secure NTP daemon developed by the OpenBSD project.
4. Windows Time Service (w32time) – The built-in NTP service for Windows operating systems.
5. Meinberg NTP – A robust NTP distribution for Windows, based on the original ntpd.
6. GPSD and NTPsec – Specialized solutions that provide precise time synchronization using GPS time sources.

Each of these options has its own strengths and is suited for different use cases, from enterprise-level deployments to personal and embedded applications.

Why NTP Matters for Amateur Radio

For amateur radio operators, accurate timekeeping is more than just a convenience—it’s a necessity. Here’s why:

1. Digital Modes and Weak Signal Communications

Many modern digital communication modes, such as FT8, JT65, and WSPR, require tight time synchronization. A clock drift of just a few seconds can lead to failed decodes or missed transmissions.

2. Accurate APRS Positioning

The Automatic Packet Reporting System (APRS) relies on timestamps to properly relay position and telemetry data. A misaligned clock can cause packets to be out of sync, leading to errors in location reporting.

3. Logbook Accuracy for Contests and QSOs

In amateur radio contests, accurate timestamps are crucial for log entries. Organizations like the ARRL and CQ Magazine require precise time records to verify QSOs and prevent disputes.

4. Satellite and Moonbounce Communications

When working with satellite communications and Earth-Moon-Earth (EME) contacts, precise timing ensures that transmissions and receptions are correctly aligned for optimal signal propagation.

5. Emergency Communications and Coordination

During emergencies, ARES, RACES, and other ham radio emergency networks rely on accurate logs and coordinated transmissions. A well-synchronized network ensures efficient communication between operators.

Conclusion

Public NTP servers play an essential role in time synchronization for a vast array of applications, including amateur radio. Whether you’re a network administrator, a financial analyst, or a ham radio operator, ensuring precise time synchronization improves reliability, accuracy, and efficiency. Leveraging public NTP services can significantly enhance digital communications, log accuracy, and overall operational effectiveness in the amateur radio world.

If you’re an amateur radio operator, take a moment to configure your system to use a reliable NTP server—you’ll notice the benefits immediately!

References

• Network Time Protocol (NTP) – Wikipedia
• NTP Pool Project
• Google Public NTP
• Chrony NTP Service
• Meinberg NTP Software

The post Understanding Public NTP Servers: A Vital Tool for Time Synchronization appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What is FreshRSS?

FreshRSS is an open-source RSS feed aggregator that allows you to collect and read all your favorite content in one place. Unlike many other RSS platforms, FreshRSS is designed to be easy to set up, use, and customize to meet your specific needs. You can host FreshRSS on your own server, keeping control over your personal data and feeds.

What makes FreshRSS particularly appealing is its light footprint—designed to run on modest server hardware—and its extensive customizability, making it a fantastic tool for both hobbyists and professionals. Whether you’re following ham radio blogs, technical discussions, or personal news feeds, FreshRSS consolidates all your content into a single, organized interface.

Key Features of FreshRSS

1. Multi-User Support and Anonymous Reading Mode

FreshRSS isn’t just for solo users; it’s built to handle multiple accounts. Whether you’re a team of developers, ham radio enthusiasts, or just want to share access with friends or colleagues, FreshRSS makes it easy to manage multiple user profiles. Additionally, it includes an anonymous reading mode, allowing users to browse content without signing in. This is particularly useful for those who prefer a more private or casual browsing experience.

2. Real-Time Updates with WebSub

One of FreshRSS’s standout features is its support for the WebSub standard, which allows for real-time push notifications from compatible sources. Unlike traditional RSS, where you need to manually refresh or rely on polling intervals, WebSub enables instant updates as soon as new content is published on supported sites. This is particularly useful for staying updated with real-time information such as live ham radio broadcasts, news, or blog posts.

With WebSub, services like WordPress, Blogger, Medium, Friendica, and other compatible platforms can push updates to your FreshRSS feed instantly, saving you time and ensuring you’re always in the loop.

3. Mobile-Friendly with Native App Support

FreshRSS supports integration with mobile clients via two distinct APIs—Google Reader API and Fever API. These APIs ensure that you can use a wide range of mobile RSS apps like Readrops, Capy Reader, FeedMe, and FocusReader on Android or Fluent Reader, RSS Guard, and Newsboat on Linux and Windows.

These apps are capable of syncing quickly, fetching content even while offline, and managing your feeds in an intuitive, user-friendly way. For example, the Readrops Android app allows you to access FreshRSS with offline functionality and fast syncing, ensuring you have access to all your feeds regardless of connectivity.

4. Customizable Tagging and Web Scraping

FreshRSS allows you to create custom tags to better organize your feeds, whether you want to group them by topic, priority, or type of content. For instance, you can tag all your ham radio-related feeds with a specific label, making it easy to filter and find the content you’re most interested in.

Additionally, FreshRSS supports Web scraping via XPath, allowing you to scrape websites that don’t offer an RSS or Atom feed. You can also scrape JSON documents, further enhancing the flexibility of your feed aggregation. This is especially useful for sites that may have niche content but don’t provide a standard feed format. It means you can pull in content from any site, regardless of whether it offers RSS or not.

5. Feed Sharing and Export

FreshRSS isn’t just about reading your own feeds. It also allows you to reshare selections of articles via HTML, RSS, and OPML. This is particularly useful for ham radio groups or communities where you may want to share your curated list of articles, news, or resources with others. Whether it’s a blog post or a technical document, you can easily export or share it with others in a variety of formats.

Additionally, FreshRSS supports integration with external apps, providing a seamless experience across different platforms and use cases.

6. Advanced Configuration and Extensions

For those who want to fine-tune FreshRSS to meet their specific needs, the platform supports a variety of advanced configuration settings. These are located in the config.default.php file, which can be modified in data/config.php for customized behavior.

For users who want even more functionality, FreshRSS supports a wide range of extensions. These extensions allow you to add custom features, tweak the interface, or improve the integration with other tools. The repository dedicated to FreshRSS extensions provides numerous ways to further enhance the platform. From advanced filters to custom display themes, the possibilities are vast.

Why Choose FreshRSS on freshrss.hamradio.my?

By using freshrss.hamradio.my, you’re accessing a tailored experience for ham radio enthusiasts and hobbyists. The platform allows you to consolidate all your feeds, whether they’re related to amateur radio, tech blogs, or anything else you find interesting, into one organized interface. The security and customization that FreshRSS offers ensure that you have control over your data, all while providing a simple and intuitive user interface.

Additionally, with the inclusion of WebSub, mobile client compatibility, and web scraping features, you can stay updated instantly without worrying about manually refreshing or missing out on content.

How to Get Started with FreshRSS

To explore the demo, visit freshrss.hamradio.my. Here, you can try out the platform’s features, check how it works in a live environment, and decide whether FreshRSS fits your needs.

Once you’re ready to install FreshRSS on your own server, you can follow the instructions provided on the official FreshRSS GitHub repository. The GitHub page offers detailed installation instructions for manual installs, as well as automated deployment options using Docker, YunoHost, Cloudron, and other methods.

Contributing to FreshRSS

As an open-source project, FreshRSS thrives on contributions from the community. Whether you’re reporting bugs, suggesting new features, or developing new extensions, FreshRSS offers various ways for users to get involved. You can open issues, submit pull requests, or even develop new features to help improve the platform.

Visit the GitHub repository to learn more about contributing and to check out the documentation for setting up and maintaining FreshRSS.

Conclusion

FreshRSS is an excellent solution for anyone looking to aggregate and manage their RSS feeds in a clean, organized, and customizable way. By using freshrss.hamradio.my, you can experience the power and flexibility of FreshRSS while staying connected to the ham radio community and other interests. Whether you’re following live updates, scraping custom web content, or managing your feeds on the go, FreshRSS offers a full-featured, self-hosted solution that is perfect for power users and beginners alike.

Start your journey today with FreshRSS!

The post Explore FreshRSS on freshrss.hamradio.my: A Powerful Self-Hosted RSS Aggregator for Ham Radio Enthusiasts appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.