OS X and Windows always had a hybrid architecture since the beginning, and with the push for user space drivers for third parties even more so.
Most commercial RTOS are microkernel based, like QNX and INTEGRITY.
Even Android imposes a fake microkernel like architecture since Project Treble, where since Android 8 classical Linux drivers are considered "legacy".
Then there is the whole irony that those that strongly argue for monolithic kennels, nowadays run Linux on top of a type 1 hypervisor, full of containers.
"Hybrid architecture" is a PR exercise. These are monolithic designs with a better marketing team.
Imagine if somebody tells you their new programming language has a "hybrid" numeric type. It has all the advantages of floating point numbers, yet none of the disadvantages of the integer types. Wow!
Wait, hang on, let's look a bit more closely, those are floats. They've just described floats, but used some semantic sleight of hand to claim they're a "hybrid" numeric type.
Others enjoy that there is some effort in place to have RPC comunnication between kernel modules instead of direct function calls, a hard push for third party drivers only to exist in userspace and a standard ABI for extensions.
I rather see the progress side, even if partial, than hold to legacy designs.
See I could also call a PR exercise to safe languages that depend on using unsafe everywhere on their lower layers, maybe they aren't safe after all.
And yet we know that isn't the case.
Although it's easier to look at what's technically different in a language like Rust, probably more important is a philosophical difference and the resulting community.
Let's use an example I gave recently to my line manager (who is technical but not an excellent programmer): Sort stability. C++ says, here's sort function, and in the documentation by the way this is unstable, if you need a stable sort that's named stable_sort(); Rust says, here's a sort function, if you know enough to know you don't need a stable sort, there's an unstable_sort() function which is faster [and exists in tiny embedded systems since it doesn't need an allocator]. Unstable sort isn't unsafe (well, it is in C++ but that's C++ for you, it's not a fact about unstable sorting) but philosophically it violates the principle of least surprise as your default sort() function, and that would be a foot gun.
Go has an "unsafe" library with the dangerous stuff in it. But unlike Rust it doesn't have the safe philosophy and so e.g. as we saw recently Go doesn't feel the need to even warn you that things aren't thread safe and some Go proponents think you're crazy if you expected anything to exhibit thread safety.
If I saw a clear RPC philosophy in an OS like Windows I'd mostly go along with what you're saying. If when I looked at Windows I saw a bunch of loosely coupled systems communicating using a well defined protocol, I'm on board that's really not just a monolithic kernel. But what I see instead is mostly layers smeared on top of a monolithic kernel, some of which pretend to be RPC but are really just doing a syscall to some kernel code where the work happens. The language of RPC is used in some places, but the philosophy is largely absent.
Or having been a former Microsoft or Apple employee working on kernel stuff, then I could eventually value the opinion how fake they happen to be.
Yet somehow I get the feeling, from both of us, only I have delved into such internals.
C++ indeed has std::ranges::sort() and std::ranges::stable_sort()
However Rust's [T].sort() is paralleled by [T].sort_unstable()
That is, I just got the Rust names in the wrong order. The orthography is different because how these work under the hood is very different, but that's not important here.
But this is OK, as long as Unsafe is a monad!
This is similar to what I heard from other people about NT. IIUC, NT was called hybrid because it allowed something similar to loadable modules.
https://en.m.wikipedia.org/wiki/Local_Inter-Process_Communic...
Additionally, since Window 10, all critical modules are sandboxed, and running under hypervisor control when hardware support is present.
https://www.microsoft.com/security/blog/2020/07/08/introduci...
This is something that Windows 11 requires, secure kernel hardware requirements aren't optional.
Calling it a marketing exercise only reveals a lack of understanding about the subject, and possibly some bias as well.
Definitely my case.
So far, you can write drivers for USB devices (https://libusb.info/), simple I/O devices (https://www.kernel.org/doc/html/v5.14/driver-api/uio-howto.h...), and filesystems (FUSE) in userspace. There are probably more, but those are the ones I know about off the top of my head.
The performance really depends on your application. There’s a lot in the kernel network stack (eg iptables/nftables) that not every application needs and that might be costly. But then again for usual TCP based applications with larger dataflows the kernel path is also already decently optimized with hardware offloads - and running userspace networking stacks comes with its own issues.
If networking functions like sendmsg make up > 30% of an applications profile it can be worthwhile to investigate it.
- Microkernels need more development effort for equal functionality, something that was a constraint when he was doing Linux on his own.
- The context switching penalties on 386s were ginormous - it's much more reasonable now, I'd even say it's not much more penalizing than thread switching.
- We live in a multi-master world with IOMMU - tons of devices have virtual address spaces on their own, with most of them doing DMA transfers.
If you really wanted, could build a minimal kernel and move many devices to be inserted at runtime.
Anyway, wouldn’t mind if all that was made a lot smarter and made more accessible to people.
Don't forget the original (for Linux anyway), SEL4.
Also, seL4 comes from a long line of L4 microkernels (https://en.wikipedia.org/wiki/L4_microkernel_family#History) which actually predates Linux (L3 was developed back in '88).