Why AI Image Models Still Get Text Wrong in 2026

AI image models get text wrong because of how they picture a scene: they work on a shrunken copy of the image, and they only know what writing tends to look like, not that each letter is a fixed symbol. The problem gets measurably worse under aggressive quantization, which is why text is the first thing to break on a phone. Anyone who has made a few AI images has seen it. A shop sign carries bold, well-lit lettering that spells nothing. The letters have the right weight, the right angle, the right shadow. They still are not words.

Three problems stack up. The model works on a shrunken copy of the image, and fine detail is the first thing that copy throws away. The model also has no idea that a letter is a fixed symbol; it only knows what writing tends to look like. And writing is unusually strict. A face drawn slightly wrong still reads as a face. One wrong letter turns a word into nonsense.

“AI cannot do text” is already a dated description of the largest cloud models. What follows is why the problem exists, why bigger models handle it better, and why text is the first thing to break on a phone.

Diffusion works on a compressed image, and text is the detail it drops

These models do not clean up, or denoise, pixels directly. They work on a shrunken map of the image, where one cell stands for roughly an 8×8 block of pixels. The technical name for that map is a latent. A 512×512 image becomes a 64×64 grid of cells. Shrinking the image is what makes these models fast enough to be practical, and fine high-frequency structure (small, sharp, tightly packed detail) is what it sacrifices.

For most of a picture that is a good trade. Skin, leaves, fabric, blurred background lights: with textures like these, a plausible rebuild is indistinguishable from the original, so no viewer can tell the invented pixels from the real ones. The part that shrinks and rebuilds the image is called the autoencoder. It is free to throw away the exact pixel values and invent statistically similar ones on the way back out. Letters work the other way. The difference between an e and a c is one thin stroke a couple of pixels wide, and a merely “statistically similar” rebuild of that stroke is a different letter, or no letter at all.

So small text is damaged before the creative part of the model makes a single choice. It has already been squeezed through a stage built to lose exactly this kind of detail. That same design choice is what keeps model files and memory budgets manageable, as covered in how diffusion models work.

The model has no concept of a glyph

Nobody ever told the model that letters are fixed symbols drawn from a set alphabet. It only learned what writing looks like: dark marks of even thickness, lined up in rows, with the spacing and rhythm of real text. So that is the texture it produces. Nothing inside it can tell a correct letter shape from a convincing letter-shaped mark. (The technical name for a letter shape is a glyph.)

The prompt side makes this worse. The part that reads your words chops them into chunks rather than single characters. (Those chunks are called tokens, and the reader is the text encoder.) A word like BAKERY may reach the model as one or two chunks with the spelling sealed inside. The model then has to draw six particular shapes in a particular order, working from a description that never names them one by one. Liu and colleagues showed this directly. They swapped in a text encoder that does see individual characters, and spelling in the generated images measurably improved. That is strong evidence that the character-blind chunking is part of the failure.

This also explains what the failure looks like. You rarely get random scribble. You get something that passes for a language at a glance: the right mix of common letters, letter pairs joined in believable ways, near-words like BAKRERY or CAFFE. The model is picking from the whole range of things that look like writing, because that is the only thing it was ever taught.

Letters are unforgiving in a way faces are not

Text fails in plain sight because writing leaves no room for a near miss, while almost everything else in an image does. Shift a nose two pixels and the face still reads as that face. Change one letter in HELLO and the word is broken for every reader, obviously and for good. The model may be making mistakes at the same rate in both cases. Only the cost of the mistake is different.

• A sliding scale versus a fixed set. Most of a picture sits on a sliding scale, where a near miss is simply another valid look. Letters come from a fixed set, and a near miss usually lands outside it.
• No partial credit across a word. A word is right only if every character is right. At a 95% success rate per character, a six-letter word comes out correct about 74% of the time. A twelve-letter word drops to about 54%.
• Readers check text, not texture. Nobody audits the individual leaves on a tree. Everybody reads a sign, so every error in it gets caught.
• Errors add up across a line. Letter height, the baseline they sit on, and the spacing all have to stay steady from one end of a line to the other. Each cleanup decision the model makes is a local one, shaped by a small neighborhood of the image, and nothing in the process guarantees that a whole line stays in agreement.

Why the biggest models got much better at it

Text improved because the models grew and got better at language. The clearest single lever was the part that reads the prompt. Saharia and colleagues found that scaling up that language model improved image–text alignment more than scaling the image generator itself did. That language model is frozen, meaning its weights stay fixed while the image model trains. A richer reading of the prompt carries more of what the model needs to place specific characters.

Three other changes added to that. Models moved to higher native resolutions, so a line of text covers more cells in the shrunken map and each stroke has room to exist. The number of internal settings, or parameters, went up too, which gave the network room to memorize letter shapes as well as general texture. That is part of why these models are gigabytes large. And training data got better curated, with more images whose caption states the text visible in the frame.

On the largest cloud systems, short headline text in a clear typeface now usually comes out right. The blanket claim that AI cannot render text is out of date. What has not been solved is the hard tail: long passages, small type, dense paragraphs, unusual scripts, and any job where a specific font must be matched exactly. Those still fail. They fail for the structural reasons above.

Compression can make text harder

Quantization stores model weights at lower precision to reduce size. It can introduce errors, including in fine details such as lettering, but text can already fail in the full-precision model. A failed sign is not proof that compression caused the problem.

There is no universal bit-width threshold that predicts text quality. The base model, quantization method, which components are compressed, and the prompt all matter. Include exact lettering among your test cases, but compare it with faces, geometry, and the other tasks you care about.

Two other on-device limits pull the same way. Small models have less capacity to spend on letter shapes than the multi-billion-parameter cloud systems that recently got good at text. And few-step turbo models take one to four passes over an image rather than dozens. Each pass is a chance to turn a nearly right shape into an exactly right one, and there are far fewer of them.

What this means when you generate on Onhand

Onhand includes Turbo and Detailed Images alongside other model choices. SDXL Turbo’s published model card lists legible text as a limitation. Other models may produce different results, but Onhand does not guarantee exact spelling, a specific typeface, or accurate small print.

For a poster, cover, or product graphic, generate the illustration with space for a title, then add the exact text in a layout editor. Read every word in the exported file. A short word can be one useful evaluation prompt, but it is not a complete test of model quality.

If exact lettering matters, see how a large cloud model compares: Onhand vs Midjourney covers where the cloud still leads on image quality and prompt handling.

Sources

Primary sources for the claims above, so you can check them rather than take our word for it.

• Rombach et al., High-Resolution Image Synthesis with Latent Diffusion Models (2022). The latent-space design, including the downsampling factor behind the fine-detail loss described here.
• Liu et al., Character-Aware Models Improve Visual Text Rendering (2022). Direct evidence that character-blind text encoders are a cause of misspelled text in generated images.
• Saharia et al., Photorealistic Text-to-Image Diffusion Models with Deep Language Understanding (2022). The finding that scaling the text encoder improves image–text alignment more than scaling the generator.