DEV Community: Thiago Longo Moraes

NEXO has a Multimedia mode: clinical cases built around an exam you have to read yourself. An ECG, a chest X-ray, a CT, a dermatoscopy image, a heart or lung sound. The exam arrives as one of the clues, and you name the diagnosis the same way as in any NEXO case, with ICD-10 proximity feedback on every guess.

This post is about why we put images and sounds inside the clues, and what that changes about practicing diagnosis.

Why does a diagnosis game need images and sounds?

In a text case, someone has already interpreted the exam for you. "The ECG shows ST elevation in the inferior leads" is a finding that was read by somebody else. At the bedside, you get the tracing.

A lot of the hard part of diagnosis lives in that step: looking at an image or listening to a sound and deciding what it shows. Text cases skip it. So in Multimedia, the clue is the exam itself, and the reading is your job.

Which exams are in Multimedia mode?

Imaging: X-ray, CT, MRI, ultrasound, PET/CT and mammography.
Tracings: ECG.
Scopes: upper endoscopy, colonoscopy, otoscopy, colposcopy and fundoscopy.
Skin and physical exam: dermatoscopy and physical exam images.
Lab and pathology: histopathology, blood smear and karyotype.
Sound: cardiac and respiratory auscultation.

A few examples from the mode's showcase:

Chest X-ray: pulmonary tuberculosis
Histopathology: colorectal adenocarcinoma
Physical exam: petechiae
Cardiac auscultation: aortic regurgitation

How does a Multimedia case play?

It works like every NEXO case. The case unfolds in up to 6 clues, and at least one of them carries the exam: an image you can look at, or an audio clip you can play. Captions follow the language you play in.

You search ICD-10 for the diagnosis you suspect and submit it. Every guess comes back with its distance from the answer: exact ICD, same category, same group, same chapter or different chapter. If you miss, the next clue opens.

That feedback matters more here than anywhere else. Suppose the tracing shows an arrhythmia and you named the wrong one. A "same group" result tells you that you read the rhythm in the right family and picked the wrong member. A "different chapter" result tells you that you misread the exam. Both are wrong, and they don't mean the same thing.

Is this an ECG quiz?

Not exactly. An ECG quiz usually shows a tracing and asks what it shows. A Multimedia case puts the tracing inside a clinical story: who the patient is, what brought them in, what the exam found. You read the ECG in context, and the answer is a diagnosis, not a pattern name.

The same goes for auscultation. A heart or lung auscultation quiz plays a sound and asks you to name it. In NEXO, the sound is one clue among others, and you still have to decide what disease explains the whole picture.

So if you are looking for ECG quiz practice, an auscultation quiz or radiology games for students, Multimedia is close to that, with one difference: the exam is part of the reasoning, not the whole question.

How do you unlock Multimedia?

Multimedia is unlocked by exam type, with synapses, the in-game currency you earn by solving cases. It works on any plan: Free, Pro or Max. You can start with the exam you most want to practice, say ECG or chest X-ray, and add others later.

Can I turn a Multimedia case into an Anki card?

Yes. The Anki button on the result screen creates a card straight from NEXO and opens it in the Anki app, and on image cases you can take the case image into the card: image on the front, diagnosis on the back.

Who is Multimedia for?

It's for medical students who want to practice reading exams in context, residents who look at tracings and images every day, and doctors who want to keep those skills sharp outside their own specialty. A cardiologist can meet a fundoscopy, and a student can hear a murmur they haven't met on the wards yet.

Like every case in NEXO, Multimedia cases are fictional cases with real clinical presentation, written for teaching.

FAQ

What is NEXO's Multimedia mode?
A mode of clinical cases built around an exam: imaging, ECG, scopes, dermatoscopy, histopathology, blood smear, karyotype, physical exam, and cardiac and respiratory auscultation. The exam is one of up to 6 clues, and every guess gets ICD-10 proximity feedback.

Is there a game to practice reading ECGs, X-rays and heart sounds through clinical cases?
Yes. NEXO's Multimedia mode puts ECGs, X-rays, other imaging and auscultation audio inside clinical cases. You read the exam in context and name the diagnosis.

Is Multimedia free?
It is unlocked by exam type with synapses, which you earn by solving cases, on any plan. The Daily case is free on every plan.

Can I make Anki cards from Multimedia cases?
Yes. The Anki button creates the card from the case and opens it in the Anki app, with the case image on image cases.

Are there tropical medicine clinical cases?
That's a different mode. Continents organizes cases by regional epidemiology across Africa, the Americas, Asia, Europe and Oceania, with diseases that are endemic or prevalent in each region.

Where can I play?
On the web at nexo.wiki.br and on iPhone ("NEXO: Medical Diagnosis" on the App Store).

NEXO is a daily medical diagnosis game for clinical reasoning, with a Multimedia mode where ECGs, imaging and auscultation are part of the clues. Play at nexo.wiki.br or get it on the App Store.

All cases are fictional cases with real clinical presentation, written for teaching. NEXO is an educational game and is not medical advice.

NEXO and Anki: turn a clinical case into an Anki card, right after you play

Thiago Longo Moraes — Thu, 08 Oct 2026 15:24:31 +0000

NEXO integrates with Anki. After every case, the Anki button on the result screen creates a card straight from NEXO and opens it in the Anki app, ready to save. It can also find the cards you already have on that diagnosis, and on image cases you can take the case image into your card.

NEXO is not a flashcard app. It has no decks and no spaced repetition of its own. The Anki button connects the case you just played to the Anki you already use.

Why does a medical diagnosis game need Anki?

A lot of medical students run their study life in Anki: medical Anki decks, a deck from medical school, cards written the night before an exam. The review system already exists, and it works.

What a clinical case adds is context. You meet a diagnosis as a story: a presentation, a history, an exam finding, a test result. When you miss it, or get it only at the last clue, that's exactly the moment you want to keep it.

The problem is the gap between the two. You finish a case, think "I should make a card for this", and by the time you open Anki the thought is gone. The Anki button closes that gap in one tap.

What does the Anki button do?

Create a card in Anki. NEXO builds the card from the case, with the diagnosis and the key points from the clinical explanation, and opens it directly in the Anki app. You review it and save it to your deck.

Find my Anki cards. It searches your Anki for the cards you already have on that diagnosis, in the language you play in, so you can review them right away instead of next month.

Image cases. On Multimedia cases (an X-ray, an ECG, a skin lesion, a fundoscopy) you can take the case image into the card: image on the front, diagnosis on the back, a recognition card built from the case you just played.

What NEXO is not

NEXO doesn't have its own flashcards, decks or spaced repetition, and it doesn't schedule reviews. Your cards and your review schedule live in Anki. NEXO is for practicing diagnostic reasoning on fictional cases with real clinical presentation, with ICD-10 proximity feedback on every guess, and the Anki button makes the two work together.

Who is it for?

Medical students in the clinical years who review with Anki between rotations, residents who keep a personal deck, and anyone who has looked for clinical cases for their Anki deck and found only static question lists. If you study with Anki in Portuguese or Spanish ("anki medicina" decks are everywhere), play NEXO in that language and your cards come out in the same language as your deck.

FAQ

Does NEXO integrate with Anki?
Yes. After each case, the Anki button creates a card from the case and opens it directly in the Anki app. It also finds your existing cards on that diagnosis, and on image cases it takes the case image into the card.

Does NEXO have its own flashcards or spaced repetition?
No. NEXO works alongside Anki: your cards and your review schedule stay in Anki.

Is there a clinical case game that works with Anki?
NEXO is a daily medical diagnosis game that works with Anki. You play a case with up to 6 clues, get ICD-10 proximity feedback on each guess, and then send that diagnosis to Anki as a card.

Does it work with Anki decks in other languages?
Yes. Cards and searches follow the language you play NEXO in: Portuguese, English, Spanish, French, German or Russian.

Where can I play?
On the web at nexo.wiki.br and on iPhone ("NEXO: Medical Diagnosis" on the App Store).

NEXO is a daily medical diagnosis game for clinical reasoning that works with Anki: up to 6 clues, ICD-10 feedback, and an Anki button that turns each case into a card. Play at nexo.wiki.br or get it on the App Store.

All cases are fictional cases with real clinical presentation, written for teaching. NEXO is an educational game and is not medical advice.

Adrenaline: the timed mode in NEXO, a medical diagnosis game where you choose the dose before the clock starts

Thiago Longo Moraes — Thu, 08 Oct 2026 15:24:09 +0000

NEXO has a timed mode called Adrenaline: one clinical case a day against the clock, with a dose you choose before you start. The higher the dose, the less time you get and the bigger the reward. It sits next to the Daily case, which has no clock at all.

This post is about why a diagnosis game built around taking your time also has a mode that takes time away, and how the two fit together.

Why does a daily medical diagnosis game need a timed mode?

The Daily case is deliberately slow. You read a clue, form a hypothesis, decide whether you know enough to commit, and you can take as long as you need. That's the part of diagnosis we wanted to train first: reasoning with incomplete information.

But a lot of clinical reasoning doesn't happen at that pace. On a shift, the first impression of a case is often formed in a minute or two, and it shapes everything after it. We wanted a place to practice that too, without turning the Daily case into a race.

So the clock lives in its own mode. The Daily case stays the way it was, with no timer. Adrenaline is the opt-in version: the same kind of case, the same up to 6 clues, the same ICD-10 proximity feedback, and a clock that keeps running while you think.

How does Adrenaline work?

There is one Adrenaline case per day, and it is the same case for every player that day. Before the clock starts, you pick a dose:

Low dose: 5 minutes, 1.2x reward. The case area and the ICD range still show up as hints.
Medium dose: 3 minutes, 1.5x reward. The case area shows up, the ICD range does not.
High dose: 1 minute, 2x reward. No hints.

In the Daily case, the area of the case appears at clue 3 and the ICD range at clue 5. In Adrenaline, the dose decides which of those hints you get. A higher dose takes away time and help at the same time, and pays more for it.

You choose the dose by dragging the plunger of a syringe on the screen. Once you start, the dose is locked.

From there it plays like any NEXO case. You search ICD-10 for the diagnosis you suspect and submit it. If you miss, the next clue opens. Every guess gets the same 5-level feedback: exact ICD, same category, same group, same chapter or different chapter. The difference is that the clock is running while you read, search and decide.

What happens when the time runs out?

When the clock reaches zero, you get one chance to add 30 seconds to that case. On the Max plan it's free. On other plans it costs synapses, the in-game currency. If you don't take it, or the extra time runs out too, the case ends without points.

When you solve it, the dose multiplies the reward for that case: points, synapses and XP. The result screen also tells you how you did against the players who picked the same dose that day.

A few details matter in practice:

You can pause. If you leave the case, the clock stops. You can come back and continue any time before midnight, Brasília time.
The connection doesn't eat your time. If the connection drops, the clock stops instead of running in the background.
A new day closes the case. After midnight, Brasília time, an unfinished Adrenaline case no longer counts and a new one is available.

Isn't the point of NEXO that it's not a quiz with a timer?

That's still true for the Daily case. It has no clock, and it's built for the pace of careful reasoning: incomplete information, a working hypothesis, and the decision of when to commit.

Adrenaline is a separate mode for a different skill. It doesn't replace the Daily case, and the Daily case doesn't become timed. You can play both on the same day, or ignore Adrenaline entirely.

What the clock adds is pressure on the decision itself. With a high dose, you don't have time to reveal every clue and search every candidate. You have to recognize the pattern, pick the most likely diagnosis and live with the ICD-10 feedback. A near miss under the clock still tells you your reasoning was on track. A distant miss tells you that your first impression went somewhere else.

Who is a timed diagnosis game for?

It's for anyone who already plays the Daily case and wants a second, faster case on the same day. Medical students who want to practice first impressions before ward work, residents who already think under time pressure on shift, and doctors who just like the challenge.

If you are new to NEXO, the Daily case is the better place to start. Adrenaline makes more sense once the clue format and the ICD-10 search feel familiar, and a low dose is the gentle way in.

Like every case in NEXO, Adrenaline cases are fictional cases with real clinical presentation, written for teaching.

FAQ

Does NEXO have a timed mode?
Yes. NEXO has a timed mode called Adrenaline: one case a day against the clock. Before you start, you choose a dose. Low dose gives you 5 minutes, medium 3 minutes and high 1 minute, and a higher dose means a bigger reward.

What is the Adrenaline dose?
The dose sets the time limit, the hints you get and the reward multiplier: 1.2x on low, 1.5x on medium and 2x on high. It's chosen before the clock starts and can't be changed after that.

Is the Daily case timed?
No. The Daily case has no clock. You read the clues and commit when you think you know enough. Only Adrenaline runs against the clock.

Can I get more time?
Once per case, when the time runs out, you can add 30 seconds. It's free on Max and costs synapses on other plans.

Is Adrenaline a USMLE game?
No. NEXO is not a USMLE or PLAB simulator. Adrenaline is timed practice of diagnostic reasoning: you name the diagnosis from clinical clues and get feedback on how close your guess was in ICD-10.

Where can I play?
On the web at nexo.wiki.br and on iPhone ("NEXO: Medical Diagnosis" on the App Store).

NEXO is a daily medical diagnosis game for clinical reasoning: the Daily case with no clock, Adrenaline against the clock, up to 6 clues and ICD-10 feedback. Play at nexo.wiki.br or get it on the App Store.

All cases are fictional cases with real clinical presentation, written for teaching. NEXO is an educational game and is not medical advice.

Clinical reasoning in six languages: taking a guess-the-diagnosis game to medical students around the world

Thiago Longo Moraes — Wed, 07 Oct 2026 19:17:48 +0000

NEXO is a clinical reasoning game for doctors and medical students: you guess the diagnosis of one new fictional case a day, from up to 6 clues, and get a score based on how close you were. You can play it in six languages, and this post is about why and what that changed about the cases themselves.

Why does a clinical reasoning game need more than one language?

Clinical reasoning is universal. Fever, cough and a consolidation on the chest X-ray make the same puzzle in São Paulo, Madrid, Lyon, Munich, Moscow or Chicago. But the way doctors learn to name things is local. Students study in their own language, sit their exams in it, and talk to patients in it.

A game that asks you to reason in a second language measures your vocabulary as much as your thinking. We wanted NEXO to measure the thinking. So the goal was never "add subtitles." It was to let a student in each country play in the language they actually practice medicine in.

Which languages can you play NEXO in?

NEXO is available in Portuguese, English, Spanish, French, German and Russian. The daily case is the same for everyone, so a student in Brazil and a resident in Germany are working on the same case on the same day and can compare how many clues they needed.

One principle guided the translations:

Diagnosis names follow the official ICD-10 version for each language. That means WHO ICD-10 in English, DATASUS CID-10 in Brazilian Portuguese, CIE-10-ES in Spanish, CIM-10 in French, ICD-10-GM in German and МКБ-10 in Russian. When you search for your guess, you see the names doctors in your country actually learned.

And we keep listening: the site lets players vote for the next language they'd like to see.

How does a guess-the-diagnosis game handle diseases that are common somewhere else?

As NEXO reached more countries, we kept asking ourselves one question: common where?

A "classic" case in one country is a rarity in another, and what you see depends a lot on where you train. A diagnosis game that only reflects one country's epidemiology quietly teaches that the rest of the world is exotic.

So we added Play by Continent, a mode with 103 cases organized by regional epidemiology across Africa, the Americas, Asia, Europe and Oceania. Each region brings conditions that are endemic or prevalent there. A few examples from the mode's showcase:

Africa: Hansen disease
Americas: histoplasmosis
Asia: talaromycosis
Europe: tularemia
Oceania: crusted scabies

For a student, it's a way to travel through medicine: to meet the diseases a colleague on another continent sees often, and to practice recognizing them before one shows up in your own clinic. With travel and migration, someone else's disease can become a diagnosis you have to make.

How do medical students around the world play the same case?

The daily case works like a shared ritual. Everyone gets the same case, the clues arrive one at a time, and you decide when you know enough to commit.

Every guess is placed in the ICD-10 hierarchy, so a guess in the same category as the answer gets different feedback from one in a different chapter. A near miss tells you your reasoning was on track. A distant miss tells you to rethink the problem.

Afterwards, a global leaderboard and daily streaks give people a reason to come back tomorrow. If you've played Wordle, the shape will feel familiar.

What the game trains is pattern recognition, differential diagnosis and classification awareness, one case at a time. It runs on the web and on iPhone, so it also works as a clinical reasoning app for medical students who want diagnosis practice between classes, ward work and question-bank sessions.

The library has 649 cases across the daily case, Play by Continent and a Multimedia mode with clinical imaging and auscultation, so one day's case can come from cardiology and the next from dermatology. All of them are fictional cases with real clinical presentations, written for teaching.

FAQ

Is there a guess the diagnosis game in languages other than English?
Yes. NEXO is available in Portuguese, English, Spanish, French, German and Russian, with the same daily case for every player. If you're looking for a daily diagnosis game in Portuguese or Spanish, it's the same game, with diagnosis names from the official ICD-10 version for that language.

How do you guess the diagnosis in NEXO?
Read the first clue, search ICD-10 for the diagnosis you suspect and submit it. If you're not sure yet, reveal the next clue, up to 6. Each guess comes back with its distance from the answer, from exact ICD to different chapter.

What makes NEXO a clinical reasoning game and not a quiz?
You commit to a diagnosis with incomplete information, and every guess gets feedback on its distance from the answer in ICD-10: exact ICD, same category, same group, same chapter or different chapter. A near miss and a distant miss mean different things.

What is Play by Continent?
A mode with 103 cases organized by regional epidemiology across Africa, the Americas, Asia, Europe and Oceania. It is unlocked with sinapses, the in-game currency you earn in the daily case.

Where do the diagnosis names come from?
From the official ICD-10 version for each language, such as ICD-10-GM in German or CIE-10-ES in Spanish.

How do I start?
Read how it works, try a demo case, or see how NEXO compares with other ways to study. Everything starts at nexo.wiki.br.

NEXO is a clinical reasoning game: guess the diagnosis from up to 6 clues, with ICD-10 feedback, in 6 languages. Play on the web at nexo.wiki.br or get it on the App Store.

All cases are fictional cases with real clinical presentations, written for teaching. NEXO is an educational game and is not medical advice.

Why we built NEXO, a daily medical diagnosis game that works like a Wordle for doctors

Thiago Longo Moraes — Wed, 07 Oct 2026 19:17:03 +0000

NEXO is a daily medical diagnosis game for doctors and medical students. Every day there is one new clinical case, told in up to 6 clues, and you try to name the diagnosis using as few clues as you can. The shortest way to describe it is a Wordle for doctors.

This post is about why it exists and what we tried to do differently from a quiz.

What is a Wordle for doctors?

Wordle worked because it was small. One puzzle a day, the same for everyone, a few minutes long, and then you're done until tomorrow. Nobody needed a study plan to play it.

NEXO keeps that shape and changes the content: it's a daily diagnosis puzzle instead of a word puzzle. Instead of letters, you get clinical information: a presentation, a history, an exam finding, a test result. The first clue is visible, and you reveal the next ones only if you need them. Fewer clues, more points.

The case is the same for every player that day, so you can compare your result with friends and colleagues.

The point isn't a quiz with a timer. It's a small version of what diagnosis feels like: incomplete information, a working hypothesis, and the decision of when you know enough to commit.

What makes a medical Wordle different from a word game?

In a word game, a letter is either in the right place or not. A diagnosis has more structure than that, and NEXO is built around one idea: missing by a little is not the same as missing by a lot.

Most question banks score you as right or wrong. At the bedside, those two words hide very different situations. If the answer is appendicitis and you said cholecystitis, you were reasoning in the right place and landed on a neighbor. If you said heart attack, you were somewhere else entirely. Both are wrong. They don't mean the same thing.

So in NEXO you submit each guess by searching ICD-10, the international classification of diseases, and the guess is scored by its distance from the answer in the ICD-10 tree. The feedback has 5 levels: exact ICD, same category, same group, same chapter, or different chapter. That ICD-10 proximity feedback is the core of the game.

If the answer is an acute myocardial infarction (I21) and your guess comes back as "same chapter", you know you were thinking about the circulatory system. You missed, but not at random.

We treat a wrong guess as information, not failure. A near miss tells you your reasoning was on track. A distant miss tells you to step back and rethink the problem. Both are more useful than a red X.

How does a daily medical diagnosis game fit into a busy week?

Clinical reasoning is a skill, and skills improve with repetition and feedback. For most students and residents the hard part isn't motivation. It's time. Long study sessions compete with shifts, exams and sleep.

One daily case fits in the gaps: the five minutes between two consultations, or the train ride before a shift. You read, you think, you commit, you get feedback. Then you come back tomorrow.

Over a few weeks, that turns into a five-minute clinical reasoning habit: practice that fits between ward work, classes or question-bank sessions, instead of an occasional cram session.

That rhythm is deliberate. Streaks, achievements and a global leaderboard turn it into a habit rather than a chore.

The daily case is also free, forever. We don't see that as a pricing tier. It's a position we hold: the daily practice of clinical reasoning shouldn't live behind a paywall.

What NEXO is not

NEXO is not a USMLE or PLAB simulator, a flashcard app, an AI tutor or a clinical reference. Those tools treat medical knowledge as content to study. NEXO treats diagnostic reasoning as something you practice.

It isn't an ICD-10 coding trainer either. ICD-10 enters as the ruler: you search it to submit a guess, and it measures how far that guess landed from the answer.

It works alongside whatever you already use. If you want to see where it sits next to AMBOSS and Prognosis, there's a comparison page.

Who is a daily medical diagnosis game for?

It's a medical diagnosis game for doctors and students alike: medical students, residents, new doctors, practicing physicians and specialists. Anyone who enjoys the challenge of diagnosis.

If you're looking for a daily diagnosis game for medical students, the format stays approachable: you can try a diagnosis after the first clue or keep exploring as the case unfolds, and faster, sharper reasoning earns more points.

Beyond the daily case, there is a Continents mode organized by regional epidemiology and a Multimedia mode with clinical imaging and auscultation. Together that's 649 cases, available in 6 languages. A cardiologist can meet a dermatology case, and a student can meet a presentation they haven't seen on the wards yet.

All of them are fictional cases with real clinical presentations, written for teaching. None of them describes an identifiable person.

FAQ

What's a good Wordle-like game for doctors?
There are a few. Doctordle is a diagnosis guessing game built on daily clinical scenarios. NEXO is a daily medical diagnosis game with up to 6 clues per case, where every guess gets ICD-10 feedback on how close it was, from exact ICD to different chapter.

What is the best medical Wordle?
It depends on what you want to practice. If the goal is diagnosis rather than vocabulary, look for a game where a wrong answer still tells you something. In NEXO, every guess is placed in the ICD-10 hierarchy, so a near miss and a distant miss get different feedback.

Are there games like Doctordle?
Yes. If you want a Doctordle alternative with ICD-10 feedback, NEXO is one option: one fictional case a day, up to 6 clues, and ICD-10 proximity feedback on every guess. NEXO also has archived cases.

How does scoring work in this medical Wordle?
Each guess is placed in the ICD-10 hierarchy: exact ICD, same category, same group, same chapter or different chapter. The fewer clues you use, the more points you get.

Is this medical diagnosis game free?
Yes, the daily case is free, forever. The Continents and Multimedia modes are unlocked with sinapses, the in-game currency you earn in the daily case, on any plan. Pro and Max add more cases beyond the daily one.

How long does a case take?
About 5 minutes, which is why it works as a daily habit.

Where can I play?
On the web at nexo.wiki.br, and as a medical diagnosis game app for iPhone ("NEXO: Medical Diagnosis" on the App Store). You can read how it works or try a demo case first.

NEXO is a daily medical diagnosis game for clinical reasoning: one case a day, up to 6 clues, ICD-10 feedback, 6 languages. Play at nexo.wiki.br or get it on the App Store.

All cases are fictional cases with real clinical presentations, written for teaching. NEXO is an educational game and is not medical advice.

i18n in Expo (React Native) and Next.js with one shared dictionary and a fallback language

Thiago Longo Moraes — Fri, 25 Sep 2026 02:38:12 +0000

When you ship the same product on mobile and on the web, translations tend to drift apart: a label gets fixed in the app and stays wrong on the site. The simplest cure is one dictionary, shared by both, with one clear rule for what happens when a key is missing.

This is the setup I'd recommend after working on NEXO, a daily medical diagnosis game for clinical reasoning practice, which runs in six languages on an Expo app and a Next.js site. The code below is a generic example with a tiny dictionary, not NEXO's actual files. It uses no i18n library, just TypeScript. Libraries like i18next are great too, and the concepts are the same.

How should I structure translation files for React Native and Next.js?

Keep them in a folder both apps can import (a workspace package, or a shared folder with a path alias):

// shared/i18n/messages.ts
export const LOCALES = ['en', 'es', 'fr', 'de', 'pt', 'ru'] as const;
export type Locale = (typeof LOCALES)[number];
export const FALLBACK: Locale = 'en';

export function isLocale(value: string | null | undefined): value is Locale {
  return !!value && (LOCALES as readonly string[]).includes(value);
}

type Dict = Record<string, string>;

export const messages: Record<Locale, Dict> = {
  en: { 'home.title': 'Today', 'home.greeting': 'Hi, {name}!', 'streak.one': '{count} day', 'streak.other': '{count} days' },
  es: { 'home.title': 'Hoy', 'home.greeting': '¡Hola, {name}!' },
  fr: { 'home.title': "Aujourd'hui", 'home.greeting': '' },
  de: {},
  pt: { 'home.title': 'Hoje' },
  ru: { 'home.title': 'Сегодня', 'streak.one': '{count} день', 'streak.few': '{count} дня', 'streak.many': '{count} дней', 'streak.other': '{count} дня' },
};

Flat keys ('home.title') are easy to grep, easy to diff, and easy to check for missing entries in CI. Notice the empty French greeting. Half-finished files look like that all the time, and your fallback should handle it.

What should happen when a translation is missing?

Decide it once, in one function. A sensible chain is: current language, then the fallback language, then the key itself. An empty string counts as missing, so a blank entry never renders as a blank button:

// shared/i18n/t.ts
import { messages, FALLBACK, type Locale } from './messages';

export function lookup(locale: Locale, key: string): string | undefined {
  const value = messages[locale][key];
  return value ? value : undefined; // '' counts as missing
}

export function translate(
  locale: Locale,
  key: string,
  params?: Record<string, string | number>,
): string {
  const template = lookup(locale, key) ?? lookup(FALLBACK, key) ?? key;
  return template.replace(/\{(\w+)\}/g, (_, k) =>
    params && k in params ? String(params[k]) : `{${k}}`,
  );
}

translate('fr', 'home.greeting', { name: 'Ana' }); // "Hi, Ana!" (French entry is empty)
translate('es', 'home.subtitle');                  // "home.subtitle" (missing everywhere)

Returning the raw key is deliberate. In development, home.subtitle on screen tells you exactly what's missing. In code, you can detect it (result === key) and choose a different fallback for a specific case.

A tip from experience: long content (articles, product descriptions, help pages) often deserves a different rule from interface labels. A missing button label in English is fine. A paragraph that switches language halfway through is not. Whatever you choose there, make it an explicit decision rather than a side effect of the UI fallback.

How do I handle plurals across languages?

English has two plural forms. Russian has more, and the choice depends on the number's last digits: 1 день, 2 дня, 5 дней, 21 день. Intl.PluralRules knows the rules for each locale:

import { lookup, translate } from './t';

export function plural(locale: Locale, baseKey: string, count: number) {
  const category = new Intl.PluralRules(locale).select(count); // 'one' | 'few' | 'many' | 'other' ...
  const key = `${baseKey}.${category}`;
  const hasKey = lookup(locale, key) ?? lookup(FALLBACK, key);
  return translate(locale, hasKey ? key : `${baseKey}.other`, { count });
}

plural('ru', 'streak', 3);  // "3 дня"
plural('ru', 'streak', 21); // "21 день"
plural('en', 'streak', 3);  // "3 days"

Always define .other in every language that has plurals. It's the category Intl.PluralRules returns for fractions in Russian, and it's the safety net when a category is missing.

Intl.PluralRules is available in modern browsers and Node. On React Native, check what your JavaScript engine supports; if it's missing, add a polyfill such as @formatjs/intl-pluralrules with the locale data you need.

Use Intl.DateTimeFormat(locale) and Intl.NumberFormat(locale) for dates and numbers too, instead of formatting them by hand.

How do I detect the device language in Expo?

expo-localization gives you the user's preferred locales in order:

// app/i18n/LanguageProvider.tsx
import { getLocales } from 'expo-localization';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { createContext, useContext, useEffect, useRef, useState } from 'react';
import { FALLBACK, isLocale, type Locale } from '@/shared/i18n/messages';
import { translate } from '@/shared/i18n/t';

const KEY = 'app.language';

function deviceLocale(): Locale {
  for (const l of getLocales()) {
    if (isLocale(l.languageCode)) return l.languageCode;
  }
  return FALLBACK;
}

type I18n = {
  locale: Locale;
  setLocale: (l: Locale) => void;
  t: (key: string, params?: Record<string, string | number>) => string;
};

const Ctx = createContext<I18n | null>(null);

export function LanguageProvider({ children }: { children: React.ReactNode }) {
  const [locale, setLocaleState] = useState<Locale>(deviceLocale);
  const userChose = useRef(false);

  useEffect(() => {
    AsyncStorage.getItem(KEY).then((saved) => {
      if (!userChose.current && isLocale(saved)) setLocaleState(saved);
    });
  }, []);

  const setLocale = (l: Locale) => {
    userChose.current = true; // an explicit choice beats anything loaded later
    setLocaleState(l);
    AsyncStorage.setItem(KEY, l);
  };

  const t = (key: string, params?: Record<string, string | number>) => translate(locale, key, params);

  return <Ctx.Provider value={{ locale, setLocale, t }}>{children}</Ctx.Provider>;
}

export const useI18n = () => {
  const ctx = useContext(Ctx);
  if (!ctx) throw new Error('useI18n must be used inside LanguageProvider');
  return ctx;
};

The userChose ref covers a subtle case: if saved settings (or a user profile from your backend) load after the user has picked a language, they shouldn't overwrite that choice.

How do I set up locale routes in the Next.js App Router?

Put the locale in the URL. It's shareable, cacheable and good for SEO:

app/
  [lang]/
    layout.tsx
    page.tsx
middleware.ts

Redirect bare paths to a locale based on the Accept-Language header:

// middleware.ts (Next.js 16 renames this file to proxy.ts and the export to `proxy`)
import { NextResponse, type NextRequest } from 'next/server';
import { LOCALES, FALLBACK, isLocale } from '@/shared/i18n/messages';

export function middleware(request: NextRequest) {
  const { pathname } = request.nextUrl;
  if (LOCALES.some((l) => pathname === `/${l}` || pathname.startsWith(`/${l}/`))) return;

  const header = request.headers.get('accept-language') ?? '';
  const preferred = header.split(',').map((p) => p.split(';')[0].trim().toLowerCase().slice(0, 2));
  const locale = preferred.find(isLocale) ?? FALLBACK;

  request.nextUrl.pathname = `/${locale}${pathname}`;
  return NextResponse.redirect(request.nextUrl);
}

export const config = { matcher: ['/((?!api|_next|.*\\..*).*)'] };

Browsers send their languages in order of preference, so taking the first supported one works for almost all traffic. If you need full q-value handling, the negotiator package parses the header properly.

Set <html lang>, reject unknown locales, and tell search engines about every version of the page:

// app/[lang]/layout.tsx
import type { Metadata } from 'next';
import { notFound } from 'next/navigation';
import { LOCALES, FALLBACK, isLocale } from '@/shared/i18n/messages';
import { translate } from '@/shared/i18n/t';

export function generateStaticParams() {
  return LOCALES.map((lang) => ({ lang }));
}

export async function generateMetadata(
  { params }: { params: Promise<{ lang: string }> },
): Promise<Metadata> {
  const { lang } = await params;
  const locale = isLocale(lang) ? lang : FALLBACK;
  return {
    metadataBase: new URL('https://example.com'),
    title: translate(locale, 'home.title'),
    alternates: {
      canonical: `/${locale}`,
      languages: {
        ...Object.fromEntries(LOCALES.map((l) => [l, `/${l}`])),
        'x-default': `/${FALLBACK}`,
      },
    },
  };
}

export default async function Layout(
  { children, params }: { children: React.ReactNode; params: Promise<{ lang: string }> },
) {
  const { lang } = await params;
  if (!isLocale(lang)) notFound();
  return (
    <html lang={lang}>
      <body>{children}</body>
    </html>
  );
}

In Next.js 15 and later params is a promise, so it's awaited. Typing it as string and narrowing with isLocale keeps TypeScript honest, because the URL can contain anything. The alternates.languages map becomes hreflang links (with metadataBase making them absolute), which help search engines show the right language to the right user.

How do I keep six languages in sync?

A fallback hides gaps, which is good for users and bad for noticing them. Add a CI check that lists keys present in the fallback language but missing or empty elsewhere. It compares base keys, because Russian legitimately has .few and .many entries that English doesn't:

// scripts/check-messages.ts (run with: npx tsx scripts/check-messages.ts)
import { messages, LOCALES, FALLBACK } from '../shared/i18n/messages';

const PLURAL = /\.(zero|one|two|few|many|other)$/;
const base = (key: string) => key.replace(PLURAL, '');
const required = new Set(Object.keys(messages[FALLBACK]).map(base));
let failed = false;

for (const locale of LOCALES) {
  if (locale === FALLBACK) continue;
  const have = new Set(
    Object.entries(messages[locale]).filter(([, v]) => v !== '').map(([k]) => base(k)),
  );
  const missing = [...required].filter((k) => !have.has(k));
  if (missing.length) {
    failed = true;
    console.error(`${locale}: ${missing.join(', ')}`);
  }
}
process.exit(failed ? 1 : 0);

With the example dictionary, it fails and prints lines like fr: home.greeting, streak and de: home.title, home.greeting, streak.

Two more habits help. First, have specialized text reviewed by a native speaker who knows the field; machine translation is a first draft at best, and for a medical product like NEXO one wrong term can change the meaning. Second, use one locale format everywhere (en or en-US) and convert only at the edges.

What I'd keep from this

One shared dictionary for the app and the site, imported by both.
One definition of "missing" (absent or empty), applied in one function, so the two platforms can never disagree about it.
Intl.PluralRules instead of hand-written plural logic, with .other always defined.
The language in the URL on the web, and the device language (overridable by the user) in the app.
A CI check, so gaps show up in a pull request instead of in front of a user.

FAQ

Do I need an i18n library?
Not for small or medium apps. A typed dictionary and a translate() function go a long way. Reach for a library when you need ICU message syntax or translation-platform integrations.

Should the fallback be English?
Usually, for interface text. Choose whatever language most of your users can read.

Can the Expo app and the Next.js site share the same files?
Yes. Plain TypeScript objects work in both, and sharing them is what keeps the two apps from drifting.

I'm building NEXO, a daily medical diagnosis game for clinical reasoning practice, where a wrong guess is scored by its proximity in the ICD-10 hierarchy, available in six languages. See how it works, or play in Spanish or German. On iPhone: App Store.

Every case in NEXO is fictional and written for teaching. NEXO is not medical advice.

Fuzzy search in Postgres with pg_trgm and Supabase (multilingual, typo-tolerant)

Thiago Longo Moraes — Fri, 25 Sep 2026 02:35:02 +0000

Users type "cafe" for "Café", "munchen" for "München", or miss a letter. You don't need a separate search engine for that. Postgres ships pg_trgm for fuzzy matching and unaccent for accent-insensitive comparison, and both are available on Supabase.

NEXO is a daily medical diagnosis game for clinical reasoning practice, built on Supabase in six languages, so tolerant search matters to me. This tutorial uses an invented places table; every snippet was run on PostgreSQL 17.

How do I enable pg_trgm and unaccent on Supabase?

In the Supabase dashboard, go to Database → Extensions and enable pg_trgm and unaccent, or run this in the SQL editor:

create extension if not exists pg_trgm  with schema extensions;
create extension if not exists unaccent with schema extensions;

Supabase's default search_path includes extensions; inside functions, set it explicitly or schema-qualify.

What is pg_trgm and how does it match typos?

pg_trgm splits text into trigrams (three-character groups, with words padded by spaces) and compares how many two strings share:

select show_trgm('londn');
-- {"  l"," lo","dn ",lon,ndn,ond}

It provides scoring functions, threshold operators, and GIN/GiST operator classes so they (and LIKE '%...%') can use an index.

What example table does this tutorial use?

create table public.places (
  id    bigint generated always as identity primary key,
  lang  text not null check (lang in ('en', 'es', 'fr', 'de', 'pt', 'ru')),
  name  text not null
);

insert into public.places (lang, name) values
  ('en', 'London'), ('en', 'Londonderry'), ('en', 'New London'),
  ('en', 'Babylon'), ('fr', 'Café de Flore'), ('de', 'München'),
  ('ru', 'Москва');

How do I make Postgres search accent-insensitive?

unaccent() is STABLE, not IMMUTABLE, because the dictionary it uses depends on search_path. Indexes and generated columns need immutable functions, so wrap it and pin the dictionary with the schema-qualified two-argument form:

create or replace function public.immutable_unaccent(text)
returns text
language sql
immutable
parallel safe
strict
as $$
  select extensions.unaccent('extensions.unaccent'::regdictionary, $1)
$$;

(If you installed the extension into public, use public.unaccent('public.unaccent', $1).) Now add a normalized column:

alter table public.places
  add column name_norm text
  generated always as (lower(public.immutable_unaccent(name))) stored;

lower() follows the database's LC_CTYPE, so with a UTF-8 locale "МОСКВА" and "москва" normalize to the same value.

Which index should I use for pg_trgm, GIN or GiST?

create index places_name_norm_trgm
  on public.places
  using gin (name_norm extensions.gin_trgm_ops);

GIN accelerates %, <%, LIKE and ILIKE, but not ORDER BY ... <->; index-assisted nearest-neighbour ordering needs GiST (gist_trgm_ops). When you filter first and sort the candidates, GIN is a good default.

similarity vs word_similarity: which pg_trgm function should I use?

select similarity('london', 'londn'),        -- 0.44444445
       word_similarity('lond', 'new london'),  -- 0.8
       'londn' % 'london'     as fuzzy,        -- true
       'lond' <% 'new london' as word_fuzzy;   -- true

similarity(a, b) compares whole strings; a % b is true when it exceeds pg_trgm.similarity_threshold (default 0.3).
word_similarity(a, b) compares a with the best-matching part of b; a <% b uses pg_trgm.word_similarity_threshold (default 0.6). Ideal for search-as-you-type.
a <-> b is the distance, 1 - similarity(a, b).

Thresholds are ordinary settings (per session, role or function):

set pg_trgm.similarity_threshold = 0.4;

select name, similarity(name_norm, 'munchen') as score
from places
where name_norm % 'munchen'
order by name_norm <-> 'munchen'
limit 5;
-- München | 1

How do I rank exact, prefix and fuzzy matches in one query?

Users expect "lon" to show "London" before "Babylon", so the function ranks exact matches, then prefixes, then word prefixes, then fuzzy matches:

create or replace function public.search_places(
  p_query text,
  p_lang  text,
  p_limit int default 20
)
returns table (id bigint, name text, score real)
language plpgsql
stable
security invoker
set search_path = public, extensions
set pg_trgm.word_similarity_threshold = 0.5
as $$
declare
  q text := lower(public.immutable_unaccent(trim(coalesce(p_query, ''))));
begin
  if q = '' then
    return;
  end if;

  return query
  select p.id, p.name,
         (case
            when p.name_norm = q                   then 4
            when p.name_norm like q || '%'         then 3
            when p.name_norm like '% ' || q || '%' then 2
            else word_similarity(q, p.name_norm)
          end)::real as score
  from places p
  where p.lang = p_lang
    and (
      p.name_norm like q || '%'
      or p.name_norm like '% ' || q || '%'
      or (length(q) >= 3 and q <% p.name_norm)
    )
  order by score desc, length(p.name), p.name
  limit least(greatest(p_limit, 1), 50);
end;
$$;

select * from search_places('lon', 'en');
-- London 3, Londonderry 3, New London 2, Babylon 0.5
select name from search_places('cafe', 'fr');     -- Café de Flore
select name from search_places('MUNCHEN', 'de');  -- München
select name from search_places('москв', 'ru');    -- Москва

Details worth keeping:

security invoker (the default, made explicit) runs with the caller's privileges, so row-level security still applies.
stable declares that it doesn't modify data.
set search_path makes the extension operators resolve no matter who calls it.
Skip fuzzy matching under three characters; prefix matching is enough there.
Cap the limit in the database, not only in the client.

Pick the threshold by scoring your own typos and unrelated words, not by guessing.

How do I secure the search function with grants and RLS on Supabase?

Postgres grants execute on new functions to PUBLIC, and Supabase's default privileges also grant it to anon and authenticated. If search should require sign-in:

revoke execute on function public.search_places(text, text, int) from public, anon;
grant  execute on function public.search_places(text, text, int) to authenticated;

alter table public.places enable row level security;
create policy "places are readable by signed-in users"
  on public.places for select
  to authenticated
  using (true);

Replace using (true) with your own rule.

How do I call the search function from supabase-js?

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);

export async function searchPlaces(query: string, lang: string) {
  if (!query.trim()) return [];
  const { data, error } = await supabase.rpc('search_places', {
    p_query: query,
    p_lang: lang,
    p_limit: 20,
  });
  if (error) throw error;
  return data;
}

Debounce input and ignore out-of-order responses. In NEXO, that plus a server-side limit keeps search responsive.

How do I check that Postgres uses the trigram index?

With seven rows Postgres will (correctly) scan the table, so I loaded 200,000 extra rows and ran the function's query with a literal:

explain (costs off)
select id, name from places
where lang = 'en'
  and (name_norm like 'londn%'
       or name_norm like '% londn%'
       or 'londn' <% name_norm);

 Bitmap Heap Scan on places
   Recheck Cond: ((name_norm ~~ 'londn%'::text) OR (name_norm ~~ '% londn%'::text) OR ('londn'::text <% name_norm))
   Filter: ((lang = 'en'::text) AND ((name_norm ~~ 'londn%'::text) OR (name_norm ~~ '% londn%'::text) OR ('londn'::text <% name_norm)))
   ->  BitmapOr
         ->  Bitmap Index Scan on places_name_norm_trgm
               Index Cond: (name_norm ~~ 'londn%'::text)
         ->  Bitmap Index Scan on places_name_norm_trgm
               Index Cond: (name_norm ~~ '% londn%'::text)
         ->  Bitmap Index Scan on places_name_norm_trgm
               Index Cond: (name_norm %> 'londn'::text)

For broad terms matching many rows, a sequential scan can be the right plan.

Does pg_trgm work for Cyrillic, CJK and other languages?

Check your locale. pg_trgm only keeps characters that LC_CTYPE considers letters or digits. In a UTF-8 locale (such as C.UTF-8 or en_US.UTF-8) Cyrillic, Greek and accented Latin work. In a database with LC_CTYPE = C, show_trgm('москва') returns {} and "Café" loses its "é". Check with select datctype from pg_database where datname = current_database();.
CJK is weak. Without spaces between words, a phrase becomes one long "word" and short queries score low: similarity('東京', '東京タワー') is about 0.29, under the default threshold. Consider bigram-based approaches such as the pg_bigm extension, where available.
unaccent is for Latin-script diacritics. It won't transliterate "Москва" to "Moskva". If you need cross-script matching, store a transliterated alias.
Trigrams aren't stemming. Long documents want full-text search.

What I'd keep from this

An immutable unaccent wrapper, a generated normalized column, one GIN index and a stable, security invoker function cover most search boxes without new infrastructure.

FAQ

Is pg_trgm available on Supabase?
Yes. Enable it under Database, Extensions, or run create extension pg_trgm with schema extensions.

Why can't I use unaccent() directly in an index?
It is STABLE, not IMMUTABLE. Wrap it in an immutable SQL function that pins the dictionary, then index a generated column.

GIN or GiST for trigram search?
GIN is a good default when you filter first and then sort. GiST is needed for index-assisted ORDER BY ... <-> nearest-neighbour ordering.

Does pg_trgm replace full-text search?
For names, titles and short labels, usually yes. For long documents and stemming, use full-text search.

Every case in NEXO is fictional and written for teaching. NEXO is not medical advice.

Grading a wrong answer by how wrong it is: ICD-10 proximity scoring in Postgres

Thiago Longo Moraes — Mon, 21 Sep 2026 22:01:43 +0000

Most quiz apps have one bit of output: right or wrong. For a medical diagnosis game, one bit throws away almost everything interesting.

A physician who answers unstable angina when the case is a myocardial infarction has done something very different from one who answers bacterial meningitis. The first is a neighbour on the differential. The second is a different organ system entirely. Collapse both into "wrong" and the learner gets no signal about which mistake they made.

We build NEXO, a daily clinical reasoning game. Players answer with an ICD-10 diagnosis, and we score the answer by how far it sits from the correct code on the ICD-10 tree. This post is about how that is implemented, why it lives in the database, and a tautology that quietly killed one of the five levels for a while.

The ICD-10 code is already a tree

An ICD-10 code carries its own hierarchy in its characters:

G40.1
│││ └── subdivision
││└──── category    (G40, epilepsy)
│└───── block       (G4x, episodic and paroxysmal disorders)
└────── chapter     (G, diseases of the nervous system)

So you do not need a graph traversal or a distance matrix to know that G40 and G43 are closer than G40 and J18. You need a prefix comparison. Walk up from the full code, one character at a time, and the first level where the two codes agree is the proximity.

That gives five outcomes:

Prefix match	Feedback	Meaning
full code	exact	correct answer
3 characters	category	right category, wrong subdivision
2 characters	block	right block of related conditions
1 character	chapter	right chapter, wrong disease
none	distant	wrong branch entirely

Why this runs on the server

The scoring is a Postgres function, not client code. That is deliberate.

The client never holds the correct answer and never decides whether a guess was right. It sends a string; it gets back a verdict. Putting the comparison in the app would mean shipping the answer to the device, which for a daily game with a global leaderboard means shipping tomorrow's answers to anyone willing to read a memory dump.

The function is SECURITY DEFINER with a pinned search_path, and it takes a row lock on the game session before it touches anything:

SELECT * INTO v_sessao
FROM sessoes_jogo
WHERE id = p_sessao_id
  AND usuario_id = v_uid
FOR UPDATE;

The FOR UPDATE matters more than it looks. Without it, two submissions racing from a flaky connection can both read the same attempt count, both pass the six-attempt cap, and both append to the attempts array.

Normalising before comparing

ICD-10 codes reach us in several shapes. G40.1, G401, g40.1. Before any comparison, both sides are stripped to alphanumerics and upper-cased:

v_guess_norm   := upper(regexp_replace(p_tentativa, '[^A-Za-z0-9]', '', 'g'));
v_correto_norm := upper(regexp_replace(v_caso.cid10,  '[^A-Za-z0-9]', '', 'g'));

Normalising here and not at the edge means the rule holds no matter which client is calling. It also means the prefix comparison below can be plain left() on a clean string.

The comparison

IF v_guess_norm = v_correto_norm THEN
  v_feedback := 'exato';
ELSIF left(v_guess_norm, 3) = left(v_correto_norm, 3) THEN
  v_feedback := 'categoria';
ELSIF left(v_guess_norm, 2) = left(v_correto_norm, 2) THEN
  v_feedback := 'grupo';
ELSIF left(v_guess_norm, 1) = left(v_correto_norm, 1) THEN
  v_feedback := 'capitulo';
ELSE
  v_feedback := 'distante';
END IF;

Four comparisons, no lookup table, no ICD-10 reference data at query time. The hierarchy is in the string.

The bug: a condition that was always true

The version before this one tried to express "same numeric block" as a range check instead of a prefix check:

ELSIF left(v_guess_norm, 1) = left(v_correto_norm, 1)
  AND (left(v_guess_norm, 2) >= left(v_correto_norm, 1) || '0'
   AND left(v_guess_norm, 2) <= left(v_correto_norm, 1) || '9')
THEN v_feedback := 'grupo';
ELSIF left(v_guess_norm, 1) = left(v_correto_norm, 1)
THEN v_feedback := 'capitulo';

Read the range condition carefully. If the first characters already match, then left(guess, 2) is that letter followed by one more character. The bounds are that same letter followed by 0 and by 9. Every digit falls inside. So for any two codes in the same chapter, the grupo branch always fired.

Which made the capitulo branch dead code. The fifth level existed in the schema, in the client, in the copy on the website, and never once reached a player.

Nothing crashed. No error was logged. Players got a slightly-too-generous verdict and there was no way to notice from the outside, because "same block" and "same chapter" both render as an amber near miss. It only surfaced when someone went looking for how often each level fires and found one of them at exactly zero.

The fix was to delete the cleverness and compare prefixes.

What I would take from this

A tautology is the quietest kind of bug. It does not throw. It does not return null. It returns a plausible answer, forever. The only signal was a distribution with a zero in it, and you only see that if you go looking.

Put the hierarchy in the identifier when you can. ICD-10, and a lot of other clinical coding, is designed so that the code is the path. That turns "how related are these two diagnoses" from a graph problem into string slicing, which is fast enough to run inside the transaction that records the attempt.

Boolean ranges deserve a truth table. Both branches of that ELSIF chain read fine in review. The failure only shows up if you write down what the range actually evaluates to when the first character matches.

NEXO is a daily clinical reasoning game for physicians and medical students. One fictional case a day, six clues in order, and an answer given as an ICD-10 code. The daily case is free.

nexo.wiki.br · App Store

Every case is fictional and written for teaching. NEXO is not medical advice and is not for use with real patients.

I used the ICD-10 tree as a scoring function

Thiago Longo Moraes — Mon, 21 Sep 2026 18:41:33 +0000

Most medical quiz apps score you as right or wrong. That throws away the part that matters. In clinical reasoning, mistaking cholecystitis for appendicitis and mistaking it for a myocardial infarction are not the same mistake. One is a near miss inside the acute abdomen. The other is a different organ system.

So when we built NEXO, a daily diagnosis game for physicians and medical students, we made the scoring reflect that.

The idea

ICD-10 is a tree. A code like I21.0 sits inside category I21, inside group I20-I25, inside the chapter for diseases of the circulatory system. That hierarchy is already a distance metric. We just had to use it.

When a player submits a guess, we compare the guessed code against the answer and return the deepest node they share:

exact code         I21.0  vs  I21.0
same category      I21.9  vs  I21.0
same group         I20    vs  I21.0
same chapter       I50    vs  I21.0
different chapter  J18    vs  I21.0

Five levels instead of two. A player who lands on "same chapter" learns they were reasoning in the right system and missed the specific entity. A player who lands on "different chapter" learns something else entirely. Both are wrong answers, and they are not worth the same.

Keeping the answer secret

The daily case is the same for every player worldwide, and the answer has to stay hidden until the day rolls over. The comparison runs server side against the stored code. The client never receives the answer, only the level. That kept the API small: send a code, receive an enum.

The harder problem: cases that hold up

Generating a plausible clinical case with an LLM takes seconds. Generating one a physician will not tear apart is a different problem. A clue that sounds right but does not belong to the diagnosis is worse than no clue at all.

We built NEXO Core for that. Every disease, syndrome, exam, clinical finding and ICD-10 code is a node. Edges connect what clinical practice treats as neighbors: pneumonia connects to its etiological agent, its radiological pattern, its differentials. The graph currently holds around 11,500 concepts and 26,000 edges, drawn from 27 reference textbooks.

Every generated case crosses that graph before approval. Each clue has to appear among the neighboring concepts of the proposed diagnosis. A clue that does not, fails. It is a structural check, not a human reading it over and nodding.

Stack

React Native with Expo for the app
Supabase for Postgres, auth, storage and edge functions
Next.js on Vercel for the marketing site and the case management backoffice
RevenueCat and StoreKit 2 for subscriptions
Sentry for crash reporting

649 cases across 25 specialties, in six languages.

What I would do differently

Start with the graph, not the cases. We wrote a few hundred cases before the graph existed and had to re-audit all of them against it afterwards. That audit found problems a read-through had missed.

NEXO is live on iOS and the daily case is free forever, with no ads. The site is at nexo.wiki.br and the app is on the App Store.

Happy to answer questions about the graph or the scoring.