• Overview and Kernel Basics
• Monolithic Kernels
• Microkernels
• Hybrid/Modular Kernels
• Case Studies: Linux, NT, XNU, seL4
• Security, Reliability, and Performance
• Exercises

• Kernel: privileged core managing CPU, memory, devices, and system calls.
• Design axes: code placement (kernel vs user), isolation, IPC cost, extensibility.
• Trade-offs: performance vs. reliability, simplicity vs. feature velocity.

• Definition: most services (VFS, drivers, networking, memory mgmt, schedulers) in kernel space.
• Pros: fast in-kernel calls, fewer context switches, shared address space simplifies data structures.
• Cons: larger TCB, bugs crash the whole system, harder to isolate faulty drivers.
• Examples: Linux (modular), traditional UNIX.
• Modularity: loadable kernel modules allow runtime extension but still run in kernel mode.

• Definition: move most services to user space servers; kernel provides IPC, scheduling, address spaces.
• Pros: small TCB, better isolation, crash containment, formal verification feasible (e.g., seL4).
• Cons: IPC overhead, more context switches, careful design needed to avoid priority inversion.
• Examples: Minix 3, QNX, seL4, L4 family.
• Optimizations: fast IPC paths, copy-on-write, capabilities, priority inheritance.

• Definition: microkernel-inspired structure but with some services in kernel for performance.
• Pros: practical balance: performance near monolithic for hot paths, isolation for others.
• Cons: complexity; must choose partitioning well.
• Examples: Windows NT (hybrid), XNU (macOS: Mach + BSD + IOKit), Fuchsia (Zircon microkernel with services).

• Linux: monolithic with modules; fast syscalls, mature scheduler (CFS), eBPF for safe extensibility.
• Windows NT: hybrid; executive + kernel + drivers in kernel space; user-mode subsystems (Win32, POSIX legacy).
• XNU: Mach microkernel + BSD services; IOKit for drivers; user-mode frameworks on top.
• seL4: formally verified microkernel with capability-based security; tiny TCB.

• Security: smaller TCB and capability systems aid microkernels; monolithic kernels rely on code quality and hardening.
• Reliability: fault isolation of drivers/services in user mode vs. performance of in-kernel paths.
• Performance: syscall, IPC, and context switch costs dominate microkernel overhead; mitigations include zero-copy IPC.
• Extensibility: modules, eBPF, user-mode drivers provide safer extension points.

1. Measure syscall vs. IPC latency on your system; estimate overhead of moving a driver to user space.
2. Sketch a minimal microkernel API: primitives for threads, address spaces, and IPC; propose a simple capability model.
3. Design which macOS components run in kernel vs. user space and justify the partitioning.

What's New in Kernel Design (2024-2025)

• eBPF Revolution: Extended Berkeley Packet Filter now enables safe in-kernel programmability for networking, observability, and security without kernel module risks.
• Rust in Kernel: Linux kernel now supports Rust for drivers and subsystems, providing memory safety while maintaining performance.
• Microkernel Resurgence: Google's Fuchsia Zircon and Microsoft's research on microkernel-like isolation show renewed interest in capability-based security.
• Hardware Security Features: Intel CET, AMD SEV, and ARM Memory Tagging extend kernel protection against modern threats.

OS Development for Your Custom OS

• Start Simple: Begin with a monolithic kernel for basic functionality (VFS, scheduler, memory management).
• Modular Design: Use loadable modules for device drivers to keep the core kernel stable and extensible.
• Security First: Implement capability-based permissions and memory isolation from the start.
• Game Integration: Design your kernel with real-time scheduling priorities for smooth game performance.
• Article System: Build VFS layers that support rich metadata for your article browsing system.

Practical Implementation Tips

• Memory Management: Use buddy allocator for physical memory and slab allocator for kernel objects.
• Process Management: Implement PCBs with file descriptor tables and signal handling.
• Device Drivers: Create a unified driver interface with plug-and-play capabilities.
• File System: Layer VFS over specific file systems (ext4-like for articles, procfs for system info).
• Graphics: Start with framebuffer support, evolve to GPU drivers for game acceleration.