Kairav Dutta ka1rav6

Kairav Dutta

`I write the layer underneath.`

_{BTech CSE · IIIT Delhi · class of '29 · 18 · runs on make -j$(nproc)}

$ file $(which kairav)
kairav: ELF 64-bit LSB executable, x86-64, dynamically curious,
        statically linked against C, interpreter /lib/ld-coffee.so

$ kairav --version
kairav 18.0.0 (build iiitd-cse-2029)
origin   : competitive programming → systems → graphics → ML infra
linked   : C11 · C++20 · Zig · Python · TypeScript · x86-64 asm
warnings : 1 (grass_touching.service inactive)

`$ whoami`

I came in through competitive programming and stayed for everything sitting under it — allocators, bytecode, sockets, gap buffers, shader pipelines, build graphs. Most of what I build is a thing I could have installed, written badly on purpose first, so I'd know what the good version was actually doing.

The other half of me just wants pixels on screen and a game loop that hits frame time.

Note

Written instead of installed: a build system, a rule engine, a tensor library, an HTTP server, a logging library, a GUI toolkit, a text editor, and a language.

`$ tree ~/stack`

Where my repos actually live, top to bottom:

┌─ user ──────────────────────────────────────────────────────┐
│  games & apps       ctf-game · tetris · doodle-jump · gmtk  │
├─ tooling ───────────────────────────────────────────────────┤
│  build & codegen    pico · lazycmake · copa · K             │
├─ runtime ───────────────────────────────────────────────────┤
│  engines & VMs      vela (bytecode VM) · game_server        │
├─ library ───────────────────────────────────────────────────┤
│  primitives         zcore (tensors) · logx · ezui           │
├─ syscall ───────────────────────────────────────────────────┤
│  raw interfaces     http-server (sockets) · textmex (tty)   │
└─────────────────────────────────────────────────────────────┘
   ▲ I keep drifting down this stack. It hasn't stopped yet.

`$ ls ~/work --sort=interesting`

`vela`

Embeddable rule engine in C. JSON rules get compiled to bytecode and executed on a stack VM.

Interesting because rules stop being an if-tree and become an instruction stream — arena allocator, bitmask fact storage, thread-safe, ships as libvela.a.

C11 bytecode-vm CMake

`zcore`

A tensor library in Zig — storage / shape / stride primitives first, autograd on top.

Interesting because the fastest way to understand ML infra is to rebuild the part everyone treats as a black box.

Zig SIMD autograd

`pico`

A build system for C++. No CMake, no config file, no CMakeLists.txt archaeology.

Interesting because it's the tool I got annoyed enough to replace — automatic dependency discovery and packaging, just pico build.

C++ build-systems

`logx`

One file. Ten languages. Zero dependencies. The same logging API, hand-ported to each.

Interesting because holding one design honest across Python, JS/TS, C, C++, Rust, Go, Java, Zig and assembly forces you to see what's language and what's actually the idea.

C C++ Rust Go Zig asm

`ctf-game`

3D capture-the-flag on OpenGL + GLFW, Assimp model loading, ReactPhysics3D, ImGui debug tooling.

Interesting because gameplay is the easy part — the hard part is keeping physics bodies and render transforms in sync at 60fps.

C++20 OpenGL physics

`K`

A language that transpiles to C++ — nicer syntax and error messages, same low-level control. Lexer → parser → transpiler.

Interesting because writing a compiler front-end is the fastest cure for thinking syntax is arbitrary.

Python C++ compilers

$ ls ~/work --all · the rest of the shelf

systems & from-scratch

repo	what it is
`http-server-cpp`	HTTP/1.1 server built on raw Linux sockets — no HTTP library anywhere in it
`text-editor`	textmex — vim-flavoured terminal editor, gap buffer, raw terminal I/O
`chess-engine`	Chess in C11 — SAN parsing, move legality, check/checkmate detection, plays in the terminal
`efficient-data-engine`	C++ background data processing core with a Python CLI on top
`CP`	Codeforces CP31 solutions, deliberately written in a different language each time

tools other people can install

repo	what it is
`lazycmake`	`lazygit`-inspired TUI that scaffolds and builds CMake projects for you
`copa`	Generates ready-to-use C/C++ header files and keeps them updated
`header-file-generator`	VS Code extension — header files for C/C++ without the boilerplate
`variable-case-converter`	VS Code extension — convert variable case across a selection or a whole file

graphics & games

repo	what it is
`tetris`	Tetris clone in C++ / SDL2
`game_server`	Multiplayer game server framework in C++ with SDL
`ezui`	Thin, sane GUI layer over SDL
`gmtk-26`	GMTK game jam 2026 entry
`doodle-jump`	Pygame doodle-jump, written as a modular-design exercise

ML, data & apps

repo	what it is
`hand-gesture-recognition`	Gesture recognition model driving a game — MediaPipe + OpenCV
`studentBurnoutRiskPredictor`	Burnout-risk classifier trained on a Kaggle dataset
`ROTA-gen`	Automatic shift-rota generation for a company
`pykworldsim`	Python library that simulates a world — people, cities, relationships
`college-website-mvp`	College site MVP, Django-flavoured
`ka1rav6.github.io`	The portfolio itself — TypeScript

`$ man kairav`

Not a list of everything I've touched — what I actually reach for, and when.

when the problem is…	I reach for
latency, memory, "why is this slow"	`C11/C23` `C++20` `Zig` `x86-64 asm`
pixels on a screen	`OpenGL` `GLFW` `SDL2` `Qt` `ImGui`
it has to exist by tomorrow	`Python` `FastAPI` `Flask` `Django` `React + Vite + Tailwind`
it has to learn something	`PyTorch` `OpenCV` `MediaPipe` `scikit-learn` `OR-Tools`
it has to remember something	`PostgreSQL` `MongoDB` `SQLite`
it has to build & ship	`CMake/Make` `pybind11` `vcpkg` `Linux` `GitHub Actions` `VS Code API`

`$ git log --graph --oneline`

* aug 2026  hackathon season at IIITD — byld, zero-dependency
|
* jul 2026  zcore: tensors in Zig · pico: a build system with no config
|
* jun 2026  vela: rules → bytecode → stack VM · first 3D game in OpenGL
|
* may 2026  HTTP/1.1 from raw sockets · SDL2 games · gesture recognition
|
* apr 2026  a text editor with a gap buffer · a language that emits C++
|
* mar 2026  first tools shipped: VS Code extensions, data engine, site
|
* feb 2026  Codeforces CP31 — the repo that started all of this

_{Every entry above is a repo, not a plan. One consistent bad habit: read the spec, then write the thing the spec describes.}

`$ ps aux | grep -v code`


dev	Byld, IIITD
ops	LDA IIITD · IEEE · Cultural Council
priors	`97.4%` class XII (centum in math) · `97.6%` class X · JEE AIR `5217`

`$ ./status --live`

The block below isn't a widget service — it's regenerated every morning by an Action in this repo: the GitHub API, ~150 lines of Node, and no dependencies.

38 public repos · 40 stars · shipping since Feb 2026 · synced 2026-08-30 08:52 UTC

most recently touched

repo	lang	what	last push	state
`ka1rav6.github.io`	TypeScript	Making a website that contains my portfolio	today	`building`
`zero-dependency`	C++	Our submission for the zero dependency's hackathon	today	`building`
`pico`	C++	A whole build system for c++ projects.	19d ago	`warm`
`CP`	C	A mix of my solutions of Codeforces CP31 questions in different languages.	19d ago	`warm`
`hand-gesture-recognition`	Python	Creating a Hand Gesture recognition AI model for a game	20d ago	`warm`
`chess-engine`	C	A chess engine in c made to help you play chess even on the terminal.	1mo ago	`resting`

where the time goes _{(primary language, public repos)}

C++         ██████████████████████  10 repos
Python      ██████████████████████  10 repos
TypeScript  ███████░░░░░░░░░░░░░░░  3 repos
C           ███████░░░░░░░░░░░░░░░  3 repos
Makefile    ███████░░░░░░░░░░░░░░░  3 repos
JavaScript  ████░░░░░░░░░░░░░░░░░░  2 repos

`$ ./contact`

Mail me if you're building something that shouldn't work but does.

ka1rav6.github.io · kairavdutta@gmail.com · in/kairavdutta · @ka1rav6

_{compiled without warnings · built with coffee · merge conflicts mostly resolved IRL · source}

Navigation Menu