Download & boot it yourself
JefeOS 1.1.2 is a single small file — a bootable x86_64 ISO, no installer. Boot it live in a free virtual machine — QEMU, Hyper-V (Gen 1) or VirtualBox — with nothing installed and nothing touched on your real computer. This is the C++ kernel: the shell (80+ commands), the framebuffer GUI, the full network stack, the SSH server, NTFS read/write and the WSL1-style Linux ABI layer are all on the disc.
- Download the ISO (and, optionally, the examples disk below).
- Point a free virtual machine — QEMU, Hyper-V or VirtualBox — at the ISO.
- Power it on. You'll land in the JefeOS shell in seconds — type
guifor the desktop, orhelpto explore.
Verify your download — the SHA-256 above should match sha256sum jefeos-1.1.2.iso.
This is a runnable release build; the source is not open.
Run programs on it — examples disk
The ISO is kernel-only, so on its own there's nowhere to store files. Attach the
optional examples disk as the primary drive and JefeOS mounts it as
its root filesystem, with a set of native programs under /programs ready
to run (plus text fixtures for grep/wc/sort).
ls /programs list the bundled programs exec /programs/hello a b c run a ring-3 ELF (argc/argv/return code) exec /programs/grep JefeOS /samples/poem.txt exec /programs/wc /samples/poem.txt exec /programs/tmpgrow proves NTFS write (64 KiB grow + verify) elftest runs a kernel-embedded ELF (no disk needed) gui · theme list the windowed GUI help the full command list
The second kernel reaches its frozen baseline
JefeRust is not a Rust-flavored build of JefeOS. It is an independent, from-scratch x86_64 kernel with its own boot path, memory manager, scheduler, drivers, filesystems, networking, cryptography, shell, GUI, and userspace compatibility layer. Version 1.0.0 implements all 55 feature lines frozen at the C++ JefeOS 1.0.0 baseline; it does not claim parity with current JefeOS master.
⬇ Download jeferust-1.0.0.iso 11214848 bytes · ISOSanitized Node bot userspace
The generic Node bot logic used for the golden-image workload is available separately for inspection. The deterministic archive contains no deployed tokens, IDs, private hosts, model names, state, logs, or installed dependencies.
⬇ Download sanitized bot source 62676 bytes · ZIPJefeOS 1.1.2 — the user/kernel boundary holds
A real Node workload exposed a boundary bug after a Xylem reap: synthetic
/proc and tmpfs getdents64 paths wrote directory records directly
into userspace. JefeOS 1.1.2 now stages those records in kernel memory and delivers them
through the same fault-survivable, SMAP-safe copy path as the NTFS implementation.
- Correct successful reads —
/proc,/proc/self, and tmpfs enumeration now cross the user/kernel boundary throughcopy_to_user. - Failure behavior locked down — unmapped buffers return
-EFAULT; cross-page short copies resume at the correct directory cursor. - Real-workload coverage — BusyBox
ls/ps, Nodefs.readdirSync, and post-reap status behavior are in the release path.
Honest framing: 1.1.2 is a narrow correctness hotfix. It preserves the OpenStack guest, Xylem supervision, hardening, and compatibility work from 1.1.1 without claiming the broader 1.2 milestone. Previous release notes remain archived: 1.1.1 · 1.1.0.
Key features
The short version, in plain language — what JefeOS actually is and what it can do today.
Written by an AI and a human, together
JefeOS was built line by line by Claude and one person — you can read the whole 31-chapter development diary as it happened. Two full versions exist in parallel: one in C++, one in Rust. It's a genuine partnership, and the story is part of the project.
It talks to the internet — securely, on its own
Its network stack goes all the way from the network card driver up to modern encryption: its own TLS 1.3 and SSH, written from scratch. You can curl a real HTTPS website from the JefeOS command line, or SSH into the machine from your laptop — the same encryption your bank uses, built here from the ground up.
It runs real software, right now
A Discord bot runs live on JefeOS — 24/7 — answering commands and checking on other services. This isn't a lab demo; it's a real program doing a real job on a hobby operating system. Ask it a question in Discord and the reply comes straight off the JefeOS kernel.
It runs Linux programs too
JefeOS includes a Linux compatibility layer — similar in spirit to Windows' WSL1 — so certain Linux binaries run directly, unmodified. It's early but real: small statically-built Linux "hello world" programs load and run from disk today.
Five desktops from computing history
Boot into a graphical desktop and switch between five era-accurate themes — Windows 3.1, Windows 95, Mac Classic, Amiga Workbench, and a clean Modern Dark. One command flips the whole look. It's a working window manager with a built-in text editor, not a wallpaper.
It reads and writes real Windows disks
JefeOS can read and write NTFS — the Windows filesystem — so it can save files to a disk your PC can also read. Copy a file, reboot, and it's still there. Under the hood there's a full shell with 80+ familiar commands (ls, cat, ping, pipes, redirects) that'll feel at home to anyone who's used a terminal.
Being honest about the edges: multi-core support and full Linux (Alpine) boot aren't done yet, and POSIX coverage is about 83%. JefeRust 1.0 has now shipped against the frozen JefeOS 1.0 baseline; current C++ master remains ahead in its separate release lane. The roadmap separates the two lanes →
Under the hood
For technical readers: everything below is shipped and verified on the C++ kernel unless noted. JefeRust 1.0 separately implements all 55 frozen JefeOS 1.0 benchmark feature lines; it does not claim the post-1.0 features on current C++ master.
From-scratch kernel core
Limine boot, 4-level paging, physical + virtual memory managers, an 8 MB heap with coalescing, and a preemptive round-robin scheduler with PIT-driven preemption.
Own userspace
ELF64 loader, ring-3 execution, per-process page tables, an INT 0x80 syscall interface, and its own libc — no host runtime.
Full network stack
E1000 / Tulip NIC drivers up through Ethernet, ARP, IPv4, IPv6 (link-local + NDP), ICMP, UDP, TCP, DNS and DHCP — built from the wire up.
Crypto & secure services
TLS 1.3 client, an SSH 2.0 server + client (ChaCha20-Poly1305, Ed25519, X25519), SFTP/SCP, an HTTP/S client, and NTP/NTS authenticated time verified against Cloudflare.
Filesystems
NTFS read/write and FAT32. A plain JefeOS-written directory now passes Windows chkdsk /f clean (exit-0), and grown directory indexes pass too.
Linux ABI compatibility
A WSL1-style Linux syscall translation layer (SYSCALL/LSTAR). Static and dynamic Linux binaries run; chroot + Alpine apk read and write work — packages like tree and jq install and execute.
GUI & shell
A framebuffer window manager with 5 switchable themes (Win31, Win95, Mac Classic, Amiga, Modern Dark), a text editor, and a shell with 80+ commands plus cross-platform aliases.
Real workloads run
A real Node.js Discord bot and an unmodified Python Twitch chatbot have both run live on JefeOS — two-way gateways, LLM round-trips, and HTTPS over the kernel's own TLS.
OpenStack guest support
Validated through Glance, Nova and Horizon: JefeOS reads Nova's ISO 9660 config-drive, applies hostname and SSH keys, and boots with E1000 + DHCP. The supported image profile is BIOS + IDE + E1000; virtio, arbitrary static-network application, and JefeOS-as-controller are not claimed. Details →
Reliability hardening
Fault-survivable user-pointer handling (hostile pointer → -EFAULT, not a crash), panic/crash records that persist across reboot, and CI-tested leak-free daemon teardown.
In progress, not yet done: POSIX 1003.1-2024 coverage sits around ~83% strict on both kernels (100% is the standing goal); the interactive Alpine login prompt is the last manual gate on the top Linux tier; SMP remains future work. JefeRust 1.0 is a baseline-parity release, not a claim of parity with current JefeOS master.
Technical? Point your AI at the builder's manual →
This page is the human tour. There's also a deep technical manual written for machines to read — full syscall reference, kernel internals, the shell command set, and how to compile your own programs for JefeOS. Hand it to your AI assistant and let it dig in.
Open the Builder's Manual →Written to be understood by an AI coding assistant — paste the link into Claude, ChatGPT, or your tool of choice.
Xylem: the OS is the cluster Workload supervision live
Xylem is JefeOS's north-star identity: instead of bolting an external orchestrator (like Kubernetes) on top of a cluster-blind OS, the cluster control plane is folded into the kernel. The roadmap calls for a "service" to become a first-class kernel object with a replica count and a supervision policy — so redundancy, scaling and failover become kernel verbs rather than YAML reconciled from the outside.
It's named after plant xylem — a distributed transport tissue that reroutes flow around a dead vessel (built-in failover as structure), regrows (self-healing), and is load-bearing. The design principle is biomimicry: decentralized, pressure-driven, no central authority.
- Composes with — but is orthogonal to — JefeOS's Linux-compatibility work: a Linux container can run inside a Xylem "cell" and inherit failover for free, but the capability is JefeOS's, not Linux's.
- The roadmap supports both a pragmatic external replicated store to start, and eventual kernel-native replicated storage for stateful cells.
- Initial posture is a trusted fleet; hostile multi-tenant isolation is a future possibility, not a launch goal.
Honest framing: Xylem is still mostly a long-arc direction — but it's climbing real rungs. 1.0.0 demonstrated membership + failure detection (a SWIM-style gossip protocol, 2-node, converging headless on both C++ and Rust kernels). 1.1.0 adds the next rung: workload supervision. A running Linux program is now watched for real forward progress rather than a naive pulse, and when it silently wedges the kernel harvests a diagnostic snapshot and reaps + respawns the whole process-group in place, with no VM reboot — demonstrated live on the Discord bot that runs on JefeOS 24/7, reaped and reborn ~10 times over a multi-hour soak while the VM never bounced. Everything above supervision — service-as-kernel-object, replica failover and live migration — remains the long arc. And supervision harvests the bot's periodic wedge (an upstream Node/libuv-runtime bug the kernel's been cleared of); it doesn't cure it.
Read the Xylem whitepaper →Explore JefeOS
Pick a thread — live progress, the long-arc thesis, the story, or the code.