Shashank Gowda T

MotionCode: Show it an animation, get the code.

2026 · AI · Live

Drop in a screen recording or GIF of a UI animation and MotionCode hands back working CSS, GSAP and Framer Motion code for it. No more scrubbing frame by frame to copy an animation by eye.

• Reads the timing, easing and keyframes straight from the video
• All three code outputs come from one spec, so they always agree
• Free to try, with paid plans and team workspaces

Your video stays with you

The clip is split into frames in the browser, on a canvas. Only a few sampled frames, packed into one contact sheet, go to the server, so the upload is small and the original video never leaves your laptop.

One spec, three outputs

Gemini (or OpenAI, if you switch it) reads the frames and returns a motion spec: timing, easing and keyframes. The CSS, GSAP and Framer Motion code are all generated from that same spec, so they never disagree with each other.

Check it before you copy it

The generated code plays in a sandboxed preview next to the editor, so you can see whether it matches before it goes anywhere near your project.

Limits live in the database

Plan limits are enforced by a Postgres row-level policy on insert, not by the UI, so tampering with requests in the browser does not get you extra projects. Payments go through Razorpay subscriptions.

Built with Next.js, TypeScript, Supabase, Gemini API, GSAP, Framer Motion, CodeMirror, Razorpay.

Live site · Source code

OneCLIQ: Paste a GitHub link, get the right download or an honest review.

2026 · Tools · Live · Runner-up at Hacktoberfest Hack Day Bengaluru, 18 October 2026. Live on Vercel, and the CLI is on npm as onecliq.

Built in a day at Hacktoberfest Hack Day Bengaluru, where it was runner-up. Give OneCLIQ any GitHub link and it picks the one release file built for your computer, reviews a pull request with Gemma 4, or teaches your coding agent a new skill.

• Finds the right file for your OS and chip, and shows where it came from
• Gemma 4 reviews a pull request and says plainly whether it is safe to merge
• The same tools as a website, a CLI on npm and an MCP server

The right download

It reads a project’s latest stable release, works out which file matches your OS and CPU, and links straight to it on GitHub. A trust report shows the release age, digests and attestations, and a dropped file can be checked against the release by its SHA-256 alone, so the file itself never leaves your computer.

Reviews you can repeat

gemma-4-31b-it reviews the diff and the 26B mixture-of-experts model takes over when it is busy. Findings are ranked from must-fix to nit, and the merge verdict is worked out from them in code, not by the model, so the same findings always give the same answer. A pool of free-tier keys rotates when one is rate limited.

One engine, three doors

The website, the oqgit CLI and the MCP server all share one engine with no framework code in it. Claude Code, Codex or Cursor can call the same review and release tools over MCP, and 44 agent skills install into six coding agents with one command.

Built with Next.js, TypeScript, Gemma 4, Gemini API, MCP, Vercel, Vitest, Playwright.

Live site · Source code

Vercelify: Turn the old laptop in your drawer into your own Vercel.

2026 · Tools · Live · Built for Hacktoberfest Hack Day Bengaluru, 23 October 2026. Installs on a spare Ubuntu or Debian laptop with one command.

Push to GitHub and your app goes live, like on Vercel, except it runs on a spare laptop you already own and costs nothing a month. You control it from a desktop app on your Mac, and when a build fails, Gemma 4 reads the log and tells you why.

• Push to deploy, preview links for pull requests and one-click rollback
• Gemma 4 explains a failed build in three lines: cause, fix and a check
• Private by default over Tailscale, with databases and your own domain if you want

Why did my deploy fail?

Build logs are long and mostly noise, so it keeps only the error lines with a little context and the last 30 lines, up to 5,000 characters. Gemma 4 E2B in Ollama, on your Mac or on the server, answers with the cause, the fix and a command to confirm it, in under 120 words. It only suggests; it never edits your code or redeploys.

Built on Coolify

It does not reinvent hosting. Coolify builds each app into its own Docker container and Traefik routes requests to it. A small Rust agent on the server reports health and disks, handles pairing and checks GitHub for new commits, and an optional Cloudflare Tunnel puts an app on the internet without opening a port at home.

Looks after old hardware

One script sets the laptop up, keeps it running with the lid closed, and watches temperature, battery, disk and memory, slowing things down before it overheats. It also reads the common parts of vercel.json, so redirects, rewrites, headers and cron jobs carry over.

Built with Rust, Tauri, React, TypeScript, Gemma 4, Ollama, Coolify, Docker, Tailscale.

Source code

Lanox: A language model I trained from zero, on one person.

2026 · AI · Live

A small language model I wrote by hand and trained from random weights until it texts like one specific person. No pretrained model and no borrowed tokenizer, just about 15M parameters. You can chat with it on the site.

• Trained in three rounds: small talk, real chats, then a judge model
• Runs on a single CPU core, so it is cheap to keep online
• Learns from new chats every few days, and only ships if it got better

Three rounds of training

First it learns to hold a conversation at all, on Hinglish small talk that Qwen generated. Then it is fine-tuned on real WhatsApp and Discord history at a lower learning rate. Last comes a GRPO loop, where a local Qwen3-4B judge scores groups of replies and the model learns from the ranking.

Keeping the voice

The obvious failure is reward hacking: the model works out what the judge likes and drifts towards it. A divergence penalty against the frozen phase-two model stops that. It can get better, but it cannot turn into someone else.

It keeps learning

The playground on the site talks to a small FastAPI server on Railway that runs the model as ONNX with a KV cache, on one CPU core. Every reply is logged, and every couple of days a Colab notebook runs another GRPO round on those chats. The new checkpoint only ships if it scores at least as well as the live one.

Built with PyTorch, Qwen3-4B, GRPO, ONNX Runtime, FastAPI, Next.js, Live2D, Hugging Face.

Live site

RustCast: A keyboard launcher for Linux, written in Rust.

2026 · Tools · Live · Version 0.7.2 is out, with ready-made Linux packages.

Press Alt + Space to open apps, find files, do maths, or type what you want in plain English. It also has a screenshot editor with text recognition, a screen recorder and clipboard history, all in one small native app.

• Type “open downloads then show desktop” and it runs both steps
• Screenshot studio: annotate, read text out of images, pin to screen
• Records one window even when other windows cover it

Jev

Type “jev open downloads then show desktop” and you get a list of actions to run with Enter: open folders and files, launch or close apps, tile windows, start a recording. Several steps collapse into one “Run all” row.

Screen recorder

It can lock onto one window, so nothing dragged over it shows up, and it keeps recording even when that window is minimised. You can add more windows mid-recording, and RustCast paints itself out of every frame. It encodes with ffmpeg, and on GNOME Wayland it records through the portal and PipeWire.

Screenshot studio

A screenshot opens in an editor for arrows, text and blur. It can read text, code and whole tables out of the image with Tesseract on your machine, pull a colour palette, compare two shots, or pin one on top of every window.

Clipboard and screenshots

Text and image history is saved to disk and survives a restart. A screenshot pops up as a thumbnail you can drag into any app as a PNG, over XDND on X11 and through a small Wayland helper so native Wayland apps accept the drop too.

Built with Rust, iced, x11rb, GTK, Tesseract, ffmpeg, PipeWire.

Download · Source code

Namma Ooru: A whole room builds one living 3D Bengaluru from their phones.

2026 · Graphics · In progress · Built for Hacktoberfest Hack Day Bengaluru on 16 October 2026. It goes live there.

Snap any object with your phone and Gemma turns it into a building in the right part of a 3D Bengaluru that everyone in the hall shares. Then walk into it, ride an auto through the real streets, and chat with people in five languages.

• The city is built from real map data: 1.4 million building outlines
• Pin a photo where you took it and it goes up on that street
• Dasara Night lights the city up and the elephant procession walks to Town Hall

Real Bengaluru

The map comes from Overture Maps: 1.43 million building footprints, 371k road segments, Namma Metro on its viaduct and about 199k named places. A Python script reads only Bengaluru out of the public release with HTTP range requests and cuts it into 13,622 small tiles that Web Workers load around the camera.

Photo to building

Gemma 4 on the Gemini API boxes the object in the photo, names it, and picks the neighbourhood it belongs in. If Gemma is down or rate limited the player is told to try again, and the build is not counted against them.

One city for everyone

With no keys it runs on an in-memory backend. With Supabase set up, Postgres holds the state, a private bucket holds the photos and Realtime keeps every phone and the projector in the same city, however many serverless instances are running.

Built with Next.js, three.js, React Three Fiber, Supabase, Gemma 4, Web Workers, Python, Playwright.

Private repository.

Computeus: Lets any AI model use a computer, on desktops of its own.

2026 · AI · In progress

Gives any AI model a mouse, a keyboard and a screen on hidden desktops, so it never takes over yours. It plans the task first, runs the parts that can run at the same time, and saves every step so you can rewind.

• Every agent works on its own hidden screen that you can watch live
• Blurs emails, card numbers and passwords before a model sees the screen
• You can pause any agent, take over, and hand it back

Hidden desktops

Every agent gets its own Xvfb virtual screen to click, type and take screenshots on. The native Rust app shows them all in a live grid, and you can take over any one of them and hand it back.

Only what changed

The vision pipeline sends the model as little as it can. If nothing changed it gets one line of text, a small change gets just that region, and several changes become one numbered contact sheet.

Private by default

Before a screenshot goes to a model, on-device OCR finds emails, card numbers, API keys and anything typed into a secret field, and blocks them out. No-Touch Zones mark areas an agent can never click or see.

Fork and Race

A hard step can run as several candidates at once, each on its own desktop. The first one to succeed wins and the rest are stopped straight away. A lead model plans and cheaper worker models do the steps.

Memory and rewind

Every action and every screen the model saw goes into one SQLite file. The Brain Map reuses the fastest path that worked before, and you can branch a new live run from any earlier point.

Built with Rust, GPUI, Xvfb, SQLite, MCP, OCR.

Private repository.

ArcSpace: My terminal for running coding agents side by side.

2026 · Tools · In progress

One window that tiles Claude Code, Codex and normal shells in a grid, so I stop juggling terminal windows. Every session shares the same markdown notes, and a voice agent can open new agents for me.

• Every pane is a real terminal, so agents behave exactly as usual
• Shared notes the agents can read and write through MCP
• Each pane can use a different Claude account

Real terminals

An Electron shell over React 19. Every pane is a real PTY, not an imitation of one, so the agents behave exactly as they would in a normal terminal. Panes sit in a split tree you can resize, split and rearrange, and there are 343 tests behind it.

Shared notes

ArcMemory is just a folder of markdown files linked with [[wikilinks]], and the graph comes from parsing those links. A built-in MCP server lets Claude and Codex read and write the same notes I do.

Voice agent

A Live2D character sits on a terminal’s title bar and talks through Deepgram’s Voice Agent API, one WebSocket instead of separate speech-to-text, LLM and text-to-speech calls. Tell it what you want built and it opens a new Claude or Codex pane for the job.

Several Claude accounts

Each pane can use a different Claude subscription. Every account keeps its own login through CLAUDE_CONFIG_DIR, while settings, skills and history are shared, so a session started on one account can be resumed on another.

Built with Electron, React 19, TypeScript, node-pty, xterm.js, SQLite, Deepgram, MCP.

Private repository.

Kai: Gives Gemma 4 a hand: it uses your computer while you watch.

2026 · AI · In progress · Builds for Linux, Windows and macOS. Still being tested before a public release.

A desktop app for Linux, Windows and macOS that lets Gemma 4 use your computer one visible step at a time. It looks at the screen, clicks, types and runs commands, and you can stop it from any app with one shortcut.

• Passed 14 of 14 everyday desktop tasks on Gemma 4 26B in my benchmark
• Asks before anything risky, and never solves a CAPTCHA or guesses a code
• Runs fully offline on a 4B model in about 4.4 GB of RAM

Numbered marks

Every button and field from the accessibility tree gets a number drawn on the screenshot, so Gemma answers “click #14” instead of guessing pixels. The loop is observe, ground, decide, act, verify, one action per step, and Kai’s own overhead is about 65 ms a step.

Fast on purpose

The 26B mixture-of-experts model takes every step and the dense 31B only the one after a failure. The prompt is ordered so vLLM can reuse its cache, replies are capped short, and opening an app or a URL skips the model entirely.

Your model, your machine

Gemma 4 runs on your own DigitalOcean GPU Droplet with vLLM, brought up with one script, and falls back to the Gemini API. A model store ranks 16 open models for your computer, and any GGUF vision model on Hugging Face can be pulled in.

Sub-agents

Switch on Team and Kai splits a task into sub-agents: terminal work runs in parallel, screen work takes turns, and you get one report at the end. A finished run can be saved as a skill, so the next one skips steps the model no longer needs to think about.

Built with Rust, GPUI, Gemma 4, vLLM, DigitalOcean, Gemini API, Accessibility APIs.

Private repository.

Peek-a-Boo: Catches whoever is reading your screen over your shoulder.

2026 · Tools · Live · Not on the Play Store yet. Install the APK straight from GitHub.

An Android app that watches the front camera while you use your phone. When someone else looks at your screen, a small notch pops up with a live count, and every peek goes into a daily report. It all runs on the phone and the app has no internet access.

• Learns your face in ten seconds, so you are never counted
• Pro version blurs the screen for anyone looking from the side
• Only counts real peeks, not faces passing by

Only real peeks

ML Kit finds the faces, but a face only counts if it is turned towards the screen, close enough to read it, and keeps looking for a moment. Scanning slows from about 5 fps to 2 when nobody is around, and stops when the screen is off.

It knows you

You enrol your face in about ten seconds, and from then on you are never counted, even when a friend holds your phone and you lean in. Repeat peekers are grouped by face signature, so the report counts people, not just peeks.

Privacy Shield

The Pro version puts a filter over the screen the moment someone looks: you can still read it head-on, but from the side the text washes out. It works like the S26 Ultra’s privacy display, on any phone, and can be limited to apps like banking and chats.

Feel

Jetpack Compose with spring motion everywhere, and native ports of a few React Bits components: rolling counters, hold-to-confirm buttons, swipe-to-delete with undo.

Built with Kotlin, Jetpack Compose, CameraX, ML Kit, Room, DataStore.

Download · Source code

GrindEasy: Your AI coding tool, on your Discord profile.

2026 · Tools · Live · On npm as grindeasy 0.10.0.

A tiny local app that shows which AI coding tool you are using, like Claude Code, Codex or Cursor, as a live card on your Discord profile. Your hours climb you from Bronze to Diamond on an opt-in public leaderboard.

• One command to set up: npx grindeasy
• Never opens your code or prompts, only checks when files last changed
• Watches 13 tools, with a public leaderboard you can join

Privacy

It works out which tool is active only from when that tool’s session files were last modified. It never opens them, so your code and prompts stay on your machine. The leaderboard only ever receives totals.

Leaderboard

The leaderboard server has zero runtime dependencies, just node:http and node:sqlite, with Discord login and anti-cheat that clamps whatever a client reports. The website is Next.js on Neon Postgres with Drizzle.

Setup

Run “npx grindeasy” and you are done: no Discord developer portal, no config file. It also serves a local dashboard, plus a JSON endpoint you can hook up to a status bar.

Built with TypeScript, Node.js, Discord RPC, SQLite, Next.js, Neon Postgres, Drizzle ORM.

Live site · Source code

Stellar: Paste a GitHub repo, get an animated 3D star map of its history.

2026 · Graphics · Live

Stellar turns a repository’s real commit history into a galaxy. The first commit ignites at the centre, branches form constellations, merges draw lines between them and releases shine brighter. Any README can embed its own galaxy as an image.

• Reads public history straight over Git, no GitHub token needed
• Live animated GIF and SVG badges for any README
• A Go API with a shared Redis cache, so popular repos are only cloned once

Real history

The Go API does a blob-less bare clone, reads the log, branches, tags and merges, and returns them as one versioned contract. It never decides where a star goes: the browser lays the galaxy out from that contract with three.js, the same way every time.

Badges

GitHub READMEs cannot run WebGL, so the API draws the galaxy itself as an SVG or a looping GIF from the same contract, with a five-minute cache. The image links through to the full interactive map.

Holding up

An Upstash Redis cache and a build lease shared across instances mean one clone serves everyone asking for the same repository. A bounded queue, per-visitor rate limits and a memo for repos that are too big keep one visitor from slowing it down for the rest.

Built with Go, Next.js, three.js, TypeScript, Upstash Redis, Vercel.

Live site · Source code

Paper Trail: A walk printed on one sheet of paper, so the phone can stay home.

2026 · AI · Live · Runs locally with Ollama or Docker, and deploys to Render with one blueprint.

Paper Trail turns your real neighbourhood into an eight-page paper zine written by Gemma 4: a hand-drawn map, things to spot, a riddle and a box to sketch in. Print it, fold it, walk. When you are back, one photo of the sheet and Gemma reads your pencil.

• The route comes from real OpenStreetMap places, picked without AI
• Every line Gemma writes is checked against the real places before it prints
• One photo of the filled sheet: ticks, handwriting and sketches read back

Written, then checked

Gemma writes the zine in two stages, a plan and then the copy for each panel. Every reply is checked against a schema, against the real places on the route and against the size of the panel it has to fit. A failure retries with the exact error, and repeated failures fall back to a template, so it never dead-ends.

Reading the pencil

The browser finds the four printed corner marks, flattens the photo and cuts it into panels. Ticks are measured by ink darkness inside the known boxes, Gemma reads four small crops, and where the two disagree you get one tap to fix it.

Open models

Gemma 4 runs on your own machine through Ollama, on Ollama Cloud or through the Gemini API, with fallback between them. Built for the DEV Hacktoberfest Open-Source AI Challenge, week one: Touch Grass.

Built with Next.js, TypeScript, Gemma 4, Ollama, three.js, OpenStreetMap, IndexedDB.

Source code

Ground Zero: Four real nuclear tests, rebuilt in three.js.

2026 · Graphics · Live

Pick Trinity, Crossroads Baker, Castle Bravo or Tsar Bomba, or set your own yield, and watch it happen in your browser. The fireball, blast timing, heat and cloud height all come from the published physics equations.

• Stand 10 km away and you see the flash before you hear the blast
• Ray-marched mushroom cloud that rises with the Earth's curvature
• Drop observers anywhere and read the pressure and heat they feel

Physics

The fireball grows by Taylor–Sedov, overpressure follows Kinney–Graham with ground reflection, and the shock front moves at the Rankine–Hugoniot speed. Stand 10 km out and you see the flash, then hear nothing until the shock actually reaches you.

The cloud

A ray-marched volumetric fireball rolls up into the mushroom cap, with the afterwind stem, a dust skirt and the condensation ring. Earth curvature is modelled, so Bravo’s cloud, seen from 145 km away, rises up from below the horizon.

Baker

The underwater shot gets its own treatment: the spray dome, a hollow 1.8 km water column, the base surge rolling out across the lagoon, and the USS Arkansas being lifted and sunk.

Sandbox

A timeline from 1 µs to 25 minutes, observers you can drop anywhere with live pressure, heat and dose readouts, and a Rapatronic camera mode that saves the frame as a PNG.

Built with three.js, GLSL, JavaScript, Web Audio, Web Workers, Vite.

Live site · Source code

Multiverse: A Doctor Strange scene, rendered live in your browser.

2026 · Graphics · Live

An 86-second, shot-for-shot remake of the multiverse fall from Doctor Strange in the Multiverse of Madness, through 20 universes. There is no video file: every frame is drawn live on your graphics card and the music is made in the page.

• Each of the 20 universes is its own 3D scene
• Opens like a game, with a title screen and chapter select
• Can export itself frame by frame into an MP4

Rendering

Each universe is its own ray-marched scene, lit with photographic HDRIs and scanned PBR materials. Real 3D models are baked into distance fields, so they sit inside those worlds instead of looking pasted on.

It opens like a game

Gold title lettering drawn in WebGL, a sling-ring loader that fills up while the shaders compile, then a menu with chapter select and settings. It asks if you want to enter the multiverse. Saying no does not work for long.

Exporting a video

A Playwright script steps the page one frame at a time and pipes each frame into ffmpeg, so the MP4 has exactly the same motion blur and trails as the live version.

Built with WebGL2, GLSL, JavaScript, Web Audio, Playwright, ffmpeg.

Live site · Source code

Superspot: A field guide to the cars of Earth.

2026 · Fullstack · Offline · The database behind it is paused right now, so the globe opens but sightings don’t load.

See a car worth noticing, snap it, and it lights up on a night-time globe. Every model is treated like a species, with a rarity, a field-guide page and the cities it has been spotted in.

• An AI checks every photo is really a car before it counts
• No sign-up: pick a handle and start spotting
• Photo locations are blurred to about 1 km for privacy

Is it a car?

Every photo goes to Gemini with one question: is this a car? The Go API spreads those checks over a pool of free-tier Gemini and Gemma models, keeps each one under its rate limits with budgets stored in Postgres, benches a model when Google says it is out of quota, and asks a second model if the first is slow.

No accounts

You pick a handle, and the API stores it with the hash of a secret key that lives in your browser. No email, no password.

Privacy

Photos are resized and re-encoded, which strips the camera metadata and GPS, and the location on a sighting is blurred to a grid of about 1 km before anyone sees it.

Live

New sightings and comments reach every open copy of the app through Supabase Realtime, usually within a second. Browsers can only read. Every write goes through the Go API.

Built with Go, pgx, React, TypeScript, MapLibre, Supabase Realtime, Gemini API, Vercel.

Live site

GovBot: Government schemes, over WhatsApp.

2026 · AI · Offline · The backend is switched off for now, so you can click around the demo but can’t finish a flow. All the code is in the repo.

Many people who qualify for scholarships and welfare schemes never apply because the portals are confusing. GovBot moves it into WhatsApp: find what you qualify for, share your documents once, and it fills the forms for you.

• Works entirely inside a WhatsApp chat
• Documents come from DigiLocker or a photo, and are stored once
• Fills the real government forms, the step people pay a cyber cafe for

The chat

A FastAPI flow router runs the conversation over the WhatsApp Cloud API, with separate LangGraph agents for the scholarship schemes. Sessions are tied to a phone OTP, and a half-finished application picks up where you left it.

Documents

Documents come in through DigiLocker, with a consent link that expires after 30 minutes, or as photos that Gemini reads the fields out of. Either way they end up in one vault, so nobody has to upload their Aadhaar twice.

Form filling

Playwright takes the saved profile and fills in the forms on the actual government portals. That is usually the step people pay a cyber cafe to do.

Officer side

Officers get dashboards for disbursements, numbers by region, and applications flagged as possible fraud.

Built with FastAPI, LangGraph, Next.js, Supabase, Gemini API, WhatsApp Cloud API, Playwright, ChromaDB.

Live site · Source code

Proveno: Keeps track of what your coding agents did.

2026 · Tools · In progress

When several AI agents work in the same codebase, it gets hard to tell who changed what or what it cost. Proveno tracks that for Claude Code and Codex, stops them editing the same file at once, and gets a second model to review changes.

• Shows which agent and model changed each file
• File locks so two agents never overwrite each other
• Cost is always marked as an estimate, never guessed

Honest numbers

Which agent and model touched a file is exact, read from the real transcripts and hook payloads. Cost is always labelled as an estimate, prices come from a dated file instead of memory, and a model it doesn’t know shows up as unpriced rather than guessed.

Collision locks

It runs a small MCP server the agents talk to. Locks live in a shared SQLite table with a TTL, so a crashed agent can’t hold a file forever, and an agent asking for a held file is told who has it and until when.

Setup that checks itself

“proveno init” wires up the Claude Code, Codex and git hooks and backs up every file it touches. Then it actually runs the hook command, and if that fails it says so, instead of quietly capturing nothing.

Built with TypeScript, Node.js, MCP SDK, SQLite, Commander.

Source code

cc-plus-plus: An agent terminal dressed up as Turbo C++.

2026 · Tools · Live · All three parts are finished. It runs from source, there is no installer yet.

A terminal for AI coding agents with the full blue-and-yellow Borland Turbo C++ look. Every pane is a real terminal, and it can find the MCP servers already on your machine or build new ones.

• Finds the MCP servers you already use in Claude, Cursor and others
• Builds a new MCP server for any app that does not have one
• Generated servers are locked down by default

MCP Hub

It reads the MCP servers you have already set up in Claude Code, Claude Desktop and Cursor, asks which ones you want, and passes them to the agents it launches. It never edits your own configs.

MCP Forge

For an app that has no MCP server, it scaffolds one around a CLI, a folder or a local HTTP API, hands it to an agent to fill in, then smoke-tests it with a real MCP client before connecting it.

Safe by default

The generated servers run commands without a shell, keep file access inside one folder, and refuse HTTP requests to any other origin. The template takes care of that, so it holds even if the agent writes sloppy code.

Built with Electron, TypeScript, xterm.js, node-pty, MCP SDK, electron-vite.

Source code

claude-clone: A coding agent harness, built from scratch to see how one works.

2026 · AI · In progress

A small TypeScript version of the loop behind tools like Claude Code. It streams the model's answer, runs the tools it asks for, feeds back the results, and repeats until the job is done.

• Works with Anthropic, OpenAI-style APIs and Groq
• Two tools, Read and Bash, with output trimmed to fit
• Kills commands that hang

Any provider

A provider is anything that can stream a reply. There is one for Anthropic and one for OpenAI-compatible APIs, and it uses Groq by default. The agent loop doesn’t know which one it is talking to.

Two tools

Read and Bash. Bash output is cut to the last 2,000 lines or 50 KB so a noisy command can’t fill the context, a hung command is killed after a timeout, and on Windows it finds Git Bash by itself.

Built with TypeScript, Node.js, Anthropic SDK, OpenAI SDK, Groq.

Source code

MedStock AI: Stock and expiry tracking for hospitals.

2026 · Fullstack · In progress

Tracks medical supplies across hospitals and departments: what is in stock, which batches are about to expire, and emergency requests when something runs out. It also predicts demand so reorders go out in time.

• Warns before batches expire
• Emergency requests between departments
• Front and back end generated from one API spec, so they never drift

One contract

A pnpm monorepo with an Express API and a React frontend. The API is written down once as an OpenAPI spec, and Orval generates the Zod schemas and the React Query client from it, so the two sides can’t drift apart.

Built with TypeScript, React, Express, PostgreSQL, Drizzle ORM, OpenAPI, Orval, Zod.

Source code

nano_database: A tiny Redis-style database, in C.

2026 · Backend · Archived

A key-value database I wrote from scratch in C to learn how Redis-style stores work. You can talk to it over the network with plain text commands, straight from netcat.

• Every write is saved to disk at once, so a crash loses nothing
• Each read is a single disk seek
• No libraries, just C and sockets

Storage

Writes are only ever appended to a log file and flushed straight away, so a crash doesn’t lose data. An in-memory hash table maps each key to its byte offset in that file, so a read is a single seek.

Built with C, TCP sockets, Hash table.

Source code