Minimal x86 kernel compiles and runs single NES emulator without OS or memory protection

The kernel is designed to execute exactly one program: an NES emulator. By embedding the emulator directly into the kernel binary, the project removes the traditional separation between kernel and userspace. This eliminates context-switching overhead and simplifies memory management, but at the cost of any isolation between the system and the running program. Any crash in the emulator would crash the entire system, as there is no recovery mechanism or process separation.

Memory management is intentionally minimal. The kernel does not implement paging or virtual memory, which means the emulator and kernel share a flat physical address space. While this reduces complexity and improves performance for the single workload, it also means there is no protection against buffer overflows or invalid memory accesses. The design assumes the emulator is bug-free or that the system is used in a controlled environment where crashes are acceptable.

The build process is streamlined for simplicity. The project uses a standard Makefile and requires only a cross-compiler for i686 targets. The resulting kernel.elf binary can be booted directly via GRUB multiboot or emulated in QEMU. Optional tooling allows generating a bootable ISO, making it possible to run the kernel on physical hardware. This approach prioritizes ease of compilation and deployment over portability or scalability.

Beyond the NES emulator, the kernel supports a few additional programs, such as a Mandelbrot fractal renderer and a color palette viewer. These examples demonstrate that the kernel can run other simple graphical workloads, but they all share the same limitations: no dynamic loading, no memory protection, and no support for concurrent execution. The project is effectively a proof of concept for running a single, trusted program in a bare-metal environment.

The absence of an OS layer means the kernel must handle all hardware initialization and low-level operations itself. This includes setting up the stack, initializing basic system services, and managing the framebuffer for display output. While this approach is common in embedded systems, it contrasts with general-purpose operating systems, which provide abstractions for hardware and resource management. The trade-off here is between simplicity and flexibility, this kernel is optimized for one task, not adaptability.