Private product showcase / Build-verified research OS
Starfish
A next-gen operating system with a direct road to the GPU for gaming and AI compute.
The operating-system layer of our owned stack
Why this changes the game
Three reasons to care.
Boot from our own loader into our own kernel, filesystem, userland, and shell.
A direct road from apps to pixels, GPUs, and AI compute without the legacy maze.
Multicore scheduling, syscalls, pipes, framebuffer, journaling, and hot edit-build-boot.
Proof today
The current machine, without mythology.
The research slice includes a UEFI loader, kernel, page tables, allocator, interrupts, preemptive multicore scheduling, ring-3 userland, syscalls, pipes, framebuffer output, FIT64 images and journal replay, an sf> shell, and a virtual-machine boot loop. It is not yet a finished, hardened, general-purpose OS.
The boldest games and AI systems eventually hit rules, overhead, and indirection inside an operating system their builders cannot change.
Starfish makes startup, memory, files, scheduling, graphics, applications, and compute part of the same understandable stack. Yeho is its language path, YUI its interface system, and Yodi its future intelligence layer.
Energy is an architecture decision
Run the machine. Not the baggage.
North Star: the world's most optimized, energy-efficient operating system. Starfish is built to scale down until the OS nearly disappears, then scale up without hiding the hardware from the person building on it.
Tracked implementation source, excluding documentation, archived implementations, generated files, dependencies, and build output.
The present UEFI loader, kernel, and userland core before the fixed-size filesystem and disk containers.
The OS can live with the machine.
North Star: bake Starfish into device firmware or load it into memory, so purpose-built hardware can operate without depending on a permanent drive.
Wake only when the work exists.
North Star: let a remote sensor run its admitted workload once an hour, record what changed, then return to its lowest-power state.
One tiny system for one clear job.
North Star: package an app with only the operating-system capabilities it needs, without carrying a general desktop into every cloud service.
Use the hardware you actually own.
Starfish is designed to keep machine authority inspectable, from memory and scheduling to files, pixels, applications, GPUs, and future AI compute.
The connected stack
Nothing powerful lives alone.
Public Academy
Learn Starfish from the inside.
Every public guide, field lesson, and architecture map for this system is gathered here. No membership is required to study these rooms.
Starfish: a guide to the operating-system research
Understand Starfish's UEFI loader, kernel, userland, filesystem, and VM research path, plus the proposed Yeho and Qube co-design. Public guide and evaluation steps.
Open in the Academy ↗02 / Architecture mapStarfish interactive architecture
Select stations, trace routes, and see which layer owns each important Starfish decision.
Open in the Academy ↗Open the machinery
Follow the whole system.
See the route first. Then open the architecture or complete manual when you want every chamber, boundary, and proof.
InteractiveSee inside the systemOpen the architecture map ↗A glimpse inside
Six doors into the machine.
Direct, predictable, inspectable
Starfish is a skunkworks OS for rapidly prototyping hardware, graphics, engines, and applications without inheriting a large legacy stack.
The OS, language, interface, and intelligence fit together
Starfish owns machine authority; Yeho is the language and application system; YUI is the interface system; Yodi may observe and control admitted capabilities through typed permissions rather than bypassing the OS.
UEFI loader to kernel handoff
The x86_64 loader reads ELF64 or bounded flat kernels, gathers framebuffer, memory-map, firmware, timer, module, and command-line data, exits boot services, and jumps through a documented ABI.
One explicit machine handoff
The loader/kernel boundary is a little-endian, 16-byte-aligned structure covering image placement, memory, framebuffer, firmware tables, timers, modules, command line, and boot state.
A compact kernel you can trace
The kernel brings up descriptor tables, exceptions, paging, physical allocation, heaps, interrupts, timers, SMP, a scheduler, syscalls, files, pipes, devices, and framebuffer diagnostics in visible layers.
The practical device ladder
Starfish grows through a prioritized set of drivers: timers and input, PCI and storage, networking, display metadata, and later GPU and architecture-specific paths.
The door is open