The Desktop Never Got T9: Why That Happened and How LLMs Could Fix It

We write most of our work text on a computer: emails, documentation, tickets, code, code comments. Yet smart autocorrect stayed on the phone. There, a word is fixed as you type, while on a PC the user gets a red wavy line and a context menu on right-click.

The gap has been visible since smartphones got touch keyboards, which is more than a decade and a half. A recent Habr article revisits the question: why the desktop never learned to do more, and whether LLMs can fix that. Below we go through the reasons and what language models actually change here.

The original publication in the RSS feed gives only a teaser, so what follows relies on the well-known architecture of text input and the state of the market.

Why the phone got autocorrect and the PC did not

On a smartphone, the keyboard is an application. It sees the coordinates of every touch, the probability of hitting neighboring keys, and the context of the phrase being typed. Autocorrect is a necessity there: a finger is larger than a key, and typing is impossible without it. The keyboard developer controls the entire input layer, so it can substitute words, change previous ones, and learn from the owner's habits.

On the desktop, the picture is the opposite. A physical keyboard is more precise, errors are mostly fewer, and there is no acute need. In addition, text ends up in browsers, IDEs, messengers, terminals, and office suites, and each has its own text engine. There is no single point where you can intercept input and cleanly change a word. You have to work through accessibility APIs or system-level hooks. This is fragile, differs for every OS, and often breaks in protected fields.

There is also the question of trust. A program that reads everything you type resembles a keylogger by definition. For work data, that is a serious obstacle: lawyers and security teams will readily ban such a tool.

What language models change

Classic autocorrect relies on a dictionary and n-gram statistics. It fixes typos within a word well, but understands context poorly: it cannot tell "ложить" from "класть" based on the meaning of the phrase, and it stumbles on professional jargon. A language model looks at the whole sentence and assesses which word fits. Apple has already moved autocorrect in iOS to a transformer-type model, and macOS has gained built-in continuation suggestions. That means the major vendors are ready to bring this to the desktop, although so far they are doing it cautiously and mostly for a limited set of languages.

The main change has to do with size. Models with a few billion parameters, such as the Phi-3-mini class with 3.8 billion, already run on a laptop without the cloud. This removes part of the privacy problem: the text does not leave the machine. Latency and resources remain.

The benchmarks for such a tool look like this:

• suggestion latency: on the order of 100 ms, otherwise it lags behind typing;
• model size: from hundreds of millions to several billion parameters, in quantized form;
• offline operation, with no text sent to a server;
• support for Russian, with its cases and free word order, where weak models make more mistakes;
• configurable exclusions for passwords, the terminal, and code.

What to do about it in practice

If you need smart correction on a PC right now, there are three workable paths. First: use the spelling and style checking in your browser and office suites. It does not replace T9, but it covers some of the tasks. Second: install a local tool built on a small model and test it on your own texts, paying attention to latency and to how it behaves in an IDE and a terminal. Third: if you build such products, start with narrow scenarios, such as correction in a single application or a single field, and only then move up to the system level.

Whichever you choose, check three things. Where the text is processed: locally or in the cloud. Which applications the tool does not touch. And how it behaves in Russian, not only in English. A desktop T9 remains a niche for now, but there are noticeably fewer technical obstacles to it than a few years ago.