Interactive Tag Network
An interactive topological map visualizing links between research topics, prototypes, and engineering guides.
All Lab Articles (13)
Append-Only Storage and Two-Tier VACUUM: How KAI Handles Deletes Safely
Borrowing from PostgreSQL and LSM-tree databases, KAI's document store achieves zero-copy reads, crash-safe deletes, and background physical reclamation.
Training-Free Vector Quantization: Lloyd-Max Codebooks on the Unit Sphere
How KAI compresses 6 KB float32 vectors into ~768 bytes - without ever looking at your data - using the geometry of high-dimensional spheres and optimal scalar quantization theory.
Inside the SIMD Search Pipeline: How KAI Scans Millions of Vectors in Milliseconds
A deep dive into nibble-split lookup tables, blocked memory layouts, and architecture-specific SIMD kernels - the techniques that make sub-millisecond vector search possible.
Parsing BMP Files on a Microcontroller With Almost No RAM
How to read, decode, and draw Windows BMP images on a tiny microcontroller by streaming pixels straight from an SD card - no framebuffer, no megabytes, just a couple of rows of RAM.
Bridging Async and SIMD: The Tokio + Rayon Architecture of a High-Performance Rust Server
Building a vector search server that handles hundreds of concurrent HTTP requests while running SIMD operations at full CPU efficiency.
WebAssembly Is the Plugin System We Always Wanted
WASM finally cracked the oldest problem in software extensibility: running someone else's untrusted code, written in any language, safely and fast. Here's why plugin systems everywhere are quietly being rebuilt on it.
Settling the Framework Debate: Why Svelte 5 Won
After fifteen years of religious wars over frontend frameworks, one of them quietly solved the problem. A technical case for Svelte 5 - runes, the compiler, the benchmarks, and the honest tradeoffs - from a consultancy that ships across the stack.
From embedded to cloud - why we work both ends of the stack
Most teams own one layer. We own the whole pipeline, from the C++ on a sensor to the pixel on a dashboard - because the worst bugs live in the seams between them.
LLM inference in production: latency, caching, and the hidden costs
Running language models in production is an engineering problem long before it's a product problem. What we've learned about streaming, prompt caching, batching, the self-host-versus-API decision, and the costs nobody puts on the slide.
Taming legacy PLCs: bridging SCADA data to modern cloud dashboards
A project story about pulling real-time data out of decade-old industrial hardware and building a cloud monitoring layer on top - the protocols, the edge gateway, the OT/IT divide, and the surprises along the way.
Rust on microcontrollers: a pragmatic field report after 12 months
We've shipped Rust firmware on three production embedded projects. Here's the honest accounting - where it genuinely earns its keep, where C++ is still the right call, and what living with the toolchain is actually like.
NULL: How Do You Define Nothing? And Why Would You?
Null pointers quietly do nothing at all - and that's exactly the problem. A deep dive into the origins, memory mechanics, and how C, C++, Rust, Go, Java, and Swift each tackle the absence of a value.
Hello - and why this journal exists
The founding entry for the Siktec Lab - a working journal from a small consultancy that goes deep on hard engineering. What we'll write about, why, and what kind of reader we're writing for.