x86 Bare-Metal Project

Project SigmaBoot ALPHA

A tiny operating system kernel focused on clarity: Multiboot startup, VGA terminal, PS/2 keyboard and mouse input, lock-state LEDs, and release-ready CI.

Warning: Experimental alpha software. Features and behavior may change without notice.

kernel.iso boot preview
PROJECT SIGMABOOT
Kernel booted successfully.
Keyboard input is ready (IRQ1 interrupt-driven, US scancodes).
PS/2 mouse driver is ready (IRQ12 packet streaming). Use 'mouse' for state.
Type below:
> hello world
LOCKS  CAPS:OFF  NUM:ON  SCRL:OFF  M:--- P:12
            

Core Features

Boot Path

Multiboot-compliant startup via GRUB with clean assembly handoff into C kernel entry.

VGA Terminal

Text rendering, color controls, tab/newline/backspace support, and scroll-safe output zone.

Keyboard

IRQ1 interrupt-driven PS/2 input, US scancode translation, lock key behavior, LED synchronization, and a heap-backed input queue with fallback.

Status Bar

Persistent bottom-row lock-state display with CAPS/NUM/SCRL, live mouse activity (`M:... P:...`), and uptime (`T+Xs`).

Build and Run

Use the ISO directly. Do not extract it to boot.

Local Commands

make -C kernel all
        make -C kernel iso
        qemu-system-i386 -cdrom kernel/build/kernel.iso

Boot From Release Asset

qemu-system-i386 -cdrom kernel.iso

For hardware, write kernel.iso directly to USB with Rufus or Balena Etcher.

Release Pipeline

GitHub Actions builds kernel.bin, kernel.elf, and kernel.iso, then attaches downloadable artifacts to each published release.

Open Latest Release

Roadmap

Done: VGA terminal, keyboard lock LEDs, lock status bar, and IRQ1 interrupt-driven input (IDT + PIC remap).

Done: CI build artifacts, release asset pipeline, and project website/docs with GitHub Pages deployment.

Done: exception ISRs with a fault diagnostics screen (vector/name/error code/EIP/CS/EFLAGS).

Done: PIT timer IRQ0 and uptime display integrated into the status bar.

Done: tiny command shell (`help`, `clear`, `version`, `locks`, `uptime`).

Done: Multiboot memory map viewer command (`memmap`) for boot-time physical layout visibility.

Done: early physical memory manager groundwork with bitmap frame tracking and `pmm` stats.

Done: heap allocator groundwork (`kmalloc`/`kfree`) backed by PMM frames with `heap` stats.

Done: dynamic shell command buffer migrated to heap-backed allocation with growth and history.

Done: keyboard IRQ queue migrated to heap-backed allocation with static fallback.

Done: decimal print formatting buffer migrated to heap-backed allocation with static fallback.

Done: memmap line composition migrated to a reusable heap-backed scratch buffer with stack fallback.

Done: exception diagnostics formatting migrated to a heap-backed workspace buffer with static fallback.

Done: PMM stats line formatting migrated to a heap-backed buffer with stack fallback.

Done: heap stats line formatting migrated to a heap-backed buffer with stack fallback.

Done: shared stats and diagnostics formatting consolidated into a dedicated `stats_util` module.

Done: allocator diagnostics expanded with `heapfrag` fragmentation view and deterministic `heapstress [rounds]` stress runs.

Done: allocator leak-trace and per-size live allocation histogram diagnostics added (`heapleaks`, `heaphist`).

Done: lightweight heap integrity checks added for corrupted headers and split/merge invariant mismatches (`heapcheck`).

Done: allocator corruption injection tests added for negative-path validation of integrity diagnostics.

Done: integrity fault details are exposed in a compact shell diagnostics summary command (`heaptriage`) for faster triage.

Done: host-side coverage reached 100% for heap allocator, diagnostics, and formatter test paths.

Done: first PS/2 mouse driver integrated on IRQ12 with packet decode, shell state command (`mouse`), and a live status-bar activity indicator.

Done: host-side PS/2 mouse driver tests added and wired into test/coverage pipelines (`mouse_test`).

Next: add a shell-accessible heap corruption injection command so triage output can be exercised without recompiling.