KernRift

# Linux / macOS (installs krc, kr, and stdlib to ~/.local/)
curl -sSf https://raw.githubusercontent.com/Pantelis23/KernRift/main/install.sh | sh

# Windows PowerShell (installs krc.exe, kr.exe, and stdlib to %LOCALAPPDATA%\KernRift\)
irm https://raw.githubusercontent.com/Pantelis23/KernRift/main/install.ps1 | iex

# Homebrew (macOS / Linux)
brew install kernrift

# Scoop (Windows)
scoop bucket add kernrift https://github.com/Pantelis23/KernRift
scoop install kernrift

# Winget (Windows)
winget install Pantelis23.KernRift

# AUR (Arch Linux)
yay -S kernrift

# Or download directly (x86_64 / ARM64)
curl -L -o krc https://github.com/Pantelis23/KernRift/releases/latest/download/krc-linux-x86_64
curl -L -o kr  https://github.com/Pantelis23/KernRift/releases/latest/download/kr
chmod +x krc kr && sudo mv krc kr /usr/local/bin/

fn fib(uint64 n) -> uint64 {
    if n <= 1 { return n }
    return fib(n - 1) + fib(n - 2)
}

struct Point {
    uint64 x
    uint64 y
}

static uint64 counter = 0

fn main() {
    Point p
    p.x = fib(10)     // 55
    p.y = 42
    uint64 msg = "KernRift!\n"
    write(1, msg, 10)
    exit(p.x + p.y)   // 97
}

// Direct memory access for kernel development
fn main() {
    uint64 buf = alloc(4096)

    // Write a uint32 to memory
    unsafe { *(buf as uint32) = 0xDEADBEEF }

    // Read it back
    uint32 val = 0
    unsafe { *(buf as uint32) -> val }

    // Array operations
    uint8[256] table
    uint64 i = 0
    while i < 256 {
        table[i] = i
        i += 1
    }
    exit(table[42])  // 42
}

// Naked ISR entry — no compiler-generated prologue
@naked fn isr_timer() {
    asm { "cli"; "nop"; "sti"; "iretq" }
}

// Hardware register manipulation with bitfields
fn enable_paging(uint64 cr0_val) -> uint64 {
    uint64 pg = bit_set(cr0_val, 31)   // set PG bit
    uint64 pe = bit_set(pg, 0)          // set PE bit
    return pe
}

// Signed comparisons for kernel math
fn clamp_signed(uint64 val, uint64 lo, uint64 hi) -> uint64 {
    if signed_lt(val, lo) { return lo }
    if signed_gt(val, hi) { return hi }
    return val
}

# Compile to fat binary (8 platform slices, BCJ+LZ-Rift-compressed)
$ krc program.kr -o program.krbo

# Run on any platform
$ kr program.krbo

# Or compile for a single architecture and run directly
$ krc --arch=x86_64 program.kr -o program
$ ./program

# Safety analysis
$ krc check module.kr

# Living compiler — patterns + fitness score
$ krc lc program.kr
=== KernRift Living Compiler Report ===
Functions: 12
Calls: 45
Unsafe ops: 3
Patterns found: 2
Fitness score: 85/100

# The compiler compiles itself
$ krc --arch=x86_64 krc-source.kr -o krc