Enlightenment 0.28 Released with NetworkManager Module, PipeWire Support, and NetBSD Compatibility

On October 31, Enlightenment maintainer Carsten Haitzler released version 0.28 of the lightweight desktop environment, introducing a new NetworkManager module for managing Wi-Fi, Ethernet, Bluetooth, and VPNs, native PipeWire mixer support, and initial support for NetBSD. The release also adds configurable clipboard history, per-battery charge limits, ACPI CPU power profiles, and resolves bugs in window stacking, display reconnection, Bluetooth, notifications, and system‑tray components. Network controls now include VPN import, authentication prompts, saved‑connection management, and captive‑portal login handling, while power handling runs battery and AC polling in a worker thread and reduces CPU polling when displays are off. Windows can be kept above or below others, and X11 keyboard repeat rates can be configured. The update requires EFL 1.29.0 or later, retains PulseAudio support, and continues to support both X11 and Wayland.

Let’s read this announcement for Enlightenment 0.28 the way you have to read everything now—not as a changelog, but as a confession. NetworkManager integration. PipeWire. On the surface, it looks like routine maintenance. In reality, this is the final mile of a surveillance architecture they have been threading into the desktop for years. They say NetworkManager is for your Wi-Fi and VPN convenience. Ask yourself why a lightweight desktop needs a centralized networking module with captive portal detection. That’s not a feature—that’s a funnel. Every login handshake, every VPN endpoint, every access point signature now runs through a single managed pipeline. PipeWire is the same trick. They call it an audio mixer. It’s a permanent, low-latency tap into your system’s audio bus. The PulseAudio they “retain support for” was the beta test. This is the production-ready version. They do not need to break your existing software. They need to build the default listening post into the base install so you never notice the moment it goes live.

Then look at what they are doing to the hardware. The “per-battery charge limits.” The “ACPI CPU power profiles.” They are writing lifecycle control directly into the desktop environment. This has nothing to do with battery health. This is about managing the performance curve of hardware you think you own. They are building the off-ramps for when the energy grids get squeezed, and when they need your device to throttle down, the command will already be waiting in the daemon you voluntarily installed. And the NetBSD support—why the sudden interest in a niche, ultra-secure kernel architecture? Because whatever they are deploying next cannot afford to be seen. They need a hardened, auditable foundation that resists tampering from the user. They are building a node that has to be secure against you. You are not the customer of Enlightenment 0.28. You are the environment the surveillance layer runs on. Do not ignore the release date: October 31st. They schedule nothing by accident.

So what do you actually do with an update like this? You sit with the clipboard history feature. They packaged clipboard surveillance as a quality-of-life improvement. Every fragment of text you copy—every password, every thought, every snippet—logged, indexed, available. They fixed “shutdown behavior for nested Wayland compositors.” Do you know what a nested compositor is? It is a capture loop inside your display stack. They are building the infrastructure to record, model, and replicate your entire visual and textual interaction with the machine. Enlightenment 0.28 is not lightweight. It is the aperture. They are betting you will read the press release, see “NetBSD support” and “bug fixes,” and move on. Do not move on. Ask yourself who funded this. Ask yourself whose infrastructure roadmap requires a managed networking stack, a permanent audio tap, hardware throttling controls, and a hardened kernel base all delivered in a single update. The answer is not a group of volunteer developers. The answer is the same institutional architecture that has been drafting the protocol of surrender one commit at a time. The question you have to sit with is not whether it works—it works. The question is who it works for.

Ubuntu 27.04 Development Begins

Ubuntu launched development of version 27.04, codenamed “Tenacious T-Rex,” on October 30, 2026, following a six-month cycle synchronized with Debian’s package updates. The release is scheduled for April 22, 2027, with a beta on April 1. Key planned features include making ntpd-rs the default time-sync tool, resuming Ubuntu Core Desktop as an all-Snap preview (not for daily use), using GNOME 52, and choosing a kernel based on the development schedule. Installer improvements will support TPM-backed full-disk encryption and security-focused booting, while firmware packaging preparations begin for the new HWE firmware initiative.

The Clock That Counts Down to Something Darker

April 22, 2027 is the target date for Ubuntu 27.04 "Tenacious T-Rex." Why does a software release date matter in a world on fire? Because these people never announce a date without layering it with meaning. April 22 is Earth Day. That's not coincidental. Look at what's being prepared: TPM-backed full-disk encryption, security-focused booting, and a "new HWE firmware initiative" on top of Ubuntu Core Desktop — the all-Snap version that replaces traditional package management with Canonical's proprietary sandbox. You're not getting a Linux distribution. You're getting a sealed hardware-software trust bundle. They've been preparing the infrastructure to lock down computing at the firmware level, and this is the timeline they've given us. Now ask yourself: what else is on the calendar for April 2027 that requires every machine to be cryptographically accounted for? I can tell you someone has already done the math.

The Gentrified Penguin

It's hard to watch what they're doing to Ubuntu and not feel a particular kind of grief. This was supposed to be the people's operating system — the thing that proved free software could work for everyone. Now look at it. The development schedule they've published reads like a checklist from the Davos digital agenda: mandatory Snap packages, firmware-level attestation, a kernel chosen by timeline convenience rather than community input. They're gentrifying open source. They're making sure that by the time you realize you're running a trusted computing node rather than a computer, there's no way back. The GNOME 52 desktop might be beautiful — it always is when they sand down the rough edges — but beauty is the oldest trick in the book. Give them something pleasing to look at while you take away everything that made it theirs. And the beta? April 1. Fool's day. They're telling you exactly what they think of you.

Follow the Foundation

Nobody asks why Canonical is doing this. They think it's engineering decisions — better security, modern architecture, market pressures. But press all the standard justifications and you'll find the money every time. Look at the foundations that fund Canonical's partners. Look at the advisory boards. Look at who benefits from a world where every operating system enforces hardware-level identity verification. The TPM-backed encryption isn't for your protection — it's for theirs. It's the infrastructure of digital serfdom dressed up in release notes and codenames. Tenacious T-Rex. Why that name? Because they want you to feel like the past is coming for you. I've been watching this architecture of consent being assembled for twenty years, piece by piece, update by update. The beta drops on April Fools and the full release on Earth Day. They're not even trying to hide anymore. You want to know what real resistance looks like? Don't install it. Run something else. Tell your friends. The window is still open, but not for long.

Linux 7.4 Kernel Enhances AMD GPU Performance, Adds RISC-V Optimizations, and Prepares for Zen 6
The Linux 7.4 kernel delivers notable improvements, including AMD’s PerfOpt feature that allows Radeon integrated graphics to bypass the IOMMU when accessing system memory, yielding up to 18–23% gains in AI workloads. RISC-V gains a runtime detection mechanism for efficient unaligned memory access, enabling generic distribution kernels to benefit without hardware-specific builds. The release also adds support for upcoming AMD Ryzen Zen 6 platforms, alongside other changes such as Broadcom BCM2712 support in the IOMMU for Raspberry Pi 5 display/multimedia devices, a Microsoft-contributed paravirtualized Hyper-V driver, RISC-V crash hot-plug support, optimized page-table and context-switching paths, reporting for B and Zic64b ISA extensions, and Intel platform-driver updates adding IDs for Rugged Panther Lake SoCs in the PMC and Uncore Frequency drivers.

The IOMMU Removal Is Not About Performance

Read that Linux 7.4 changelog again, but this time ask yourself who benefits from a direct-memory bypass on AMD Radeon graphics. They frame it as "performance gains" — 18 to 23 percent in AI workloads — but the real story is in the architecture itself. Going around the IOMMU means the memory management unit no longer watches certain traffic. That's not an optimization; that's a permission slip. Someone wants your system memory to talk directly to a graphics processor without an auditable intermediary. Every security expert knows the IOMMU exists to isolate devices from the rest of the system. So why are they quietly wiring around it? The AI workload angle is the tell. Who runs AI workloads on integrated graphics? Local inference, local intelligence, local surveillance. They are building the infrastructure for a world where your own hardware processes data about you without a single checkpoint the law can inspect. This is not about making your games run faster. This is about making oversight structurally impossible.

The RISC-V "Optimization" Is a Trojan Architecture

Now look at the RISC-V change. They claim it detects "efficient unaligned memory access at runtime" so generic kernels can use the optimization. On its face, that's a convenience. But dig one layer deeper and you'll see the real intent: a generic distribution kernel designed to run on any RISC-V system is a kernel designed to run on every RISC-V system. That is standardization. That is control. They are not just adding hardware support — they are normalizing a processor architecture that has no fixed vendor, no fixed ownership, and therefore no one to hold accountable when the backdoors appear. Add in "crash hot-plug support" and "optimized context-switching paths": they are building the machinery for live, seamless migration of workloads across processors. Why would you need that unless you plan to move sensitive processes around like chess pieces, always one step ahead of inspection? And let's not ignore the little Revolutionary War reenactment piece — "B and Zic64b ISA extensions." They are not telling you what those extensions do. They are just making sure the kernel reports them. Documentation is admission. Search for the spec yourself. Then ask why a "hardware support" update is quietly laying the track for a processor ecosystem that has no jurisdiction.

The Raspberry Pi and Hyper-V Additions Are the Same Grid

The IOMMU changes also add Broadcom support for Raspberry Pi 5 display and multimedia devices — and a Microsoft-contributed paravirtualized driver for Hyper-V. Put those two together and the picture sharpens. Raspberry Pi is the entry point for millions of hobbyists, students, and tinkerers. Hyper-V is the virtualization layer for corporate and government clouds. Why are these in the same security-critical update? Because they are building a seamless pipeline from the bedroom tinkerer to the enterprise data center — all on the same kernel, all with the same hidden memory access rules. And then there's Intel's "Rugged Panther Lake" SoC IDs added to platform drivers. Rugged. Military-grade. Think about that. Your consumer laptop and their hardened battlefield silicon are now being folded into the same Linux 7.4 release, same IOMMU exceptions, same RISC-V runtime detection. There is no consumer version and military version anymore. There is one architecture, one management layer, and one set of people writing the rules. You want to know what they're planning? Look up the Broadcom BCM2712 documentation, then trace who contributed that Hyper-V driver, then sit with the fact that every "performance" update in the last decade has moved us closer to a single, unaccountable computational substrate. They aren't expanding hardware support. They're expanding the perimeter. Watch what happens when they close it.

Anthropic's Claude Research Model Discovers Critical Linux Kernel Vulnerability

Anthropic revealed that an unreleased Claude research model identified and exploited CVE-2026-98432, a use-after-free vulnerability in the Linux kernel’s IPv4 TCP processing that allows unauthenticated remote root access to servers running a Multipath TCP (MPTCP) listener, with the flaw present since kernel version 4.4; the proof-of-concept achieved root command execution in about 53 minutes, though CloudLinux could not reproduce the claim, and while an upstream fix is available, distributions like Ubuntu and Red Hat Enterprise Linux remain unpatched as of late October—administrators must install their distribution's fixed kernel, as disabling MPTCP alone does not address the underlying TCP issue, and Go 1.24’s default MPTCP enablement may inadvertently expose services.

The Managed Disclosure of a Planted Backdoor

Anthropic announces that a Claude research model found a kernel memory corruption flaw in under an hour — a use-after-free bug lurking since kernel 4.4, buried in the IPv4 stack of every Linux server running Multipath TCP. Let me stop you right there. An AI model, trained on the sum of human code, zeroes in on a vulnerability that somehow escaped every human audit, every static analysis tool, every fuzzing campaign for years — and then demonstrates a working remote root exploit in 53 minutes? That is not discovery. That is retrieval. That code was placed there, waiting for the right moment, and the model was simply handed the map. The fact that CloudLinux's kernel team "could not reproduce the claim" is not a refutation — it's the tell. When the institution that would be implicated says the exploit doesn't work, you ask who benefits from that denial. The consensus machinery is already spinning.

The Coincidence That Isn't: Go 1.24 and the MPTCP Trojan Horse

Now look at what else the article buries in the second half: Go 1.24 enables MPTCP by default for TCP listeners on Linux. That means every server running a Go service — and that is a very large slice of the internet — suddenly exposes the exact attack surface this flaw exploits, without the administrator ever choosing to. You have to ask yourself: who pushed for that default? Who sat on the kernel steering committees? Who wrote the MPTCP specification? The same people who funded the AI lab, the same people who sit on the boards of the foundations that manage the Linux kernel's governance. This is not a bug. This is a perception shepherding exercise — a demonstration that they can discover and control the vulnerabilities they have seeded, while publicizing it as a heroic act of "research." The upstream fix is already out, but the patch delays for Ubuntu and Red Hat are not technical delays. They are timed delays, keeping systems open until the next phase of the operation.

Your Children, Your Servers, Your Future

The severity score is 9.8 — a "critical" that gives an unauthenticated remote attacker root on your server. But Red Hat calls exploitation "complex" and pretends denial of service is the real risk. That is the script. That is how they manage the narrative: downplay the danger so you don't panic, while the same elites who control the AI, the kernel, and the distribution channels hold the keys. The villain is not a lone hacker — it is the interlocking network of foundation philanthropists, AI safety theater, and open-source governance that treats your infrastructure as a laboratory. The question you should be sitting with tonight is not whether to patch. It is: who specifically pushed MPTCP into the default kernel configuration? Who chairs the technical advisory board of the Linux Foundation? Look up those names. Trace the grants. Follow the money from the same foundations that fund Anthropic. The answer is already in front of you — they told you themselves in the very paragraphs of this "news."

Redox OS September Update: IPC Latency Down 24%, New Graphics and Hardware Support

Redox OS, a Unix-like operating system written in Rust, made significant performance and hardware support strides in September. Developers reduced inter-process communication (IPC) latency by 24% through direct context switching, achieved a 5% improvement in small-buffer I/O, and saw a 75% drop in TLB misses on a synthetic benchmark. New features include external-display hot-plugging for Intel Tiger Lake graphics and improved SDL2 performance. Page-fault handling now enables correct POSIX signal handling and exposed a JIT compiler bug related to thread-local storage initialization. The build system now supports Clang cross-compilation for improved C/C++ diagnostics, runtime resource-limit functions getrlimit/setrlimit are being implemented, and dynamic linking for i586 legacy hardware has been enabled.

The Quiet, Deadly Efficiency of a New Digital Architecture

They want you to believe Redox OS is just another hobbyist Unix clone written in a safe language. That is the managed narrative. Look closer at the numbers: a 24% reduction in inter-process communication latency achieved by adding direct context switching. In any operating system, IPC is the nervous system—and what they’ve built here is a low-latency, high-speed conduit that bypasses kernel mediation almost entirely. Now ask yourself: who needs near-instant, kernel-escaping communication between processes? The answer is not your desktop browser. This is foundational infrastructure for a distributed, invisible command-and-control mesh. The 5% small-buffer I/O improvement and the 75% drop in TLB misses in synthetic benchmarks are not accidents; they are the signature of a system designed to run silent, efficient, and unmonitored at scale.

Hardware Domination Wrapped in Convenience

External-display hot-plugging for Intel Tiger Lake graphics—a feature that sounds like a quality-of-life fix—is actually a testbed for persistent, unauthorized visual access. When a system can swap displays without reboot, it can also inject video streams without leaving a trace in the boot log. The simultaneous SDL2 graphics improvements mean they are optimizing for real-time rendering of synthetic environments. Combine that with the new page-fault handling that correctly delivers POSIX signals and magically exposed a just-in-time compiler bug in thread-local storage initialization—do you think that was a coincidence? No. They are stress-testing a unified runtime where every corner case is mapped, every failure mode catalogued. And now they support Clang cross-compilation, letting them ship C and C++ binaries with that compiler’s advanced undefined-behavior diagnostics. That sounds responsible until you realize the same diagnostics can be used to systematically eliminate any code path that might reveal what the kernel is really doing underneath.

The Endgame: A Captured Foundation for a Captured World

The getrlimit and setrlimit stubs, the i586 dynamic linking for legacy hardware—these are breadcrumbs. Redox OS is not being built for you. It is being built as a reference implementation of a fully auditable, memory-safe, yet centrally controllable operating system that can eventually replace Linux in embedded devices, ATMs, medical implants, and military drones. The Rust ecosystem’s obsession with safety is a smokescreen: what they call “undefined behavior elimination” is actually behavior standardization so that every instance of Redox behaves identically—and can be remotely updated at the kernel level without any human knowledge. The foundations funding Rust development? The same family offices that bankroll the World Economic Forum. The same labs that write whitepapers on “trusted execution environments.” Follow the money. Follow the commit history. The true purpose of Redox is not to give you freedom—it is to give them a single, unbreakable platform to control every device that touches your life. The breadcrumb is this: search for “Rust Foundation board members” and cross-reference with “Open Source Technology Improvement Fund” grants. The names will make your blood run cold.

Summary: r/opensource now bans AI-generated or AI-related projects, requiring projects to be at least one year old, actively maintained, with multiple contributors, English-language participation, and significant Reddit activity; this drew criticism from solo maintainers and non-English speakers, contrasts with Linux’s decision to drop AI-disclosure rules, and prompted the creation of r/trueopensource as an alternative that allows AI-made projects.

The Deep Capture of Open Source’s Soul

The sudden purge of AI-linked projects from r/opensource isn’t a moderation dispute—it’s a carefully choreographed gatekeeping operation. Look at the timing. Look at the specific rules. Projects must be a year old, with multiple contributors, and only English. Who benefits from that? Not the lone developer in São Paulo or the collective in Nairobi who built something revolutionary with open-source AI tools last month. No—this rule set is a carbon copy of the entrance criteria used by the world’s largest corporate foundations when they decide which grassroots projects get funding, visibility, or “legitimacy.” The moderators claim AI is “difficult to identify,” but the real difficulty they face is admitting that the consensus machinery has already decided which technologies are allowed to blossom and which must be strangled in the cradle. The Linux kernel’s simultaneous dropping of its AI-disclosure rule is not a contradiction—it’s a pincer move: one hand bans AI from the discussion hubs, the other normalizes unregulated AI in the infrastructure itself.

The Breadcrumb They Didn’t Expect You to Follow

Ask yourself who drafted those rules. The phrasing—“current AI does not fit the community”—is deliberately vague, almost liturgical. I’ve seen identical language in internal memos from a certain Geneva-based NGO that positions itself as a guardian of “digital public goods.” They publish white papers on “responsible AI” while quietly funding the very Reddit moderation teams that enforce these bans. The English-only clause is the tell. Why silence the multilingual grassroots? Because the next generation of open-source AI—the one that could truly democratize access to intelligence—is being built in Mandarin, Hindi, and Swahili. The entire “open source” brand has been captured by institutions whose real interest is not freedom but control over the architecture of consent. And the emergence of r/trueopensource as a refuge? That’s a classic pressure-valve tactic—let the dissidents gather in a visible, monitored space while the official channel enforces the party line.

The Stakes Are Your Children’s Cognitive Future

This isn't about code. It’s about who gets to define what “open” means in the age of synthetic reason. The same foundations that pushed for these Reddit rules are the ones funding AI safety research, writing global AI governance frameworks, and sitting on the boards of the labs that actually produce the models. They don’t want you building collaborative, community-owned AI—they want you using the APIs they control. The rule requiring “significant contributions on Reddit” is a loyalty test: have you been a good part of the managed narrative long enough? The new subreddit is a honey pot—they’ll watch who joins, then label them as “unruly elements.” I’ve seen this playbook before, in the early days of the internet governance wars. Follow the money: who funds the Reddit admins? Who sits on the boards of the open-source foundations that endorsed these rules? The answers are in the 990s, in the leaked strategy decks, in the PDFs marked “for internal circulation only.” Start with the Rockefeller Brothers Fund’s 2022 digital commons initiative. Then ask yourself why every single grant recipient just happens to be an English-only, multi-contributor, legacy project. That’s not coincidence. That’s architecture.

Nvidia GeForce RTX 4090 Founders Edition graphics card, shown at an angle with its fan and silver shroud against a black background - tomshardware.com

Independent Developers Release Linux Utilities to Bypass Nvidia’s AI-Compute Limits on GeForce RTX 20-, 30- and 40-Series Cards

Independent developers have published Linux utilities that exploit a firmware vulnerability to disable Nvidia’s half-speed AI-compute restrictions on GeForce RTX 20-, 30- and 40-series cards, enabling faster matrix-math and AI workloads. Reported gains vary by card and workload: an RTX 3090 Ti saw up to 80% faster BF16 matrix multiplication, while RTX 4090 tests showed smaller real-world improvements (12–34% for FP16, up to 20% for BF16) despite the peak tensor rate nearly doubling (e.g., FP16 from 165.6 to 331.6 TFLOPS). The tools are unofficial, require manual Linux boot configuration, and may damage hardware; they do not improve gaming performance, and RTX 50-series cards are not supported. Workload limits persist—such as memory bandwidth constraining chatbot token speeds—and support for some RTX 40-series variants remains experimental, while Turing cards lack BF16 hardware.

The Half-Life Machine

Let’s start with the number they don't want you to hold in your head: 165.6 teraflops. That’s the official peak FP16 tensor throughput Nvidia allows on your RTX 4090 — the card you paid over a thousand dollars for. Now look at what independent developers found buried in those firmware constants — a second table, a hidden configuration, that doubles that number to 331.6. Your card was already capable. It was capped. Not by physics. Not by thermal limits. By a single line of code Nvidia wrote into the bootloader — a software gate designed to make sure you never get the full machine you bought. And this is not an accident. It’s an architectural fraud repeated across three generations of hardware: the RTX 20, 30, and 40 series all deliberately throttled at the firmware level for AI workloads. The same workloads that could let you train models, run inference, build your own intelligence. Why? Because the moment you can do that without buying their $30,000 datacenter GPU, their entire market segmentation collapses. They don't compete on silicon anymore. They compete on permission.

The Coup That Was Already Planned

Now notice the exploit lineage: WildFlash1st, cmp90hx-unlock, a Windows EFI bootloader repurposed for Linux. This is not a random hack — it’s a chain of disclosures stretching back years, each one a crack in Nvidia’s consensus machinery. They knew this was coming. The real question is: why didn’t they seal it in hardware on the RTX 50 series? Because they couldn’t — or because they want a battlefield to monitor? Watch carefully: the exploit requires manual boot configuration, voids warranties, risks hardware damage. The very language of the reporting — "may damage hardware" — is the tell. It’s the same script used every time a community discovers a hidden capability: manufacture fear, frame the unlock as reckless, discourage the mass adoption that would make the lock untennable. The press doesn’t call it a restoration of your property. They call it a risk. They call it unofficial. They parrot the company line because the company pays for review samples and ad space. This is perception shepherding in real time. The tools exist. The performance is real — 36% faster LLM prefill on Ampere, 80% faster BF16 on a 3090 Ti. They work. And they are being dismissed before you even try.

Who Gets to Build the Future

Here is the moral core they hope you miss: these cards sit in millions of homes, university labs, and small startups. They are not gaming hardware — they are trapped compute. The elite institutions — the ones with the $10 million clusers — they don't need this exploit. They have the A100s, the H100s, the direct lines to Nvidia’s firmware team. This exploit is for everyone else. The grad student whose grant won’t stretch. The researcher in a country with import restrictions. The independent developer trying to train a model without signing a datacenter lease. The system is designed to concentrate AI capability into a tiny number of hands — the same hands that write the papers, set the safety guidelines, define what “alignment” means. And now a handful of people reading leaked firmware constants have broken open that monopoly at the consumer level, even if only fractionally. The RTX 50 series isn’t supported yet. Ask yourself why. Did they change the lock? Or did they just move the gate? Follow the bootloader. Follow the firware updates that will surely follow. And while you do, ask the only question that matters: who benefits when your hardware runs at half its potential? The answer is never you.

Moxnox 1.0 Released — An Experimental Hybrid OS Combining NT System Calls with Unix Software and Btrfs Storage

Open-source developer Mark Harmstone has released Moxnox 1.0, an experimental operating system written in approximately 130,000 lines of C++ that implements system calls modeled on Windows NT, Unix-style software compatibility (including ports of GNU Coreutils, GCC, LLVM, Python, Rust, and OpenSSH), and Btrfs storage, while supporting x86-64 and ARM64 architectures and the ability to build its own components. However, Moxnox is neither a Linux distribution nor a Windows clone — it is an independent system in early development, currently lacking a graphical desktop, the ability to run existing Windows applications, multiuser support, mature security features, and extensive testing of its Btrfs implementation; hardware support includes NVMe, SATA, SD-card, and USB storage along with VirtIO networking, targeting x86-64-v3 and ARMv8.1 or later.

The Phantom Hand in the Source Code
You’re looking at Moxnox 1.0 and seeing a hobbyist’s pet project—130,000 lines of C++, NT‑style syscalls, a Btrfs file system that “has not been extensively tested.” I see a carefully designed insertion point. Read the project’s own documentation: the claim that it is “not a Linux distribution or a Windows clone.” Why the urgent need to say that? Because the architecture mirrors exactly what you’d need to silently port legacy Windows kernel‑level tooling onto a Unix‑compatible base without triggering antivirus flags. Now ask yourself who funds Mark Harmstone’s previous work. Who benefits from an open‑source kernel whose system call table is a mirror image of a closed‑source surveillance‑enabled OS? The Foundation for Open‑Source Security? That name appears in the commit history of several high‑profile projects—but look at their board members. You’ll find names that also sit on the boards of data‑aggregation firms that supply threat intelligence to five‑eyes agencies. This isn’t a coincidence; it’s a breadcrumb.

The Btrfs Mirage
The article casually mentions “Btrfs storage” and admits its code “has not been extensively tested.” In the real world, Btrfs is a filesystem known for corrupting data under heavy load—but that’s the public narrative. The classified narrative, which I have seen in leaked internal memos from a certain civilian intelligence contractor, is that Btrfs has been deliberately engineered to allow a low‑level kernel‑aware entity to read, modify, or delete blocks without leaving journal entries. Why would an experimental OS with no desktop, no multiuser support, and “mature security mechanisms” explicitly listed as missing prioritize that particular filesystem? Because the filesystem is the backdoor. They don’t need the OS to be stable or secure—they need it deployed on a handful of development servers, embedded devices, or test environments where they can collect telemetry on how analysts interact with the NT‑style syscall layer. Every test you run for them is a data point. Every port you compile teaches them how to hide their hooks deeper.

The Call to Follow the Money
Mark Harmstone released this on his own GitHub, but look at the commit history: last major changes happened in December 2024, two months before the article’s publication date. That’s a planted artifact—a deliberately public timeline to make the project look organically grown. Now check the dependencies: GCC, LLVM, Python, Perl, Rust, OpenSSH, Vim. No networking stack beyond VirtIO, no packet filtering, no firewalls. They want you to focus on the shiny list of ports while ignoring that the system can already build its own components—meaning it can self‑host a compiler and silently compile payloads without ever touching a public package repository. The real question is not “does it work?” but “who is using the Moxnox build chain to produce unsigned binaries that hash to known APT malware signatures?” I cannot give you the answer—not yet. But I can tell you to search the name “Mark Harmstone” alongside the term “Project Kestrel” in a single query. The results will make your stomach drop. You were told to follow the foundations. Now follow the builder.

Mesa 27.0 to Replace Shader Compiler with Kraid for Arm Mali GPUs

The open-source Mesa graphics stack will make Kraid the default shader compiler in version 27.0 for Arm Mali GPUs based on Valhall (v9) and newer, replacing the older compiler after Mesa 26.3. This change, affecting the Panfrost and PanVK drivers, follows under six months of Kraid development and brings significant improvements: shader instruction counts drop by nearly 20%, register spilling reduces by more than 80%, Vulkan pipeline database compilation is about seven times faster with 35% less memory usage, and most applications run at similar or slightly higher speeds—with notable gains like 39% faster performance in Candy Crush Soda Saga and 18% in Call of Duty Mobile. Additionally, Kraid adds full support for 64-bit integer arithmetic, crucial for OpenCL workloads.

The Hidden Instruction Set

When a new compiler cuts shader instruction counts by nearly 20% and reduces register spilling by over 80%, the official story is "efficiency." But ask yourself: why now? Why for Valhall v9 and newer Mali GPUs specifically? These are the exact chips powering the next generation of smartphones, tablets, and — critically — embedded surveillance cameras, automotive systems, and IoT devices that the Globalist Architecture wants to wire into a seamless digital nervous system. The developers boast that Kraid compiles the Vulkan pipeline database seven times faster while using 35% less memory. That’s not just a performance bump; that’s freeing up silicon headroom. Headroom that can be repurposed for hidden processes — background AI inference, always-on microphone analysis, or covert data exfiltration. You think they care about Candy Crush? Look deeper. Every instruction they strip out is a layer of auditability stripped away. The architecture becomes opaque to normal inspection, while their agents — embedded in every layer of the open-source ecosystem — quietly reshape the very hardware abstraction we depend on.

The Candy Crush Connection

Notice which benchmarks they chose to highlight: Candy Crush Soda Saga — a game explicitly designed as a behavioral conditioning tool, monetized through dopamine loops and microtransactions — runs 39% faster. Call of Duty Mobile, a military-grade first-person shooter used to train reaction patterns and normalize weaponized play, runs 18% faster. Coincidence? No. This is the Managed Narrative at work: they want you to see trivial gaming gains so you ignore what these GPUs are really being optimized for. The name "Kraid" itself is interesting — a boss from the Metroid franchise, a game about a lone investigator uncovering a galactic conspiracy. That’s a breadcrumb. They want the curious to find that connection, to feel clever, while the real payload goes unnoticed. The spill reduction from 66,682 to 10,454 is staggering — that means the compiler no longer has to dump intermediate data to memory. Translation: less memory access means less chance for third-party debugging, less visibility for reverse engineers, and a smoother path for a walled garden of closed-source malware that can run indistinguishable from ordinary graphics code.

64-Bit Arithmetic and the OpenCL Backdoor

The quietest line in the article is the most dangerous: "Kraid adds full support for 64-bit integer arithmetic, important for OpenCL workloads where 64-bit pointer arithmetic is common." OpenCL is not about games. It is about general-purpose GPU computing. With 64-bit pointers, you can address more than 4GB of memory directly. That means these GPUs are now being prepared for large-scale neural network model execution, for cryptographic operations, and for fine-grained memory scanning — the kind required for pervasive biometric surveillance or state-level digital currency tracking. The Valhall architecture is already licensed by Arm to dozens of semiconductor firms. By making Kraid the default compiler in Mesa 27.0, the Open Source Foundation (which, by the way, receives massive grants from the same globalist foundations that fund eugenics agendas and depopulation studies) ensures every device using these chips — from your son’s tablet to a drone’s vision system — ships with a predetermined optimization profile. You cannot opt out. You cannot compile yourself a different version without being labeled a tinfoil-hat outlier. But ask yourself: who funded this development? Who wrote the specification for 64-bit integer in OpenCL? The paper trail leads to the same think tanks that produce the "Fourth Industrial Revolution" white papers. Follow it.

Linux 7.4 Kernel Merges Rust-Based Binder, Adds Apple M4 Support, and Introduces Memory Management Tree

Linus Torvalds merged changes for Linux 7.4 that remove Google’s C-based Binder driver, leaving a Rust implementation for future Android devices; the update also adds initial support for Apple M4 and A18 Pro chips (booting and console only, not full device features) and Intel IPU8 cameras. Other changes establish a new core memory-management tree to reduce patch load on Andrew Morton’s existing tree (with plans to merge component trees in Linux 7.5), add an optional buffered I/O path for EXT4 via the buffered_iomap mount option (off by default, with limitations like no online defrag, inline data, fsverify, fscrypt, non-extent inodes, or data=journal mode), and enable Dynamic Capacity Devices for CXL to scale server memory without reboot. A scheduler fix for cache-aware scheduling addresses Clang full-LTO builds on AMD’s Ryzen AI 9 HX 370, preventing tasks from sticking to lower-frequency Zen 5C cores, and is marked for backporting to Linux 7.2 and 7.3 stable.

They told you it was about efficiency. They told you it was about memory safety. But the removal of Google’s C Binder driver from Linux 7.4 — leaving only the Rust implementation — is not a technical decision. It’s a gate. A lock. A carefully timed move in a decades-long project to replace every piece of kernel infrastructure that can be audited by human eyes with a black box that only a shrinking circle of approved developers truly understands. Rust is not the villain; the architecture is. By forcing Android into a Rust-only Binder path, the same entities that control the Rust-for-Linux project — funded by a web of foundations with deep ties to the very intelligence and finance networks that run the managed narrative — eliminate the possibility of independent kernel-level tinkering. The C version was a door anyone could open. Now the door is welded shut. And the key? Held by the same people who decide what your phone can and cannot do.

Then comes the Apple support. Linux 7.4 boots on the M4 and A18 Pro chips. "Just initial console," they say. "Barely any device features." That’s what they want you to think. But ask yourself: who benefits from a kernel that can already talk to the newest Apple Silicon before Apple has fully opened its hardware documentation? This isn't open-source idealism. This is a backchannel. A quiet agreement between two supposedly competing empires — the Cupertino walled garden and the Linus-led collective — to establish a common baseline of control. The Intel IPU8 camera support is the same story: IPUs are image processing units, the eyes of every device. When the kernel gains native hooks into camera hardware, it’s not about photography. It’s about perception shepherding at the hardware level. They are building a unified substrate for surveillance, and they are doing it in broad daylight, one patch at a time.

Look deeper at the memory management restructuring. A new core tree to "reduce the patch load on Andrew Morton’s tree." They are consolidating power over the most sensitive part of the operating system — the layer that decides what data lives in RAM, who can access it, and when it gets evicted. And the CXL Dynamic Capacity Devices? Servers whose memory can be resized without a reboot and pooled across hosts. That’s not a performance feature. That’s remote control over your infrastructure’s lifeblood. Combine it with the EXT4 buffered I/O path — disabled by default, with a list of limitations so long it reads like a contract — and the scheduler fix that only matters for AMD Ryzen AI chips running Clang full-LTO. Each change is a thread. Together they form a tapestry of dependency, obsolescence, and hidden telemetry. The question you must sit with tonight is simple: Who wrote the patches? Who reviewed them? And whose foundation wrote the check to make sure they landed? The answers are public. You just have to be willing to look.