TopoHooks: Gemma turns country names into sound-alike pictures for dyslexic kids

W. van Kuipers — Thu, 15 Oct 2026 17:28:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge: Side Hustle, in the Best Use of Gemma category.

What I built

My son is ten and dyslexic (as am I). Learning the countries and capitals of Europe means reading and remembering long strings of letters that mean nothing to him. What he does remember is silly pictures. In Dutch "Bulgarije" is bul + ga rijen: a graduation hat on top of a car. He does not have to remember the spelling, he has to remember the car with the hat.

TopoHooks is a small web app built around that trick:

Map. An interactive map of Europe. Tap a country and see its name, its capital and its picture hook.
Cards. The map shows a country, he thinks of the name, flips the card and sees the name, hears it read aloud, and sees the picture hook ("Bul → hat, ga rije → car"). A card he has never seen shows the answer straight away, because you cannot recall what you were never told.
Practise. A quiz with three answers where the wrong answers are the neighbouring countries, because those are the ones that get confused. What he gets wrong comes back more often; what he gets right comes back less often.
Made for dyslexia. Lexend or OpenDyslexic with one switch, short sentences, a listen button on every name, calm pictures instead of busy ones, and no timers.
Dutch and English. Dutch is the default, English is one click away. The sound-alikes are different in each language, so each language has its own set of hooks, its own prompts and its own review.

Who would pay for this

The first user is my son, and he is the reason it exists. Parents of children with dyslexia, remedial teachers and tutors already pay for printed flash cards, apps and lessons, and they all have the same problem: a generic deck does not contain this child's trick for remembering this word.

The thing worth paying for is not the Europe deck, it is the process that makes one: Gemma proposes sound-alike hooks for any list of names or words, finds calm, openly licensed pictures, and a parent or tutor only has to reject what is wrong. Topography is the first deck. Obvious next ones are other countries' topography, the periodic table, or a school's vocabulary list.

The license modal for the app would be per owner (tutor, remedial teacher or school) based on the number of children they want to hand out access to. This way the cost per child kan be kept low and the hassle of parents having to buy a license is eliminated.

Demo

At this time I didn't manage to set-up hosting for the application so it only runs at a local machine.

Code

https://github.com/wvankuipers/topo-hooks

How it works, and where Gemma fits

names (nl/en) ──► Gemma drafts sound-alike hooks, split into pieces
                  (each piece = one drawable object: "Bul" → bull)
              ──► Openverse search (CC0 / public domain / CC BY only)
              ──► Gemma looks at the pictures and rejects the bad ones
              ──► I review by exception ──► he picks his favorite per piece

1. Gemma drafts the hooks. Gemma gets one name and has to return structured JSON: the pieces of the name, what each piece sounds like, and one drawable object per piece. The output is checked in code, not trusted: the pieces must spell the name exactly, and the drawing must be one to three English words that are not on a blocklist. If Gemma gets it wrong, the script tells it what was wrong and asks again. Dutch and English have separate system prompts and examples.

2. Pictures come from search, not from an image generator. I first planned to generate the pictures. I chose to search Openverse instead, for three reasons: the pictures are real, human-made and openly licensed (CC0, public domain or CC BY, and every picture shows its credit and license), I do not have to worry about a generator producing something strange for a ten-year-old, and there is no GPU needed for generation. The cost is that some objects are hard to find as a clean drawing, which turned out to matter (see below).

3. Gemma checks the pictures. The vision model sees each candidate and returns what it sees, a list of problems (wrong object, text in the picture, a checkerboard, a real person, not suitable for children, too busy, not calm) and a score. This is a filter, not a guarantee, so:

4. A parent reviews by exception. The review page shows every idea with its pictures, Gemma's notes and each picture's licence. Everything is approved unless I reject it. An idea only goes live when every piece has at least one approved picture. Then he picks his favorite picture per piece, stored in his own browser.

What went wrong, and what I did about it

This is the part I learned the most from.

A small model describes a cow and says everything is fine. The 4B model accepted dogs and cows as "a bull". I made it write what it sees first, then ask a second, text-only question: does what it saw match what I wanted? That removed most of these.
"Transparent PNG" that is not. Some stock images are JPEGs with a grey checkerboard painted in. A title that promises transparency over a file without an alpha channel is rejected before Gemma sees it.
Cheap checks first. On a CPU, one picture takes 15 to 25 seconds to look at. So the pipeline goes cheapest first: skip titles about matches, maps and logos, then a text-only title check (about 3 seconds), then the picture itself, then the text-only cross-check (about 1.5 seconds).
The quiz leaked the answer. When only one of the three options had a picture, the picture gave away the right answer. Now pictures are only shown when all three options have one.
Rejected pictures were checked again on every run. They are now remembered, so a re-run only looks at new candidates.

Running Gemma: CPU, GPU and both

I wanted this to work without a GPU, because that is what I have (a 2017 Intel MacBook Pro) and because a tutor or parent will not have one either.

	Model	Measured
CPU only	`gemma3:4b` through Ollama	about 12 to 15 s to draft a name, 15 to 25 s to look at a picture; about 3 to 6 minutes per piece
Hybrid	`gemma3:4b` drafts on the laptop, `gemma3:12b` checks pictures on a GPU Droplet	TODO: fill in minutes per piece and total run time

The honest result of the CPU-only run: on a 4-core machine, 2 of 7 pieces (Bulgaria, Norway, Denmark) ended up with a picture. The 4B model is strict and noisy, and under strict licenses some objects ("garage", "bull") have few clean drawings. So I built the hybrid route: the laptop drafts (cheap), and the big Gemma on a DigitalOcean GPU Droplet only looks at pictures, reached through an SSH tunnel so nothing is exposed to the internet. After the run the Droplet is switched off. Only public Openverse pictures are sent to it; nothing about my son leaves the laptop.

TODO: after the Droplet run, add the real yield (pieces with at least one approved picture out of the total, per language) and one before/after picture of a hook that the 4B model could not find and the 12B model did.

Why open innovation matters here

Cost. The expensive part is looking at hundreds of pictures. With open weights I pay for a few hours of a Droplet, once per deck, and not per image to an API. That is what makes "a deck for every child" something a tutor could afford.
Privacy. The app has no accounts. His progress and his picture picks live in his own browser. Gemma runs on my laptop or on my own Droplet, never behind someone else's API.
Fit to a niche. The hard problem is Dutch sound-alikes ("garije" sounds like "garage"). I could shape the prompts, examples and checks for exactly that, and swap the model without changing anything else (--model, --vision-model).
Open all the way down. Open-weight Gemma, Ollama, and pictures that creators chose to share under open licenses. Every picture in the app links back to its creator.

First user

I gave the app running on my local machine to my son. Together we set the images that he liked, that was a lot of fun as the results where not always very correct. Then he started clicking around on the map and learning all the pictures together with the names. He also did a practice run with the images enabled and already found that he remembered the names better then before by looking ayt the images. He didn't spend to much time on the app so I can't tell if it will help him to improve his knowledge about the countries and capitals in the long run but the first results looked promising.

What is next

More decks: capital pictures, other regions, and a "bring your own list" mode for a tutor.
A way to add my own picture for a piece when search comes up empty.
Read the numbers: how many pictures a parent rejects after Gemma's check, per language.

Built with

Next.js, TypeScript and Tailwind, d3-geo for the map, Ollama with Gemma 3 (gemma3:4b, gemma3:12b), Openverse, sharp, vitest.

DEV Community: W. van Kuipers