Space repetition review
Favorite screen
Setting screen
Home screen
An algorithm problem
App logo 1024x1024

Inspiration

I come from Android development, and CS fundamentals have always been my weak spot. I'd tell myself I'd practice algorithms regularly, then open a problem, stare at a wall of code, and close the tab. The only time I really studied was the week before an interview, cramming everything back in and panicking.

I assumed it was just me. Then I started asking friends and coworkers, and almost all of them had the same story.

So I built TaroLens. The idea is simple: algorithms are easier to understand when you can watch them run. I wanted something I could open on the bus, spend five minutes with, and still remember afterwards.

What it does

TaroLens has three main parts.

Short daily lessons on CS fundamentals. They're small enough that doing one a day doesn't feel like homework.

Animated visualizations for every algorithm problem. You watch the pointers move, the heap rebalance, the DP table fill in cell by cell. Seeing it happen made things click for me in a way that reading code never did.

Spaced repetition with FSRS (Free Spaced Repetition Scheduler), the same scheduler Anki uses now. Each concept has a Difficulty $D$, Stability $S$, and Retrievability $R$, and memory decays along a power-law curve:

$$ R(t) = \left(1 + \frac{19}{81}\cdot\frac{t}{S}\right)^{-0.5} $$

$S$ is roughly how many days it takes for your chance of remembering to drop to 90%. TaroLens schedules the review around then, just before you'd forget. Each successful review makes $S$ bigger, and the reviews where you barely remembered count the most. After a handful of reviews, the gaps stretch out to months.

How we built it

I knew Android and wanted to finally learn iOS, so Kotlin Multiplatform with Compose Multiplatform was an easy pick. I got to stay in Kotlin and still ship to both platforms from one codebase.

My first version was fully offline, with every lesson and screen built into the app. That worked until I needed to fix a typo. Every small change meant code review, build, store review, release. For an app that's mostly content, that wasn't going to work.

So I added a backend and wrote a server-driven UI renderer for the visualizations. Lessons now live on the server as data, and the app renders them natively. I can add a lesson or fix something a user reported without shipping an update.

A lot of the remaining time went into animations. The whole app depends on them feeling smooth, so I kept adjusting timings and transitions until they stopped looking off to me.

Challenges we ran into

Backend was the big one. I'd barely touched it before this project, and connecting a real backend to the app took me a while to get right.

RevenueCat was new too. I'd never set up in-app subscriptions, and getting them working correctly on both Android and iOS took a few attempts.

And I only had about two months. I didn't want to ship something half-finished, so scope and deadline were constantly fighting each other.

I used AI tools a lot along the way, for brainstorming, design, and writing code. But plenty of it was still me sitting there debugging and redoing things by hand until they felt right.

Accomplishments that we're proud of

The biggest one is that I actually shipped it. I've wanted to put out my own app for years, and now it's live and I use it every day myself.

I'm also happy with the server-driven UI setup. Adding a new visualization is now mostly writing data rather than app code, so the app can keep growing without me rebuilding things.

And I wrote and deployed my own backend functions for the first time. It feels like a real step from mobile dev toward full-stack.

What we learned

Scoping matters more than I expected. With two months and a content-heavy app, I had to keep cutting and reprioritizing.
Plan for change early. If I'd built the server-driven pipeline from the start, I wouldn't have had to rewrite the offline version.
KMP can share both logic and UI between Android and iOS, and the app still feels native on each.
The basics of backend and payments: designing APIs, deploying functions, and setting up subscriptions with RevenueCat.

What's next for TaroLens: Visualize Algorithms

More lessons first. I want to keep adding algorithms, each with its own visualization.

I'll keep improving the existing lessons based on what users tell me.

And I want to get the word out, mostly through social media, so more developers can find it. If it makes interview prep a little less dreadful for someone, that's worth it.