Cyrus Kakkar
← home

Cyrus Kakkar · catalogue of works · sheet 1 of 1

The Log

Every project is a mark down one shared depth axis of twelve bands, deepest at the left. A band is lit only where that project demonstrably touched that layer, and the reason is printed with it at 1:50. Gaps are drawn as gaps: a systems tool with a terminal UI touches the kernel and the screen and nothing in between, and the hole in the middle is the point.

  • 29 entries
  • 12 bands
  • 97 lit cells, each cited
  • 27 distinct marks
  • 10 with full case studies
scale
sort
  1. 01

    Silicon

    7 entriesgates, boards, instruction sets: work with no operating system under it
  2. 2025/26Enhanced 8-Bit CPU↓ PHYSICALshipped
    A synthesizable 8-bit Harvard CPU with multi-level caches and a 16×16 systolic array accelerator.
    • PHYSICALsynthesisable for FPGA fabric, not a simulator toy
    • GATE/RTLa Harvard-architecture core written in Verilog RTL, plus a 16x16 systolic array
    • FIRMWAREexample programs run bare metal on the core, with no OS beneath them
    • ISA/ARCHseparate instruction and data memory, and an L1/L2/L3 cache hierarchy
    • COMPILERa hand-written assembler in the toolchain, with a performance analyser
    VerilogFPGAIcarus Verilog
    always @(posedge clk)specimen · Verilog
    5 of 12 layers: PHYSICAL, GATE/RTL, FIRMWARE, ISA/ARCH, COMPILER.
  3. 2023Environmental Monitoring System↓ PHYSICALshipped
    An ultra-low-power ARM Cortex-M system in C/C++ with I2C sensors and wireless telemetry.
    • PHYSICALI2C temperature and humidity sensors reading the actual room, to ~95% accuracy
    • FIRMWAREC/C++ on an ARM Cortex-M with aggressive power management for long deployment
    • NETWORKwireless telemetry off the board
    • INTERFACEan LCD readout on the device itself
    C/C++ARM Cortex-MI2C
    no public sourcespecimen withheld · course project, 2023: no public repository
    4 of 12 layers: PHYSICAL, FIRMWARE, NETWORK, INTERFACE.
  4. 2025/26AI Inference Accelerator↓ GATE/RTLshipped
    An int8 MNIST classifier in SystemVerilog that agrees bit for bit with a NumPy model of its own integer pipeline, in 1,701 cycles an image.
    • GATE/RTLeight pipelined signed MAC lanes, ReLU and an int32 to int8 requantize-and-saturate stage, in synthesizable SystemVerilog
    • COMPILERVerilator compiles the RTL to a C++ model, driven by testbenches over the real MNIST test set
    • DATAint8 weights with a calibrated hidden shift, and a NumPy reference that must agree with the RTL bit for bit
    SystemVerilogVerilatorC++PythonNumPyPyTorch
    product_r <= in_data * weight;specimen · SystemVerilog
    3 of 12 layers: GATE/RTL, COMPILER, DATA.
  5. 2026Brother Eye Terminal↓ FIRMWAREshipped
    One no_std, heap-free crate renders the entire terminal: it runs in an SDL window today and will run on the RP2040 unmodified.
    • FIRMWAREthe render core is no_std with no allocator and no clock, running on fixed-capacity heapless buffers with nothing beneath it but embedded_graphics
    • NETWORKpolls GitHub’s public events API unauthenticated, and backs off on X-RateLimit-Reset instead of retrying into the wall
    • RUNTIMEa polling thread hands results to the render loop over a channel, and a manual refresh wakes it early through a second one
    • DATAa 32-event heapless ring, ten event kinds, and today/streak computed over that buffer alone
    • INTERFACEa 240x135 phosphor console: seven log rows, an inverted tag block for releases and PRs, and a live command line
    Rustno_stdembedded-graphicsheaplessSDL2ureqserdeCargo workspaces
    no public sourcespecimen withheld · personal project, 2026: no public repository
    5 of 12 layers: FIRMWARE, NETWORK, RUNTIME, DATA, INTERFACE.
  6. 2026gotobykkrwhofrags↓ ISA/ARCHpublished
    Desugars goto into a safe match-driven state machine at compile time. Zero unsafe. On crates.io.
    • ISA/ARCHLLVM folds the generated loop to the same assembly as hand-written control flow
    • COMPILEReight compile-time passes: segment splitting, label indexing, hoisting, codegen
    • RUNTIMEthe desugared program is a dispatch-table state machine running inside a generated loop
    RustProc MacrossynquoteLLVM
    #[goto(strict)]specimen · Rust
    3 of 12 layers: ISA/ARCH, COMPILER, RUNTIME.
  7. 2026crement↓ ISA/ARCHpublished
    n++, ++n, n--, --n with zero unsafe and zero runtime overhead beyond a single += / -=.
    • ISA/ARCHthe postfix clone is erased to a register move for any Copy type
    • COMPILERdeclarative macros, Span::mixed_site hygiene, and ++ told apart by Joint token spacing
    RustDeclarative MacrosToken StreamsCargo
    crement!(n++)specimen · Rust
    2 of 12 layers: ISA/ARCH, COMPILER.
  8. 2022CPU Simulator↓ ISA/ARCHshipped
    A C++ CPU simulator with a 3-stage pipeline, hazard detection, and data forwarding.
    • ISA/ARCHa custom ISA with a 3-stage pipeline, hazard detection, branch prediction and data forwarding
    C++Assembly
    if (EX.rd == ID.rs) forward();specimen · C++
    1 of 12 layers: ISA/ARCH.
  9. 02

    Systems

    10 entrieskernels, processes and the wire
  10. 2026Ultron↓ KERNEL/OSshipped
    Dual-stream audio, 6 STT providers, multi-LLM routing, and local RAG over your meeting history.
    • KERNEL/OSa macOS window-layer trick makes it invisible to screen capture; system loopback audio; keys in OS safeStorage
    • NETWORKa phone-mirror that streams transcript and answers to any device on the local Wi-Fi
    • RUNTIMEreal-time audio on dedicated threads bridged to an async runtime, streaming over IPC
    • DATAthe live transcript is indexed into sqlite-vec for semantic search over past sessions
    • SERVICEsix STT providers and multi-LLM routing behind a fallback chain and circuit breakers
    • INTERFACEa hotkey-summoned overlay and a ~3k-line settings hub
    ElectronReact 19TypeScriptNode.jsViteSQLitesqlite-vecDeepgramONNX Whisper
    safeStorage.encryptString(key)specimen · TypeScript
    6 of 12 layers: KERNEL/OS, NETWORK, RUNTIME, DATA, SERVICE, INTERFACE.
  11. 2026Trav↓ KERNEL/OSshipped
    One async engine core drives a terminal dashboard and a Tauri desktop app from a single shared snapshot.
    • KERNEL/OSjailed download paths, path sanitisation, and an LRU FilePool to cap open file handles
    • NETWORKpeer wire protocol framing, HTTP and UDP trackers, magnet parsing, DHT/KRPC
    • RUNTIMEan async engine loop on Tokio with command/event channels and spawn_blocking SHA-1
    • DATAbencode parsing, info-hash generation, and a rarest-first piece manager
    • INTERFACEa ratatui dashboard with sparklines and a Tauri desktop app with a system tray
    RustTokioRatatuiTauriNext.jsTypeScriptcrossterm
    Arc<RwLock<EngineSnapshot>>specimen · Rust
    5 of 12 layers: KERNEL/OS, NETWORK, RUNTIME, DATA, INTERFACE.
  12. 2026Brainiac↓ KERNEL/OSshipped
    A real-time voice↔AI loop in Rust: mic → Deepgram STT → DeepSeek → Aura TTS, in a ratatui TUI.
    • KERNEL/OScpal captures PCM on a dedicated thread, because the CoreAudio stream is !Send
    • NETWORKDeepgram streams transcripts back over a WebSocket
    • RUNTIMEthe audio channel doubles as a lifecycle signal, so shutdown is clean without cancellation tokens
    • INTERFACEa live waveform TUI in ratatui, plus a minimal SSH-friendly mode
    RustTokiocpalrodioRatatuiDeepgramDeepSeek
    cpal::Stream: !Sendspecimen · Rust
    4 of 12 layers: KERNEL/OS, NETWORK, RUNTIME, INTERFACE.
  13. 2025Spectre-Grid↓ KERNEL/OSshipped
    Live packet capture with geo-mapping and Shannon-entropy analysis to spot encrypted vs plaintext traffic.
    • KERNEL/OSraw TCP/UDP packet capture off the interface
    • NETWORKdestinations mapped by GeoIP, entropy used to tell encrypted traffic from plaintext
    • DATAa GeoIP database queried per packet, and Shannon entropy computed per flow
    • INTERFACEa matrix-style feed over a Mercator world map, with country flags and risk indicators
    RustRatatuiGeoIPNetworking
    shannon_entropy(&payload)specimen · Rust
    4 of 12 layers: KERNEL/OS, NETWORK, DATA, INTERFACE.
  14. 2025GhostVault↓ KERNEL/OSshipped
    A privacy-first RAG system that runs entirely offline with automatic document ingestion and source attribution.
    • KERNEL/OSa filesystem watcher auto-ingests the data folder the moment it changes
    • RUNTIMEOllama runs Llama3 on the machine itself: no cloud API is ever called
    • DATAChromaDB vectors with exact page-level source attribution
    • INTERFACEa Chainlit chat with three answering personalities
    PythonLlamaIndexChainlitOllamaChromaDB
    Ollama(model="llama3")specimen · Python
    4 of 12 layers: KERNEL/OS, RUNTIME, DATA, INTERFACE.
  15. 2026Tojizenin↓ KERNEL/OSshipped
    An offline-first workout logger on WatermelonDB’s C++ SQLite bindings. No cloud, no subscriptions, zero-latency queries.
    • KERNEL/OSWatermelonDB's Objective-C/C++ SQLite bindings, compiled in Xcode and sideloaded past Expo Go
    • DATAset-level rows on device, with 1RM and volume charted per exercise over time
    • INTERFACEa custom routine builder over an auto-seeded Push/Pull/Legs preset, imperial or metric
    React NativeExpo RouterTypeScriptWatermelonDBNativeWindReanimatedvictory-native
    Q.where('exercise_id', id)specimen · TypeScript
    3 of 12 layers: KERNEL/OS, DATA, INTERFACE.
  16. 2023CI/CD Pipeline↓ KERNEL/OSshipped
    A full Jenkins/Docker CI/CD pipeline with multi-stage deploys and approval gates.
    • KERNEL/OSDocker containers isolate the build environment across dev, test and prod
    • SERVICEcommit-triggered build and test automation, multi-stage deploys, approval gates, scanning
    JenkinsDockerGit
    no public sourcespecimen withheld · personal project, 2023: no public repository
    2 of 12 layers: KERNEL/OS, SERVICE.
  17. 2025TBM↓ KERNEL/OSshipped
    Real-time CPU/memory/process monitoring for Linux & macOS with Levenshtein fuzzy search.
    • KERNEL/OSplatform-native process APIs: /proc on Linux, sysctl and Mach on macOS
    • INTERFACEa sortable live process table in ftxui with Levenshtein fuzzy search
    C++17FTXUICMakeGoogle Test
    sysctl(KERN_PROC_ALL)specimen · C++17
    2 of 12 layers: KERNEL/OS, INTERFACE.
  18. 2026Shibuya Incident↓ NETWORKshipped
    Real-time 3D city mapping with a Rust WebSocket backend handling 10k+ concurrent connections.
    • NETWORKa Rust/Tokio WebSocket backend holding 10k+ concurrent connections
    • GPUcustom GLSL layers over WebGL through deck.gl
    • RUNTIMETokio, at 10 to 100 times lower latency than the Python equivalent
    • DATAhexagon binning of live points, and per-building attributes
    • SERVICEthe backend streams live city data out to every connected client
    • INTERFACEa 3D map of Shibuya you can fly through
    Next.js 15TypeScriptDeck.glMapboxRustTokio
    tokio::spawn(handle_socket(ws))specimen · Rust
    6 of 12 layers: NETWORK, GPU, RUNTIME, DATA, SERVICE, INTERFACE.
  19. 2022SDN Traffic Management↓ NETWORKshipped
    A centralized SDN controller doing dynamic, QoS-aware traffic routing over OpenFlow.
    • NETWORKan OpenFlow controller rewriting routing tables for QoS and congestion, tested in Mininet
    • DATAper-switch flow-table state, updated from live traffic measurement
    • SERVICEa centralised controller process the switches connect in to
    PythonSDNOpenFlowMininet
    no public sourcespecimen withheld · course project, 2022: no public repository
    3 of 12 layers: NETWORK, DATA, SERVICE.
  20. 03

    Graphics

    4 entrieswork dispatched to the card
  21. 2026Strata↓ GPUshipped
    25M+ points at 60fps in the browser via WebGPU, with a Rust/WASM LAS parser 20× faster than JS.
    • GPUWebGPU compute shaders in WGSL cull and draw 25M+ points at 60fps
    • RUNTIMEthe LAS/LAZ parser is Rust compiled to WASM, streaming inside the browser VM
    • DATAa custom binary .LAS/.LAZ parser over an octree index with virtual chunking into VRAM
    • INTERFACEa floating-panel Svelte UI with live distance, area and volume measurement
    SvelteKitTypeScriptWebGPUWGSLRustWebAssemblywasm-packgl-matrix
    @compute @workgroup_size(64)specimen · WGSL
    4 of 12 layers: GPU, RUNTIME, DATA, INTERFACE.
  22. 2026hugostrange↓ GPUshipped
    Recovers a real, editable scene graph from 2D drawings, path-traces it with Cycles, and exposes every parameter to Claude over MCP.
    • GPUheadless Blender/Cycles path tracing, dispatched to GPU render workers
    • DATAa strict typed scene graph in pydantic v2, millimetres everywhere, with an edit_log
    • SERVICEan MCP edit server and a race-safe Supabase render-job queue
    • INTERFACEthe edit surface is a conversation: Claude asks rather than inventing a number
    Pythonpydantic v2Blender / CyclesMCPCSG geometryPaddleOCRpypdfium2Supabase
    thickness_mm: floatspecimen · Python
    4 of 12 layers: GPU, DATA, SERVICE, INTERFACE.
  23. 2025/26Sukuna↓ GPUshipped
    A 3D audio-reactive web app with Spotify integration and manga-style post-processing.
    • GPUa manga post-processing stack: halftone, chromatic aberration, impact frames
    • SERVICESpotify OAuth and the playback API driving the scene in real time
    • INTERFACEeight character themes over a React-Three-Fiber visualiser, synced to the beat
    Next.js 15React Three FiberThree.jsSpotify APIZustand
    useFrame((state, delta) =>specimen · TSX
    3 of 12 layers: GPU, SERVICE, INTERFACE.
  24. 2025Black Hole Simulation↓ GPUshipped
    GPU ray tracing of gravitational lensing, accretion disk physics, and spacetime curvature in OpenGL/GLSL.
    • GPUGLSL compute shaders carry the geodesic maths, ray-tracing light bent around the hole
    • INTERFACEa real-time viewer with an accretion disk and grid-deformation spacetime
    C++17OpenGLGLSLCMake
    rs = 2.0 * G * M / (c * c);specimen · GLSL
    2 of 12 layers: GPU, INTERFACE.
  25. 04

    Product

    8 entriesruntimes, stores and the surface a person actually uses
  26. 2026Fatty↓ RUNTIMElive
    One strength tracker on the web, a native iPhone app and an Apple Watch: every set lands in one atomic grain, the analytics are computed in Postgres, and an AI judge ranks you on a ladder of Kengan’s deadliest fighters.
    • RUNTIMEa service worker and an IndexedDB queue log offline, and a Capacitor shell carries the same site into a native iPhone app
    • DATAone atomic set-level grain, nothing derived stored; 1RM and tonnage from security-invoker views and RPCs, isolation proven by pgTAP
    • SERVICEZod-validated Server Actions, Google and Apple sign-in, APNs and web push, a token-scoped watch API, a DeepSeek judge
    • INTERFACEa mid-workout logger, Live Activities and widgets on the iPhone, and a SwiftUI Apple Watch app
    Next.js 16React 19TypeScript 6SupabasePostgres + RLSCapacitor 8SwiftUITailwind v4DeepSeekpgTAP
    using (auth.uid() = user_id)specimen · SQL
    4 of 12 layers: RUNTIME, DATA, SERVICE, INTERFACE.
  27. 2026Aaspaas↓ RUNTIMEshipped
    A marketplace dressed as a wheat-pasted street poster wall: five screen-print inks, halftone dots, and Hindi set as large as the English.
    • RUNTIMEevery page is a React Server Component, so only the moving parts ship JavaScript at all
    • DATAproximity-first ranking through a typed content layer, shaped for one PostGIS query at 240,000 rows
    • INTERFACE48 static pages and nine hand-built interactive pieces, all of which stop under reduced motion
    Next.js 16React 19TypeScriptTailwind v4MotionVercel
    typedRoutes: truespecimen · TypeScript
    3 of 12 layers: RUNTIME, DATA, INTERFACE.
  28. 2023Task Manager API↓ RUNTIMEshipped
    A Rails REST API with JWT auth, Redis caching (60% less DB load), and Sidekiq background jobs.
    • RUNTIMESidekiq worker processes run email and reports off the request thread
    • DATAPostgreSQL behind a Redis cache that cut database load by around 60%
    • SERVICEa REST API with JWT auth and role-based access, under an RSpec suite
    Ruby on RailsRedisSidekiqPostgreSQL
    no public sourcespecimen withheld · personal project, 2023: no public repository
    3 of 12 layers: RUNTIME, DATA, SERVICE.
  29. 2025/26LogicLamp↓ RUNTIMEshipped
    A client brand site in Next.js 15: physics-driven adaptive cursor, lazy-loaded heavy sections, and a disciplined red-on-minimal design system.
    • RUNTIMEthe map and the contact form are code-split out and loaded only on demand
    • INTERFACEan adaptive cursor, white on dark and dark on light, with spring trailing and a scroll bounce
    Next.js 15ReactTypeScriptTailwind CSSFramer Motion
    mix-blend-mode: differencespecimen · CSS
    2 of 12 layers: RUNTIME, INTERFACE.
  30. 2026Deploy Security↓ DATAlive
    A static Next.js 16 site for a Metro Vancouver security firm, with a server-only contact relay, Zod on the server, and end-to-end tests on desktop and mobile.
    • DATAone site file drives every service page, the nav, the footer, the JSON-LD and the sitemap
    • SERVICEa React Server Action validates with Zod and relays to FormSubmit from the server, so the recipient never reaches the browser
    • INTERFACEstatic pages from one service template, with section reveals as CSS scroll-driven animations
    Next.js 16React 19TypeScript 6Tailwind CSS 4Zod 4MotionVitestPlaywright
    no public sourcespecimen withheld · client work, 2026: private repository
    3 of 12 layers: DATA, SERVICE, INTERFACE.
  31. 2026Layered Living↓ DATAlive
    A live storefront doing real revenue: browse → Razorpay → GST invoice → email.
    • DATAan idempotent Postgres RPC for exactly-once orders, RLS on every user table, money as integer paise
    • SERVICERazorpay verified server-side with constant-time HMAC-SHA256, a webhook safety-net, Resend mail
    • INTERFACEan editorial storefront with an optimistic Zustand cart over a Supabase source of truth
    Next.js 16React 19TypeScriptSanitySupabaseRazorpayResendTailwind v4
    amount_paise: numberspecimen · TypeScript
    3 of 12 layers: DATA, SERVICE, INTERFACE.
  32. 2026Love Sick↓ DATAshipped
    A two-person app with realtime presence, RLS-locked data, and a dual-model AI "relationship prescription".
    • DATARLS locks every table so a partner sees only what is shared, with compatibility overlap derived
    • SERVICESupabase Realtime presence, plus a DeepSeek analyst and a GPT-4o coach writing the insight
    • INTERFACEa two-person dashboard of overlap, deep-cut question exchanges and a streak
    Next.js 16TypeScriptSupabaseFramer MotionOpenAI
    channel.on('presence', ...)specimen · TypeScript
    3 of 12 layers: DATA, SERVICE, INTERFACE.
  33. 2020Chirper↓ DATAshipped
    A social platform in C++ with custom data structures and MongoDB persistence.
    • DATAa hand-rolled doubly-linked list for post storage, persisted to MongoDB
    C++MongoDBOOP
    Post* next; Post* prev;specimen · C++
    1 of 12 layers: DATA.

29 entries · 27 distinct marks · hover a row, or click a band to dim the rest

  • PHYSICALsilicon, sensors, the world itself
  • GATE/RTLregisters, nets, synthesisable logic
  • FIRMWAREcode with no operating system under it
  • ISA/ARCHinstruction sets, pipelines, caches
  • COMPILERbuild-time program transformation
  • KERNEL/OSsyscalls, processes, devices, isolation
  • NETWORKthe wire: packets, sockets, protocols
  • GPUshaders and work dispatched to the card
  • RUNTIMEthe execution substrate: threads, VMs, async
  • DATAschemas, indexes, stores, wire formats
  • SERVICEthe server side: APIs, auth, jobs, queues
  • INTERFACEthe surface a person actually looks at