Chapter 46: Project Roadmap

46.1 Where We Are

Our kernel is a monolithic ARM64 kernel for QEMU virt (Cortex-A72) and Raspberry Pi 4/5 targets. It boots, manages memory, schedules processes, handles exceptions, communicates over UART, runs user-space programs through a shell, and renders graphics through a window manager. The following subsystems are implemented:

Completed Subsystems

Area	Chapters	Status
Boot and kernel entry	1-10	Stable
Exception and interrupt handling	11-14	Stable
Physical memory allocation	15	Stable
Virtual memory and paging	16-20	Stable
Kernel heap allocator	21	Stable
Process scheduler	22	Stable
Process and thread management	23-24	Stable
Synchronization primitives	25-28	Stable
Inter-process communication	29	Experimental
Filesystem and VFS	30-31	Experimental
Driver model	32	Experimental
UART driver	33	Stable
Framebuffer	34	Stable
Storage (SD/block)	35	Experimental
Networking	36	Experimental
ELF loader	37	Stable
User space entry	38	Stable
Shell	39	Stable
Graphics and window manager	40-41	Experimental

46.2 Short-Term Priorities (1-3 Months)

These improvements should come next, ordered by priority:

1. Stabilize the filesystem: fix known bugs in the VFS and the FAT32 driver. Support file creation and deletion, not just read. Add fsck-like consistency checks.
2. Complete networking: implement TCP (not just raw Ethernet frames). Add a simple socket API and a loopback device for local testing.
3. Improve the driver model: add device tree probing for automatic driver loading. Implement a standard driver lifecycle (probe, init, remove).
4. Add user-space programs: port core utilities (ls, cat, cp, mv, rm, mkdir) using the filesystem. Build these as ELF executables loadable by the kernel.
5. Implement dynamic linking: extend the ELF loader to handle shared libraries, reducing the size of user-space executables.
6. Expand the test suite: add automated tests for each subsystem, aiming for 70%+ code coverage in the core kernel.

46.3 Medium-Term Goals (3-6 Months)

1. Raspberry Pi 4/5 support: port the kernel to run on real hardware. Key differences include: BCM2711/BCM2712-specific UART, GPIO, and interrupt controller (GIC-400 vs. GIC-v3), different device tree layout, and SD card controller differences. See Chapter 8 for platform-specific boot details.
2. SMP support: enable multiple CPU cores. This requires: per-CPU data structures, CPU bring-up (PSCI), spinlock refinements, and cache coherency management.
3. Virtual memory optimizations: implement lazy page allocation (COW), demand paging, and swap. These reduce memory usage and allow overcommitment.
4. POSIX signal handling: add signal delivery from kernel to user-space processes. Required for many standard POSIX APIs and process termination.
5. Real-time clock and timers: add a system clock, high-resolution timers, and the POSIX timer API. Enable sleep(), alarm(), and timeout-based syscalls.
6. Performance profiling: add instrumentation points, a perf-like subsystem for sampling CPU counters, and tools to analyze kernel performance.

46.4 Long-Term Vision (6-12 Months)

1. Self-hosting: the kernel should be able to compile itself. This requires a working C compiler (or cross-compilation setup) running on the OS, plus sufficient POSIX API coverage.
2. Graphical desktop environment: evolve the window manager into a full desktop with panels, icons, drag-and-drop, and a compositor that handles transparency and visual effects.
3. Network stack maturity: full IPv4/IPv6 support with TCP congestion control, DNS resolution, DHCP client, and a socket API compatible with BSD sockets.
4. Security features: ASLR, stack canaries, SMEP/SMAP (PAN on ARM64), W^X enforcement, and a capability-based access control model.
5. USB stack: implement EHCI/XHCI driver for USB keyboard, mouse, and storage support. Essential for real hardware usability.
6. Research directions: explore unikernel configurations (kernel as a library), seL4-style formal verification of critical paths, and Rust-based kernel modules alongside C.

46.5 How to Contribute

If you are building this kernel as part of a team or study group:

• Start with areas marked "Experimental" in the subsystem table above. These need the most work and offer the best learning opportunities.
• Pick one subsystem and become its owner. Read all chapters related to it, understand the code, and drive improvements.
• Write tests first for any new code you add. Follow the testing patterns from Chapter 43.
• Follow the coding standards from Chapter 44 and the git workflow from Chapter 45.
• Document your work. Update the relevant chapter if you change the design, and add a changelog entry for significant changes.
• Review each other's code. The kernel is complex; bugs are easy to miss. A second pair of eyes catches most of them.

46.6 Measuring Progress

Track progress against these milestones:

Milestone	Criterion
v0.1	Boots to shell, UART output, basic memory management
v0.2	User-space programs, filesystem read, ELF loader
v0.3	Filesystem write, networking (UDP), driver model
v0.4	TCP/IP, graphics, window manager, user input
v0.5	Raspberry Pi 4/5 support, SMP
v1.0	Self-hosting, stable API, comprehensive test suite

46.7 Summary

Our kernel has come a long way, from a bare-metal "Hello World" on UART to a multitasking, multi-user operating system with graphics and networking. The short-term priorities are stabilizing the filesystem and networking stacks. Medium-term, the focus shifts to real hardware and SMP. Long-term, the goal is a self-hosting, secure, performant OS that can serve as a platform for further research and experimentation. The roadmap is a guide, not a contract. Priorities will shift as the kernel evolves and as the team learns what matters most.