This project implements a microkernel-based operating system simulation that demonstrates minimal kernel functionality and user-space services. The system emphasizes inter-process communication (IPC), fault isolation, and modular OS design, following microkernel principles.

The project is developed as a working prototype/simulation running on Linux, fulfilling all course requirements.

• Design and implement a minimal microkernel
• Implement IPC-based message passing
• Move traditional kernel services to user space
• Create at least three user-space services
• Demonstrate fault isolation
• Compare performance with a monolithic design

• Process/service registration
• Message routing (IPC)
• Basic scheduling simulation

Minimal, bootable freestanding C kernel scaffold targeting i386 (32-bit x86) via Multiboot2 + GRUB.

This repo is being used by a 7-person team to build a microkernel-ish prototype in 7 days:

• minimal kernel core
• IPC message passing
• at least 3 services
• a fault-isolation demo (service crash + restart)
• a performance comparison (IPC vs direct call)

Detailed team breakdown + timeline: see docs/TEAM_PLAN.md.

1. Install prerequisites inside WSL (Ubuntu):

sudo apt update
sudo apt install -y build-essential gcc-multilib grub-pc-bin xorriso qemu-system-x86

2. Build ISO:

make

3. Run in QEMU:

make run

PowerShell wrappers (calls WSL):

./scripts/build.ps1
./scripts/run.ps1

Build-critical code (current):

• src/arch/i386/boot.S: Multiboot2 header + entry point
• src/arch/i386/linker.ld: kernel linker script
• src/kernel/: kernel C code (VGA text output, serial, panic, IPC, service registry)
• boot/grub/grub.cfg: GRUB menu entry

Collaboration folders (team work areas):

• kernel/: future home for kernel subsystems (planned)
• ipc/: IPC design + implementation work (implemented)
• services/: service modules (3 services implemented: console, echo, timer)
• tests/: validation steps and (optional) host-side tests
• docs/: architecture, team plan, contributing, perf writeups, services demo

Architecture overview: see docs/ARCHITECTURE.md.

UI overview (serial CLI + next steps): see docs/UI.md.

Services demo: see docs/SERVICES_DEMO.md for complete guide.

Three services have been implemented:

1. Console/Log Service - Centralized logging via IPC
2. Echo Service - Request/reply pattern demonstration
3. Timer Service - Periodic tick message distribution

Try them in QEMU:

make run
# Type in console:
services       # List all services
log Hello      # Send log message
ipcecho Test   # Test echo service

See services/README.md for details.

Build & Run Tasks (VS Code or terminal):

• Build ISO:
  • Command: wsl --cd <workspaceFolder> -- make
  • Description: Builds the microkernel ISO image.
• Run QEMU:
  • Command: wsl --cd <workspaceFolder> -- make run
  • Description: Boots the microkernel in QEMU for testing.

Service Commands (in QEMU CLI):

• services — List all registered services.
• log <text> — Send a log message to the console service.
• ipcecho <text> — Send an echo request via IPC.
• timertick — Trigger a timer tick to all subscribers.

Other Useful Commands:

• help — Show all available commands.
• crash — Simulate a service crash (for fault isolation testing).
• bench [count] — Run performance benchmarks.

How to Test:

1. Build and run the kernel:
   • In VS Code: Use the "Build ISO (WSL)" and "Run QEMU (WSL)" tasks.
   • In terminal: Run the build and QEMU commands above.
2. In the QEMU CLI, use the service commands to interact with and test each service.

• Use issues from docs/ISSUES.md as the starting backlog.
• Every PR links an issue and includes a QEMU boot check.
• See docs/CONTRIBUTING.md for lightweight rules.

The full schedule and member responsibilities are in docs/TEAM_PLAN.md.