I write C. That's not a limitation — it's a philosophy.

Self-taught developer with roots deeper than most people's entire career. Started on a VIC-20, grew up on a C64, shipped BASIC on a Casio PB-100, developed games for the Nintendo DS, and never stopped going lower. If it runs on bare metal, speaks in bits, or has no OS to hold its hand — I'm already interested.

• ZinterPL — a full custom interpreted language written entirely in C, targeting constrained hardware like the ESP32. Lexer, parser, VM, memory allocator: every layer is handwritten. It started as Zcomply, a personal proof of concept to answer one question — "can I actually build my own language?" — and grew into something real.
• Perceptron / AI — neural network fundamentals built from scratch. In C, obviously.
• Breadboard computer — a homebrew computer built from scratch on breadboard. I'm using ESP32s as logic units — easier to reason about than discrete gates, but they behave close enough to the real thing. What I actually care about is watching bits move: seeing how information travels through a system you built with your own hands. On top of it I'm writing a minimal OS — no GUI, no shell, no abstractions. It prints fixed strings to screen, loaded from punched cards. Yes, punched cards. I know. I like retro things.
• Cyberdeck — built around a Raspberry Pi 4 and a 4-inch vertical CRT, the kind you find in old video intercoms. Keyboard-controlled only. The keyboard layout lives in its own repo.
• ESP32 embedded projects — USB dongles with TFT displays, WiFi APs, custom firmware. Hardware that fits in your pocket and runs code that fits in your head.

My first programs were Bash scripts written on Windows in middle school. Text-based games with no real gameplay — stuff like Communist Battleground, inspired by the old teletype games of the 70s. No graphics, no engine, just strings printed to a terminal and an if-else tree. I might still upload them as repos, as a fossil record.

Before that, I had paper. I used to write programs by hand and trace execution line by line, drawing tables to track every variable's state at every step. No debugger. No runtime. Just logic and a pen. That's still how I think about code — every value has a place, every instruction has a consequence, and if you can't trace it on paper, you don't really understand it yet.

⚙️  C            ████████████████████  (home)
💾  C64 BASIC    ██████████████░░░░░░  (senior)
🧮  PB-100 BASIC ███████████░░░░░░░░░  (old soul)
🔩  6510 ASM     █████████░░░░░░░░░░░  (senior)
🌐  HTML         █████░░░░░░░░░░░░░░░  (when I must)
🎨  CSS          ████░░░░░░░░░░░░░░░░  (when I must)
🐍  Python       ███░░░░░░░░░░░░░░░░░  (learning, Flask)

I collect retro hardware — consoles, computers, peripherals — and I bring them to exhibitions to let people interact with machines they've never touched or have long forgotten. There's something important about putting a working C64 in front of someone who's never seen one boot up.

I'm also into electronics in general: schematics, signal tracing, understanding what's actually happening at the component level. The breadboard computer is the natural consequence of all of this.

The VIC-20 taught me that a machine doesn't care about your intentions. The C64 taught me that constraints breed creativity. The PB-100 taught me that you can program anywhere, on anything. The DS taught me that shipping something real is a different skill entirely. The ESP32 taught me that embedded is where software gets serious. The cyberdeck taught me that hardware is just software you can touch. And ZinterPL is my answer to the oldest question in computing: "what if I built the tool itself?"

Currently a student. Always building something.

"I still debug on paper. Some habits from the C64 era you just don't want to lose."