Why Does Subscript Only Have 14 Characters

The fourteen lowercase Latin letters with a subscript code point are a, e, h, i, k, l, m, n, o, p, r, s, and t. Type subscript through the Fancy Text Generator subscript row and you get something like ₛᵤbₛcᵣᵢₚₜ, with b, c, d, f, g, u, and every capital letter still sitting at normal height. People paste that into a bio, see the patchwork, and assume the tool is broken. Unicode simply never assigned subscript code points for most of the alphabet.

If you have wondered why subscript only 14 characters exist while superscript covers nearly every lowercase letter, the answer lives in a 1990s math-notation decision, not a missing font file. Below is what subscript actually is, which Unicode blocks hold the glyphs, which letters map and which do not, what to use when half your word stays tall, and where pasted subscript tends to fall apart on real platforms.

What are subscript characters?

Subscript characters are Unicode code points that render a glyph below the normal baseline, smaller than the surrounding text. They are not CSS font-size or vertical-align. Each tiny letter is its own character from the Superscripts and Subscripts block and a handful of extension ranges. When you paste H₂O into a plain-text field, the 2 is U+2082, a subscript digit, not a styled regular two.

Chemists and physicists got these glyphs first. Subscript digits handle CO₂; subscript Latin handles tensor indices. Social bios came decades later, and the character set was never expanded to cover them.

Why did Unicode stop at fourteen subscript letters?

Unicode reserved the Superscripts and Subscripts block at U+2070 through U+209F for notation that sits above or below the baseline. Within that range, subscript digits 0 through 9 occupy U+2080 through U+2089. Subscript operators like plus, minus, equals, and parentheses fill U+208A through U+208E. The Latin subscript letters that landed in the original block are a (U+2090), e (U+2091), h (U+2095), k (U+2096), l (U+2097), m (U+2098), n (U+2099), o (U+2092), p (U+209A), s (U+209B), t (U+209C), and x (U+2093).

Four more letters arrived later outside the core block: i at U+1D62, r at U+1D63, u at U+1D64, and v at U+1D65 in Latin Extended-D, plus j at U+2C7C in Latin Extended-C. The phrase "subscript only 14 characters" refers to the original core set before j, u, v, and x were added, and even seventeen mapped lowercase letters is nowhere near a full alphabet.

The gap is deliberate dead space. Notation simply did not need subscript b or q. A variable named b in a paper uses normal Latin. Subscript n handles an index; subscript i handles another. Bios asking for uniformly tiny English in 2026 are using a character set frozen for 1990s journals.

Compare that to superscript in the same block. Superscript lowercase pulls from U+2070 through U+209F plus modifier letters in Latin Extended-B and Latin Extended-D. You get a through z minus q, which is why hello shrinks fairly evenly in superscript but becomes ₕₑₗₗₒ in subscript with only the l characters guaranteed to drop.

Which lowercase letters have a subscript mapping?

Seventeen lowercase Latin letters map today. The original fourteen-core set that people cite is a, e, h, i, k, l, m, n, o, p, r, s, t. Extensions add j, u, v, x. Everything else in the Latin lowercase range passes through at full size.

Nine lowercase letters have no subscript at all: b, c, d, f, g, q, w, y, z. Every uppercase letter from A through Z also lacks a mapping. Digits 0 through 9 and the operators +, -, =, (, ) do subscript cleanly, which is why H₂O and x₁ look correct while CO₂ with a subscript letter in the middle of a word does not.

I reach for small caps instead of subscript whenever more than two letters in a word lack a mapping, because the patchwork reads broken in bios.

Run test through a subscript map and you get ₜₑₛₜ, which looks uniform because all four letters happen to be in the set. Run quick and you get qᵤᵢcₖ, with q and c jumping back to normal height. That is the honest limitation: subscript works when your word is built from the allowed letters, and it fails silently everywhere else.

What can you do when subscript cannot cover your word?

When more than a few letters lack mappings, subscript is the wrong tool. Switch to small caps, superscript, or circled Unicode from the same Fancy Text Generator grid. Small caps replaces every Latin letter through code points in U+1D00 through U+1D7F and related ranges. hello becomes ʜᴇʟʟᴏ in a typical small caps map, with no random tall letters in the middle.

Superscript covers nearly the full lowercase alphabet. Capitals still stay tall, so mixed-case bios look patchy, but an all-lowercase phrase like notes shrinks more evenly than the same word in subscript. For chemical notation (H₂O, CO₂) or math indices (xₙ, aₑ), subscript is exactly what Unicode intended. For arbitrary English, it was never meant to work.

Where does subscript text break on real platforms?

Pasted subscript survives in many UTF-8 text fields, but survival is not the same as usefulness. Apps that run input through NFKC or strip "special characters" before storing a bio can remove subscript code points or fold them to ASCII. You paste ₕᵢ, save, and reopen to find hi at normal size. Preview after save, not just after paste.

Search and mention indexing often tokenize plain ASCII. Subscript code points encode differently from the letters they resemble, so a display name with subscript may not match what a friend types. Subscript works as inline flair in a bio line, not as a searchable handle.

Extension-range subscripts like j at U+2C7C render on current iOS and Android system fonts, but older devices or niche apps ship fonts that cover U+2070 through U+209F and miss Latin Extended-C. One letter in an otherwise tiny word snaps back to full size. That is a font gap, not a broken paste.

For style comparisons when subscript feels too patchy, read cursive vs script vs italic. For the broader paste-versus-PNG split, see unicode text vs font generators.

Frequently asked questions about subscript character limits

What are the fourteen subscript letters?

The core fourteen lowercase Latin letters with subscript code points are a, e, h, i, k, l, m, n, o, p, r, s, and t. Unicode added j, u, v, and x later in extension ranges. Nine other lowercase letters and every uppercase letter have no subscript mapping, so they stay full size beside the tiny ones.

Why does subscript only have fourteen characters?

Unicode added subscript Latin for mathematical and chemical notation in the 1990s, not for shrinking arbitrary English words. The Superscripts and Subscripts block at U+2070 through U+209F covers digits, operators, and a fixed set of letters that notation actually needed. The standard never grew a full alphabet because that was never the design goal.

What Unicode block holds subscript characters?

Most subscript glyphs live in the Superscripts and Subscripts block from U+2070 to U+209F. A few letters spill into Latin Extended-D at U+1D62 through U+1D65 and Latin Extended-C at U+2C7C. Superscript digits and letters mostly share the same block, with additional modifier letters scattered in Latin Extended-B and Latin Extended-D.

Why do some subscript letters render at normal size?

Any character without a subscript code point passes through unchanged. Lowercase b, c, d, f, g, q, w, y, and z have no mapping. Every uppercase A through Z also stays tall. Punctuation outside the map, emoji, and CJK characters remain full size too. The patchy output is a map limitation, not a font bug.

What is the difference between subscript and superscript in Unicode?

Subscript lowers a small fixed set of Latin letters and digits using code points in U+2070 through U+209F and related extension ranges. Superscript raises a much larger lowercase alphabet plus digits and common operators from the same block and scattered modifier letters. Superscript still skips every uppercase letter. Neither style shrinks an arbitrary word uniformly.

Why does subscript text break on some platforms?

Apps that normalize text on save may strip uncommon code points or replace them with ASCII lookalikes. Search and mention systems often index plain ASCII, so subscript in a username may not match a typed handle. Older fonts omit extension-range subscripts like j at U+2C7C, which makes one letter in a word jump back to full size.