Kernel Development Journal

With dynamic record lifecycles active in the Tadpole toolchain, we leveraged this capability to eliminate one of the oldest technical debts in the Bullfrogg kernel: unmanaged communication cells in low physical RAM. Previously, early bootstrap and post-heap subsystems passed state through hardcoded memory offsets like `0x01020030` and `0x01020038`. We transitioned the kernel to a unified `SystemContext` record allocated directly on the intrusive kernel heap at Stage 04, establishing explicit ownership over the platform, memory managers, and storage fabric.

The migration revealed several subtle bare-metal invariants that required rigorous isolation. During early bootstrap, an address collision occurred where the scheduler core table (`SCHED_BASE`) and the framebuffer singleton were both mapped to `0x01021600`. Because of this overlap, idle task yields were clobbering display state, while the abort console's `tasks` command misinterpreted the framebuffer pointer as a run-queue head, triggering unhandled page faults. Relocating `SCHED_BASE` to `0x01021200` with dedicated early zeroing cleanly decoupled task tracking from video hardware.

We further hardened the SMP bringup and hardware discovery pipeline. Premature Local APIC queries inside ACPI enumeration were triggering fault loops prior to paging enablement, while AP wake loops stalled due to uncalibrated timer counts. By anchoring LAPIC ID discovery post-mapping and driving calibration off the hardware HPET, all AP cores now reliably advance through the real-mode trampoline to `Probe 0x33`, initialize per-core PAT settings, arm per-CPU `IA32_GS_BASE` blocks, and synchronize cleanly across the multi-core bringup barrier.

Finally, we overhauled the interactive PS/2 and serial abort chord engine. Handlers for toggling between the splash screen and the debug TTY (`Chord D`), pausing log queues, and spawning console diagnostics were decoupled from legacy bootloader cells and re-routed directly through `sysctx_get_root()`. With artificial post-init timing delays pruned, CheddarOS boots smoothly into an SMP-synchronized environment with NVMe block storage and CheddarFS mounted in roughly 1.3 seconds.

Until now, CheddarOS records operated primarily as static singletons or raw pointers cast over known memory buffers. While deterministic, this approach created architectural friction for desktop-grade abstractions—most notably dynamic UI widgets, windowing structures, and growable buffer pools. To eliminate this bottleneck, we engineered native heap record lifecycle management directly into the Tadpole compiler.

We expanded Tadpole's grammar and lexer with two dedicated keywords: `new` as an expression and `destroy` as a first-class statement. In `TadpoleParser.cs`, `ParsePrimary` handles scoped record construction with parameter lists, while `ParseStatement` captures teardown targets. At the same time, we hardened the compiler's diagnostic engine to reject reserved keywords used as variable names with actionable, contextual errors.

Backend code generation in `X64Emitter.cs` lowers both primitives under standard Microsoft x64 calling conventions while enforcing 16-byte RSP frame alignment. A `new` expression calculates the record footprint, calls `allocate_memory`, spills the instance pointer across argument evaluations, and invokes the record's `constructor` with `self` loaded into `RCX`. Conversely, `destroy` introduces an automatic null guard, dispatches the record's `destructor` for internal teardown, and hands the backing allocation to `free_memory`.

To tie the compiler directly to the Bullfrogg kernel, `heap.tad` was updated with top-level allocator hooks into the intrusive free-list heap at `0xFFFFC00000000000`. During bare-metal verification in `widget_test.tad`, dynamic instantiation, field assignment, method execution, and explicit destruction were tested end-to-end. The intrusive free list immediately reclaimed and coalesced the freed block, confirming zero-drift memory recycling without fragmenting the kernel heap.

With `new` and `destroy` fully operational in native Tadpole, the path is cleared for a comprehensive kernel refresh—unlocking modular desktop UI components, clean driver state lifecycles, and modern system software design.

Emulators lie through their teeth. QEMU is extraordinarily forgiving: virtual devices transition instantaneously, DMA shares host-coherent cache lines, framebuffers sit conveniently below 4 GB, and peripheral devices appear neatly on Bus 0. To break free from virtual training wheels and prepare CheddarOS for physical motherboards, we launched 'Operation MetalPond'—a strict, ground-up audit of our bare-metal hardware compliance.

The audit uncovered several critical areas where physical silicon would have triggered early triple-faults or silent corruption. Modern discrete GPUs map GOP framebuffers high in 64-bit MMIO space, exposing our boot structure's legacy 32-bit truncation. We immediately widened `BootParams.framebuffer` across `boot.tad`, `vmm.tad`, and `framebuffer.tad`, ensuring full 64-bit physical address handling regardless of memory topology.

Next, we systematically hardened the storage stack. Physical NVMe controllers enforce variable microcode readiness windows via `CAP.TO`, which we now inspect to calculate dynamic timeout ceilings. To prevent CPU cache coherency races during PCIe bus mastering, we introduced `PAGE_FLAG_UNCACHEABLE` (`0x1B`, asserting `PWT` and `PCD`) into the VMM, strictly remapping Admin queues, I/O queues, and our read buffers with preceding `invlpg` invalidations and `sfence`/`lfence` pipeline serialization.

We closed out the offensive by tackling SMP allocation boundaries and PCIe bridge topologies. We enforced a strict sub-4GB guarantee on initial PML4 root table allocations to protect real-mode AP trampoline handoffs. Finally, `pci.tad` was upgraded with recursive Type 0x01 bridge traversal—complete with cycle-detection bitmaps and memory-space bus mastering enablement—ensuring physical M.2 NVMe drives wired behind PCH chipset lanes are discovered instantly.

All seven P0 blockers have been executed and verified. The kernel advances to Generation 11 in the CheddarFS pool, maintaining perfect QEMU stability while meeting the uncompromising demands of physical silicon.

We have achieved a major milestone for CheddarOS deployment and disk architecture: the system now boots as a fully autonomous, self-contained NVMe storage device. Previously, running iterative builds relied on QEMU mounting an external host-backed FAT directory fallback. With today's pipeline overhaul, our primary `cheddar_disk.img` handles the entire boot chain from firmware handoff to secondary generational mounting.

The key breakthrough came from teaching `cFS-Cli` how to perform surgical in-place ESP updates. Zone B (the UEFI System Partition from LBA 2048 to 1,048,575) was re-architected to conform strictly to EDK2's `FatPkg` specifications. By configuring a standard 32-sector reserved region, zeroing out 16-bit FAT fields, writing proper FSInfo and backup boot sectors, and aligning cluster allocation, firmware immediately recognizes the ESP as an active filesystem on `Boot0001` without manual shell intervention.

Simultaneously, we extended `cFS-Cli inject-esp` to carry both `BOOTX64.EFI` and the stitched `CHEDDAR.BIN` binary into the FAT32 volume, eliminating external boot dependencies. Right alongside the firmware payload, the pipeline automatically issues an `inject-file` transaction to write the new kernel straight into the CheddarFS `/System/` hierarchy.

Because this injection adheres to native CheddarFS Copy-on-Write (CoW) semantics, updating the operating system advances the active superblock to Generation 6 while leaving all prior generational snapshots completely untouched. The result is an instantaneous, non-destructive workflow: compile in Tadpole, stitch the flat binary, inject in-place, and watch all 4 SMP cores take flight directly from raw NVMe storage.

Today was a massive leap forward for both the Tadpole compiler and the CheddarOS (Bullfrogg) kernel. We completed a comprehensive overhaul of Tadpole's control-flow mechanics, implementing first-class `break` and `continue` loop-control keywords alongside statement-level `select ... end select` and expression-level `match ... end match`.

The addition of `break` and `continue` immediately cleaned up complex driver polling loops and multi-stage initialization sequences. In the AP SMP bringup routines, resource allocation checks that previously wrapped dozens of lines inside nested flag checks were converted into clean guard clauses, while hardware-wait loops now exit early via break the instant target cores register online rather than grinding through redundant polling cycles.

For multi-way branching, `select` and `match` eliminate sprawling linear if/or-if ladders. Both constructs feature comma-delimited match lists (`when 1, 2, 3`), avoiding accidental C-style fallthrough while grouping shared logic. To preserve bare-metal safety, the X64Emitter avoids push/pop alignment hazards by allocating target spill slots directly inside the frame reserve (`mov [rbp - off], rax`), guaranteeing strict 16-byte stack alignment across arbitrary nested calls.

Alongside these features, we hardened the grammar from v0.2.0 to v0.3.0 by completely removing the ambiguous 'bare end' allowance. Every construct—functions, records, loops, assemblies, and branches—now mandates explicit closers (`end function`, `end while`, `end select`), providing deterministic parser recovery. We capped the day by migrating `keyboard.tad`, replacing 40+ scancode equality checks with a single clean `match` and routing COM1 console chords through `select`, all verified with zero kernel regressions across 4 ticking SMP cores.

Tadpole has officially broken past purely procedural semantics. The compiler now features full Stage-1 record-based OOP with instance method lowering (`expr.Method(args...)`), resolving instance targets directly to static `Record::Method(self, args...)` dispatches adhering strictly to MS x64 calling conventions.

With compiler-level OOP online, almost the entire CheddarOS driver stack was systematically refactored. Procedural singletons have been restructured into clean, encapsulated record representations—including `Timer`, `PciBus`, `Pmm`, and `Lapic`—providing structured instance accessors while preserving exact bare-metal field layouts.

On the storage front, CheddarFS received an upgraded file catalog schema to break free from the 14-character filename constraint, enabling arbitrary long filenames across the volume. Generation 2 mounting was validated seamlessly off our NVMe test storage.

To support our storage pipeline, we developed `cFS-Cli` for unattended image generation and `cFS-Now` (CheddarFS Inspector)—a visual desktop tool featuring an allocation block map visualizer, raw 4K hex inspections, and real-time superblock CRC32C validation across active generational slots.

No foreign C runtime, no third-party assemblers, and zero glue layers. The CheddarOS (Project Bullfrogg) kernel is executing live on bare-metal x86-64 architecture with 100% Tadpole compiled code.

During early handoff, the bootloader encounters a relocated entry at 0x05DAD000 and immediately jumps to native Tadpole execution. From there, the kernel configures the PMM bitmap, initial page tables, registers the 256-entry IDT via LIDT, and loads the kernel GDT without relying on external toolchains.

The kernel enumerates ACPI tables via XSDT, activates HPET timers, and wakes all Application Processors via INIT/SIPI broadcast sequences. Four physical SMP cores synchronize and check in at 1.278s before the PCI subsystem scans ECAM space to map BAR0 and bring the NVMe controller online.

From there, CheddarFS verifies its superblock magic, locks Generation 1, and mounts read-only right as the interactive bootscreen swaps between the graphical horizon and the raw COM1 ring log via hardware chords.