         ___                 root@opencoreC
       /     \               -----------------
      |  (o)  |  ___         OS: opencoreC Microkernel x86_64
      |       | /   \        Kernel: v0.1.0-release (Rust #![no_std])
       \ ___ / | (o) |       Uptime: 42 mins, 12 secs
                \___/        Shell: osh (opencore shell 1.0)
    [=== opencoreC ===]      Display: 1280x800 @ 60Hz 32bpp (Linear FB)
        x86_64 SMP           DE / WM: LVGL v8.3 Windows/KDE Compositor
       Ring 3 Userspace      CPU: QEMU Virtual CPU (4 Cores SMP)
      Fast-Path IPC Cap      Memory: 38 MiB / 509 MiB (7%)
                             Network: Realtek RTL8139 (10.0.2.15)
                             ACPI: S5 Poweroff, Reset, MADT 4 Cores
                             Security: Ring 3 Signal Fault Isolation (SIGSEGV)
                             Entropy: Hardware RNG (RDRAND / TSC)

A state-of-the-art, capability-based microkernel operating system written in Rust and modern C++20.
Designed from scratch for x86_64 long mode, featuring SMP multi-core affinity, an LVGL-powered desktop compositor, hardware ACPI power management, hardware random generation, and fault-tolerant process signal isolation.

🚀 Key Highlights & Subsystems

⚡ 1. SMP Multi-Core & Core Affinity Optimization

Application Processor Startup: Secondary cores (Core 1, 2, 3) are booted via the Limine SMP protocol with dedicated TSS descriptors (PER_CPU_TSS), GDT, IDT, SSE/AVX registers, and fast-path syscall MSRs (IA32_LSTAR, IA32_STAR, IA32_FMASK).
Fast Non-Locking CPU ID: Uses CPU MSR 0xC0000103 (IA32_TSC_AUX) to retrieve the current physical core index in a single assembly instruction (rdmsr).
Dedicated Core Affinity:
- Core 0: Microkernel Core, Hardware Timer PIT (100 Hz), Hardware IRQs (Mouse, Keyboard, RTL8139 NIC).
- Core 1: Dedicated to gui_server — 60 FPS graphics rendering without lag or priority inversions.
- Core 2: Dedicated to sh (Interactive shell and command execution).
- Core 3: Dedicated to background servers (init_server, uart_driver, procmgr).

🪟 2. LVGL v8.3 Windows/KDE Desktop GUI

Hardware PS/2 Mouse Tracking: Smooth double-buffered cursor rendering at 1280x800 resolution directly over Limine linear framebuffer (0x80000000).
Zero-Lag Window Dragging: High-performance dirty-region raster bands (BUF_HEIGHT = 80) and optimized composition.
Windows 11 / KDE Plasma Aesthetic:
- Glassmorphic Taskbar with Start Menu button, running task chips, and live CMOS digital clock.
- Interactive Start Menu with quick application launcher and system power controls.
- Task Manager / Resource Monitor: Real-time multi-core CPU utilization meters across all 4 cores and physical memory progress bar.
- Linux-style Graphical Terminal: Dark-mode terminal with blinking cursor and full command interpreter.
- About System & Network Diagnostics Center: Real-time RTL8139 MAC, IP, and packet counters.

🌐 3. Realtek RTL8139 PCI Fast Ethernet Network

PCI Bus Mastering: Auto-probes PCI bus 0:2:0, enables Bus Master DMA.
Zero-Copy Physical DMA: Configured with physical transmit and receive ring buffers (0x90000000).
Network Stack: Full ARP request/reply, IPv4 packet parsing, and ICMP Echo transmission (ping 10.0.2.2).

🛡️ 4. Process Signals & Fault Isolation (Ring 3)

Kernel Stability: Ring 3 crashes no longer trigger Kernel Panics:
- Vector 14 (#PF Page Fault) \rightarrow SIGSEGV (11)
- Vector 13 (#GP General Protection) \rightarrow SIGSEGV (11)
- Vector 6 (#UD Invalid Opcode) \rightarrow SIGILL (4)
- Vector 0 (#DE Divide by Zero) \rightarrow SIGFPE (8)
Faulting threads are cleanly isolated, logged with crash diagnostics (RIP, ErrCode, CR2), and terminated. The microkernel, GUI desktop, and sibling tasks remain fully active. Test with crash_test.

🔋 5. Hardware ACPI Subsystem

Table Discovery: Scans BIOS memory (0xE0000..0xFFFFF) for RSDP with checksum verification.
Tables Parsed: RSDT, FADT (PM1a_CNT), MADT (LAPIC CPU Core Discovery), HPET, MCFG.
Power Management: Native hardware ACPI S5 Sleep/Poweroff and 8042/ACPI hardware reset.

🎲 6. Hardware Random Number Generator (RNG)

Entropy Sources: Checks CPUID for hardware RDRAND (Leaf 1, ECX 30) and RDSEED (Leaf 7, EBX 18).
PRNG Fallback: Xorshift64* stirred with CPU cycle counter (rdtsc) and CMOS RTC.
Syscall & Tool: Syscall 22 (SYS_GETRANDOM) and user command random / rng generating UUID v4 identifiers.

💻 7. Interactive Terminal Shell (`osh`)

Stylized Powerline Prompt: ┌──(root@opencoreC)-[~]\n└─#
Built-in fastfetch: Integrated system information tool with custom ASCII logo and ANSI palette.
Log Isolation: Daemon logs (gui_server, procmgr, init_server) are routed to dmesg, leaving the interactive terminal pristine.

🏛️ Architecture Overview

graph TD
    subgraph Hardware [Physical & Virtual Hardware]
        CPU["x86_64 SMP (4 Cores)"]
        FB["Linear Framebuffer (1280x800@32bpp)"]
        NIC["PCI Realtek RTL8139 Fast Ethernet"]
        PS2["PS/2 Keyboard & Mouse"]
        ACPI_HW["ACPI FADT / MADT / PM1a"]
        RNG_HW["Hardware RNG (RDRAND/RDSEED)"]
    end

    subgraph Ring0 [Rust Microkernel - Ring 0]
        SCHED["SMP Scheduler (Core Affinity & Quantum)"]
        VMM["4-Level Paging (PML4) & VMM"]
        PFA["Physical Frame Allocator (Bitmap)"]
        IPC["Fast-Path Rendezvous & Capability IPC"]
        SIG["Signal Dispatcher (SIGSEGV/SIGILL/SIGFPE)"]
        DMESG["Kernel Circular Log Ring Buffer"]
    end

    subgraph Ring3 [Isolated User Space - Ring 3]
        GUI["gui_server (LVGL Desktop Compositor) [Core 1]"]
        SH["sh (Interactive UNIX Terminal Shell) [Core 2]"]
        INIT["init_server (System Root Server) [Core 3]"]
        UART["uart_driver (16550 Serial Driver) [Core 3]"]
        PROC["procmgr (Process & Server Manager) [Core 3]"]
    end

    Hardware <--> Ring0
    Ring0 <--> Ring3

📁 Repository Structure

opencoreC/
├── boot/
│   └── limine/                      # Limine bootloader binaries & installer
├── build/                           # Output directory for ELF binaries & disk image
├── config/
│   ├── linker.ld                    # Higher-half kernel linker script (0xffffffff80000000)
│   └── user.ld                      # Userspace Ring 3 ELF linker script (0x400000)
├── hal/                             # Hardware Abstraction Layer (PCI, 16550 UART)
├── include/
│   └── abi/
│       ├── ipc.h                    # Fast-Path IPC register layout & protocols
│       ├── syscalls.h               # System call numbers, structures, and POSIX signals
│       └── types.h                  # ABI primitive types
├── kernel/                          # Microkernel crate (Rust #![no_std])
│   ├── Cargo.toml
│   ├── asm/
│   │   ├── context.S                # Preemptive context switcher (switch_to)
│   │   └── syscall_entry.S          # Fast syscall/sysretq entry trampoline
│   └── src/
│       ├── main.rs                  # Kernel entry point & subsystem orchestrator
│       ├── arch/                    # GDT, TSS, IDT, SMP, ACPI, Syscalls
│       │   ├── acpi.rs              # RSDP, RSDT, FADT, MADT parser & poweroff
│       │   ├── gdt.rs               # Per-CPU GDT & TSS selectors
│       │   ├── idt.rs               # IDT vectors & Ring 3 signal fault handler
│       │   ├── smp.rs               # SMP multi-core AP boot & TSC_AUX per-CPU query
│       │   └── syscall.rs           # Fast-path syscall dispatcher
│       ├── drivers/                 # Microkernel drivers
│       │   ├── dmesg.rs             # Circular kernel log ring buffer
│       │   ├── keyboard.rs          # PS/2 keyboard driver
│       │   ├── mouse.rs             # PS/2 mouse driver with screen clamping
│       │   ├── rng.rs               # Hardware RNG (RDRAND / RDSEED / PRNG)
│       │   ├── serial.rs            # 16550 UART serial logger
│       │   └── timer.rs             # PIT 8254 timer (100 Hz preemptive ticks)
│       ├── ipc/                     # Capability-based synchronous rendezvous IPC
│       ├── mm/                      # Physical Frame Allocator & 4-Level Paging
│       └── sched/                   # Preemptive Multi-Core Scheduler & Threads
├── lib/
│   ├── libc/                        # Minimal freestanding C library (string, stdlib, stdio)
│   ├── libipc_cpp/                  # C++20 RAII IPC endpoints & message wrappers
│   └── lvgl/                        # LVGL v8.3 embedded graphics library
├── servers/                         # Ring 3 User-space processes
│   ├── gui_server/                  # Windows/KDE Desktop Compositor (LVGL v8.3)
│   ├── init_server/                 # System root server
│   ├── procmgr/                     # Process & server manager daemon
│   ├── sh/                          # Interactive UNIX shell (Powerline prompt & fastfetch)
│   └── uart_driver/                 # 16550 COM1 serial driver server
├── limine.conf                      # Limine bootloader configuration
├── Makefile                         # Unified build system
└── README.md                        # Documentation & project manual

🛠️ Build & Run Guide

Prerequisites (Ubuntu/Debian)

sudo apt-get update
sudo apt-get install -y build-essential gcc g++ qemu-system-x86 nasm mtools xorriso
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add x86_64-unknown-none

Quick Commands

Target	Description
`make all`	Compiles the Rust microkernel, freestanding libc, drivers, and Ring 3 servers.
`make image`	Builds a bootable 64 MiB hybrid FAT32 disk image (`build/opencoreC.img`) with Limine BIOS + UEFI.
`make gui`	Launches QEMU in GUI mode with the LVGL Desktop Compositor, hardware mouse, and terminal.
`make run`	Launches QEMU in serial console mode with `fastfetch` and the Powerline shell prompt.
`make clean`	Cleans all compiled binaries, intermediate objects, and disk images.

⌨️ Shell Command Reference (`osh`)

Available in both the Serial Console (make run) and the GUI Terminal Window (make gui):

Command	Description
`fastfetch` / `neofetch`	Displays the system summary, ASCII logo, and ANSI color palette.
`smp` / `cpu`	Displays online physical cores, current executing CPU, and per-core scheduler ticks.
`acpi`	Displays ACPI RSDP status, MADT discovered cores, and FADT power management ports.
`random` / `rng`	Generates 16 bytes of entropy via hardware RNG and formats as a UUID v4.
`crash_test`	Triggers a Ring 3 null-pointer fault to verify kernel `SIGSEGV` signal handling.
`ps`	Lists active threads, states (`READY`, `RUNNING`, `BLOCKED`), RIP, and CPU ticks.
`top`	Dynamic multi-core process and CPU load monitor.
`mem` / `free`	Displays Physical Frame Allocator (PFA) RAM usage (Total, Used, Free).
`ifconfig` / `ip`	Displays Realtek RTL8139 PCI Fast Ethernet MAC, IP, and status.
`ping <ip>`	Transmits real ICMP Echo Ping packets over RTL8139 PCI DMA.
`dmesg`	Displays the circular kernel and background daemon log ring buffer.
`date`	Queries CMOS Real-Time Clock date and time.
`uptime`	Displays system uptime and PIT timer clock ticks.
`uname -a`	Prints operating system name, kernel version, and architecture.
`whoami`	Prints the active user identity (`root`).
`kill <tid>`	Sends a termination request to stop a specific thread by PID.
`calc <expr>`	Freestanding arithmetic calculator (`+`, `-`, `*`).
`ls` / `dir`	Lists files in the in-memory RAM disk.
`cat <file>`	Reads and displays text file contents.
`touch <file>`	Creates a new file in RAM disk.
`clear`	Clears the terminal screen.
`reboot`	Reboots the machine via ACPI / 8042 reset.
`poweroff` / `exit`	Powers off the computer via hardware ACPI S5 shutdown.

📜 License

Distributed under the MIT / Apache-2.0 dual license. See LICENSE for details.

README.md

🌟 opencoreC: High-Performance x86_64 Microkernel OS