wubbery://kernels — Linux, Windows NT, macOS and Apple Silicon
There is no portable way to touch a kernel. So we wrote it three times.
io_uring on Linux, I/O Ring on Windows NT and kqueue on macOS do the same job through three incompatible syscall surfaces. Anything that reaches ring 0 has to be written once per kernel — there is no abstraction that survives it, and every attempt to build one has ended in the lowest common denominator. Which is precisely why the decision layer sits above that boundary and the execution layer sits below it: the theorem is portable, the kernel is not, and separating them is what lets one improvement land on three operating systems without a line of platform code being touched.
What actually binds
The abstraction everyone reaches for is the thing that loses the win
A portable I/O layer has to expose what all three kernels agree on, which is close to what the slowest of them can do. That is a reasonable trade for an application and a fatal one for a substrate whose entire argument is that the tax lives below the application. The alternative is to accept three implementations and make sure the part worth improving is not in any of them.
Which is why the split is where it is
What to route, what to keep, what to prefetch, what to refuse, what to spend a watt on — none of that is platform-specific, because what a request costs you does not change when you change kernel. Ring-0 packet handling, zero-copy DMA and unified-memory addressing are nothing but platform. Put the boundary between them and an improvement to the first lands everywhere at once.
And consoles are three more kernels, at six profiles
PlayStation is a BSD-derived kernel behind its own graphics API with a hardware decompression path nothing else has. Xbox is NT-derived and does not accept Win32, reaching the GPU through its own Direct3D variant. Handhelds are a third kernel again, at two clock profiles depending on the dock. Within a family the machines differ enough to count separately — a smaller console is a different memory budget, not a lower preset. Six execution profiles. The decision layer above them is byte-identical, which is the only reason six is tractable at all.
The half of the problem nobody else is holding
Serving runtimes are exceptional at execution and live in user space on one platform, with no decision layer to speak of. Routers and cost tools decide well and can never reach a kernel, because they sit behind an API call — one to four network hops before any thinking starts. Both halves are being solved. They are not being solved by the same system, and the value of doing so is the whole argument for a floor.
Measured, on a named alternative
Guards are reported blocked-of-attempted, never as a percentage — “zero violations” without the attempt count is a claim about nothing. Each is posed against a case that passes the check the industry already runs, because a guard that only catches obvious mistakes measures nothing.
Pooled memory is sized for the moment every host peaks together, because peak correlation is treated as a property of the fleet rather than of the schedule that drives it.
Turns a pooling case that could not pay into one that does by staggering execution windows, and states the pool the fleet then actually needs.
Paging policy is inherited from whichever kernel the code was first written against, and the tier boundaries are wrong everywhere else.
Places each page against the deadline it has to meet rather than against the default the platform happened to ship.
The workload is assumed compute-bound because that is what the profiler on one platform reports, and the accelerator sits waiting on memory.
Refuses compute purchases for a workload where added FLOPs return nothing, and names which of compute and bandwidth actually binds.
A memory fabric is bought because the capacity arithmetic works. The capital arithmetic was never run, and it is the one that decides.
Refuses pooling on a fleet where every host peaks together and the multiplexing never arrives.
Memory is installed, powered, financed and unreachable by anything that needs it, and it gets counted as a pooling win when it was a procurement error.
Separates the procurement error from the insurance so neither is claimed as a benefit it did not produce.
Reproduce every number above
One command, one seed, the same answer — on your hardware, in front of you. Almost no infrastructure vendor can do that, and it is the only reason to believe any of the figures on this page.
POST https://api.wubbery.com/v1/bench/all-modules
{ "seed": 1 }What we will not claim: 1:1 parity means the same decision reaches the same outcome on all three kernels, not that the underlying primitives are equivalent — they are not, and pretending otherwise is how portable I/O layers end up slower than the platform they wrap. Each kernel's execution tier states its own supported versions and its own limits. Nothing on this page claims a benchmark on a platform we have not measured; where a module's figure is platform-sensitive, its bench record says so.
Figures measured at seed 1 on the WUBBERY substrate engine and reproducible with the command above. WUBBERY is independent; company and product names are used for identification only and imply no endorsement.