This looks quite interesting to me... please give Clint feedback if we should include in powertoys or not!
I vote yes!
Dave understand the depths... it's good to step back once an a while, I get caught up in all the warts - it's easy to find the faults, this post brings me joy.
Happy Birthday, Windows 11... It's an amazing operating system with massive power just below the surface.
I would change and add many things, but there are many, many more I wouldn't. These are the hidden gems, pieces of Windows that people take for granted.
Like the subsystem model. Win32 was never the operating system. It was a personality bolted onto NT, same as the old OS/2 and POSIX subsystems. That design decision from 1993 is why WSL exists at all. WSL1 ran Linux binaries as pico processes against a translation layer; WSL2 runs a real Linux kernel in a utility VM, and your distro still shows up as a normal Windows process tree you can attach a debugger to. People treat that as a feature. It is Dave Cutler's subsystem idea, still paying rent thirty years later.
ACLs on every object, not just files. A process, a thread, a section, an event, a mutant, a token, a job — each one carries a security descriptor. The Object Manager doesn't special-case "files get security, everything else is a free-for-all." Open a handle and the Security Reference Monitor checks the ACL. That is why you can lock down a named pipe, a registry key, or another process with the same model, and why "run as" and restricted tokens actually mean something.
The Object Manager itself. One namespace. \Device, \BaseNamedObjects, \Sessions, \Registry.
Handles, reference counts, and a consistent lifetime model for almost everything the kernel exposes. Most of what you think of as "Windows APIs" is a user-mode wrapper over an object you opened by name or by inheritance.
I/O completion ports and the I/O manager. Overlapped I/O is not a later bolt-on. IRPs, cancel routines, and a completion port that a thread pool can drain are how a service handles tens of thousands of sockets without a thread per connection.
NTFS sits on the same path: journaling, the USN change journal, reparse points, sparse files, hard links, transactions when you want them. Cloud placeholders and symlinks are reparse points. They are not a hack layered on later.
Job objects. A process is not the unit of resource control. A job is. CPU rate, memory, I/O, kill-on-close, nested jobs. Windows containers and a lot of sandboxing are just job objects with a nicer hat.
ALPC for the cross-process calls you never see. Services, RPC, COM activation, the window manager talking to win32k — local procedure calls with security context carried along, not a pile of ad-hoc shared memory.
And under it all, a type-1 hypervisor. The root partition is a guest. VBS, HVCI, Credential Guard, and the WSL2 VM are the same machinery. Memory integrity and isolated LSASS are not apps. They are partitions the kernel agreed to live beside.
None of this shows up in a screenshot. It is why the thing still runs software from the 90s, a Linux toolchain, a GPU game, and a hypervisor-isolated credential store on the same box without each of those being a separate product. The shell can be argued with. The executive underneath it is the part I would keep.
You could slap a new face on it tomorrow, and it would look entirely fresh while being incredibly stable thanks to 30+ years of dedicated engineering.
100% approved
Today I'm coining a new internet slang term:
ai;dr
AI, didn't read.
Start using this to reply to comments that are obviously written by AI and watch what happens.
Readers added context they thought people might want to know
It has already been coined
x.com/seclilc/status…
Containers for AI tools, and more. I've used MXC for safe running of generated EXEs, but you can use it for anything. Inspirations was agentic tools isolated securely on your machine.
Congratulations to the team on this milestone! v1.0.0!
Releases · microsoft/mxc
github.com/microsoft/microso…
Very excited that the WinUI team has migrated to working primarily in Github! We have more progress to make here, but it's great to see the team get more aligned with the OSS community!
github.com/microsoft/win-dev…
Getting agents to understand WinUI is important, we recognize that they are trained so much better for other libraries out of the box. With this new set of skills we are optimizing for creating the best UX as efficiently as possible with a coding agent!
With Microsoft.UI.Reactor we ended up doing a diffing approach, for one primary reason - we wanted to start with the assumption of an unchanging language (C#) and desire for ergonomic programming. If you either compromise on these fine grained tracking may be better.
For our experiment, we wanted to achieve two things; a ergonomic modern API that worked for humans and agents, and to authentically target WinUI (no new framework!).
I fully expect we will change 100% of the API surface area in Reactor, moving from fluent to record creation, or even moving from diffing to dependency tracking.
github.com/microsoft/microso…
Coarse grained diffing is where you generally let ignorant code run and then you compare the output of what it last produced and just produced, and then you make updates to some output (typically stateful DOM).
I've worked on a couple reactive/functional systems. I think they generally break down into fine grained tracking or coarse grained diffing.
Fun stuff, working on C# & Rust programming model for WinUI... very experimental, trying to do the development in the open. Would love feedback.
C#: github.com/microsoft/microso…
Rust: github.com/microsoft/windows…
@codemonkeychris on theads/IG.
done with this Truth Social clone...
pour one out for what Twitter used to be.
Twitter feed has turned into garbage with all this suggested content. Likes of likes, topics, based on your likes… it’s just so much noise.
Spent a bunch of time blocking and turning off as much suggested content as I can… will see if the feed recovers, otherwise it’s useless









