sys_threnos_ai that gives any process direct AI query access at the kernel level. (2) An AI-aware filesystem where every inode carries an embedding vector ID. (3) A session-aware AI daemon with persistent context memory across reboots — the OS remembers your work history.sys_threnos_ai syscall and a Unix domain socket at /run/threnos/ai.sock.threnos/ ├── boot/ # Phase 2 — Bootloader │ ├── stage1.asm # 512-byte MBR │ ├── stage2.asm # Protected mode switch │ └── uefi/ # UEFI path (GNU-EFI) │ ├── kernel/ # Phase 3-6 — Kernel core │ ├── arch/x86_64/ │ │ ├── boot.asm # Kernel entry stub │ │ ├── gdt.c / gdt.h # Global Descriptor Table │ │ ├── idt.c / idt.h # Interrupt Descriptor Table │ │ ├── isr.asm # Interrupt service routines │ │ ├── paging.c # 4-level page tables │ │ └── acpi.c # Power management │ ├── mm/ │ │ ├── pmm.c # Physical memory bitmap │ │ ├── vmm.c # Virtual memory mapping │ │ └── heap.c # kmalloc / kfree │ ├── proc/ │ │ ├── process.c # PCB, fork, exec, exit │ │ ├── thread.c # TCB, kernel threads │ │ ├── sched.c # CFS scheduler │ │ ├── elf.c # ELF binary loader │ �� └── signal.c # POSIX signals │ ├── drivers/ │ │ ├── keyboard.c │ │ ├── timer.c # PIT + HPET │ │ ├── vga.c # Text mode + framebuffer │ │ ├── pci.c # PCI bus enumeration │ │ ├── ahci.c # SATA disk driver │ │ ├── nvme.c # NVMe driver │ │ ├── rtl8139.c # Network card driver │ │ └── usb/ # XHCI USB stack │ ├── ipc/ │ │ ├── pipe.c │ │ ├── msgqueue.c │ │ └── shmem.c # Shared memory │ ├── syscall/ │ │ ├── table.c # 64 syscall dispatch │ │ └── sys_ai.c # sys_threnos_ai (unique) │ └── net/ │ ├── ethernet.c │ ├── arp.c │ ├── ip.c │ ├── tcp.c │ ├── udp.c │ └── socket.c │ ├── fs/ # Phase 7 — Filesystem │ ├── vfs.c / vfs.h │ ├── threnosfs/ # Custom filesystem │ ├── fat32/ # FAT32 for USB/SD compatibility │ └── initrd/ # Initial RAM disk │ ├── ai/ # Phase 9 — AI Engine │ ├── threnos-aisvc/ # Main AI daemon (Python) │ ├── embeddings/ # FS indexer │ ├── context/ # Persistent session memory │ └── ipc-bridge/ # Kernel socket bridge (Rust) │ ├── userspace/ # Phase 5 — Userspace │ ├── libc/ # Minimal C stdlib │ ├── init/ # PID 1 │ └── daemons/ │ ├── shell/ # Phase 10 — thrsh ├── ui/ # Phase 10 — TUI dashboard ├── pkg/ # thrpkg package manager ├── sdk/ # Developer SDK ├── tools/ # Build scripts └── iso/ # ISO image builder
sudo apt update && sudo apt install -y \ build-essential bison flex \ libgmp3-dev libmpc-dev libmpfr-dev \ texinfo libisl-dev nasm \ qemu-system-x86 xorriso grub-pc-bin \ gdb git make cmake
x86_64-elf — produces 64-bit bare metal code.export TARGET=x86_64-elf export PREFIX="$HOME/threnos-toolchain" export PATH="$PREFIX/bin:$PATH" # Build Binutils (linker, assembler wrappers) mkdir -p ~/src/build-binutils && cd ~/src/build-binutils ../binutils-2.41/configure \ --target=$TARGET --prefix=$PREFIX \ --with-sysroot --disable-nls --disable-werror make -j$(nproc) && make install # Build GCC without headers (freestanding) mkdir -p ~/src/build-gcc && cd ~/src/build-gcc ../gcc-13.2.0/configure \ --target=$TARGET --prefix=$PREFIX \ --enable-languages=c,c++ \ --without-headers --disable-nls make all-gcc all-target-libgcc -j$(nproc) make install-gcc install-target-libgcc # Verify x86_64-elf-gcc --version # Should print gcc 13.2.0
export PATH="$HOME/threnos-toolchain/bin:$PATH" to your ~/.bashrc. Every compile command in this guide uses x86_64-elf-gcc, not system gcc.# Run THRENOS with GDB server on port 1234 qemu-system-x86_64 \ -cdrom threnos.iso \ -m 2G -smp 2 \ -serial stdio \ -s -S # -s = GDB port 1234, -S = pause at start # In another terminal: gdb threnos.bin (gdb) target remote :1234 (gdb) break kernel_main (gdb) continue
[BITS 16] [ORG 0x7C00] ; BIOS loads here _start: xor ax, ax ; Zero segment registers mov ds, ax mov es, ax mov ss, ax mov sp, 0x7C00 ; Stack below bootloader cld ; Clear direction flag mov si, msg_boot call print16 ; Load Stage 2 from disk (sectors 2–12) mov ah, 0x02 ; BIOS: read sectors mov al, 15 ; 15 sectors = 7.5KB mov ch, 0 ; Cylinder 0 mov cl, 2 ; Start sector 2 mov dh, 0 ; Head 0 mov bx, 0x8000 ; Load destination int 0x13 jc .disk_err jmp 0x0000:0x8000 ; Jump to Stage 2 .disk_err: mov si, msg_err call print16 hlt print16: ; Print SI string via BIOS lodsb or al, al jz .done mov ah, 0x0E int 0x10 jmp print16 .done: ret msg_boot db 'THRENOS Stage 1', 13, 10, 0 msg_err db 'Disk Read Error', 0 times 510-($ - $$) db 0 dw 0xAA55 ; Boot magic (REQUIRED)
e_entry.; ── Step 1: Get memory map from BIOS (E820) get_memory_map: mov di, 0x500 ; Store at 0x500 xor ebx, ebx mov edx, 0x534D4150 ; 'SMAP' .loop: mov eax, 0xE820 mov ecx, 24 int 0x15 jc .done add di, 24 test ebx, ebx jnz .loop .done: ; ── Step 2: Enable A20 via Fast A20 in al, 0x92 or al, 2 out 0x92, al ; ── Step 3: Load GDT + enter protected mode lgdt [gdt32_ptr] mov eax, cr0 or eax, 1 mov cr0, eax jmp 0x08:protected32 [BITS 32] protected32: ; ── Step 4: Set up PML4 for long mode (identity map 4GB) ; ... (page table setup, see source) ; ── Step 5: Enable PAE + LME + PG bits → long mode mov eax, cr4 or eax, (1<<5) ; CR4.PAE mov cr4, eax mov ecx, 0xC0000080 rdmsr or eax, (1<<8) ; EFER.LME wrmsr mov eax, cr0 or eax, (1<<31)|(1<<0) mov cr0, eax jmp 0x08:long_mode_entry [BITS 64] long_mode_entry: ; ── Step 6+7: Load kernel ELF → parse → jump to e_entry call load_kernel_elf jmp rax ; rax = kernel entry point
nasm -f bin boot/stage1.asm -o build/stage1.bin
nasm -f bin boot/stage2.asm -o build/stage2.bin
dd if=/dev/zero of=threnos.img bs=512 count=4096
dd if=build/stage1.bin of=threnos.img conv=notrunc
dd if=build/stage2.bin of=threnos.img seek=1 conv=notrunc
qemu-system-x86_64 -drive format=raw,file=threnos.img
# Expected output: THRENOS Stage 1 ... THRENOS Kernel Loaded#define VGA_BASE ((uint16_t*)0xB8000) #define VGA_COLS 80 #define VGA_WHITE_ON_BLACK 0x0F00 static int vga_col = 0, vga_row = 0; void vga_putchar(char c) { if (c == '\n') { vga_col = 0; vga_row++; return; } VGA_BASE[vga_row * VGA_COLS + vga_col] = VGA_WHITE_ON_BLACK | c; if (++vga_col >= VGA_COLS) { vga_col = 0; vga_row++; } } void kernel_main() { vga_clear(); vga_print("THRENOS v0.1 — kernel_main() reached\n"); gdt_init(); idt_init(); pic_remap(0x20, 0x28); ; IRQ 0-7 → INT 32-39, IRQ 8-15 → INT 40-47 asm volatile("sti"); ; Enable interrupts vga_print("GDT, IDT, PIC initialized.\n"); // ... continue to Phase 4 for(;;) asm volatile("hlt"); }
struct gdt_entry { uint16_t limit_low, base_low; uint8_t base_mid, access, flags_limit_high, base_high; } __attribute__((packed)); struct gdt_entry gdt[6] = { [0] = {0}, // Null [1] = GDT_ENTRY(0, 0xFFFFF, 0x9A, 0xA), // Kernel code (Ring 0) [2] = GDT_ENTRY(0, 0xFFFFF, 0x92, 0xC), // Kernel data (Ring 0) [3] = GDT_ENTRY(0, 0xFFFFF, 0xFA, 0xA), // User code (Ring 3) [4] = GDT_ENTRY(0, 0xFFFFF, 0xF2, 0xC), // User data (Ring 3) [5] = {0}, // TSS (filled at runtime) }; void gdt_init() { gdt_ptr.limit = sizeof(gdt) - 1; gdt_ptr.base = (uint64_t)&gdt; asm volatile("lgdt %0\n\t" "mov $0x10, %%ax\n\t" // Kernel data selector "mov %%ax, %%ds\n\t" "mov %%ax, %%es\n\t" "mov %%ax, %%ss\n\t" :: "m"(gdt_ptr) : "ax"); }
; Macro: ISR stub that pushes a dummy error code + interrupt number %macro ISR_NOERRCODE 1 isr%1: push 0 ; Dummy error code push %1 ; Interrupt number jmp isr_common_stub %endmacro %macro ISR_ERRCODE 1 isr%1: push %1 jmp isr_common_stub %endmacro ISR_NOERRCODE 0 ; Divide by zero ISR_NOERRCODE 1 ; Debug ISR_NOERRCODE 3 ; Breakpoint ISR_ERRCODE 8 ; Double fault ISR_ERRCODE 14 ; Page fault ; ... all 32 CPU exceptions isr_common_stub: pusha ; Save all registers mov ax, ds push rax mov ax, 0x10 ; Kernel data segment mov ds, ax call isr_handler ; C handler pop rax mov ds, ax popa add rsp, 8 ; Pop error code + ISR number iretq ; Return from interrupt
void acpi_shutdown() { // Write SLP_TYPa | SLP_EN to PM1a_CNT_BLK outw(fadt->pm1a_cnt_blk, slp_typa | SLP_EN); // If that didn't work, try PM1b if (fadt->pm1b_cnt_blk) outw(fadt->pm1b_cnt_blk, slp_typb | SLP_EN); // Fallback: qemu-specific port outw(0x604, 0x2000); // QEMU shutdown asm volatile("hlt"); } void acpi_reboot() { // Method 1: ACPI reset register (if present) if (fadt->reset_reg.address) outb(fadt->reset_reg.address, fadt->reset_value); // Fallback: PS/2 keyboard controller reset outb(0x64, 0xFE); }
pmm_alloc_frame() and pmm_free_frame(). Mark kernel pages, BIOS reserved areas, and MMIO regions as used.#define PAGE_SIZE 4096 #define FRAMES_TOTAL (4UL * 1024 * 1024 * 1024 / PAGE_SIZE) static uint64_t bitmap[FRAMES_TOTAL / 64]; // 1 bit per frame static inline void frame_set(uint64_t frame) { bitmap[frame/64] |= (1ULL << (frame%64)); } static inline void frame_clear(uint64_t frame) { bitmap[frame/64] &= ~(1ULL << (frame%64)); } static inline int frame_test(uint64_t frame) { return (bitmap[frame/64] >> (frame%64)) & 1; } uint64_t pmm_alloc_frame() { for (uint64_t i = 0; i < FRAMES_TOTAL/64; i++) { if (bitmap[i] == 0xFFFFFFFFFFFFFFFF) continue; int bit = __builtin_ctzll(~bitmap[i]); // First free bit uint64_t frame = i*64 + bit; frame_set(frame); return frame * PAGE_SIZE; } return 0; // OOM }
#define KERNEL_VBASE 0xFFFF800000000000ULL #define PAGE_PRESENT (1ULL << 0) #define PAGE_WRITE (1ULL << 1) #define PAGE_USER (1ULL << 2) #define PAGE_NX (1ULL << 63) void vmm_map(uint64_t *pml4, uint64_t virt, uint64_t phys, uint64_t flags) { uint64_t pml4i = (virt >> 39) & 0x1FF; uint64_t pdpti = (virt >> 30) & 0x1FF; uint64_t pdi = (virt >> 21) & 0x1FF; uint64_t pti = (virt >> 12) & 0x1FF; // Walk/create page table levels uint64_t *pdpt = get_or_create(pml4, pml4i); uint64_t *pd = get_or_create(pdpt, pdpti); uint64_t *pt = get_or_create(pd, pdi); pt[pti] = phys | flags; asm volatile("invlpg (%0)" :: "r"(virt) : "memory"); } // Page fault handler (ISR 14) void page_fault_handler(registers_t *regs) { uint64_t addr; asm volatile("mov %%cr2, %0" : "=r"(addr)); // Implement demand paging / CoW here kpanic("Page fault at 0x%llx", addr); }
kmalloc walks the list for a free block of sufficient size; kfree marks it free and merges adjacent free blocks.typedef struct heap_block { size_t size; uint8_t free; struct heap_block *next; } heap_block_t; static heap_block_t *heap_head = NULL; static uint64_t heap_end = KERNEL_HEAP_START; void* kmalloc(size_t size) { heap_block_t *b = heap_head; while (b) { if (b->free && b->size >= size) { b->free = 0; if (b->size > size + sizeof(heap_block_t)) split_block(b, size); // Split oversized block return (uint8_t*)b + sizeof(heap_block_t); } b = b->next; } return expand_heap(size); // Allocate new pages } void kfree(void *ptr) { heap_block_t *b = (heap_block_t*)((uint8_t*)ptr - sizeof(heap_block_t)); b->free = 1; coalesce_free_blocks(); // Merge adjacent free blocks }
// Map physical MMIO region into kernel virtual space void* mmio_map(uint64_t phys_addr, size_t length) { uint64_t virt = vmm_alloc_kernel_range(length); for (size_t i = 0; i < length; i += PAGE_SIZE) { vmm_map(kernel_pml4, virt + i, phys_addr + i, PAGE_PRESENT | PAGE_WRITE | PAGE_NX | PAGE_NO_CACHE); } return (void*)virt; } // Usage — e.g., map AHCI controller registers: ahci_base = mmio_map(pci_get_bar(ahci_dev, 5), 0x1100);
fork() clones the PCB and page tables (copy-on-write). exec() replaces the address space with a new ELF binary. exit() frees all resources.typedef struct process { uint32_t pid, ppid; uint64_t *pml4; // Page table root fd_t fds[MAX_FDS]; // Open file descriptors sig_handler_t signals[NSIG]; // Signal handlers char cwd[PATH_MAX]; // Current working dir char name[64]; int exit_code; struct thread *threads; // Thread list struct process *next; } process_t; process_t* sys_fork(process_t *parent) { process_t *child = kmalloc(sizeof(process_t)); memcpy(child, parent, sizeof(process_t)); child->pid = next_pid++; child->ppid = parent->pid; child->pml4 = vmm_clone_pml4_cow(parent->pml4); // Copy-on-write child->threads = clone_thread_state(parent->threads); process_enqueue(child); return child; }
typedef struct thread { uint64_t rsp, rip, rflags; uint64_t rax,rbx,rcx,rdx,rsi,rdi; uint64_t r8,r9,r10,r11,r12,r13,r14,r15; uint64_t rbp; uint64_t *kernel_stack; // 16KB kernel stack uint32_t tid; uint8_t state; // READY / RUNNING / BLOCKED / ZOMBIE uint64_t sleep_until; // For sleep() / timer process_t *process; // Owner process struct thread *next; } thread_t; thread_t* thread_create(process_t *proc, void(*entry)(), bool kernel) { thread_t *t = kmalloc(sizeof(thread_t)); t->kernel_stack = pmm_alloc_frame() * 4; // 4 pages = 16KB stack t->rsp = (uint64_t)t->kernel_stack + 16*1024; t->rip = (uint64_t)entry; t->rflags = kernel ? 0x202 : 0x3202; // IF=1, IOPL=0 or 3 t->state = THREAD_READY; t->process = proc; return t; }
// Timer ISR calls this every 4ms void sched_tick(registers_t *regs) { thread_t *cur = current_thread; cur->vruntime += 4; // Add 4ms of runtime save_context(cur, regs); // Pick thread with minimum vruntime (red-black tree in real impl) thread_t *next = pick_min_vruntime(); if (next == cur) return; // No switch needed current_thread = next; next->state = THREAD_RUNNING; cur->state = THREAD_READY; // Switch page tables if different process if (next->process->pml4 != cur->process->pml4) load_pml4(next->process->pml4); restore_context(next, regs); } // Architecture-level context switch (assembly) void save_context(thread_t *t, registers_t *r) { t->rax = r->rax; t->rbx = r->rbx; t->rcx = r->rcx; t->rdx = r->rdx; t->rsi = r->rsi; t->rdi = r->rdi; t->rsp = r->rsp; t->rbp = r->rbp; t->rip = r->rip; // ... all 16 regs }
exec(), the kernel reads the ELF file, validates the magic bytes, iterates PT_LOAD segments, maps them into the process's virtual address space at the requested virtual addresses, sets up the stack with argv/envp, and jumps to e_entry.int elf_load(process_t *proc, const char *path) { vfs_node_t *file = vfs_open(path, O_RDONLY); Elf64_Ehdr ehdr; vfs_read(file, 0, sizeof(ehdr), &ehdr); // Validate ELF magic: 0x7F 'E' 'L' 'F' if (memcmp(ehdr.e_ident, "\x7FELF", 4) != 0) return -ENOEXEC; if (ehdr.e_machine != EM_X86_64) return -ENOEXEC; // Load each PT_LOAD segment into process address space for (int i = 0; i < ehdr.e_phnum; i++) { Elf64_Phdr phdr; vfs_read(file, ehdr.e_phoff + i*sizeof(phdr), sizeof(phdr), &phdr); if (phdr.p_type != PT_LOAD) continue; for (uint64_t off = 0; off < phdr.p_memsz; off += PAGE_SIZE) { uint64_t frame = pmm_alloc_frame(); vmm_map(proc->pml4, phdr.p_vaddr + off, frame, PAGE_PRESENT | PAGE_USER | (phdr.p_flags & PF_W ? PAGE_WRITE : 0) | (phdr.p_flags & PF_X ? 0 : PAGE_NX)); } vfs_read(file, phdr.p_offset, phdr.p_filesz, (void*)phdr.p_vaddr); memset((void*)(phdr.p_vaddr + phdr.p_filesz), 0, phdr.p_memsz - phdr.p_filesz); } proc->threads->rip = ehdr.e_entry; setup_user_stack(proc); return 0; }
void signal_send(process_t *proc, int signum) { proc->pending_signals |= (1 << signum); } // Called when returning from kernel to user space void signal_deliver(thread_t *thread, registers_t *regs) { process_t *proc = thread->process; if (!proc->pending_signals) return; int sig = __builtin_ctzll(proc->pending_signals); proc->pending_signals &= ~(1 << sig); if (sig == SIGKILL || proc->signals[sig] == SIG_DFL) { sys_exit(proc, 128 + sig); return; } // Build signal frame on user stack → call handler in Ring 3 setup_signal_frame(thread, regs, sig, proc->signals[sig]); }
uint32_t pci_read(uint8_t bus, uint8_t dev, uint8_t fn, uint8_t reg) { uint32_t addr = (1<<31) | (bus<<16) | (dev<<11) | (fn<<8) | (reg & 0xFC); outl(0xCF8, addr); return inl(0xCFC); } void pci_enumerate() { for (int bus=0; bus<256; bus++) for (int dev=0; dev<32; dev++) for (int fn=0; fn<8; fn++) { uint32_t id = pci_read(bus, dev, fn, 0); if ((id & 0xFFFF) == 0xFFFF) continue; // No device uint16_t vendor = id & 0xFFFF; uint16_t device = id >> 16; uint8_t class = pci_read(bus,dev,fn,8) >> 24; uint8_t subcls = (pci_read(bus,dev,fn,8) >> 16) & 0xFF; pci_register(bus, dev, fn, vendor, device, class, subcls); kprintf("PCI %02x:%02x.%x vendor=%04x dev=%04x class=%02x\n", bus, dev, fn, vendor, device, class); } }
syscall_fn syscall_table[64] = {
/* POSIX-compatible */
[0] = sys_read, [1] = sys_write,
[2] = sys_open, [3] = sys_close,
[4] = sys_exit, [5] = sys_fork,
[6] = sys_exec, [7] = sys_mmap,
[8] = sys_munmap, [9] = sys_getpid,
[10] = sys_getppid, [11] = sys_wait,
[12] = sys_stat, [13] = sys_fstat,
[14] = sys_lseek, [15] = sys_mkdir,
[16] = sys_rmdir, [17] = sys_unlink,
[18] = sys_rename, [19] = sys_dup2,
[20] = sys_pipe, [21] = sys_socket,
[22] = sys_bind, [23] = sys_connect,
[24] = sys_send, [25] = sys_recv,
[26] = sys_kill, [27] = sys_signal,
[28] = sys_sleep, [29] = sys_chdir,
[30] = sys_getcwd, [31] = sys_uname,
/* THRENOS custom syscalls */
[60] = sys_threnos_ai, // ★ NL query to AI engine
[61] = sys_threnos_embed,// Get embedding for text
[62] = sys_threnos_ctx, // Read AI session context
[63] = sys_threnos_info, // OS info + build metadata
};syscall(60, query, len, resp, resp_len) to get an AI response. This is the core of THRENOS's AI integration.typedef struct { uint8_t buf[4096]; uint32_t head, tail, count; bool write_closed; semaphore_t space, data; // Blocking semaphores } pipe_t; ssize_t pipe_write(pipe_t *p, const void *buf, size_t n) { for (size_t i = 0; i < n; i++) { sem_wait(&p->space); // Block if full p->buf[p->head % 4096] = ((uint8_t*)buf)[i]; p->head++; p->count++; sem_post(&p->data); // Signal reader } return n; } /* Shared memory */ int shmem_create(size_t size) { uint64_t phys = pmm_alloc_frames(size / PAGE_SIZE); int id = shmem_register(phys, size); return id; // Both processes call shmem_attach(id) } void* shmem_attach(process_t *proc, int id) { shmem_t *shm = shmem_lookup(id); uint64_t virt = vmm_alloc_user_range(proc->pml4, shm->size); for (size_t i = 0; i < shm->size; i += PAGE_SIZE) vmm_map(proc->pml4, virt+i, shm->phys+i, PAGE_PRESENT|PAGE_USER|PAGE_WRITE); return (void*)virt; }
int main() { // Start system daemons in order const char *daemons[] = { "/sbin/threnos-devd", // Device manager "/sbin/threnos-netd", // Network daemon "/sbin/threnos-fsd", // Filesystem daemon "/sbin/threnos-aisvc", // ★ AI service "/bin/thrsh", // Neural shell NULL }; for (int i = 0; daemons[i]; i++) spawn(daemons[i]); // Supervision loop — restart crashed daemons while (1) { pid_t died = waitpid(-1, NULL, 0); if (is_critical(died)) respawn(died); } }
vfs_node_t and a set of function pointers (ops). Every filesystem registers its ops. vfs_open(), vfs_read(), vfs_write() go through this layer and dispatch to whichever filesystem is mounted.typedef struct vfs_node { char name[256]; uint32_t flags; // VFS_FILE | VFS_DIR | VFS_SYMLINK uint64_t inode; uint64_t size; uint64_t mtime, ctime; uint64_t ai_embed_id; // ★ THRENOS: links to ChromaDB vector // Filesystem ops (function pointer table) uint32_t (*read) (struct vfs_node*, uint64_t off, uint32_t len, uint8_t*); uint32_t (*write)(struct vfs_node*, uint64_t off, uint32_t len, uint8_t*); struct vfs_node* (*finddir)(struct vfs_node*, const char*); int (*readdir)(struct vfs_node*, uint32_t idx, dirent_t*); int (*create)(struct vfs_node*, const char*, uint32_t flags); int (*unlink)(struct vfs_node*, const char*); } vfs_node_t;
ai_embed_id field unique to THRENOS.// On-disk layout: // Block 0: Superblock | Block 1-N: Inode Table // Block N+1: Block Bitmap | Block N+2+: Data typedef struct { uint32_t magic; // 0x54485253 ('THRS') uint32_t version; // 1 uint32_t block_size; // 4096 uint32_t inode_count; uint32_t block_count; uint32_t free_inodes; uint32_t free_blocks; uint32_t first_data_block; char label[32]; // Volume label uint8_t uuid[16]; } thfs_superblock_t; typedef struct { uint16_t mode; // Permissions + type uint16_t uid, gid; uint64_t size; uint64_t created, modified, accessed; uint32_t direct[12]; // Direct block pointers uint32_t indirect; // Singly indirect uint32_t dbl_indirect; // Doubly indirect uint64_t ai_embed_id; // ★ ChromaDB vector ID uint8_t reserved[32]; } thfs_inode_t;
# Build the initial ramdisk with essential binaries mkdir -p initrd/{sbin,bin,lib,run/threnos} cp build/thrsh initrd/bin/ cp build/threnos-aisvc initrd/sbin/ cp build/threnos-init initrd/sbin/init cp models/llama3.gguf initrd/sbin/ # Quantized LLM # Package as cpio archive cd initrd && find . | cpio -o -H newc | gzip > ../build/initrd.gz # In QEMU, load alongside kernel: qemu-system-x86_64 \ -kernel build/threnos.bin \ -initrd build/initrd.gz \ -m 4G
static uint32_t io_base; static uint8_t rx_buf[8192 + 16]; // Receive ring buffer static uint32_t rx_ptr = 0; void rtl8139_init(pci_device_t *dev) { io_base = pci_get_bar(dev, 0) & ~3; outb(io_base + 0x52, 0x0); // Power on outb(io_base + 0x37, 0x10); // Software reset while (inb(io_base + 0x37) & 0x10); outl(io_base + 0x30, (uint32_t)rx_buf); // RX buffer outw(io_base + 0x3C, 0x0005); // Enable TX+RX interrupts outl(io_base + 0x44, 0xF | (1<<7)); // RX config: accept all outb(io_base + 0x37, 0x0C); // Enable TX+RX } void rtl8139_send(const uint8_t *data, size_t len) { static int tx_slot = 0; memcpy(tx_buf[tx_slot], data, len); outl(io_base + 0x20 + tx_slot*4, (uint32_t)tx_buf[tx_slot]); outl(io_base + 0x10 + tx_slot*4, len & 0x1FFF); tx_slot = (tx_slot + 1) % 4; }
typedef enum { TCP_CLOSED, TCP_LISTEN, TCP_SYN_SENT, TCP_SYN_RECEIVED, TCP_ESTABLISHED, TCP_FIN_WAIT_1, TCP_FIN_WAIT_2, TCP_CLOSE_WAIT, TCP_CLOSING, TCP_TIME_WAIT, TCP_LAST_ACK } tcp_state_t; typedef struct { uint32_t src_ip, dst_ip; uint16_t src_port, dst_port; uint32_t seq, ack; tcp_state_t state; uint8_t send_buf[65536]; uint8_t recv_buf[65536]; uint32_t send_head, send_tail; uint32_t recv_head, recv_tail; } tcp_socket_t; void tcp_handle_packet(tcp_socket_t *sock, tcp_header_t *hdr, uint8_t *data, size_t len) { switch (sock->state) { case TCP_LISTEN: if (hdr->flags & TCP_SYN) { send_syn_ack(sock, hdr); sock->state = TCP_SYN_RECEIVED; } break; case TCP_SYN_RECEIVED: if (hdr->flags & TCP_ACK) sock->state = TCP_ESTABLISHED; break; case TCP_ESTABLISHED: if (len > 0) buffer_recv(sock, data, len); if (hdr->flags & TCP_FIN) { send_ack(sock); sock->state = TCP_CLOSE_WAIT; } break; } }
socket(), bind(), connect(), listen(), accept(), send(), recv() as syscalls. Userspace programs (including the AI daemon) use this to open network connections.// Userspace code — AI daemon downloading a model update int fd = socket(AF_INET, SOCK_STREAM, 0); struct sockaddr_in addr = { .sin_family = AF_INET, .sin_port = htons(443), .sin_addr = { .s_addr = resolve("models.threnos.io") } }; connect(fd, &addr, sizeof(addr)); send(fd, "GET /llama3-q4.gguf HTTP/1.1\r\n\r\n", 36, 0); // ... recv loop to download model close(fd);
import asyncio, json, os from ollama import AsyncClient from chromadb import PersistentClient from sentence_transformers import SentenceTransformer SOCKET = "/run/threnos/ai.sock" CTX_DB = "/var/threnos/context.db" # Persistent SQLite EMBED_DB = "/var/threnos/embeddings" # ChromaDB on disk ollama = AsyncClient() chroma = PersistentClient(path=EMBED_DB) embedder= SentenceTransformer("nomic-ai/nomic-embed-text-v1") fs_coll = chroma.get_or_create_collection("filesystem") async def handle(reader, writer): data = await reader.read(8192) req = json.loads(data) typ = req.get("type") if typ == "nl_command": res = await nl_to_shell(req) elif typ == "file_search": res = semantic_search(req) elif typ == "diagnose": res = await diagnose(req) elif typ == "chat": res = await chat(req) else: res = {"error": "unknown type"} writer.write(json.dumps(res).encode()) await writer.drain() asyncio.run(asyncio.start_unix_server(handle, SOCKET))
/var/threnos/context.db and includes the last 10 in every LLM prompt automatically.import sqlite3, json class ThrenosMemory: def __init__(self, db_path="/var/threnos/context.db"): self.conn = sqlite3.connect(db_path, check_same_thread=False) self.conn.execute("""CREATE TABLE IF NOT EXISTS interactions ( id INTEGER PRIMARY KEY AUTOINCREMENT, ts REAL, user TEXT, assistant TEXT, type TEXT )""") self.conn.commit() def save(self, user_msg, ai_response, itype="chat"): self.conn.execute( "INSERT INTO interactions (ts,user,assistant,type) VALUES (?,?,?,?)", (__import__('time').time(), user_msg, ai_response, itype) ) self.conn.commit() def get_context(self, n=10) -> list: rows = self.conn.execute( "SELECT user, assistant FROM interactions ORDER BY id DESC LIMIT ?", (n,) ).fetchall() return [ {"role":"user", "content":r[0]}, {"role":"assistant", "content":r[1]} for r in reversed(rows) ] # Every AI prompt includes memory context: memory = ThrenosMemory() messages = memory.get_context(10) + [{"role":"user", "content": user_input}] response = await ollama.chat(model="llama3", messages=messages) memory.save(user_input, response.message.content)
TEXT_EXT = {'.py','.c','.h','.rs','.md','.txt','.json','.log','.sh'}
def index_file(path: str):
try:
content = open(path, errors='ignore').read()[:3000]
vec = embedder.encode([content]).tolist()
fs_coll.upsert(
ids=[path],
embeddings=vec,
metadatas=[{"path": path, "mtime": str(os.path.getmtime(path)),
"ext": os.path.splitext(path)[1]}]
)
except: pass
def semantic_search(req) -> dict:
query = req["query"]
vec = embedder.encode([query]).tolist()
res = fs_coll.query(query_embeddings=vec, n_results=5)
return {"files": res["metadatas"][0], "scores": res["distances"][0]}
async def watch_filesystem():
from inotify_simple import INotify, flags
inotify = INotify()
inotify.add_watch("/", flags.CLOSE_WRITE | flags.CREATE | flags.MOVED_TO)
while True:
for event in inotify.read(timeout=1000):
path = os.path.join(event.path, event.name)
if os.path.splitext(path)[1] in TEXT_EXT:
index_file(path)
await asyncio.sleep(0)// sys_threnos_ai(query_buf, query_len, resp_buf, resp_max) int64_t sys_threnos_ai(char *query, size_t qlen, char *resp, size_t rmax) { // Copy query from userspace char *kbuf = kmalloc(qlen + 1); copy_from_user(kbuf, query, qlen); // Open Unix socket to AI daemon int sock = ksocket(AF_UNIX, SOCK_STREAM, 0); sockaddr_un_t addr = { AF_UNIX, "/run/threnos/ai.sock" }; if (kconnect(sock, &addr, sizeof(addr)) < 0) { kfree(kbuf); return -ENODEV; // AI service not running } ksend(sock, kbuf, qlen, 0); char *rbuf = kmalloc(rmax); ssize_t n = krecv(sock, rbuf, rmax, 0); kclose(sock); copy_to_user(resp, rbuf, n); kfree(kbuf); kfree(rbuf); return n; }
thrpkg install neovim # Download + install thrpkg remove neovim # Remove package thrpkg list # Show installed thrpkg search "text editor" # AI-powered fuzzy search thrpkg update # Update all packages # Package manifest format (manifest.json): { "name": "neovim", "version": "0.9.4", "arch": "x86_64-threnos", "deps": ["libluajit", "libterminfo"], "files": ["/bin/nvim", "/share/nvim/..."], "sha256": "a3f9c2..." }
# Build everything and create bootable ISO all: boot kernel userspace ai shell iso boot: nasm -f bin boot/stage1.asm -o build/stage1.bin x86_64-elf-gcc $(CFLAGS) -c boot/stage2.c -o build/stage2.o kernel: $(MAKE) -C kernel CC=x86_64-elf-gcc ai: cd ai/threnos-aisvc && pip install -r requirements.txt --target dist/ iso: all mkdir -p isodir/boot/grub cp build/threnos.bin isodir/boot/ cp build/initrd.gz isodir/boot/ echo 'menuentry "THRENOS" { multiboot2 /boot/threnos.bin; module2 /boot/initrd.gz; }' > isodir/boot/grub/grub.cfg grub-mkrescue -o threnos.iso isodir/ run: iso qemu-system-x86_64 \ -cdrom threnos.iso -m 4G -smp 4 \ -enable-kvm -serial stdio \ -net nic,model=rtl8139 -net user # Flash to USB for real hardware flash: iso sudo dd if=threnos.iso of=$(USB) bs=4M status=progress && sync