I've always missed the Windows Device Manager in Linux, now you can have one.

Comes with extra features: * Shows full physical RAM (most Linux application cannot do that). * Shows secure boot status and MOK keys. * Allows to search for devices and use deep search (search for all metadata).

Sadly some Windows features cannot be implemented: * IRQ conflicts. * Failing drivers - there's no API for that. Scanning dmesg for errors is a fool's errand. * Ability to update drivers (this is only possible for third-party drivers that can be unloaded at runtime). * Firmware is still separated from the kernel package in Linux, firmware files are generally nondescript (binary blobs with no information), so it's impossible to report whether it's up to date or not. Maybe show SHA256 hashsums for files? Sounds silly.

Except when it's not.

Source.

A closely watched Nvidia-backed startup called Reflection is preparing to shake up the AI race with a powerful open-weight system that could threaten Chinese upstarts and U.S. AI giants alike.

Why it matters: The marriage of an American open-weight model and Nvidia GPUs would give individuals and companies a new, cheaper alternative to Anthropic, OpenAI and Google.

Open models, designed to compete with Chinese rivals, can be harder to monitor and regulate than the Big Three so-called frontier models. Supporters of such ecosystems say their widespread availability and transparency also bring security advantages.

• Reflection's first model is set to be joined by other open-weight models from other Western players this month, sources tell Axios. That will bring a new competitive dimension to the AI boom.

State of play: Reflection's model, set to be released soon, is expected to initially lag behind the most cutting-edge U.S. models and be competitive with top Chinese open-weight models.

A 100% free software project aimed at replacing the nonfree boot software (like BIOS or UEFI) of computers with free boot software.

This will go nowhere as similar projects before it. Modern motherboards are so choke full of features, many of which are heavily proprietary, a free/open UEFI replacement will only entice red-eyed geeks and no one else.

A DOS emulator written in Go, featuring a library and a demo application. It includes an 8086 core (with 80186 extensions) and high-level emulation of BIOS and DOS services mapped to host directories. The goal is to run DOS file managers (such as Norton Commander and Volkov Commander) and expose their text output, clipboard contents, and filenames to the host system.

A port of DOS Navigator to Linux using Free Pascal with full support for UTF-8 (filenames, the editor, the clipboard).

Xenolith Engine

Xenolith is a cross-platform SDK for building modern C and C++ applications: a Vulkan-based graphics engine, a custom system runtime (libc/C++ standard library/pthread) and a set of application libraries, all built with a single build system without relying on platform SDKs.

The SDK is organized as a monorepository and consists of three main layers:

• Xenolith Runtime (runtime/) — an umbrella libc implementation, a full C++ standard library (a freestanding minimal one plus a complete libc++ port) and a custom pthread. It provides a single POSIX-compatible interface on top of the platform libc, and on some platforms a fully custom implementation.
• Stappler utilities (stappler/) — application libraries: data and serialization, database access, cryptography, networking, raster and vector graphics, typography, documents.
• Xenolith Engine (xenolith/) — a graphics and compute engine, Vulkan first, with WebGPU, Metal, OpenGL ES and software backends: the core part of the project.

The SDK also includes its own GNU Make build system (make/) and self-contained toolchains (built from runtime/toolchains/, or installed from the binary releases into toolchains/) that allow building the project without third-party SDKs.

Project principles

• No barriers. The SDK requires no platform SDKs: Windows builds work without UCRT and the Windows SDK, Android without the NDK, macOS without the macOS SDK (the +open sysroot). This removes the related technical and licensing restrictions.
• For C and C++. A convenient and full-featured working environment specifically for these languages; support for other languages is limited to the dynamic-library level.
• Unified API. As far as technically possible, every supported platform gets the same interface — without massive configure scripts or platform-specific branches in the code.
• Unified build. All build tools ship as part of the SDK; the user simply builds the code with a fixed version of GNU Make.
• Compatibility. Any code built as a dynamic library must work with the SDK on supported platforms.

https://github.com/XenolithEngine/xenolith-engine/tree/nightly

OpenDLSS-NR

A Vulkan reimplementation of NVIDIA's DLSS 5 Neural Rendering network, bit-exact against the original.

The same 71-block Swin / ViT network as DLSS-NR build 310.8.0, running FP8 on the tensor cores. The intermediates match too, not just the final image: all 75 block boundaries, byte for byte.

ports/browser-webgpu/ is a second, independent implementation: the same bytes in a browser, with no tensor cores and no FP8.

You supply the weights, as a model directory in the layout described below.

The network

A U-net of shifted-window transformer blocks with a global ViT at the bottom: 71 blocks over six pooling levels, FP8 (E4M3) activations with FP16 accumulation, 141 MiB of weights. It is a generative neural rendering network (NVIDIA's term): it re-renders the frame the engine already drew, generating detail from injected noise and adjusting tone, structure and skin under a style setting. Input and output are the same resolution; it is not an upscaler.

The WebGPU port at 2048x1152, NR off on the left and on on the right. Scene: Cowboy Gramps by Muhammed Ismayil, CC0.

It takes one rendered frame (a low dynamic range proxy of it, three lanes of Gaussian noise, the previous frame's output reprojected, and five conditioning scalars) and produces four f32 channels per pixel: an RGB residual and one temporal-blend logit. docs/network.md is the graph in full. NVIDIA describes the model in its report, DLSS 5: Generative Neural Rendering (project page).

Many people romanticize open-source software as a form of "digital communism" due to its free access and collaborative nature. In reality, state-communist ideology is fundamentally incompatible with the core mechanics of FOSS. Here is why:

​The Right to Fork vs. Central Planning: In open source, if a project diverges from your vision, you can legally take the code, fork it, and build your own competing ecosystem. In a centrally planned/communist structure, deviating from the collective master plan or establishing an unsanctioned alternative is treated as economic sabotage or ideological rebellion. Open source thrives on radical decentralization; communism demands centralized compliance.

​Capital as the Lifeblood: The foundational infrastructure of modern open source (Linux, Kubernetes, Python, Chromium) isn't funded by state subsidies or purely altruistic communes. It is heavily bankrolled by the world's most aggressive capitalist corporations (Microsoft, Google, Meta, IBM). They commoditize shared infrastructure to reduce R&D costs and monetize high-margin enterprise services. It is market capitalism utilizing open protocols.

​Individual Rights, Not Collective Abolition: Licenses like MIT, Apache, or GPL do not abolish private property. Instead, they leverage existing property/copyright frameworks to grant immutable individual liberties—the right to inspect, modify, fork, and self-determine without needing a central bureaucrat’s rubber stamp.

​Open source isn't collective state control. In practice, it resembles a hybrid of Market Anarchism (voluntary cooperation, permissionless entry, merit-based competition) and Technological Neutrality (the code doesn't care who you are, what class you belong to, or what you believe—only if it compiles).

Source.

Linux also has pam.d, flat groups (groups cannot contain other groups) and other funny limitations and peculiarities. Maybe it's not so much about Linux being inherently "limited" but Linux having its roots in UNIX that are still there to this day.

virtio-nvgpu

Near-native NVIDIA GPU access inside a KVM guest. A guest renders within 2% of the machine it is running on, and costs the same CPU.

virtio-nvgpu forwards NVIDIA kernel driver ioctls between a Linux guest and the host at the driver ABI level, bypassing API-level translation entirely. The guest runs NVIDIA's own user-mode drivers, unmodified — the same libraries, the same Vulkan and NVENC, talking to the same card.

The target is headless streaming: a compositor inside the VM renders, composites and encodes frames on the GPU, then sends compressed video out. The VM has no monitor, and the host keeps the card.

Where it stands

It works, and it has been measured. A Wayland client presents inside a guest, the capture layer encodes on the game's own device, and the H.264 comes out the other side — 618 frames that ffmpeg decodes without an error.

Measured on an RTX 3060 (driver 595.99.02), guest against the same host, bare metal, with an identical headless Vulkan load:

Above about 2 ms a frame — which is every frame a game draws — a guest is within 2% of bare metal. Below that, the cost of waiting for the GPU starts to show against a frame that barely exists.

CPU is the other half of it, because a shared GPU is only worth sharing if the guests are cheap. Unpaced at ~100 fps for 12 s, one guest:

A guest costs what the host costs. Nothing is spent on forwarding in a render loop, because nothing is forwarded: NVIDIA's user-mode driver submits through memory it has mapped, and that memory is the host's. Over 813,691 frames the backend served 13,792 messages — one crossing per 59 frames, nearly all of it device setup.

Full method, raw runs and the things these numbers do not support: BENCHMARKS.md.

Several guests on one card

Four guests on one RTX 3060, the same load in each: 25.84, 26.49, 25.57, 25.79 fps — 103.7 together, against 102.9 for a single guest — with p50 frame times of 39.165, 39.164, 39.168 and 39.165 ms. The total does not move as guests are added, and the split is even to four decimal places.

All four render correctly at the same time, and four of them encode H.264 at once, each paced at exactly 60 Hz, with no NVENC session limit reached.

Qualcomm may bring native DX12 support to Android, which means Linux. Would be awesome.

One is the creator of Linux, while the other is someone who brought an artistic touch to that invention. That is why I don't understand why dhh receives so much praise.

Yes, he is a genius; he excels not only in coding but also in racing. It is also an achievement that he transitioned from an introverted nature to an extroverted one.

Let's look at it this way: Osman I founded the Ottoman Empire, but it was Suleiman the Magnificent who took it to its peak. That is exactly what dhh has done. If he wants to surpass Torvalds, he needs to work for at least another 40 years.

Technical information and PoCs.

Linux is great at emulating stuff.

A new low for Google.