Typing Yorùbá means recalling tone marks and hunting for characters most keyboards hide. Tẹ̀lé removes that effort — you recognise a word instead of composing it. Fewer keystrokes, less cognitive load, written in your own language.
Tẹ̀lé makes it easy to write Yorùbá. You start a sentence, and it suggests the next word — already spelled correctly, with the right tone marks. You tap instead of typing.
Getting the tone right is the hard part, and the part no English keyboard can do for you.
Writing Yorùbá correctly means remembering which of three tones a word carries, and finding characters such as ẹ, ọ and ṣ that standard keyboards hide. Most fluent speakers were schooled in English and are unsure of the diacritics, so they either type Yorùbá without tone marks — changing the meaning — or switch to English.
Tẹ̀lé replaces recall with recognition: rather than composing a word character by character, you choose it from three suggestions — tone marks already correct.
People with motor impairments or limited dexterity, where every keystroke carries a real cost. Older and less literate users. And the many fluent speakers who avoid writing Yorùbá online — not because they cannot speak it, but because they fear getting the tone marks wrong in public.
Confidence, not just speed. Removing that hesitation is the point. When people can write their own language correctly and without effort, they show up in digital spaces as themselves. A language that is absent online slowly becomes a language people stop writing at all.
Who uses it. Yorùbá is spoken by tens of millions of people across Nigeria, most of whom now write on a phone. The first users are the ones for whom typing is hardest: people with motor impairments, older users, and the large group of fluent speakers schooled in English who avoid writing Yorùbá because they are unsure of the tone marks.
How it reaches them. Three routes, in order of effort. An Android keyboard app, free to install, is the consumer path. An SDK and API lets Nigerian banks, telcos and government services add Yorùbá input to their own apps — the same engine, licensed. And disability organisations and schools can deploy it directly to the people who benefit most.
How it sustains. The consumer keyboard stays free — charging for access to your own language would defeat the purpose. Revenue comes from licensing the engine to institutions that need Nigerian language input in their own products: banks, telecoms and government services. Because a language can be served from one small CPU server, adding the next language costs very little — which is what makes serving many of them realistic rather than aspirational.
What the next quarter buys. TensorFlow Lite conversion for on-device inference, an Android IME built around this engine, a held-out keystroke-savings benchmark, and a pilot with a disability organisation to measure real savings with real users rather than in a browser tab.
Nigeria has over 500 languages and almost none have predictive text. Tẹ̀lé runs three small LSTM models on a 2GB server for a few dollars a month. The architecture, not just the model, is the contribution — Yorùbá is the proof. Hausa, Igbo, Tiv and Efik need only a corpus and the same pipeline.
Tẹ̀lé is not a wrapper around ChatGPT or any external AI service, and it does not adapt an existing pretrained model. There is no pretrained Yorùbá language model to adapt — that absence is the gap this project exists to address.
The Yorùbá text was prepared, the vocabulary built, and three network architectures designed and trained from scratch. The system calls no third-party AI service and needs no API key. Every prediction you see on this page is produced by models running on this server — which is why it answers in about 350 ms and costs a flat server rate rather than a fee per request.
An English keyboard guesses a word. Yorùbá has to guess the word and the tone it carries — and a wrong tone is not a typo, it is a different word with a different meaning. This is why systems built for English cannot simply be pointed at tonal African languages, and a large part of why those languages have been left out of predictive text altogether.
Tẹ̀lé predicts the word together with its tone. That is the specific problem it was built to solve, and it is what makes the approach transferable to other tonal Nigerian languages rather than to Yorùbá alone.
What is running here is the prediction engine, exposed over a
/predict API. The on-screen keyboard on the demo tab is one client of it —
a phone keyboard is another. On Android that means an InputMethodService, the same
mechanism Gboard and SwiftKey use: the user enables it once in Settings and it then works
in WhatsApp, SMS and every other app. The suggestion strip above the keys is exactly the
candidate bar an IME renders. iOS supports the equivalent through a Custom Keyboard
Extension. Gboard does not accept third-party prediction plugins, so a dedicated Yorùbá
IME is the route — which also means the tone marks stay under our control rather than
being mangled by an English autocorrect.
The models are small enough for this to be realistic — a few megabytes each today, and TensorFlow Lite with quantisation is expected to shrink them considerably further. Running on the phone itself would mean no server, no data cost, and no connection needed at all. For a keyboard that matters twice over: it makes the product usable in low-bandwidth areas, and it means no keystroke ever leaves the phone. The conversion is the next piece of work, so the final size and on-device speed are not yet measured.
Deliberately small enough to be deployable where it is needed. All figures measured on the live server, not estimated.
| Server | 2 vCPU, 1.9 GB RAM — no GPU |
| Memory in use | 567 MB with all three models resident |
| Inference | 350 ms on the server, all three models plus fusion |
| Model payload | 24 MB total |
| Restart to serving | 3 seconds |
That matters for the scaling argument: an LLM-based approach to the same problem needs GPU hardware, which puts it out of reach at national scale. Tẹ̀lé serves a language from one small CPU server — which is what makes 500+ Nigerian languages a realistic target rather than a slogan.
Three architectures run on every prediction and their outputs are fused, weighted toward the strongest. Shown in the product as Tẹ̀lé Core (a single-layer LSTM baseline), Tẹ̀lé Deep (a two-layer stacked LSTM) and Tẹ̀lé Focus (an attention-augmented LSTM). The ensemble surfaces words a single model misses, and the agreement badge shows how many independently ranked each suggestion.
The three architectures were trained and compared on the same Yorùbá corpus, with ablations on diacritics and dropout. The comparison view shows each model's ranked output live, so the ensemble's behaviour is inspectable rather than asserted. The next step is a held-out keystroke-savings benchmark — the standard AAC measure — which does not yet exist for Yorùbá and would be a contribution in itself.
Tẹ̀lé was trained on a small dataset of tone-marked Yorùbá text. We would rather say so plainly than let you discover it.
What it means in practice. The model handles common, everyday Yorùbá well — the phrases people actually type. It will miss rare words, dialectal forms, proper nouns and recent borrowings, because it has never seen them. Predictions are strongest in familiar constructions and weakest at the edges of the language.
Why the corpus is small. Not for lack of effort. Yorùbá is spoken by tens of millions of people, but properly tone-marked written Yorùbá barely exists in digital form. Most Yorùbá online is written without diacritics — and text without tone marks is unusable for teaching a model which tone a word carries, since that is the exact thing it must learn. The bottleneck is not the architecture. It is that the data has never been collected.
Why this matters beyond Tẹ̀lé. Every Nigerian language faces the same wall. Models are cheap now; corpora are not. A national effort to build properly annotated corpora for Nigerian languages would unlock not just predictive text but speech recognition, translation and screen readers — for all of them. Tẹ̀lé shows how much is achievable with a small dataset. The obvious question is what becomes possible with a proper one.
Keystroke savings shown on the demo are measured live in your session, not against a benchmark corpus — formal evaluation is the next step. Prediction quality depends on correct diacritics in the input — though Tẹ̀lé now restores missing tone marks automatically, so typing mo fe still works. You can switch that off if you prefer to type the marks yourself.
How far tone restoration goes. It works by matching against the words the model already knows. A word outside that vocabulary is left exactly as you typed it — the system does not invent tone marks it has no basis for. And where one bare spelling has several readings (owo can be owó, ọwọ́ or ọ̀wọ̀) it offers them all and lets you choose, rather than deciding for you. Choosing automatically from context is the next piece of work.
The vocabulary is bounded by a small training dataset, so rare, dialectal and borrowed words will be missed. None of this is hidden: it is what the next phase of work is for.
Language counts: Blench, R. (2019). An Atlas of Nigerian Languages, 4th ed. Cambridge: Kay Williamson Educational Foundation. Also Jegede, O. O. (2024), Journal of Universal Language 25(2), 51–92.
Keystroke savings as a measure of assistive text entry: established practice in Augmentative and Alternative Communication (AAC) research.
Performance figures on this page were measured on the live server. Where something has not been measured, it is described as expected rather than stated as fact.