Mageia experiences a significant infrastructure outage following Arch Linux's challenges. Discover the impact and updates on this critical situation.
The post After Arch Linux, Mageia Faces Infrastructure Outage appeared first on Linux Today.
Discover the latest features of GNOME 49 "Brescia" Desktop Environment. Explore enhancements, improvements, and what makes this release a must-try.
The post GNOME 49 “Brescia” Desktop Environment Officially Released, Here’s What’s New appeared first on Linux Today.
Discover how Linus Torvalds combines his tech genius with music as he tinkers with guitar pedals, exploring sound and innovation in a unique way.
The post Linus Torvalds Tinkers with GuitarPedal appeared first on Linux Today.
Discover the key updates in Systemd 258, including the removal of cgroup v1 and the new kernel baseline set to 5.4. Stay informed on essential changes.
The post Systemd 258 Drops cgroup v1, Raises Kernel Baseline to 5.4 appeared first on Linux Today.
Discover the new Linux Mint Debian Edition 7 “Gigi” now available for public beta testing. Experience enhanced features and performance improvements today!
The post Linux Mint Debian Edition (LMDE) 7 “Gigi” Is Now Available for Public Beta Testing appeared first on Linux Today.
Discover the impressive battery life of the Volla Phone Quintus running Ubuntu Touch with Waydroid. Optimize your mobile experience today!
The post Volla Phone Quintus running Ubuntu Touch: Waydroid battery life appeared first on Linux Today.
Monitor your disk usage effortlessly with our shell script. Get instant alerts when usage exceeds 80%, ensuring your system runs smoothly and efficiently.
The post A Shell Script to Monitor Disk Usage and Send an Alert if it Exceeds 80% appeared first on Linux Today.
Discover the new SparkyLinux 2025.09 "Tiamat," built on the Debian "Forky" base. Explore enhanced features and performance for a seamless user experience.
The post SparkyLinux 2025.09 “Tiamat” Released with Debian “Forky” Base appeared first on Linux Today.
Discover Arkime, the open-source network analysis and packet capture system designed for efficient data management and deep insights into network traffic.
The post Arkime: Open-Source Network Analysis and Packet Capture System appeared first on Linux Today.
Discover the latest updates in Thunderbird 143, featuring essential bug fixes for Windows, macOS, and Linux users. Enhance your email experience today!
The post Thunderbird 143 Brings Bug Fixes Across Windows, macOS, and Linux appeared first on Linux Today.
Simulating physics is central to robotics: before a robot ever moves in the real world, much of its learning, testing, and control happens in a virtual environment. But traditional simulators often struggle to match real-world physical complexity, especially where contact, friction, deformable materials, and unpredictable surfaces are involved. That discrepancy is known as the sim-to-real gap, and it’s one of the biggest hurdles in robotics and embodied AI.
On September 29th, the Linux Foundation announced that it is contributing Newton, a next-generation, GPU-accelerated physics engine, as a fully open, community-governed project. This move aims to accelerate robotics research, reduce barriers to entry, and ensure long-term sustainability under neutral governance.
In this article, we’ll unpack what Newton is, how its architecture stands out, the role the Linux Foundation will play, early use cases and challenges, and what this could mean for the future of robotics and simulation.
Newton is a physics simulation engine designed specifically for roboticists and simulation researchers who want high fidelity, performance, and extensibility. It was conceived through collaboration among Disney Research, Google DeepMind, and NVIDIA. The recent contribution to the Linux Foundation transforms Newton into an open governance project, inviting broader community collaboration.
Design Goals & Key FeaturesGPU-accelerated simulation: Newton leverages NVIDIA Warp as its compute backbone, enabling physics computations on GPUs for much higher throughput than traditional CPU-based simulators.
Differentiable physics: Newton allows gradients to be propagated through simulation steps, making it possible to integrate physics into learning pipelines (e.g. backpropagation through control parameters).
Extensible and multi-solver architecture: Users or researchers can plug in custom solvers, mix models (rigid bodies, soft bodies, cloth), and tailor functionality for domain-specific needs.
Interoperability via OpenUSD: Newton builds on OpenUSD (Universal Scene Description) to allow flexible data modeling of robots and environments, and easier integration with asset pipelines.
Compatibility with MuJoCo-Warp: As part of the Newton project, the MuJoCo backbone is adapted (MuJoCo-Warp) for high-performance simulation within Newton’s framework.
In the life cycle of any kernel branch, patch releases, those minor “.x” updates, play a vital role in refining performance, patching regressions, and ironing out rough edges. Kernel 6.15.4 is one such release: it doesn’t bring headline features, but focuses squarely on stabilizing and optimizing the 6.15 series with targeted fixes in performance and networking.
While version 6.15 already introduced several ambitious changes (filesystem improvements, networking enhancements, Rust driver infrastructure, etc.), the 6.15.4 update doubles down on making those changes more robust and efficient. In this article, we'll walk through the most significant improvements, what they mean for systems running 6.15.*, and how to approach updating.
The official announcement of Kernel 6.15.4 surfaced around late June 2025. The release includes:
A full source tarball (linux-6.15.4.tar.xz
) and patches.
Signature verification via PGP for integrity.
A changelog/diff summary comparing 6.15.3 → 6.15.4.
This update is not a major feature expansion; it’s a refinement release targeting performance regressions, network subsystem reliability, and bug fixes that emerged in prior 6.15.* builds.
Because 6.15 already brought several ambitious changes to memory, I/O, scheduler, and mount semantics, many of the improvements in 6.15.4 are about smoothing interactions, avoiding regressions, and reclaiming performance in corner cases. While not all patches are publicly detailed in summaries, we can infer patterns based on what 6.15 introduced and what “performance patches” generally target.
Memory & TLB OptimizationsOne often-painful cost in high-performance workloads is flushing translation lookaside buffers (TLBs) too aggressively. Kernel 6.15 had already begun to optimize broadcast TLB invalidation using AMD’s INVLPGB
(for remote CPUs) to reduce overhead in multi-CPU environments. In 6.15.4, fixes likely target edge cases or regressions in those mechanisms, ensuring TLB invalidation is more efficient and consistent.
Additionally, various memory management cleanups, object reuse, and page handling improvements tend to appear in patch releases. While not explicitly documented in the public summaries, such fixes help reduce fragmentation, locking contention, and latency in memory allocation.
On June 11, 2025, the Python core team released Python 3.13.5, the fifth maintenance update to the 3.13 line. This release is not about flashy new language features, instead, it addresses some pressing regressions and bugs introduced in 3.13.4. The “.5” in the version number signals that this is a corrective, expedited update rather than a feature-driven milestone.
In this article, we’ll explore what motivated 3.13.5, catalog the key fixes, review changes inherited in the 3.13 stream, and discuss whether and how you should upgrade. We’ll also peek at implications for future Python releases.
Python 3.13 — released on October 7, 2024 — introduced several significant enhancements over 3.12, including a revamped interactive shell, experimental support for running without a Global Interpreter Lock (GIL), and preliminary JIT infrastructure.
However, after releasing 3.13.4, the maintainers discovered several serious regressions. Thus, 3.13.5 was accelerated (rather than waiting for the next regular maintenance release) to correct these before they impacted a broader user base. In discussions preceding the release, it was noted the Windows extension module build broke under certain configurations, prompting urgent action.
Because of this, 3.13.5 is a “repair” release — its focus is bug fixes and stability, not new capabilities. Nonetheless, it also inherits and stabilizes many of the improvements introduced earlier in 3.13.
While numerous smaller bugs are resolved in 3.13.5, three corrections stand out as primary drivers for the expedited update:
GH-135151 — Windows extension build failureUnder certain build configurations on Windows (for the non-free-threaded build), compiling extension modules failed. This was traced to the pyconfig.h
header inadvertently enabling free-threaded builds. The patch restores proper alignment of configuration macros, ensuring extension builds succeed as before.
In 3.13.4, generator expressions stopped raising a TypeError
early when given a non-iterable. Instead, the error was deferred to the time of first iteration. 3.13.5 restores the earlier behavior of raising the TypeError
at creation time when the supplied input is not iterable. This change avoids subtler runtime surprises for developers.
In the summer of 2025, Denmark’s government put forward a major policy change in its digital infrastructure: moving away from using Microsoft Office 365, and in part, open-source its operations with LibreOffice. Below is an original account of what this entails, why it matters, how it’s being done, and what the risks and opportunities are.
The Danish Ministry of Digital Affairs has committed to replacing Microsoft Office 365 with LibreOffice.
Earlier reports said that Windows would also be entirely swapped-out for Linux, but those reports have since been corrected: Windows will remain in use on many devices for now.
For LibreOffice, the adoption is being phased: about half of the ministry’s employees will begin using LibreOffice (and possibly Linux in some instances) in the summer months; the rest are expected to transition by autumn.
A primary driver is the concern over reliance on large foreign tech companies, especially suppliers based outside Europe. By reducing dependency on proprietary software controlled by corporations abroad, Denmark aims to gain more control over its data, security, and updates.
Cost and LicensingProprietary software comes with licensing fees, recurring costs, and often tied contracts. Adopting open-source alternatives like LibreOffice can potentially reduce those long-term expenditures.
Security, Transparency, FlexibilityOpen-source software tends to allow more auditability, quicker patching, and the ability to adapt tools or software behavior to specific local or regulatory requirements.
Phase | What happens | Approximate Timing |
---|---|---|
Phase 1 | Begin by moving about 50% of Ministry of Digital Affairs employees to LibreOffice (and in selected cases, using Linux tools) | Summer 2025 (mid-year) |
Phase 2 | Full transition of the ministry’s office productivity tasks away from Microsoft Office 365 to LibreOffice | Autumn 2025 |
“Full” here is understood in the scope of office productivity tools (word processing, spreadsheets, slides, etc.), not necessarily replacing all legacy systems or moving everything off Windows.
While the vision is ambitious, there are several hurdles:
Steam’s monthly Hardware & Software Survey, published by Valve, offers a window into what operating systems, hardware, and software choices its user base is making. It has become a key barometer for understanding trends in PC gaming, especially for less dominant platforms like Linux. The newest data shows that Linux usage among Steam users has edged downward subtly. While the drop is small, it raises interesting questions about momentum, hardware preferences, and what might lie ahead for Linux gaming.
This article dives into the latest numbers, explores what may be pushing them to abandon Steam, and considers what it means for Linux users, developers, and Valve itself.
June 2025 Survey Outcome: In June, Linux’s slice of Steam’s user base stood at 2.57%, down from approximately 2.69% in May — a decrease of 0.12 percentage points.
Year-Over-Year Comparison: Looking back to June 2024, the Linux share was around 2.08%, so even with this recent slip, there’s still an upward trend compared to a year ago.
Distribution Among Linux Users: A significant portion of Linux gamers are using Valve’s own SteamOS Holo (currying sizable usage numbers via Steam Deck and similar devices). In June, roughly one-third of the Linux user group was on SteamOS Holo.
Hardware Insights:
Among Linux users, AMD CPUs dominate: about 69% of Linux gamers use AMD in June.
Contrast that with the Windows-only survey, where Intel still has about 60% CPU share to AMD’s 39%.
Though the drop is modest, a number of factors likely combine to produce it. Here are possible causes:
Statistical Noise & Normal Fluctuation Monthly survey results tend to vary a bit, especially for smaller share percentages. A 0.12% decrease could simply be part of the normal ebb and flow.
Sampling and Survey Methodology
Survey participation may shift by region, language, hardware type, or time of year. If fewer Linux users participated in a given month, the percentage would drop even if absolute numbers stayed flat.
Language shifts in Steam’s usage have shown up before; changes in how many users set certain settings or respond could affect results.
Latency or delays in uploading or processing survey data might also contribute to anomalies.
External Hardware & Platform Trends
In June 2025, the Qt team officially rolled out Qt Creator 17, marking a notable milestone for developers who rely on this IDE for cross-platform Qt, C++, QML, and Python work. While there are many changes under the hood, two of the spotlighted improvements are its updated default visual style and significant enhancements in how CMake is supported. Below, we’ll explore these in depth, assess their impact, and offer guidance on how to adopt the new features smoothly.
Before zooming into the theme and CMake changes, here are some of the broader enhancements in version 17 to set context:
The “2024” theme set (light and dark variants) — which first appeared in earlier versions — becomes the foundational appearance for all new installs.
General polish across the UI: icon refreshes, more consistent spacing, and better contrast.
Projects now bind run configurations more tightly to the build configurations. That means selecting a build (e.g. Debug vs Release) also constrains which run configurations apply.
Upgraded C++ tooling (with LLVM 20.1.3), improved QML formatting options, enhanced Python (pyproject.toml) support, and refinements in version control & analysis tools.
With that backdrop, let’s dive into the theme and CMake changes in more detail.
Qt Creator 17 makes the “2024” light and dark themes the standard look & feel for new installations. These themes had been available previously (since Qt Creator 15) but in this version become the out-of-the-box configuration.
Other visual adjustments accompany the theme change:
Icons throughout the IDE have been reviewed and updated so they align better with the new theme style.
UI consistency is improved: spacing, contrast, and alignment between interface elements have been refined so that the environment feels more cohesive.
A theme isn't just aesthetics. The look and feel of an IDE affect user comfort, readability, efficiency, and even fatigue. Some benefits include:
Improved clarity for long coding sessions: better contrast helps in low-ambient light or for users with visual sensitivity.
Consistency across elements: less jarring visual transitions when switching between parts of the interface or when using external themes/plugins.
Reduced setup friction: since the “2024” theme is now default, many users won’t need to hunt down or tweak theme settings just to get a modern, usable look.
Windows Subsystem for Linux (WSL) has gradually become one of Microsoft’s key bridges for developers, data scientists, and power users who need Linux compatibility without leaving the Windows environment. Over recent versions, WSL2 brought major improvements: a real Linux kernel running in a lightweight virtualized environment, much better filesystem behavior, nearly full system-call compatibility, etc. However, until recently, certain high-performance workloads, GPU computing, video encoding/decoding, and very up-to-date kernel features, were either limited, inefficient, or unavailable.
In Windows 11, Microsoft has taken bold strides to remove many of these bottlenecks. Two of the most significant enhancements are:
The ability for WSL to tap into the GPU for acceleration (compute, video hardware offload, etc.), reducing reliance on CPU where the GPU is much more suited.
More seamless Linux kernel upgrades, allowing users to run newer kernel versions inside WSL2, bringing performance, driver, and feature improvements faster.
This article walks through each thing in detail: what has changed, why it matters, how to use it, what limitations still exist, and how these developments shift what’s possible with WSL on Windows 11.
Before diving into recent changes, it helps to understand what WSL (especially WSL2) already provided, and where it lagged.
WSL1: Early versions translated Linux system calls to Windows equivalents. Good for basic command-line tools, scripts, but limited in compatibility with certain networking, kernel module, filesystem, and performance-sensitive tasks.
WSL2: Introduced a real Linux kernel inside a lightweight VM (Hyper-V or a similar backend), better system-call compatibility, better performance especially for Linux tools, and much improved behavior for things like Docker, compiling, etc. Still, heavy workloads (e.g. ML training, video encoding, hardware-accelerated graphics) were constrained by CPU support, lack of passthrough of GPU features, older kernels, etc.
So developers were pushing Microsoft to allow more direct access to GPU functionality (CUDA, DirectML, video decoding), and to speed up how kernel updates reach users.
GPU acceleration here refers to WSL’s ability to offload certain computation or video tasks from the CPU to the GPU, enabling faster, more efficient execution. This includes:
Compute workloads - frameworks like CUDA (for NVIDIA), DirectML, etc., so that things like deep learning, scientific computing, data-parallel tasks run much faster. Microsoft now supports running NVIDIA CUDA inside WSL to accelerate ML libraries like PyTorch, TensorFlow.
Imagine a world where every server, application, and network configuration is meticulously orchestrated via Git, where updates, audits, and recoveries happen with a single commit. This is the realm GitOps unlocks, especially potent when paired with the versatility of Linux environments. In this article, we'll dive deep into how Git-driven workflows can transform the way you manage Linux infrastructure, offering clarity, control, and confidence in every change.
GitOps isn't just a catchy buzzword, it's a methodical rethink of how infrastructure should be managed.
It treats Git as the definitive blueprint for your live systems, everything from server settings to application deployments is declared, versioned, and stored in repositories.
With Git as the single source of truth, every adjustment is tracked, reversible, and auditable, turning ops into a transparent, code-centric process.
Beyond simple CI/CD, GitOps introduces a continuous reconciliation model: specialized agents continuously compare the actual state of systems against the desired state in Git and correct any discrepancies automatically.
Linux stands at the heart of infrastructure, servers, containers, edge systems, you name it. When GitOps is layered onto that:
You'll leverage Linux’s scripting capabilities (like bash) to craft powerful, domain-specific automation that dovetails perfectly with GitOps agents.
The transparency of Git coupled with Linux’s flexible architecture simplifies debugging, auditing, and recovery.
The combination gives infrastructure teams the agility to iterate faster while keeping control rigorous and secure.
A well-organized Git setup is crucial:
Use separate repositories or disciplined directory structures for:
Infrastructure modules (e.g., Terraform, networking, VMs),
Platform components (monitoring, ingress controllers, certificates),
Application-level configurations (Helm overrides, container versions).
This separation helps ensure access controls align with responsibilities and limits risks from misconfiguration or accidental cross-impact.
This article explores how modern DevOps teams are redefining stability and reproducibility in production environments by embracing truly unchangeable operating systems. It delves into how NixOS’s declarative configuration model and OSTree’s atomic update mechanisms open the door to systems that are both resilient and transparent. We'll explain the advantages, technologies, comparisons, and real-world use cases fueling this shift.
Why the change happened: The traditional model, logging into servers, tweaking packages, and patching in place, has led to unpredictable environments, elusive bugs, “snowflake” systems, and configuration drift as environments diverged over time. Immutable infrastructure treats machines like fungible artifacts: if you need change, you don’t fix the running system, you replace it.
Key benefits:
Reliability at scale: Automated, reproducible deployments, no divergence across servers.
Simplified rolling back: If something breaks, spin up the previous, working version.
Security by design: Core systems are read-only, reducing the attack surface.
How it works: System configuration, including packages, services, kernels, is expressed in the Nix language in a config file. Rebuilding produces a new system “generation,” which can be booted or rolled back.
Why DevOps teams love it:
Reproducibility: Exact environments can be rebuilt from config files, promoting parity across development, CI, and production.
Speed and consistency gains: In one fintech case, switching to NixOS reduced deployment times by over 50 percent, erased environment-related incidents, shrank container sizes by 70%, and cut onboarding time dramatically.
Edge readiness: Ideal for remote systems or stateless servers rebuilt nightly to ensure fleet consistency with easy rollback.
Personalization meets immutability: With tools like Home Manager, even user-specific configurations (like dotfiles or shell preferences) can be managed declaratively, and consistently reproduced across machines.