Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchExploidus is described by its author, Rahad Bhuiya, as a custom x86-64 operating-system kernel built from scratch with C and assembly. The project account traces a path from a GRUB2 boot into 64-bit mode through memory management, a filesystem, networking, system calls, a shell, and graphics. Those details are the author’s claims; the linked repository’s source, build process, and test evidence are not established here.
What Exploidus is—and what the account establishes
Rahad Bhuiya frames the project around a basic systems question: “What actually happens if you strip away Linux, Windows, libc, and every single runtime library, and sit directly on the bare metal of an x86-64 processor with nothing but C and assembly?” The article’s answer is a kernel project named Exploidus. Bhuiya writes: “That question led to Exploidus—a custom x86-64 reactive capability operating system kernel built completely from scratch.” That is the author’s description, not an independently verified characterization.
As an Amazon Associate I earn from qualifying purchases.
The project account presents a broad feature set, extending well beyond getting a kernel to boot. But the available account is not a code audit or test report: the linked repository’s current documentation, implementation, build instructions, license, and release status have not been established. Treat the architecture and feature counts below as reported by the author rather than independently confirmed capabilities.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
How the reported boot path reaches 64-bit mode
The author says Exploidus uses a Multiboot2 header and GRUB2 to load an ELF64 kernel image. The CPU does not simply begin executing the kernel in 64-bit mode: the described sequence starts with protected-mode setup, configures a Global Descriptor Table (GDT), enables Physical Address Extension (PAE), and then enables long mode before transferring execution into the 64-bit environment.
#1 Best Overall
- GRUB2 loads the image. The kernel provides a Multiboot2 header, and the bootloader loads its ELF64 image.
- Set up processor state. The reported path configures protected mode and the GDT, then enables PAE as part of preparing the transition.
- Enter long mode. After enabling long mode, execution can proceed as 64-bit kernel code.
This is a useful reminder that an x86-64 kernel’s first challenge is not application-style logic. It must establish the processor state and boot handoff that make its intended execution environment possible. Bhuiya also says early output and fault debugging were difficult because the project began without printf, a standard library, or a memory allocator. At that stage, even learning what happened before a crash required building minimal ways to observe and reason about the machine.
Memory management: page tables and executable permissions
Exploidus is reported to use four-level paging: PML4, PDPT, page directory (PD), and page table (PT). The account describes managing physical memory in 4 KB frames and marking data, heap, and stack pages with NX/XD permissions, which are intended to prevent instruction execution from those pages.
These details describe an implementation choice, not proof of a security outcome. The account does not establish how permissions are enforced across all mappings, whether they can be bypassed, or whether the kernel has been security-tested. NX/XD should therefore be understood as a reported page-protection mechanism, not a guarantee that attacks are neutralized.
What the kernel reportedly includes beyond booting
The author describes several substantial subsystems. Each item below reflects the project article’s account rather than independent inspection:
- ExFS: a custom journaling filesystem.
- Networking: an in-kernel TCP/IP stack and Gigabit Ethernet drivers.
- Capability tokens: tokens based on BLAKE3 cryptography.
- System-call interface: 82 POSIX-style system calls, as counted by the author.
The “82” figure is a project feature count, not an external benchmark or standard measure of POSIX compatibility. The article does not supply independent evidence about how completely those calls implement POSIX behavior.
Shell and graphics: the user-facing layer
The named user-facing components are exploish, a shell, and alien, a userspace compositor. The article says the compositor draws through a framebuffer blit system call and uses double buffering and dirty-region redraws. In practical terms, those techniques are intended to reduce visible drawing artifacts and avoid redrawing areas that have not changed. The account does not provide independently verified demonstrations, compatibility details, or performance measurements.
What the project story teaches about low-level work
Bhuiya’s reflections center on the details that higher-level software usually hides. Hardware behavior can be quirky; interrupts introduce concurrency concerns; abstractions carry costs; and debugging close to the machine rewards careful reasoning. These are the author’s lessons from the project, not measured universal findings.
Recommended Free Tools
- Observability has to be built. Without familiar runtime support, basic output and fault diagnosis become kernel-development tasks in their own right.
- Concurrency begins earlier than it seems. Interrupt handling can make shared state and execution order difficult to reason about.
- Abstractions are useful but not free. At this level, programmers encounter the work and trade-offs that a runtime or operating system normally manages.
For readers interested in OS development or systems programming, the project account is a tour of the breadth involved: bootstrapping, memory, I/O, interfaces, and user-facing software all connect. It is not, by itself, a reproducible tutorial or evidence that the reported components are ready for general use.
Where to explore next
The author’s article links the Exploidus code at github.com/rahadbhuiya/Exploidus. Because the repository’s current contents and build instructions are not established here, check its own documentation for the state of the project before attempting a build.
For a structured introduction to x86 operating-system development, The Little Book of OS Development is a practical guide whose description covers setting up a development environment, booting in a virtual machine, and beginning kernel work in C. It is a general learning resource, not documentation for Exploidus.
Source
The project details and direct quotation in this article come from Rahad Bhuiya’s account, “Building an x86-64 Operating System from Scratch in C: The Exploidus Story”.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
