Why Japanese Sentences Mix Kanji, Kana and Romaji in the Same Line

A Japanese sentence routinely uses four writing systems at once. This is not stylistic looseness — the choice of script per word is conventional and mostly predictable, and it carries information that would otherwise be lost in a script with no spaces.

One sentence, four scripts

Take an unremarkable sentence of the kind that appears in any office email:

私は昨日iPhoneでメールを送りました。

私      kanji     "I"                  content word, noun
は      hiragana  topic particle       grammar
昨日    kanji     "yesterday"          content word, noun
iPhone  Latin     product name         foreign proper noun
で      hiragana  instrumental particle grammar
メール  katakana  "email"              foreign loanword
を      hiragana  object particle      grammar
送り    kanji+kana stem of "to send"   content + inflection
ました  hiragana  polite past ending   grammar
。      punctuation

Nine units, four scripts, one line, and nothing about it would strike a Japanese reader as unusual. The assignment is systematic: kanji for the lexical content, hiragana for the grammatical machinery and inflection, katakana for the loanword, Latin for the brand.

The division of labour

• Kanji carry lexical content: nouns, and the stems of verbs and adjectives. Each is a morpheme, imported from Chinese, and most have multiple readings depending on context.
• Hiragana carry grammar: particles, verb and adjective endings, auxiliaries, and native words with no common kanji. The trailing kana on an inflected verb is called okurigana, and it is what tells you which inflection of the stem is meant.
• Katakana carry loanwords from languages other than Chinese, foreign names, onomatopoeia, technical and scientific terms, and occasionally emphasis — roughly the job italics do in English.
• Latin script (romaji) carries brand names, acronyms, units, model numbers and anything a company has chosen to keep in its original form. Arabic numerals sit alongside it and are now the default for figures in horizontal text.

Why it is not redundant

Japanese is written without spaces, and the script alternation is a large part of what replaces them. When a run of kanji is followed by a run of hiragana, the boundary between them is very often a word boundary: the kanji is the stem, the kana is the ending, and the next kanji starts the next word. Reading Japanese written entirely in hiragana is genuinely slow for a fluent reader, because the visual cue separating content from grammar has been removed.

The second job is disambiguation. Japanese has a great many homophones, and the kanji distinguishes them where the sound cannot. Written in kana alone, distinct words collapse into one string in the same way Vietnamese words collapse when tone marks are stripped. The script choice is carrying lexical information, not decoration.

Katakana does a third job: it marks a word as foreign, which is a real semantic signal. The same concept can exist as a native word in kanji and a borrowed word in katakana with different connotations and different registers, and a writer choosing between them is making a meaningful choice.

There is a fifth layer that only appears when the writer expects the reader to struggle: furigana, small kana printed above or beside a kanji to give its reading. It is standard in material for children and language learners, and it appears in adult prose for rare characters, unusual name readings, and deliberate wordplay where the written kanji and the given reading differ on purpose. In HTML it is the ruby element, and it is the reason Japanese text extracted from a web page can arrive with readings interleaved into the sentence — a stripper that discards tags but keeps text content will splice the furigana in as though it were prose.

What a model has to get right

A model generating Japanese is making the same script decisions a native writer makes, on every word, with no explicit rule available to it. Four places it can go wrong, in rough order of visibility:

• Kanji versus kana for a word that can take either. Many words are conventionally written in kana in modern prose even though a kanji exists. Choosing the kanji is not wrong exactly, but reads as stiff or archaic — the most common way model-generated Japanese sounds subtly off.
• Okurigana boundaries. Where the kanji stops and the kana begins is fixed by convention per verb, and getting it wrong is a spelling error a reader notices immediately.
• Katakana for a word with an established native form — or the reverse, translating a term that is conventionally borrowed.
• Register mismatch. The polite -masu forms, the plain forms and the honorific system have to be consistent across a whole document. A model that switches register mid-message produces text that is grammatical and socially wrong, which is worse.

Japanese has enough training data that models generally handle all four well, which is worth stating plainly: this is a place where the difficulty is real and the outcome is nonetheless good, because corpus volume dominates. The same script-mixing problem in a lower-resource language would not go so well.

There is one more decision the model inherits, and it is the one worth being explicit about in a prompt: full-width versus half-width forms. Unicode encodes both a full-width and a half-width variant of the Latin letters, the digits and several punctuation marks, plus half-width katakana left over from early encodings. Japanese convention mixes them — full-width for the parenthesis around a Japanese phrase, half-width for a model number or a URL — and the two forms are different code points that compare unequal. NFKC normalisation folds them together, which is exactly what you want before an equality test and exactly what you do not want before display, since it also converts half-width katakana to full-width and destroys deliberate formatting.

What breaks in a pipeline

Script mixing breaks a specific and predictable set of things, and they are all in your code rather than in the model.

• Language detection. A short Japanese string that happens to be mostly katakana and Latin can be classified as something else entirely. Detectors keyed on script ranges see mixed input and split their probability mass — the problem described on detecting language in a mixed-script document.
• Validation regexes. A name field validated against one script range rejects legitimate Japanese names, which routinely mix kanji and kana, and rejects the katakana reading field that Japanese forms conventionally ask for alongside.
• Search. A user may type a query in kana that appears in the document in kanji. Matching requires a reading-aware analyser, not string equality, and this is the single most common cause of Japanese search returning nothing.
• Sorting. Japanese collation is by reading, not by code point, and the reading is not derivable from the kanji without ambiguity — which is why Japanese databases carry a separate kana reading column.
• Sentence splitting. The full stop is 。, not ., and a splitter looking for ASCII punctuation finds one sentence in a whole document. See Japanese sentence segmentation for RAG.