A Thermodynamic Learning Algorithm from 1995 Still Works to learn Kanji Fast!

In 1995, I wrote a little program to teach myself Japanese kanji. It used Monte Carlo rejection sampling — a technique I'd borrowed from Numerical Recipes in C — to decide which flashcard to show me next. The algorithm was dead simple: each kanji had a probability value. Get it right, halve the probability. Get it wrong, double it. Pick the next kanji by rolling dice against those probabilities.

That weekend, I learned 700 kanji in 12 hours.

It was the closest I've ever come to the scene in The Matrix where Neo downloads kung fu. The program was always serving me exactly the right challenge at exactly the right moment. Six hours felt like one hour. That's flow state.

The original K2 Kanji, circa 1997. A torii gate with kanji painted on a parchment scroll, bamboo frame, and three buttons: Review, Wrong, Correct. The status bar reads "Group: Water, 1 Kanji - 50 Remaining in test." It even had a custom kanji font file (Kanjia.ttf) because good Unicode support simply didn't exist yet. You can still browse the original websites — the 1997 site and the 2001 site — preserved exactly as they were.

The program had a cult following. Fans of my game Starfleet Command found it and started emailing me: "erik. i'm stunned... i've wanted to learn for sooooo very long... this program of yours is surprisingly addictive." A USC engineering student wrote in offering to buy the full version sight unseen. A martial arts sensei passed it around his dojo.

But it was 1995 — no good fonts, desktop only, no way to test stroke order on a touch screen. I even lost the k2kanji.com domain to a spammer in China at one point (I found the old HTML placeholder page today: "K2 Kanji is temporarily unavailable while Erik Bethke tries to wrest control of k2kanji.com back from a spammer in China"). I moved on to other things. The code sat in a drawer for thirty years.

Fast Forward to Sunday Evening, March 15, 2026

I'd been meaning to resurrect K2 for a while. Last February, Claude and I had formalized the algorithm into a proper paper — proved it was equivalent to thermal annealing, connected it to Boltzmann distributions, showed why it maintains flow state. The math was beautiful. But the software was still thirty years old.

Tonight I decided to just... build it.

What Happened Next

Working with Claude Code over remote, I went from "let's do this" to a live product at k2kanji.com in a single evening session. Here's the rough timeline:

1. Read the paper — Claude pulled up the formalized K2 paper from my repo and understood the algorithm
2. Fetched 1,006 kanji — Hit KanjiAPI.dev for all Kyouiku kanji (grades 1-6), complete with meanings, readings, and stroke counts
3. Built the K2 engine — 353 lines of pure TypeScript. Rejection sampling, multiplicative p-value updates, automatic pool expansion
4. Built the UI — Mobile-first, Japanese aesthetic. Big beautiful kanji centered on washi paper. Three study modes: Meaning, Reading, Writing
5. My wife joined in — We started testing it together. She suggested starting levels so beginners aren't overwhelmed
6. Added starting levels — Beginner (0 known), Grade 1 (80), Grade 2 (240), Grade 3 (440)
7. Bought k2kanji.com — The domain was available again after all these years. Wired it up with SST v3, CloudFront, Route53, DynamoDB
8. Deployed — Live. Just like that
9. Kept going — Vocabulary mode (641 compound words that unlock as you master their components), 119 achievements, an accessible paper explaining the algorithm

Nine commits. 12,000+ lines. Every single one deployed to production.

The Algorithm in 30 Seconds

The K2 algorithm treats learning like cooling metal. Each kanji has a "temperature" (its selection probability). Hot items — the ones you're struggling with — demand your attention. Cold items — the ones you've mastered — fade into the background.

Correct answer: temperature halves. The item cools. Wrong answer: temperature doubles. The item heats back up.

The system naturally finds equilibrium. When everything in your pool has cooled enough, it injects new kanji — like a blacksmith reheating the forge. The original 1995 version called this "Marathon mode." The 2026 version just does it automatically.

No scheduling. No due dates. No guilt mechanics. Just the physics of learning.

You can read the full paper at k2kanji.com/paper.

What's Actually in There

1,006 Kyouiku Kanji — Every kanji taught in Japanese elementary school, grades 1 through 6. The original had 1,900 — we'll get there.

Three Study Modes — Meaning (see kanji, recall English), Reading (see kanji, recall pronunciation), Writing (see meaning, recall the kanji). Self-scored. Tap yes or no and move on. No friction. Same three modes the 1995 version had — some things don't need to change.

Vocabulary Mode — 641 compound words (熟語) that unlock automatically as you master their component kanji. Know 大 and 学? Here comes 大学 (university). The compounds emerge naturally from your growing knowledge. This is new — the original couldn't do this.

119 Achievements — Thematic groups like "Five Elements" (master 火水木金土), "Compass Rose" (master 東西南北), and "Samurai" (master 軍兵将戦争). Plus milestones, streaks, and hidden achievements. Each one has a Japanese subtitle.

Starting Levels — Already know some kanji? Start at Grade 1, 2, or 3. Those kanji enter your pool as "mastered" with very low probability — the rejection sampling will occasionally reach back to verify you still know the basics. About 1-2 per 100 trials. That's not a feature I coded explicitly. It's just the natural physics of the Boltzmann distribution.

Cloud Save — Your progress is stored in DynamoDB. Pick up where you left off on any device.

Why This Matters to Me

This isn't a story about AI replacing humans. It's the opposite.

I had the idea in 1995. I wrote the paper in 2026. I built the product the same year. At every step, the creative vision was mine. The algorithm is mine. The aesthetic choices, the flow state philosophy, the decision to make it free and beautiful — those are human decisions.

What Claude did was remove the friction between having an idea and holding it in your hands. The thirty-year gap between the algorithm and the product wasn't because the algorithm wasn't good enough. It was because building software used to be slow. Setting up infrastructure used to be slow. Wiring up domains and databases used to be slow.

Now it's not slow.

I sat on my couch on a Sunday evening, talked through what I wanted, and watched it materialize. My wife joined in and we played with it together, suggesting improvements in real time. Each suggestion was live on the internet within minutes.

That's what strong AI actually delivers. Not replacement. Amplification. The ability to move at the speed of your own creativity. To stay in flow state — which, fittingly, is exactly what the K2 algorithm is designed to maintain.

And hey — I finally got k2kanji.com back from that spammer.

Try It

k2kanji.com — free, no account needed, works on your phone. Enter your name and start learning.

And if you want to understand the math behind why it works, read the paper. Or for a trip down memory lane, browse the original websites: 1997 and 2001 — torii gates and all.

The forge is hot. Time to learn some kanji.