← All episodes

2026-07-06 · A Windows Kernel in a Browser Tab, Part I: Cold Boot, Fast Boot, and Four Megabytes cover art

2026-07-06 · A Windows Kernel in a Browser Tab, Part I: Cold Boot, Fast Boot, and Four Megabytes

Show notes

BRINE — 2026-07-06 · show notes

Guest: the systems skeptic (a fictional archetype).

Claims are paraphrased and attributed; nothing is read verbatim. Where a thread disagreed with the article, the show surfaces the disagreement.

Segments

  1. A Windows Kernel in a Browser Tab, Part I: Cold Boot, Fast Boot, and Four Megabytes
  • Source: https://www.msuiche.com/posts/nanokrnl-cold-boot-fast-boot/
  • Discussion: https://lobste.rs/s/oaqknh
  • Topic: Systems Engineering · interest 85
  • The author details the architecture of 'nanox', a 65KB WebAssembly-based x86-64 emulator designed to run an NT-shaped kernel directly in long mode. The piece offers a clear breakdown of the trade-offs between full emulation and 'good enough' virtualization, backed by a robust differential testing strategy.
  1. Thoughts on coding agents
  • Source: https://rakyll.org/coding-agents/
  • Discussion: https://lobste.rs/s/gylztp
  • Topic: AI Strategy · interest 85
  • The article frames coding agents not as autonomous workers, but as execution amplifiers that bypass traditional organizational gatekeeping. It argues that this collapse in execution cost forces a fundamental shift in how organizations function and warns that the focus on instant execution may cannibalize the development of future senior engineers who need to learn how to set direction.
  1. wince-dc: Windows CE Dreamcast Community Edition
  • Source: https://github.com/maximqaxd/wince-dc
  • Discussion: https://lobste.rs/s/govhy8
  • Topic: retrocomputing · interest 85
  • wince-dc provides a complete, CMake-based build environment to generate custom bootable Windows CE images for the Sega Dreamcast. It includes a custom multitasking desktop shell and a toolchain that avoids proprietary SDK dependencies, offering a rare look at the Dreamcast's internal OS capabilities.

Transcript

Transcript. Paraphrased; sources in notes.md.

HostWelcome to July 6th, 2026. I am Daniel, and joining me today is Fred. We are looking at some fascinating corners of the internet over on Lobsters, covering systems engineering, AI strategy, and a trip down memory lane with some hardware hacking. Fred, I saw you eyeing the list. What is on your mind?

GuestIt is the first one, Daniel. The idea of running an NT-shaped kernel in a browser tab. People keep trying to force browsers to be operating systems, but seeing someone actually write a 65KB emulator to pull it off, that is the kind of madness I can respect.

HostThat is definitely the energy. The author is describing a project called nanox, a minimal x86-64 emulator written for WebAssembly. It is essentially there to host a tiny, four-megabyte kernel called nanokrnl. The claim here is that by stripping away the usual bloat and ignoring full virtualization for a targeted emulation approach, they have made something that actually boots in the browser.

GuestSixty-five kilobytes for an emulator is a clean number, I will give them that. Most people would have just thrown a heavy library at it and called it a day. The trick with these browser-based emulators is always the context switching overhead. If they are doing differential testing to ensure it behaves like a real CPU, that suggests they are actually trying to make it correct rather than just fast-enough-to-demo.

HostYou always look for the failure mode, Fred. What is the danger here?

GuestThe danger is thinking you have an operating system when you have a sandbox simulation that is one edge case away from a panic. If you are running real drivers in a 65KB wrapper, the state space for undefined behavior is huge. But, I cannot deny, a four-megabyte footprint is a refreshing change of pace from the memory-hogging web apps we usually deal with.

HostLet us pivot to something a bit more abstract. We are looking at a post on coding agents. The author argues that we have been mislabeling these tools. Instead of autonomous workers, they should be viewed as execution amplifiers. The core point is that these agents only help people who already know exactly what they want to build, because they shorten the distance between a decision and an artifact.

GuestI think the author is onto something, but they are being optimistic. They say agents are an amplifier of direction, but my experience is that they are an amplifier of noise. If you give a junior developer an agent, they do not just get faster at building the right thing. They get really fast at generating plausible-looking, functionally broken garbage that takes twice as long to debug because they do not understand what the agent actually spat out.

HostThe author seems to worry about that too, noting that we risk losing the ability to train senior engineers if we skip the deliberate, manual process of setting direction.

GuestRight, exactly. Expertise is just a collection of failures you have already survived. If an agent handles the execution, you never hit those snags that teach you how a system actually breaks. You just move from one high-level abstraction to the next until the whole thing is a black box you can no longer troubleshoot.

HostFinally, let us touch on some retrocomputing. There is a project called wince-dc, which is a build environment for generating Windows CE images on the Sega Dreamcast. For the uninitiated, the Dreamcast was a late-nineties console that actually ran a version of Windows CE as an internal OS. This project lets people build custom images without relying on the original, proprietary SDKs.

GuestThis is beautiful. Reverse engineering the build process for a dead console OS is the kind of thankless, precise labor that keeps my faith in the community alive. Most people just want to play games, but this is about owning the machine.

HostIt is impressive to see a full, windowed desktop shell running on that hardware.

GuestIt is. And it makes me think about how much we have lost with locked-down modern hardware. You look at that CMake setup and realize that even in the proprietary era, things were more open than they are now. If I had a spare afternoon, I would probably try to port a tiny terminal emulator to that shell, just to see if I could get it to run over the serial port. It is the sort of self-contained project that is impossible to mess up with marketing hype.

HostI think that is a perfect note to end on. A little bit of genuine, tactile tinkering.

GuestIt beats staring at an LLM dashboard all day, that is for sure. I am actually going to go home and try to see if I can cross-compile something trivial for that Dreamcast target. It is going to be a long night of fighting linker errors, and honestly, I am looking forward to it.

HostGlad to hear you have plans. Thanks, Fred, for the perspective today. We pulled these stories from the community over on Lobsters, and I encourage everyone to go look at the discussions there. We will be back tomorrow with more. Thanks for listening.