SOFTWARE ENGINEER · BUILDER

I BUILD
THINGS THAT
ACTUALLY
RUN.

I build web applications, SaaS products, and backend systems. Along the way, I explore how AI works from the ground up.“I don't just construct user interfaces — I understand what happens underneath the stack.”

ENGINEER SPEC
SPEC: REV-2026.1
PRIMARY FOCUSFULL-STACK / SAAS
BUILDINGWEB PRODUCTS & APIS
ALSO EXPLORINGAI / LLMs & SYSTEMS
BACKENDNODE.JS · POSTGRES · REDIS
ENVIRONMENTLINUX · CLOUD · CONTAINERS
LOCATIONPUNE, INDIA
STATUS● BUILDING
CORE STACK: TS · REACT · NODETIMEZONE: UTC+05:30
TYPESCRIPT
REACT
NEXT.JS
NODE.JS
EXPRESS
POSTGRESQL
PRISMA
REDIS
TAILWIND CSS
C++17
PYTHON
GO
DOCKER
LINUX
WEBSOCKETS
REST APIS
LLM AGENTS
GIT
TYPESCRIPT
REACT
NEXT.JS
NODE.JS
EXPRESS
POSTGRESQL
PRISMA
REDIS
TAILWIND CSS
C++17
PYTHON
GO
DOCKER
LINUX
WEBSOCKETS
REST APIS
LLM AGENTS
GIT
PROOF, NOT ADJECTIVES

BUILT. TESTED. SHIPPED.

Empirical evidence of working systems over buzzwords. Ground-up implementations, native runtimes, and verified code.

C++ / MACHINE LEARNING

C++ / GPT-2 INFERENCE ENGINE

Built a GPT-2 inference engine from scratch in C++.

ARCHITECTURE
12-LAYER TRANSFORMER · 768-DIM
C++17NO RUNTIME LIBSCPU DIRECT
AI / DEVELOPER TOOLS

AI CODING HARNESS

Building a Claude Code-style local AI development harness.

CAPABILITY
LOCAL IPC · BASH TOOLING · LLM LOOP
TYPESCRIPTAGENTIC LOOPCLI ENGINE
COMMUNITY / PUBLIC CODE

OPEN SOURCE PROJECTS

Building and experimenting in public.

REPOSITORIES
CORE RUNTIMES · TOOLS · INFRA
OPEN SOURCESYSTEMSPUBLIC BUILDS
INFRASTRUCTURE & SYSTEMS

SYSTEMS ENGINEERING

Working close to runtime, infrastructure and developer tooling.

DEPLOYMENT
LINUX · DOCKER · K8S · TERRAFORM
CEX ENGINEKUBERNETESLINUX KERNEL
SELECTED WORK

THINGS I'VE BUILT.

Engineering projects and functional systems built from first principles. Rich previews with architecture diagrams by default — expand any case study for deep dives.

PROJECT 01GPT-2 INFERENCE ENGINE
01/03
PROJECT 01SYSTEMS · MACHINE LEARNING RUNTIME
01 / 03

GPT-2 INFERENCE ENGINE

Transformer forward pass implemented from first principles in C++17.

A GPT-2 inference engine implemented in C++ to explore the mechanics of transformer inference. The project focuses on model execution, tensor operations, transformer computation, and token generation without relying on a high-level inference runtime. Loads GPT-2 Small binary weights into contiguous memory buffers and executes the full forward computation graph. Generates text autoregressively with causal self-attention and temperature-scaled sampling.

KEY IMPLEMENTATION HIGHLIGHTS:
  • ■Custom tensor buffer memory management without runtime allocations during forward loop
  • ■Manual matrix multiplication kernels with cache-friendly loop tiling and SIMD-friendly layout
  • ■Full Transformer block: LayerNorm, causal masked MHA (12 heads), MLP with GELU, and residual sums
  • ■Greedy and temperature-based autoregressive decoding loop predicting 50,257 vocabulary logits
C++C++17MLINFERENCESYSTEMS
VIEW SOURCE →
INFERENCE PIPELINE
COMPACT PREVIEW
01INPUT
std::string
↓
02TOKENIZATION
vocab.bpe
↓
03EMBEDDINGS
768-dim
↓
04TRANSFORMER
124M params
↓
05LOGITS
Float32
↓
06NEXT TOKEN
Emit token
RUNTIME: PURE C++17 · ZERO RUNTIMESVERIFIED
PROJECT 02AI CODING HARNESS
02/03
PROJECT 02DEVELOPER TOOLS · AGENTIC RUNTIME
02 / 03

AI CODING HARNESS

Local CLI software-engineering harness inspired by agentic coding workflows.

A local developer tool inspired by agentic coding workflows, built to experiment with model APIs, tool execution and software-engineering agents. Implements an autonomous agent loop that executes commands, inspects files, and iterates on code within terminal sessions. Provides deterministic tool dispatch with compiler diagnostics and error recovery feedback loops. Compacts and prunes conversation context to prevent prompt overflow during long debugging runs.

KEY IMPLEMENTATION HIGHLIGHTS:
  • ■Pluggable provider interface supporting Anthropic Claude 3.5 Sonnet and OpenAI GPT-4o
  • ■Deterministic tool calling protocol: bash runner, file read/write, pattern grep, ripgrep inspection
  • ■Conversation context compaction and pruning to prevent prompt overflow during long debugging runs
  • ■Robust error recovery: feedback loops when shell commands fail or edits do not match file markers
TYPESCRIPTLLMAGENTSCLISYSTEMS
VIEW SOURCE →
AGENTIC WORKFLOW
COMPACT PREVIEW
01USER GOAL
CLI prompt
↓
02WORKSPACE DISCOVERY
ripgrep
↓
03AGENTIC LOOP
Provider
↓
04TOOL DISPATCH
IPC
↓
05OBSERVATION
Feedback
↓
06VERIFIED PATCH
Git diff
PROTOCOL: CLI HARNESS · LOCAL AGENT LOOPVERIFIED
PROJECT 03CEX MATCHING ENGINE & ORDER BOOK
03/03
PROJECT 03DISTRIBUTED SYSTEMS · FINANCIAL INFRASTRUCTURE
03 / 03

CEX MATCHING ENGINE & ORDER BOOK

First-principles centralized crypto exchange matching engine and transaction ledger.

A centralized crypto exchange (CEX) core built from scratch to demystify high-throughput financial infrastructure. Implements an in-memory limit order book matching engine with FIFO price-time priority, double-entry balance locks, atomic trade executions, and real-time order book broadcasts. Decouples fast in-memory execution from asynchronous ledger persistence for auditability and sub-millisecond matching performance.

KEY IMPLEMENTATION HIGHLIGHTS:
  • ■In-memory price-level red-black tree / sorted doubly linked list order book for deterministic sub-millisecond matching
  • ■Strict price-time priority matching algorithm for both LIMIT and MARKET orders with partial fills
  • ■Double-entry bookkeeping preventing fractional balance discrepancies or double-spend race conditions
  • ■Event-driven transaction log for state reconstruction and failure recovery
TYPESCRIPTMATCHING ENGINEORDER BOOKPOSTGRESQLLOW LATENCY
VIEW SOURCE →
MATCHING ARCHITECTURE
COMPACT PREVIEW
01ORDER SUBMISSION
REST / WS
↓
02BALANCE LOCK
Ledger check
↓
03IN-MEMORY BOOK
Price-Time
↓
04CROSS MATCHING
FIFO match
↓
05LEDGER COMMIT
Postgres / Prisma
↓
06ORDER BOOK STREAM
WebSocket
ENGINE: IN-MEMORY FIFO · DOUBLE-ENTRYVERIFIED
END OF SELECTED WORK · 03/03
NEXT: TECHNOLOGY STACK ↓
TECHNOLOGY STACK

TOOLS & TECHNOLOGIES.

Technologies I use to build full-stack web products, plus systems and AI tools I explore from first principles. Categorised by real-world usage.

POSTURE LEGEND:[B]BUILDING (ACTIVE / PRODUCTION)[L]LEARNING (DEVELOPING PROFICIENCY)[E]EXPLORING (FIRST-PRINCIPLES LABS)
CORE / BUILDING

FRONTEND & WEB APPS

Crafting responsive web applications, interactive interfaces, and design systems with strict TypeScript types, server components, and clean CSS.

VERIFIED TECHNOLOGIES:
TypeScript[B]JavaScript (ES6+)[B]React 19[B]Next.js[B]Tailwind CSS[B]HTML5 / CSS3[B]
CORE / BUILDING

BACKEND & APIS

Designing HTTP/RESTful services, event-driven WebSocket connections, background processes, and exploring Go and Python backends.

VERIFIED TECHNOLOGIES:
Node.js[B]Express[B]REST APIs[B]WebSockets (ws)[B]Python[E]Go[L]
DATA & STORAGE

DATABASES & DATA

Relational schema modeling, type-safe queries, in-memory caching, double-entry financial ledgers, and data persistence guarantees.

VERIFIED TECHNOLOGIES:
PostgreSQL[B]Prisma ORM[B]Redis[B]SQL[B]In-Memory State[B]
EXPLORING / LEARNING

AI & MACHINE LEARNING

Exploring model architectures from the ground up: Transformer attention mechanisms, local CLI agent loops, tool dispatch protocols, and on-device inference.

VERIFIED TECHNOLOGIES:
LLM API Integration[B]AI Coding Agents[B]Tool Calling Protocols[B]Transformer Forward Pass[E]On-Device Inference[L]
SYSTEMS / EXPERIMENTAL

SYSTEMS & PERFORMANCE

Investigating performance close to hardware: cache-conscious loops, zero-allocation buffers, SIMD parallelism, and memory efficiency.

VERIFIED TECHNOLOGIES:
C++17[E]Cache Locality & Tiling[E]Circular Ring Buffers[B]Contiguous Memory Buffers[B]SIMD / AVX2 (Concepts)[L]
WORKFLOW / INFRA

DEVOPS & INFRASTRUCTURE

Operating inside Linux environments, containerizing services with Docker, git-centric continuous integration, and cloud service deployments.

VERIFIED TECHNOLOGIES:
Linux (Ubuntu / Shell)[B]Docker[B]Git & GitHub Actions[B]AWS (EC2, S3)[E]Prometheus / Metrics[L]
UNDER THE HOOD

I LIKE KNOWING
WHAT'S HAPPENING
UNDERNEATH.

From model inference and memory to APIs, containers, Linux and cloud infrastructure — I enjoy understanding the systems behind the interface.

LAYER 01 / 07CODE
SCOPE: SOURCE & SYNTAX

SOURCE & SYNTAX

Strictly typed, idiomatic code in C++, TypeScript, Go, and Python. Designing explicit contracts, modular abstractions, and zero-redundancy interfaces.

SYSTEM INVARIANTS & AUDIT:Clean static typing · Deterministic behavior · Explicit error handling
TECHNOLOGIES OPERATING AT THIS LAYER:
C++17TypeScriptGoPython
SYSTEM OBSERVABILITY: ACTIVECLICK LAYERS TO INSPECT
CURRENTLY BUILDING

WHAT I'M WORKING ON NOW.

Active projects, ongoing experiments, and engineering initiatives currently in progress.

INTERACTIVE TERMINAL
■ CURRENT INITIATIVES & STATUS
DEVELOPER TOOLS · AGENTIC RUNTIMEACTIVE WORK
AI CODING HARNESS

A developer-tooling project exploring AI-assisted coding workflows, multi-provider model integration, deterministic tool execution loops, and automated feedback diffs.

TypeScriptAgent LoopsTool CallingCLI
VIEW REPO →
LOCAL INFERENCE · BROWSER RUNTIMEEXPLORATION
ON-DEVICE CHROMIUM LLM ENGINE

An engineering investigation exploring local AI model inference inside browser and Chromium runtimes for private DOM reasoning and zero-cloud API workflows.

ChromiumC++Local InferenceWebGPU
RESEARCH LOG →
SYSTEMS · MACHINE LEARNING RUNTIMEFUNCTIONAL PROTOTYPE
GPT-2 C++ INFERENCE ENGINE

A transformer forward pass implemented from first principles in standard C++17, focused on understanding the mechanics of GPT-2 inference without PyTorch, ONNX, or runtime libraries.

C++17Attention KernelsCache TilingSIMD
VIEW SOURCE →
■ GITHUB CONTRIBUTIONS / LAST 12 MONTHSLIVE SYNC
@ouroboros1X↗
745 contributions
CURRENT STREAK: 0D·LONGEST: 79D·AVG / DAY: 2.0·GITHUB MEMBER SINCE 25 JUN 2026
OctNovDecJanFebMarAprMayJunJulAugSepOctMonWedFri
Less
More
■ OPEN TO OPPORTUNITIES
●FULL-STACK & SAAS ROLES
Building high-utility web applications, scalable SaaS products, and resilient backend services.
●SYSTEMS & BACKEND PLATFORMS
Engineering high-throughput services, distributed dataflows, and developer infrastructure.
●OPEN SOURCE COLLABORATIONS
Collaborating in public on developer tools, inference experiments, and first-principles software.
INTERACTIVE CONSOLE (Type 'help', 'about', 'projects', 'stack', 'currently', 'contact', 'whoami', 'clear')
vinayak@portfolio:~$welcome
Antigravity Terminal v1.0 Type 'help' to inspect available commands.
vinayak@portfolio:~$
ABOUT

I BUILD.
I BREAK.
I UNDERSTAND.
I SHIP.

LOCATION: Pune, India [UTC+5:30]

PRIMARY FOCUS: FULL-STACK WEB & SAAS

EXPLORING: AI MECHANICS & SYSTEMS INFRASTRUCTURE

DIRECT MANIFESTO

I'm Vinayak Dhemare, a full-stack software engineer focused on building web applications, SaaS products, and reliable backend infrastructure.

My primary focus is building full-stack software that is useful, reliable, and user-centric. Alongside product development, I explore how modern systems work from first principles — understanding the mechanics underneath APIs, runtime engines, and language models.

Whether architecting real-time streaming interfaces, writing transactional ledgers, or deconstructing GPT-2 inference in pure C++ — I care about deterministic behavior, clean architecture, and shipping things that actually execute.

ENGINEERING PHILOSOPHY

FIRST PRINCIPLES.

Four guiding invariants for building systems that last.

01INVARIANT 01

UNDERSTAND THE SYSTEM

“Don't just make it work. Understand why it works.”

Abstractions are convenient until they leak. Peeling back high-level libraries to see memory buffers, network packets, and CPU instructions builds true engineering intuition.

VERIFIED RULESTRICT ADHERENCE
02INVARIANT 02

BUILD BEFORE OVERENGINEERING

“Start small. Measure. Then make it better.”

Avoid solving problems you do not have yet. Write working code, profile the hot paths under realistic workloads, and optimize with empirical benchmark data.

VERIFIED RULESTRICT ADHERENCE
03INVARIANT 03

PERFORMANCE IS A FEATURE

“Latency, memory, cost and reliability matter.”

Speed is not an afterthought. Thoughtful data structures, cache-conscious memory layouts, and low overhead translate directly into user responsiveness and lower cloud costs.

VERIFIED RULESTRICT ADHERENCE
04INVARIANT 04

SHIP THE THING

“A finished imperfect system teaches more than an unfinished perfect architecture.”

Architectures drawn in diagrams prove nothing until bytes execute on real silicon. Build the prototype, run the tests, deploy it, break it, and iterate in public.

VERIFIED RULESTRICT ADHERENCE
LET'S BUILD

HAVE SOMETHING
WORTH BUILDING?

Have a project, idea, internship opportunity, collaboration or interesting engineering problem?
Let's talk.

EMAIL:vinayak.supreme1@gmail.com