class Vyom:
    name       = "Vyom Kulshrestha"
    role       = "AI Systems Engineer & Founder"
    university = "VIT — CSE (AI/ML) · Coursework completed April 2026"
    location   = "Agra, India 🇮🇳"

    building   = {
        "Heliox OS":  "Voice + gesture AI desktop agent — JARVIS for everyone",
        "FerrumOS":   "Custom OS kernel in Rust — AI agent + Phase 2 world model on bare metal",
        "Nucle-OS":   "Software-defined DNA storage OS + NucleScript compiler + LSP + WASM playground",
    }

    stack      = ["Rust", "Python", "TypeScript", "no_std", "bare metal"]
    interests  = ["Agentic AI", "World Models", "Systems Engineering", "DNA Storage", "Compilers"]
    open_to    = ["collaborations", "research", "open source"]

I'm building a complete agentic computing stack: a desktop agent for today's hardware, a kernel designed for agents underneath it, and a research-grade molecular storage layer for the future.

An open-source JARVIS for your desktop. Control your computer with voice and hand gestures. The agent plans, executes, and reflects — autonomously, locally, privately.

• 🎙️ "Hey Heliox" always-on wake word + 30+ hand gestures (OpenCV) at sub-800ms latency
• 🧩 Full ReAct loop: Memory → Planning → Routing → Execution → Verification → Reflection
• 🔒 Privacy-first: fully local via Ollama + optional cloud (Gemini, GPT-4o, Claude)
• 🪟 Cross-platform: Tauri (Rust + Svelte) + FastAPI daemon on Windows, macOS, Linux
• 🤖 Multi-agent: 5 specialist agents (System, Code, Web, Monitor, Communications), 50+ action types
• 🧠 13 research-level features: TRIBE v2 cognitive engine, persistent vector memory (ChromaDB), self-reflection loop, simulation sandbox, self-improving prompt system, proactive suggestion engine, subconscious persona learning, always-on screen vision
• 🔌 Plugin ecosystem: Developer Tools, Media Control, Home Assistant — drop custom plugins into ~/.heliox/plugins/
• ✅ 80%+ pass rate on a 10-task autonomous benchmark (web scraping, OCR, code execution, REST APIs)

A complete OS in Rust where the AI agent has full hardware control — sees the screen, hears audio, types, clicks, browses the web. No Linux. No Python. No middleware. Now with a shipped Phase 2 world model safety gate.

Kernel & Userspace

• ⚙️ 47 syscalls · ELF loader · Ring-3 userspace · preemptive scheduler · mmap · on-demand lazy alloc
• 🖥️ Full GUI: custom compositor + window manager + App Store + 7 real userland apps (Heliox Assistant, Browser, Text Editor, Calculator, File Manager, Settings, App Store)
• 📦 libferrumgui — no_std SDK for building new apps (RGBA8 canvas, IPC, input polling)
• 📦 ferrumpkg — real package manager (ELF binary install/remove/run, persisted registry)
• 👤 Multi-user accounts — real capability-swapping on login (root / user / guest)
• 🎮 VirtIO-GPU 2D acceleration (optional, additive over Bochs VBE fallback)

Agent & World Model

• 🤖 heliox-daemon: 39 agent tools across 5 permission tiers · on-device LLM (ships real stories15M-q8.bin) · JSON-RPC 2.0 WebSocket API (port 8785)
• 🌍 Phase 2 world model safety gate — ships in production:
  • MLP transition model trained offline on real collected data (scripts/train_world_model.py), loaded at boot like the LLM checkpoint
  • Autoencoder state encoder: hand-crafted safety-critical scalars + learned latent code from real OS snapshots
  • Multi-step lookahead simulation: simulates an action several steps ahead, catching effects that only compound over time
  • Falls back to hand-coded rule table when no trained weights are staged
  • Every tool call written to /disk/heliox/world/exp.bin as (state, action, outcome) training tuple

Hardware

• 🔊 Intel HDA audio DMA · 📷 Camera YUYV capture · 🖱️ PS/2 mouse + USB HID · XHCI USB 3.0 · RTL8139 + smoltcp TCP/IP + WebSocket RFC 6455 · VGA framebuffer 1024×768 · RDRAND CSPRNG · RTC time

Security

• 🛡️ 5-tier permission model · RIP-2 instruction rewinding for restartable blocking calls · persistent deadlock-free audit logging · syscall rate limiting · CPU caps · memory bounds

A software-defined DNA storage OS in Rust — the driver layer that molecular data storage plugs into. Complete with a programming language, compiler, language server, VS Code extension, and live WASM playground.

Engine (7-layer architecture)

• 🧬 Synthesis Simulator — Illumina / Oxford Nanopore / Twist Bioscience hardware profiles, realistic substitution/indel/dropout distributions
• 🔡 Encoding Engine — Yin-Yang codec at 1.798 bits/nt, Ternary Rotating Cipher, DNA Fountain · GC 40–60%, no homopolymer runs >3, no hairpins — enforced at compile time
• 🔧 Error Correction — Reed-Solomon (Berlekamp-Welch combined error+erasure decoder, two real bugs fixed), Fountain/LT erasure codes, Partial-Order Alignment (POA) consensus with multi-round polishing and fold-order-independence guarantee
• 🔍 Retrieval & Index — primer-based addressing with indel-tolerant matching, CRISPR-sim random access, vector similarity index, semantic search
• 📁 VFS/File API — dna_write, dna_read, dna_stat, dna_delete, nucle migrate (codec/redundancy migration)
• 🤖 Agent Interface — ReAct planner for natural-language DNA file operations
• 🔌 Hardware Bridge — Provider trait with submit() → JobHandle (MockProvider, DelayedMockProvider for concurrent submission, FileExportProvider for lab JSON batch export)

NucleScript DSL — a real programming language

pool medical_archive: DnaPool {
    codec: YinYang,
    redundancy: 4x,
    profile: Illumina
}

let noisy: Pool<Illumina, 0.35%> = simulate medical_archive under Illumina
let recovered: Pool<Recovered> = consensus_vote(noisy, coverage: 10x)

fn archive_with_fallback() returns Result<DnaFile, Str> {
    let attempt: Result<DnaFile, Str> = store "patient_records.csv" into medical_archive
    let saved: DnaFile = attempt?
}

• 📐 Type system: Pool<P, E> probabilistic types propagating hardware error budgets · compile-time biological constraint validation · DNA sequence literals (seq"ATCGATCG") validated at parse time
• 🔀 Control flow: if/for (compile-time desugaring) · Result<T, E> + ? (real runtime execution) · match with exhaustiveness checking · user-defined enums
• 🧬 Generics: fn recover_from<P>(source: Pool<P, 0.35%>) — call-site unification, explicit type args
• 🔒 Effect gates: confirm hardware / confirm physical_key enforced by the compiler for synthesis, sequencing, and destructive operations
• 📦 Functions: named, anonymous closures with lexical capture, higher-order, self-recursive, effect-annotated Fn(...) -> T confirm physical_key
• ⚙️ Compiler: bio-aware MIR optimizer · VFS lowering backend · nucle check, nucle fmt, nucle test, nucle doc, nucle plan, nucle explain · stable E-* error codes with file:line:col and rustc-style source snippets

Ecosystem

• 🧩 VS Code extension — syntax highlighting, language server (diagnostics, hover, go-to-definition, document outline), format on save, run from editor · published on VS Code Marketplace
• 🌐 WASM playground — live at nuclescript.github.io/playground · Write & Run tab, Benchmark Explorer, Pipeline Visualizer · all backed by real engine, zero server
• 🖥️ Standalone playground binary — prebuilt Linux/Windows/macOS, frontend embedded, zero dependencies
• 📦 4 official packages: @nuclescript/presets, @nuclescript/profiles, @nuclescript/benchmarks, @nuclescript/recovery · package lock + verify
• 💬 nucle_lsp — full language server over stdio (tower-lsp, real Content-Length-framed JSON-RPC)
• ✅ 527 tests across 11 crates · 100% data recovery on Illumina noise · Nanopore: 5 deep bugs found, fixed, regressed

• 🎖️ GSSoC 2026 — Project Admin (Heliox OS) · NSOC 2026 — Project Admin (Heliox OS)
• ⭐ Heliox OS: 50+ stars · 100+ forks · 125+ merged community PRs · 200+ issues triaged · 19 releases
• 🦀 FerrumOS: Complete agentic OS — 47 syscalls · full GUI desktop · 7 userland apps · ferrumpkg · multi-user accounts · Phase 2 world model (MLP + autoencoder + multi-step lookahead) running in production
• 🧬 Nucle-OS: DNA storage OS — NucleScript compiler + LSP + VS Code extension + WASM playground · 527 tests · Berlekamp-Welch RS decoder · POA consensus · 4 published packages
• 🌍 World model shipped: MLP transition model + autoencoder state encoder + multi-step lookahead simulation — first open-source world model running at OS kernel level
• 🎓 CSE (AI/ML) @ VIT · Coursework completed April 2026 · Building full-time

If you're building something ambitious in agentic AI, systems engineering, compilers, or molecular computing — I'd love to connect.

"Agents deserve a kernel designed for them — not borrowed from 1970s Unix."