Development Roadmap

[ViktorPopp]

InfinityOS Development Roadmap

Phase 1: Getting Started

• Freestanding Rust Binary
  • Create a Rust executable without linking the standard library (no_std).
  • Ensure the binary can run on bare metal without relying on an underlying OS.
• Minimal Kernel
  • Build upon the freestanding binary to create a minimal kernel.
  • Implement a bootable disk image that outputs a simple message to the screen.

Phase 2: Basic Output and Testing

• VGA Text Mode
  • Implement safe abstractions for VGA text mode to display text on the screen.
  • Integrate Rust’s formatting macros for formatted output.
• Kernel Testing
  • Set up unit and integration testing for the kernel.
  • Use custom test frameworks and QEMU to execute tests and report results.

Phase 3: Interrupt Handling

• CPU Exceptions
  • Set up an Interrupt Descriptor Table (IDT) to handle CPU exceptions.
  • Implement handlers for common exceptions like divide-by-zero and invalid memory access.
• Double Fault Handling
  • Implement handling for double fault exceptions to prevent fatal triple faults.
  • Set up an Interrupt Stack Table for safe double fault handling.
• Hardware Interrupts
  • Configure the programmable interrupt controller (PIC) to handle hardware interrupts.
  • Implement handlers for periodic timer interrupts and keyboard input.
    • Add backspace support to PS2 keyboard driver.

Phase 4: Memory Management

• Introduction to Paging
  • Learn the basics of paging and virtual memory.
  • Understand the layout of multilevel page tables on the x86_64 architecture.
• Paging Implementation
  • Implement paging support in the kernel.
  • Create functions for address translation and memory mapping.
• Heap Allocation
  • Add dynamic memory support with heap allocation.
  • Set up an allocator crate to enable the use of Rust’s alloc types.
• Allocator Designs
  • Experiment with different heap allocator designs:
    • Bump allocation.
    • Linked list allocation.
    • Fixed-size block allocation.
  • Select the most suitable design for your kernel.

Phase 5: Multitasking

• Async/Await
  • Implement cooperative multitasking using Rust’s async/await.
  • Build a basic executor for asynchronous tasks.
  • Create an example task, such as an asynchronous keyboard input handler.

Phase 6: Advanced Features

• Advanced Testing
  • Expand the testing framework to cover more complex kernel features.
  • Test edge cases for memory management and interrupt handling.
• Advanced Drivers
  • Develop drivers for advanced hardware (e.g., USB, networking).
  • Create abstractions for device communication.
• User Mode
  • Add support for user-mode processes and system calls.
  • Implement basic privilege separation between user and kernel modes.
• GUI
  • Develop a basic framebuffer-based graphical user interface.
  • Create a windowing system and integrate input handling.

Phase 7: Optimization and Expansion

• SMP and Virtualization
  • Add support for Symmetric Multiprocessing (SMP) to utilize multiple CPU cores.
  • Explore virtualization to allow InfinityOS to run as a guest OS.
• Community and Ecosystem
  • Write detailed documentation and tutorials.
  • Create a library of applications and packages.
• Cross-Platform Deployment
  • Finalize cross-platform support for 32-bit and 64-bit architectures.
  • Test InfinityOS on real hardware and various emulators.

Phase 8: Security Features

• Memory Protection
  • Implement support for write-protection, non-executable memory, and guard pages.
  • Utilize hardware features like DEP (Data Execution Prevention) and ASLR (Address Space Layout Randomization).
• Secure Boot
  • Add support for a secure boot process to verify kernel integrity before execution.
  • Integrate cryptographic signing of kernel and modules.
• User Authentication
  • Introduce a basic user authentication mechanism.
  • Implement password-based login and session management for user-mode processes.

Phase 9: Networking

• Networking Basics
  • Implement a basic network stack, starting with Ethernet and IP layers.
  • Support ARP, ICMP, and UDP communication.
• TCP Implementation
  • Build a basic TCP stack to enable reliable communication.
  • Test TCP connections by implementing simple network utilities (e.g., ping, HTTP client).
• Networking Abstractions
  • Add higher-level abstractions for sockets and networking APIs.
  • Create a basic web server running on InfinityOS.

Phase 10: File Systems

• File System Basics
  • Implement a virtual file system (VFS) layer to abstract file system operations.
  • Add read/write support for simple file systems like FAT32.
• File System Drivers
  • Add support for common file systems like ext4 and NTFS.
  • Develop tools for formatting and managing file systems.

Phase 11: Software Ecosystem

• Package Management
  • Create a basic package manager to install and update kernel modules and user-mode applications.
  • Build a repository system for managing available packages.
• Shell and Utilities
  • Develop a command-line shell for interacting with the system.
  • Implement core utilities like file operations, process management, and network configuration.
• Development Tools
  • Provide tools and libraries for developing applications for InfinityOS.
  • Create an API reference and developer documentation.

Phase 12: Advanced User Features

• Enhanced GUI
  • Add support for hardware-accelerated rendering.
  • Create a graphical desktop environment with window management.
• Multimedia
  • Implement support for audio playback and recording.
  • Add video output capabilities for multimedia applications.
• Cloud Integration
  • Develop features for integration with cloud storage and services.
  • Enable remote management of InfinityOS systems.

Phase 13: Ecosystem Development

• Application Ecosystem
  • Attract and engage a developer community to create apps and tools for InfinityOS.
  • Provide a development SDK with emulators and debugging tools.
• Community Engagement
  • Establish forums, documentation hubs, and support channels for users and developers.
  • Host workshops, hackathons, and events to promote InfinityOS.