Subsystems

Memory, execution, DIS scheduler, init, relocation, userspace, and early boot.

Documentation

Memory Subsystem

The memory subsystem (helix-memory, 12 files, ~2,200 lines) manages all physical and virtual memory from early boot through full runtime.

Architecture

Memory Subsystem — Architecture5N · 4E

Minimap100%

100%

☝ Drag to pan·🤏 Pinch to zoom·Tap a node

Ctrl+FSearch

PPath

SStats

FFullscreen

EExport

Shift+DragMove node

↑↓Navigate

+/−Zoom

Physical Allocators

Allocator	Algorithm	Block Size	Use Case
`BumpAllocator`	Linear bump pointer	4 KB frames	Early boot only — fast, never frees
`BitmapAllocator`	Bit-per-frame bitmap	4 KB frames	General allocation — `find_free`, zone support
`BuddyAllocator`	Buddy system	4 KB → 8 MB	Large contiguous allocations — MAX_ORDER=11

The BuddyAllocator splits and merges power-of-2 sized blocks:

Buddy Allocator — Order Sizes8N · 7E

Minimap100%

100%

☝ Drag to pan·🤏 Pinch to zoom·Tap a node

Ctrl+FSearch

PPath

SStats

FFullscreen

EExport

Shift+DragMove node

↑↓Navigate

+/−Zoom

When a 16 KB allocation is requested, the allocator finds the smallest available block >= 16 KB and splits larger blocks in half until the right size is reached. When freed, adjacent buddies are merged back together.

Slab Allocator

For kernel heap allocations (small objects), the SlabAllocator provides 8 size classes:

Class	Object Size	Slab Layout
0	16 bytes	Free-list of 16B cells
1	32 bytes	Free-list of 32B cells
2	64 bytes	Free-list of 64B cells
3	128 bytes	Free-list of 128B cells
4	256 bytes	Free-list of 256B cells
5	512 bytes	Free-list of 512B cells
6	1024 bytes	Free-list of 1KB cells
7	2048 bytes	Free-list of 2KB cells

Each size class maintains a linked list of slabs. Allocation is O(1) — pop from the free list. Objects larger than 2 KB fall through to the buddy allocator.

Virtual Memory

subsystems/memory/src/virtual_memory/mod.rs

161rust

pub trait VirtualMapper: Send + Sync {

  fn map(&self, page: Page, frame: Frame, flags: PageFlags) -> MemResult<()>;

  fn unmap(&self, page: Page) -> MemResult<Frame>;

  fn translate(&self, virt: VirtAddr) -> Option<PhysAddr>;

  fn update_flags(&self, page: Page, flags: PageFlags) -> MemResult<()>;

  fn flush(&self, page: Page);

  fn flush_all(&self);

}

bitflags! {

3 refs

  pub struct PageFlags: u64 {

      const PRESENT       = 1 << 0;

      const WRITABLE      = 1 << 1;

      const USER          = 1 << 2;

      const WRITE_THROUGH = 1 << 3;

      const NO_CACHE      = 1 << 4;

      const ACCESSED      = 1 << 5;

      const DIRTY         = 1 << 6;

      const HUGE          = 1 << 7;

      const GLOBAL        = 1 << 8;

      const NO_EXECUTE    = 1 << 63;

}

}

Index

Address Space

Each process gets its own AddressSpace providing POSIX-like memory operations:

subsystems/memory/src/virtual_memory/address_space.rs

14rust

impl AddressSpace {

  pub fn mmap_anonymous(&self, addr: Option<VirtAddr>,

                        size: usize, flags: PageFlags) -> MemResult<VirtAddr>;

  pub fn munmap(&self, addr: VirtAddr, size: usize) -> MemResult<()>;

  pub fn mprotect(&self, addr: VirtAddr, size: usize,

                  flags: PageFlags) -> MemResult<()>;

  pub fn brk(&self, new_brk: VirtAddr) -> MemResult<VirtAddr>;

}

Index

Region management detects overlaps and automatically splits/merges adjacent regions with compatible flags.

Memory Protection

subsystems/memory/src/protection.rs

2rust

pub struct ProtectionDomain {

  pub key: ProtectionKey,     // Intel PKU key (0-15)

  pub flags: ProtectionFlags,

}

bitflags! {

2 refs

  pub struct ProtectionFlags: u32 {

      const NONE    = 0;

      const READ    = 1 << 0;

      const WRITE   = 1 << 1;

      const EXECUTE = 1 << 2;

      const RW      = Self::READ.bits() | Self::WRITE.bits();

      const RX      = Self::READ.bits() | Self::EXECUTE.bits();

      const RWX     = Self::RW.bits() | Self::EXECUTE.bits();

}

}

Index

GuardPage: Unmapped pages placed around kernel stacks to catch stack overflows. A page fault on a guard page triggers an immediate panic with a clear stack overflow message.

Execution

The execution subsystem (helix-execution, 12 files, ~2,500 lines) manages threads, processes, scheduling, and context switching.

Thread Model

subsystems/execution/src/thread/thread.rs

11rust

pub struct Thread {

  id: ThreadId,

  process: ProcessId,

  name: String,

  state: AtomicU32,                       // ThreadState

  priority: spin::RwLock<Priority>,

  flags: spin::RwLock<ThreadFlags>,

  context: spin::Mutex<ThreadContext>,

  kernel_stack: KernelStack,              // 16 KiB

  affinity: spin::RwLock<u64>,            // CPU bitmask

  cpu: spin::RwLock<Option<usize>>,

  exit_code: spin::RwLock<Option<i32>>,

}

#[repr(u32)]

2 refs

pub enum ThreadState {

  Creating = 0,  // Being set up

  Ready    = 1,  // Runnable, waiting for CPU

  Running  = 2,  // Currently executing

  Blocked  = 3,  // Waiting for event/resource

  Sleeping = 4,  // Timed wait

  Stopped  = 5,  // Stopped by signal/debugger

  Dead     = 6,  // Fully cleaned up

  Zombie   = 7,  // Terminated, not yet reaped

}

Index

ThreadContext

The hardware context saved/restored during context switches:

subsystems/execution/src/thread/thread.rs

1rust

pub struct ThreadContext {

  pub ip: u64,           // Instruction pointer

  pub sp: u64,           // Stack pointer

  pub regs: [u64; 16],   // General-purpose registers

  pub flags: u64,        // CPU flags (RFLAGS on x86)

}

Index

FPU state is saved lazily — only when a thread that used FPU/SSE/AVX is switched out and another thread needs FPU. This avoids the cost of saving 512+ bytes of XMM/YMM registers on every context switch.

Scheduler

subsystems/execution/src/scheduler/traits.rs

113rust

pub trait Scheduler: Send + Sync {

  fn name(&self) -> &'static str;

  fn version(&self) -> &'static str;

  fn init(&mut self, cpu_count: usize) -> ExecResult<()>;

  fn pick_next(&self, cpu: usize) -> Option<ThreadId>;

  fn add_thread(&self, thread: SchedulableThread) -> ExecResult<()>;

  fn remove_thread(&self, id: ThreadId) -> ExecResult<()>;

  fn thread_ready(&self, id: ThreadId) -> ExecResult<()>;

  fn thread_block(&self, id: ThreadId) -> ExecResult<()>;

  fn yield_thread(&self, cpu: usize);

  fn tick(&self, cpu: usize);

  fn set_priority(&self, id: ThreadId, priority: Priority) -> ExecResult<()>;

  fn needs_reschedule(&self, cpu: usize) -> bool;

  fn stats(&self) -> SchedulerStats;

}

Index

Three scheduling queue types are available:

Queue	Algorithm	Use Case
`FifoQueue`	First-in-first-out	Round-robin scheduling
`PriorityQueue`	Priority-sorted	Real-time threads
`MultilevelQueue`	Multiple priority bands	General purpose

Priority System

subsystems/execution/src/scheduler.rs

117rust

8 refs

pub struct Priority(pub u8);  // 0-139

8 refs

impl Priority {

  pub const REALTIME_THRESHOLD: u8 = 100;

  pub const IDLE: Priority = Priority(0);

  pub const LOW: Priority = Priority(30);

  pub const NORMAL: Priority = Priority(60);

  pub const HIGH: Priority = Priority(90);

  pub const REALTIME: Priority = Priority(120);

  pub const CRITICAL: Priority = Priority(139);

}

Index

Threads with priority >= 100 are treated as real-time and always preempt non-real-time threads.

Context Switch

subsystems/execution/src/context.rs

1121rust

2 refs

pub struct ContextSwitchEngine {

  fpu_lazy: AtomicBool,

  hooks: spin::RwLock<Vec<Arc<dyn ContextSwitchHook>>>,

}

2 refs

impl ContextSwitchEngine {

  pub fn add_hook(&self, hook: Arc<dyn ContextSwitchHook>);

  pub unsafe fn switch(

      &self, from: ThreadId, to: ThreadId,

      from_ctx: &mut ThreadContext, to_ctx: &ThreadContext,

      reason: SwitchReason,

);

}

2 refs

pub enum SwitchReason {

  Yield,        // Voluntary yield

  Preemption,   // Timer quantum expired

  Blocked,      // Waiting for resource

  Exit,         // Thread terminating

  Interrupt,    // Interrupt handling

  NewThread,    // New thread started

}

Index

Hooks are called before and after each context switch, enabling:

Statistics collection — track CPU time per thread
TLS switching — update thread-local storage pointer
FPU lazy switching — save FPU state only when needed
Performance counters — reset per-thread PMC values

Process Model

subsystems/execution/src/process.rs

11rust

pub struct Process {

  id: ProcessId,

  parent: Option<ProcessId>,

  name: String,

  state: AtomicU32,                    // ProcessState

  main_thread: RwLock<Option<ThreadId>>,

  threads: RwLock<Vec<ThreadId>>,

  children: RwLock<Vec<ProcessId>>,

  exit_code: RwLock<Option<i32>>,

}

2 refs

pub enum ProcessState {

  Creating, Running, Stopped, Zombie, Dead,

}

Index

Execution Domains

subsystems/execution/src/domains.rs

11rust

2 refs

pub enum DomainType {

  Kernel,    // Ring 0, full privileges

  User,      // Ring 3, standard process

  Driver,    // May be ring 0 or separate

  Sandbox,   // Restricted user

}

pub struct ExecutionDomain {

  id: DomainId,

  name: String,

  domain_type: DomainType,

  threads: RwLock<BTreeSet<ThreadId>>,

  processes: RwLock<BTreeSet<ProcessId>>,

}

Index

DIS Scheduler

The Dynamic Intent Scheduling system (helix-dis, 12 files, ~11,600 lines) is Helix's unique scheduling approach that schedules tasks based on intent rather than just priority.

Core Concept

Instead of assigning a static priority, each task declares an intent describing what it's trying to accomplish. The DIS engine uses this intent to make scheduling decisions, adjust time slices, and optimize for the workload:

subsystems/dis/intent.rs

1rust

#[repr(u8)]

pub enum IntentClass {

  RealTime     = 0, // Audio, video — strict deadlines

  SoftRealTime = 1, // UI rendering — best-effort deadlines

  Interactive  = 2, // User-facing — low latency

  Server       = 3, // Request-response — throughput

  Batch        = 4, // Data processing — CPU-bound

  Background   = 5, // Maintenance — lowest priority

  Idle         = 6, // Run only when nothing else needs CPU

  Critical     = 7, // Kernel services — highest priority

}

Index

Intent Specification

subsystems/dis/intent.rs

2rust

pub struct Intent {

  pub id: IntentId,

  pub class: IntentClass,

  pub flags: IntentFlags,

  pub latency: LatencyTarget,

  pub cpu_budget: CpuBudget,

  pub memory_budget: MemoryBudget,

  pub io_budget: IoBudget,

}

2 refs

pub struct CpuBudget {

  pub quota: Duration,        // Max CPU time per period

  pub period: Duration,       // Budget period

}

Index

Intent Presets

DIS provides built-in presets for common workloads:

Preset	Intent Class	Time Slice	CPU Affinity
`audio_playback`	RealTime	1 ms	Preferred single core
`video_rendering`	RealTime	2 ms	Any
`ui_thread`	Interactive	4 ms	Preferred BSP
`web_server`	Server	10 ms	Any
`database`	Server	8 ms	NUMA-aware
`compilation`	Batch	50 ms	All cores
`backup`	Background	100 ms	Any
`gc`	Background	20 ms	Any
`monitoring`	Idle	200 ms	Any

Queue Architecture

DIS integrates 7 queue levels into a unified scheduling framework:

DIS — Queue Levels7N · 6E

Minimap100%

100%

☝ Drag to pan·🤏 Pinch to zoom·Tap a node

Ctrl+FSearch

PPath

SStats

FFullscreen

EExport

Shift+DragMove node

↑↓Navigate

+/−Zoom

The IntegratedQueues struct manages all seven levels. On each tick, the scheduler picks the highest-priority non-empty queue and selects the next task from it.

Prediction Engine

DIS includes a machine-learning-based prediction engine that learns from task behavior:

subsystems/dis/optimizer.rs

14rust

pub struct PredictionEngine {

  pub fn predict_runtime(&self, task: &TaskDescriptor) -> Duration;

  pub fn predict_memory(&self, task: &TaskDescriptor) -> usize;

  pub fn suggest_strategy(&self, task: &TaskDescriptor) -> OptimizationHint;

  pub fn learn(&mut self, task: &TaskDescriptor, actual: &TaskStatistics);

}

Index

Optimization strategies include:

TimeSlice — adjust quantum based on predicted runtime
Priority — boost/demote based on behavior pattern
Affinity — pin to optimal CPU based on cache locality
Energy — consolidate tasks for power saving

Security Integration

DIS enforces isolation at the scheduling level:

subsystems/dis/isolation.rs

12rust

pub struct SecurityDomain {

  pub id: DomainId,

  pub name: String,

  pub domain_type: DomainType,

  pub default_caps: CapabilitySet,

  pub isolation: IsolationLevel,

  pub limits: ResourceLimits,

}

2 refs

pub enum DomainType {

  Kernel, System, User, Service, Sandbox, Guest, Container,

}

2 refs

pub enum IsolationLevel {

  None,      // No isolation — kernel threads

  Light,     // Basic process isolation

  Standard,  // Full memory protection

  Strict,    // Verified IPC only

  Paranoid,  // Maximum restrictions, minimal capabilities

}

Index

44 distinct capabilities are managed via a 128-bit bitmap for O(1) permission checks.

Statistics and Monitoring

subsystems/dis/stats.rs

11rust

pub struct TaskStats {

  pub cpu_time: Nanoseconds,

  pub user_time: Nanoseconds,

  pub kernel_time: Nanoseconds,

  pub wait_time: Nanoseconds,

  pub io_wait_time: Nanoseconds,

  pub context_switches: u64,

  pub voluntary_switches: u64,

  pub involuntary_switches: u64,

  pub preemptions: u64,

  pub migrations: u64,

  pub peak_memory: u64,

}

pub enum BehaviorPattern {

  CpuBound, IoBound, Mixed, Bursty,

  Periodic, EventDriven, Latency, Throughput,

}

Index

The StatsCollector performs anomaly analysis — detecting tasks that deviate from expected behavior patterns and flagging them for policy review.

Init Subsystem

The init subsystem (helix-init, 23 files, ~4,500 lines) manages the kernel's 5-phase boot sequence.

Phase Definitions

subsystems/init/src/phase.rs

1rust

pub enum InitPhase {

  Boot    = 0,  // Firmware handoff, serial console

  Early   = 1,  // GDT, IDT, heap, physical memory

  Core    = 2,  // Interrupts, timers, scheduler

  Late    = 3,  // Drivers, filesystem, IPC

  Runtime = 4,  // Userspace, modules, networking

}

Index

Phase Capabilities

Each phase unlocks new capabilities tracked via bitflags:

subsystems/init/src/phase.rs

1rust

bitflags! {

  pub struct PhaseCapabilities: u32 {

      const CONSOLE    = 1 << 0;

      const HEAP       = 1 << 1;

      const MEMORY     = 1 << 2;

      const INTERRUPTS = 1 << 3;

      const SCHEDULER  = 1 << 4;

      const TIMERS     = 1 << 5;

      const IPC        = 1 << 6;

      const DRIVERS    = 1 << 7;

      const FILESYSTEM = 1 << 8;

      const USERSPACE  = 1 << 9;

      const MODULES    = 1 << 10;

      const NETWORK    = 1 << 11;

}

}

Index

A subsystem can only be initialized if all its required capabilities are available. The init framework enforces this at runtime.

Subsystem Registration

subsystems/init/src/subsystem.rs

1181rust

pub struct SubsystemInfo {

  pub name: &'static str,

  pub phase: InitPhase,

  pub priority: u32,          // Within-phase ordering

  pub dependencies: Vec<&'static str>,

  pub capabilities: PhaseCapabilities,  // What this provides

  pub requires: PhaseCapabilities,      // What this needs

}

pub trait Subsystem: Send + Sync {

2 refs

  fn name(&self) -> &'static str;

  fn init(&mut self) -> Result<()>;

  fn start(&mut self) -> Result<()>;

  fn stop(&mut self) -> Result<()>;

  fn health_check(&self) -> HealthStatus;

  fn state(&self) -> SubsystemState;

2 refs

  fn dependencies(&self) -> &[&'static str];

2 refs

  fn capabilities(&self) -> PhaseCapabilities;

}

2 refs

pub enum SubsystemState {

  Registered, Initializing, Running, Stopping,

  Stopped, Failed, Recovering,

}

Index

13 Init Subsystems

Subsystem	Phase	Priority	Provides	Dependencies
boot	0	0	CONSOLE	None
cpu	1	10	—	boot
debug	1	20	—	boot
memory	1	30	HEAP, MEMORY	cpu
interrupts	2	40	INTERRUPTS	memory
timers	2	50	TIMERS	interrupts
scheduler	2	60	SCHEDULER	timers, memory
ipc	3	70	IPC	scheduler
drivers	3	80	DRIVERS	interrupts, memory
filesystem	3	85	FILESYSTEM	drivers, memory
security	3	90	—	memory, ipc
network	4	100	NETWORK	drivers, ipc
userland	4	110	USERSPACE, MODULES	filesystem, security, scheduler

Relocation

The relocation subsystem (helix-relocation, 12 files, ~2,000 lines, edition 2024) handles ELF binary relocation for KASLR and PIE kernel images.

Purpose

When the kernel is built as a Position-Independent Executable (PIE), all absolute addresses in the binary must be adjusted when the kernel is loaded at a different address than it was linked for. This adjustment is called relocation.

Components

Relocation — Source Tree10N · 9E

Minimap100%

100%

☝ Drag to pan·🤏 Pinch to zoom·Tap a node

Ctrl+FSearch

PPath

SStats

FFullscreen

EExport

Shift+DragMove node

↑↓Navigate

+/−Zoom

Relocation Process

Parse ELF headers from the kernel image
Read the .dynamic section to find .rela.dyn and .rela.plt
Generate KASLR offset from entropy source
Apply each relocation: *(target) = base + addend + kaslr_offset
Validate: ensure all relocated pointers fall within the kernel image
Jump to the relocated kernel entry point

Userspace

The userspace subsystem (helix-userspace, 8 files, ~3,500 lines) provides the bridge between kernel services and user programs.

ELF Loader

subsystems/userspace/src/elf.rs

212rust

2 refs

pub struct ElfLoader;

2 refs

impl ElfLoader {

  pub fn parse(data: &[u8]) -> Result<ParsedElf>;

  pub fn load(parsed: &ParsedElf, address_space: &mut AddressSpace) -> Result<LoadedElf>;

}

3 refs

pub struct ParsedElf {

  pub header: ElfHeader,

  pub program_headers: Vec<ProgramHeader>,

  pub section_headers: Vec<SectionHeader>,

  pub symbols: Vec<Symbol>,

  pub entry_point: u64,

  pub is_pie: bool,

}

Index

The loader supports:

ELF64 format (little-endian)
PT_LOAD segments for code and data
PT_INTERP for dynamic linking (future)
PIE (Position-Independent Executables)
Section headers for debug info and symbols

Runtime

subsystems/userspace/src/runtime.rs

231rust

pub struct Runtime {

  pub fn spawn(&mut self, program: &Program,

               args: &[&str], env: &Environment) -> Result<ProcessHandle>;

  pub fn kill(&mut self, pid: ProcessId, signal: Signal) -> Result<()>;

  pub fn reap(&mut self, pid: ProcessId) -> Result<ExitStatus>;

}

2 refs

pub struct ProcessHandle {

  pub pid: ProcessId,

  pub state: ProcessState,

  pub fd_table: FdTable,

}

2 refs

pub enum ProcessState {

  Created, Running, Blocked, Stopped, Zombie, Dead,

}

Index

File Descriptor Table

subsystems/userspace/src/fd.rs

115rust

2 refs

pub struct FdTable {

  entries: BTreeMap<Fd, FdEntry>,

  next_fd: Fd,

}

2 refs

impl FdTable {

  pub fn new() -> Self;  // Pre-opens stdin(0), stdout(1), stderr(2)

  pub fn alloc(&mut self, entry: FdEntry) -> Result<Fd>;

  pub fn close(&mut self, fd: Fd) -> Result<()>;

  pub fn dup(&mut self, old_fd: Fd) -> Result<Fd>;

  pub fn get(&self, fd: Fd) -> Option<&FdEntry>;

}

Index

Shell

The built-in kernel shell provides 16 commands:

Command	Description
`help`	List all commands
`exit`	Exit the shell
`echo <text>`	Print text to stdout
`clear`	Clear the screen
`ps`	List running processes and threads
`mem`	Display memory statistics
`uptime`	Show kernel uptime
`uname`	Print kernel name and version
`set <key>=<val>`	Set environment variable
`history`	Show command history
`bench`	Run benchmarks
`stats`	Display system statistics
`cat <file>`	Print file contents
`run <program>`	Execute an ELF binary
`version`	Print detailed version info
`demo`	Run kernel demonstration

The shell supports ANSI color output, command history, and an ASCII art banner on startup.

Syscall Interface

The userspace crate implements 47 syscalls (42 POSIX-compatible + 5 Helix-specific):

POSIX Syscalls:

Number	Name	Description
0	`read`	Read from file descriptor
1	`write`	Write to file descriptor
2	`open`	Open file
3	`close`	Close file descriptor
4	`stat`	Get file status
9	`mmap`	Map memory
10	`mprotect`	Change memory protection
11	`munmap`	Unmap memory
12	`brk`	Change data segment size
39	`getpid`	Get process ID
57	`fork`	Create child process
59	`execve`	Execute program
60	`exit`	Terminate process
62	`kill`	Send signal

Helix-Specific Syscalls:

Number	Name	Description
500	`helix_dis_stats`	Get DIS scheduler statistics
501	`helix_hot_reload`	Trigger module hot-reload
502	`helix_self_heal`	Trigger subsystem recovery
503	`helix_benchmark`	Run kernel benchmarks
504	`helix_kernel_info`	Get kernel version and state

Syscall ABI

subsystems/userspace/src/syscall.rs

1rust

pub struct SyscallArgs {

  pub number: usize,  // rax

  pub arg0: usize,    // rdi

  pub arg1: usize,    // rsi

  pub arg2: usize,    // rdx

  pub arg3: usize,    // r10

  pub arg4: usize,    // r8

  pub arg5: usize,    // r9

}

// Return value in rax. Error: negative errno.

Index

Early Boot

The early boot path bridges the gap between the bootloader and the full kernel. This code runs before the heap, interrupts, or scheduler are available.

Minimal Profile Entry

The helix-minimal-os crate (profiles/minimal/main.rs, ~1,700 lines) is the kernel entry point:

profiles/minimal/src/main.rs

rust

#[no_mangle]

pub extern "C" fn kernel_main(boot_info: &BootInfo) -> ! {

  // Phase 0: Boot

  serial::init();

  kprintln!("Helix OS v{}", VERSION);

  // Phase 1: Early

  heap::init(HEAP_BASE, HEAP_SIZE);  // 4 MB initial heap

  memory::init(boot_info.memory_map());

  // Phase 2: Core

  interrupts::init();

  timer::init();

  scheduler::init();

  // Phase 3: Late

  fs::mount_helixfs();

  // Phase 4: Runtime

  modules::load_all();

  userspace::init();

  // Demos

  demo_hot_reload();

  demo_self_healing();

  demo_ai_cortex();

  demo_benchmarks();

  demo_shell();

  // Event loop

  loop { halt(); }

}

Boot Protocols

Protocol	Entry Symbol	Boot Info	Paging
Limine	`limine_entry`	Limine Protocol Rev 2 requests	Higher-half provided
Multiboot2	`_start`	Multiboot2 info structure	Must set up manually
UEFI	`efi_main`	UEFI System Table	Identity-mapped, must remap

Each protocol provides a memory map, framebuffer info, RSDP pointer, and command line. The early boot code normalizes this into a common BootConfiguration.

Memory Subsystem#

Architecture#

Core Types#

Physical Allocators#

Slab Allocator#

Virtual Memory#

Address Space#

Memory Protection#

Execution#

Thread Model#

ThreadContext#

Scheduler#

Priority System#

Context Switch#

Process Model#

Execution Domains#

DIS Scheduler#

Core Concept#

Intent Specification#

Intent Presets#

Queue Architecture#

Prediction Engine#

Security Integration#

Statistics and Monitoring#

Init Subsystem#

Phase Definitions#

Phase Capabilities#

Subsystem Registration#

13 Init Subsystems#

Relocation#

Purpose#

Components#

Relocation Process#

Userspace#

ELF Loader#

Runtime#

File Descriptor Table#

Shell#

Syscall Interface#

Syscall ABI#

Early Boot#

Minimal Profile Entry#

Boot Protocols#

Memory Subsystem

Architecture

Core Types

Physical Allocators

Slab Allocator

Virtual Memory

Address Space

Memory Protection

Execution

Thread Model

ThreadContext

Scheduler

Priority System

Context Switch

Process Model

Execution Domains

DIS Scheduler

Core Concept

Intent Specification

Intent Presets

Queue Architecture

Prediction Engine

Security Integration

Statistics and Monitoring

Init Subsystem

Phase Definitions

Phase Capabilities

Subsystem Registration

13 Init Subsystems

Relocation

Purpose

Components

Relocation Process

Userspace

ELF Loader

Runtime

File Descriptor Table

Shell

Syscall Interface

Syscall ABI

Early Boot

Minimal Profile Entry

Boot Protocols