Projects

When I was a kid, I used to read books and comics while eating (Tintin, Tinkle, ACK etc.). These days I mostly read ebooks and papers, and keeping my laptop close to a plate of food is not quite convenient. One misstep and I could have a hole in my pockets.

So I built Insho 印章: a hands-free, camera-powered PDF reader that lets me navigate documents entirely with hand gestures (turning pages, smooth scrolling via a floating virtual joystick, and pinch-to-zoom), so I can sit comfortably away from the computer without touching it.

Under the hood, it runs Google MediaPipe HandLandmarker directly on-device using WebAssembly and WebGL. A custom heuristic gesture engine translates 21 3D hand landmarks into actions in real time, keeping everything private without uploading any video or documents to the cloud.

I still use it occasionally (roughly once a week or a few times a month), which is probably the real test of whether this side project was useful.

I already had a personal dashboard showing me summaries of spending and yearly/monthly trends, but I wanted to ask questions like:

“How does my grocery spending this month compare with the same month last year?”

I also didn't want to send my financial data to a cloud LLM.

So I started experimenting with small language models that could run locally on my computer. I wanted responses in a few seconds, preferably under 5s, which ruled out simply throwing a large model at the problem.

My early experiments back in January 2026 showed that sub-2B models were surprisingly bad at reliably generating analytical code. Tool calling worked better, but putting every possible tool definition into the prompt made the system slower and less accurate.

I ended up splitting the task into two stages: which tool should be used, and what parameters should it receive?

I built a 115-query evaluation suite and benchmarked small models on accuracy, speed, memory use, and failure modes on an 8 GB M1 Mac.

With a university classmate, I wrote up the findings. The part I'm probably most proud of is that I did the whole thing independently, without funding or special infrastructure, and still managed to get the work accepted at workshops at COLM and EMNLP.

Also, on a completely different metric, the resulting system helped me cut my snack spending by about 85%, saving more than ¥30,000 (and also a few body-fat percentage points, I guess).

That is probably the most tangible ROI I've ever measured.

I use LLMs almost every day, and at some point I started wondering how much of their behavior depends on the language and context in which I ask a question.

While working on SpendSight, I became interested in how NLP researchers actually evaluate these systems, so I started contributing to Cohere Labs' open-source research on LLM behavior across cultural and linguistic contexts.

My main work was building evaluation pipelines and testing models under different language and contextual conditions.

The question that kept pulling me back was quite simple:

If I ask the same thing in a different language, should I get the same answer?

This project was one of my first attempts to investigate that systematically, and it changed the way I think about LLM benchmarks. A model doesn't exist in a vacuum. The conditions around the model matter too.

For the Gemini 3 Tokyo Hackathon, my team had to build a game.

We decided to make one where people could create their own characters, and Nano Banana made it possible to turn uploaded images into usable game assets.

At one point we uploaded images of Shohei Ohtani and Cristiano Ronaldo and got them working in the game.

It was a hackathon, so the goal was less “build the perfect game” and more “build something that works before the clock runs out.”

It was also a good reminder that sometimes the best reason to build something is simply that it sounds fun.

People had always told me that leg day was the hardest day at the gym and I used to wonder, boy, is it really that bad?

I started believing them after adding Bulgarian split squats to my routine.

So I checked.

I compared my average heart rate during leg-day gym sessions with my average heart rate during other gym sessions. There wasn't a sophisticated statistical model behind it. I just compared the two series and looked at the means.

The answer was pretty much what I wanted it to be:

Leg days are harder.

Scientifically decisive? Probably not.

Emotionally decisive? 100%.

I first became interested in open source after seeing the culture around it at IIT Roorkee, and Google Summer of Code seemed like a good excuse to finally get involved.

I worked with FURY, an open-source Python library for scientific visualization, particularly around molecular visualization.

My main contribution was an MVP showing how FURY could be used for molecular visualization, along with several smaller demonstrations.

One of the less glamorous parts of the project was dealing with documentation that was, let's say, not always particularly intuitive.

More importantly, I learned how much open-source work is about things that aren't really “coding”: writing documentation, keeping code clean, communicating clearly, and helping people who use what you've built.

Back in my third semester at IIT Roorkee, I started running and tracking my health metrics with a Fitbit.

Over the next several months, I noticed my resting heart rate gradually falling. A quick web search suggested that regular cardiovascular exercise could be one possible explanation.

So I decided to test it on my own data.

I aggregated my cumulative exercise and compared it with my resting heart rate. The scatter plot showed a clear negative trend, and both Pearson and Spearman correlations were negative as well.

It was a very small experiment, and in retrospect it was also a statistically naive one. There were plenty of possible confounders, and an N=1 observational analysis certainly cannot establish causality.

But that wasn't really the point.

What interested me was that an ordinary observation from my own life could become a quantitative research question.

That was one of the things that first made applied statistics click for me.

I kept tracking my resting heart rate afterward too. During COVID, a sudden change in the metric helped alert me that something was wrong, and I self-isolated rather than risk passing it on to my family.

I had just finished watching Naruto and was very interested in Itachi at the time.

I've also been fascinated by pixel art since I was a kid, partly because I spent many hours playing retro games.

So I decided to combine the two.

I drew all the pixel art myself in Piskel, then built the animation using Python Arcade. Along the way I learned how to draw pixel art, edit video, work with animation, and read enough documentation to make the whole thing behave.

Seeing it featured by Python Arcade was especially satisfying.

It was also one of my first open-source contributions, before GSoC.

In 2018–19, when I was 17ish, I absolutely loathed programming.

We were using Turbo C++ (which, from what I know, was the rage in the Cretaceous), and programming felt frustratingly abstract to me. I couldn't really see what any of it was useful for.

Then our teacher asked us to make a project.

I liked maths and science, and I was preparing for the university entrance exams, so I thought: why not make something related to science?

I found the graphics library, started experimenting, and ended up building a simulation that rendered stars and the Milky Way.

For the first time, the things we'd been learning in class (pointers, classes, abstraction, and all the rest) suddenly became useful parts of something I could actually see.

I got so engrossed in the project that I'd spend my lunch breaks in the computer labs, stuck to computer screen, trying to debug cretaceous-era code, and ended up spending the entire holidays working on it.

My teacher was so surprised by the final result that she initially didn't believe I'd made it myself (as I was not exactly known for being a fan of programming back then).

That project completely changed how I thought about programming.

I also built a small quiz with a dynamic timing system, where faster answers earned more points, along with a leaderboard.

In retrospect, this project to me was what I presume is LLMs for most people (especially non-coders), ability to communicate with a machine in a language and getting it to do what you want it to do. It felt magical.