Linux inside Windows 95 & GPS timing, relativity, accuracy - Hacker News (Apr 22, 2026)

Let’s start with that retrocomputing curveball: an experimental project called “Windows 9x Subsystem for Linux,” or WSL9x. The idea is to run a modern Linux kernel in a cooperative, ring-0 setup alongside the Windows 9x kernel—skipping hardware virtualization entirely. The author says it didn’t require weeks of spelunking through Windows 95 internals either; just leaning on a handful of VMM services for basics like threads and memory context. Why it matters: beyond the sheer hack value, it’s a reminder that “subsystems” don’t always need a hypervisor. If this direction holds up, it could reopen interesting paths for running meaningful Linux tooling in extremely constrained legacy environments—something we haven’t talked about much since the Cooperative Linux era.

Staying in the “how computers see the world” lane, there’s a clear interactive explainer on GPS that’s worth your time, even if you think you already get it. It frames GPS as a time problem first: satellites send timestamps, your receiver turns time-of-flight into distance, and multiple satellites narrow that down into a real location. The twist that still surprises people is how central relativity is. Satellite clocks don’t tick at the same rate as clocks on Earth, and without correcting for those effects you’d rack up huge location errors fast—on the order of kilometers per day. The practical takeaway: modern positioning isn’t just clever geometry; it’s physics, statistics, and messy real-world signal problems like reflections in cities all layered together.

Now to AI on the creative side: OpenAI announced ChatGPT Images 2.0, pitching it as a step toward image generation you can actually direct—especially when text and layout are involved. The headline improvements are better prompt adherence, more dependable typography, and stronger multilingual text rendering. Why it matters: reliable text inside images is a big deal because it’s the difference between “cool demo” and “usable artifact.” If a model can consistently produce clean labels, panels, and structured compositions, you’re closer to end-to-end design output—things like posters, infographics, or editorial graphics—without a human spending half the time fixing broken lettering.

Another AI theme today is less flashy but arguably more important: agents are shifting from chat sessions to long-running background work—triggered by schedules, webhooks, and remote control across devices. One post argues that the usual HTTP request plus streaming approach just doesn’t map to that world. The core point is simple: if the agent’s work outlives your connection, you need a communications layer that survives disconnects, supports push updates, and works when multiple people—or multiple devices—are involved. The author calls this missing piece “durable transport,” and positions it as the next step beyond just “durable state.” If you’re building agent products, this is a good lens for why so many prototypes feel brittle in real life.

On the human side of AI development, Reuters and Business Insider report internal pushback at Meta over a new workplace monitoring tool. The initiative is said to record keystrokes and mouse movements, and to capture occasional screenshots during work app usage, with the stated goal of training AI systems to better understand how people use computers. Why it matters: this is exactly the kind of dataset that could accelerate “computer-using” agents, but it sits right on top of consent, privacy, and trust. Even if the intent is research, the optics are rough—and for Meta, privacy controversies are not a side story. Expect more companies to wrestle with this tension as agent ambitions collide with the reality that useful behavioral data often comes from watching humans work.

Switching gears to robotics and simulation: Google DeepMind’s MuJoCo continues to be actively maintained, with ongoing releases and improvements across tooling and platform builds. MuJoCo is one of those unglamorous foundations—fast, accurate physics simulation—that a lot of robotics and reinforcement learning work quietly depends on. Why it matters: when a simulator becomes a standard benchmark environment, improvements affect reproducibility and accessibility. Better builds and broader integrations mean more people can run the same experiments, compare results, and iterate faster—especially as more tooling moves toward browsers and lightweight environments.

In biomedical tech, researchers at the Terasaki Institute described an electronics-free smart contact lens aimed at glaucoma care. It monitors intraocular pressure and can automatically deliver medication when pressure rises, using microfluidic channels and pressure-triggered reservoirs. A smartphone app reads a visible indicator and uses a neural network to interpret it. Why it matters: glaucoma management has two stubborn problems—pressure checks are typically occasional, and adherence to daily drops is imperfect. A lens that both monitors and doses could reduce the gap between “what the treatment plan says” and “what happens at home.” It’s early, with rabbit testing and open questions like overnight monitoring and long-term comfort, but the direction is compelling: closed-loop therapy without packing electronics into your eye.

For programming language folks, Nick Fitzgerald introduced a proof-of-concept Rust garbage collector called `safe-gc` that forbids unsafe code entirely. The big design move is refusing to let you dereference GC pointers directly. Instead, you access objects through a heap handle, which keeps Rust’s borrowing rules in play. Why it matters: garbage collection in Rust usually forces someone to write unsafe code somewhere—either inside the library or in user-defined tracing. This project shows a different trade: you can keep memory safety airtight, even if users make mistakes, at the cost of some ergonomics and likely performance. It’s a practical example of Rust’s philosophy: you can often move problems from “memory corruption” into “explicit constraints and manageable failure modes.”

And finally, a lighter but useful item: a website curating dozens of widely cited “laws” and heuristics in software engineering—things like Conway’s Law, Brooks’s Law, leaky abstractions, and Goodhart’s Law. It’s organized as a reference and a shared vocabulary. Why it matters: these aren’t literal laws, but they’re recurring patterns. Having them in one place helps teams communicate about trade-offs—especially when the tricky parts aren’t just code, but planning, coordination, and the gap between how systems look on paper and how they behave under stress.