{
  "id": "input-method",
  "title": "Input Method",
  "lang": "en",
  "source_lang": "en",
  "summary": "An input method converts keystrokes, gestures, speech, or other signals into text, enabling efficient writing across languages, scripts, and computing devices.",
  "category": "computer-science",
  "subcategory": "software",
  "type": "concept",
  "aliases": [
    "Text input method",
    "Text entry method"
  ],
  "generated_at": "2026-11-06",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/input-method/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/input-method/",
      "json": "https://aiwiki.page/zh/input-method.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "An input method is a system for converting a user’s actions into text that a computer can store, display, and edit. In its broad sense, the term includes ordinary keyboard entry, on-screen keyboards, handwriting recognition, and speech dictation. In a narrower and widely used technical sense, it refers to software that interprets sequences of keystrokes or other signals to produce characters that cannot conveniently be assigned to individual keys. An input method editor, commonly abbreviated IME, is an interactive software component that supports this process, often by maintaining an unfinished composition and offering alternative interpretations.\n\nInput methods are essential to writing systems with large character inventories, including Chinese, and to systems in which written units are assembled or selected through several operations, including Japanese and Korean. They also support accented letters, complex-script composition, predictive typing, and accessible text entry. Their design connects human–computer interaction, writing-system structure, natural language processing, and operating-system architecture. A successful input method must not only identify the intended text but also allow users to inspect, correct, and commit it without losing control of what is written."
    },
    {
      "heading": "Text representation and the boundaries of input",
      "text": "An input method occupies a different layer from the physical input device and the system used to encode text. A keyboard reports key presses; a keyboard layout maps keys and modifier states to symbols or actions; an input method may interpret those results as parts of a larger composition. A user typing the Latin letters nihao with a Chinese phonetic input method, for example, may obtain 你好 rather than the five letters entered. The same physical keyboard can therefore support many languages without changes to its hardware.\n\nThe distinction between input and character encoding is fundamental. Encoding determines how abstract characters are represented as numbers and stored as bytes. An input method determines which characters the user intends to enter. Unicode provides a common character repertoire for modern text systems, while encodings such as UTF-8 specify how its values are serialized. Choosing a Chinese input method does not, by itself, select an encoding, and changing an encoding does not provide a way to type unfamiliar characters. Earlier computing systems often bundled language input with particular fonts and national encodings, making these separate functions appear more closely connected than they are.\n\nNor is there a fixed correspondence between a physical action, a character, and a visible symbol. A dead key may store an accent until the following key supplies a base letter. A Korean keyboard may combine several component letters into one displayed syllable block. An emoji sequence can include several Unicode values while appearing as a single pictograph. The distinction between a code point and a grapheme cluster consequently matters for cursor movement, deletion, selection, and character counting. An input method can produce several code points in one operation, while a text editor may treat the result as one user-perceived unit.\n\nInput is also separate from rendering. In scripts such as Arabic, software selects contextual glyph forms according to surrounding letters. In many South Asian scripts, the displayed order and arrangement of signs differ from their logical storage order. These changes are generally performed by text-layout and shaping systems, not by an input method choosing a separate character for every visible form. Input software nevertheless has to cooperate with rendering so that unfinished syllables, combining marks, and cursor positions remain intelligible.\n\nThe boundary between an input method and a typing aid is less rigid. Completion, spelling correction, and next-word prediction may operate inside a keyboard application or in the application receiving text. Some systems preserve a clear distinction between interpreting an unfinished input sequence and proposing additional words; others combine both functions. This distinction matters because converting a supplied pronunciation, correcting a misspelling, and generating an untyped continuation involve different levels of intervention in the user’s wording."
    },
    {
      "heading": "Historical development",
      "text": "Mechanical typewriters made the relation between keys and written symbols a central engineering problem well before electronic computers. Alphabetic machines could assign most letters to individual keys, whereas Chinese typewriters commonly required selection from much larger inventories of type. Japanese machines faced the additional problem of combining kana with a substantial kanji repertoire. These devices demonstrated that text entry need not mean one key for one character: selection, indexing, component decomposition, and phonetic mediation were alternative strategies.\n\nEarly electronic systems inherited keyboards, teleprinters, and restricted character sets developed largely around Latin letters, digits, and control codes. ASCII, first standardized in 1963, used a seven-bit code space and could not represent the ordinary written forms of many languages. Supporting such languages required advances in storage, fonts, displays, and encoding as well as input. The eventual availability of a large character repertoire did not solve the interaction problem: thousands of characters still had to be reached through a keyboard with comparatively few keys.\n\nPhonetic conversion became especially important for Japanese word processing. Research systems explored kana-to-kanji conversion during the 1960s and 1970s, and Toshiba introduced its JW-10 Japanese word processor in 1978. Such systems allowed users to enter a reading and select the appropriate written form instead of retrieving each kanji through a separate code. Conversion initially depended heavily on dictionaries and explicit choices. As processing capacity and lexical resources expanded, systems became better able to propose words and longer passages from continuous phonetic input.\n\nChinese computing developed several competing approaches. Chu Bong-Foo developed Cangjie in 1976, using character shapes and components as the basis of keyboard codes. Wang Yongmin’s Wubi system, introduced in 1983, likewise used structural decomposition, though with different rules. Phonetic methods based on Hanyu Pinyin and Zhuyin offered another route, linking computer entry to established pronunciation systems. These approaches served different learning backgrounds and tasks: phonetic systems reduced the need to memorize shape codes, while structural systems made it possible to enter a character without knowing its pronunciation.\n\nAs personal computers became widespread, input methods moved from specialized word processors into general operating-system services. Applications could receive text from a shared language-input component instead of implementing their own conversion systems. The growth of Unicode, whose first version appeared in 1991, helped separate multilingual input from incompatible legacy encodings. Later developments included statistical phrase conversion, downloadable dictionaries, personalized ranking, handwriting and voice input, and touch keyboards. The spread of the smartphone changed the interaction problem again: keyboards became software interfaces that could adapt their layout and predictions, but had to interpret imprecise touches on small screens."
    },
    {
      "heading": "Chinese phonetic and structural methods",
      "text": "Chinese input methods address a writing system in which a practical character repertoire is far larger than a keyboard’s key inventory. Most systems therefore encode a character through pronunciation, visual structure, or some combination of the two. Character-by-character entry remains possible, but many widely used methods allow users to enter words and phrases continuously. The conversion engine then resolves ambiguities by considering likely character sequences rather than selecting each character independently.\n\nHanyu Pinyin, officially adopted in 1958, represents Standard Mandarin pronunciation using Latin letters and tone marks. Computer input commonly omits tone marks and accepts a string of letters that is segmented into syllables. The sequence shijie, for example, may yield 世界, “world,” while the reading shishi can correspond to several words, including 事实, 实施, and 时事. Context, dictionary frequency, and user selection help distinguish these alternatives. Apostrophes can mark otherwise ambiguous syllable boundaries: xi'an identifies the two syllables of 西安, while xian can represent a single syllable.\n\nZhuyin, also known as Bopomofo, provides a different phonetic interface and is widely used in Taiwan. Its symbols represent Mandarin speech sounds without using Latin-letter spelling. Keyboard mappings assign these symbols to physical keys, and some implementations incorporate tone entry directly into the input sequence. Pinyin and Zhuyin can both produce traditional or simplified characters, depending on the system’s configuration and dictionaries. The input notation is therefore not inherently tied to one character set, although regional software defaults and vocabulary often associate particular methods with particular writing conventions.\n\nStructural methods instead describe how a character is built. Cangjie associates keys with basic graphic categories and applies decomposition rules to derive character codes. Wubi organizes components through a system related to stroke forms and character structure. Both can reduce the uncertainty caused by many characters sharing a pronunciation. Their principal learning cost is mastery of component assignments and decomposition rules. Knowing how to write a character by hand does not automatically provide its correct keyboard code, because the coding system imposes its own conventions about component boundaries and order.\n\nOther approaches include four-corner coding, stroke-sequence input, mixed phonetic–structural methods, and methods designed for non-Mandarin varieties such as Cantonese. Stroke methods can be useful when pronunciation is unknown, although short sequences may match many characters. Shape-based systems also need mechanisms for uncommon characters, variant forms, and components that are difficult to classify. Handwriting recognition offers another route for visually known characters, but recognition quality depends on writing style, stroke completeness, and the distinction between similar forms.\n\nContinuous conversion introduces problems beyond identifying individual characters. Chinese text normally does not place spaces between all words, so an engine must infer lexical boundaries and choose among overlapping interpretations. Personal names, technical vocabulary, and newly coined expressions can be poorly represented in a general dictionary. Systems therefore commonly provide candidate lists, user-defined phrases, and fallback entry modes. Mapping between simplified and traditional writing also requires lexical care: some correspondences depend on a word’s meaning and cannot be handled reliably by substituting every character in isolation."
    },
    {
      "heading": "Japanese, Korean, and other writing systems",
      "text": "Japanese text normally combines kanji with hiragana and katakana, so input involves both phonetic entry and selection of written forms. A common method accepts Latin-letter sequences, converts them into kana, and then offers kana-to-kanji conversion. Another uses a keyboard layout that assigns kana directly to keys. The reading hashi, for instance, can correspond to 橋, “bridge,” 箸, “chopsticks,” or 端, “edge,” among other possibilities. The input method must use context or explicit user selection to identify the intended spelling.\n\nJapanese conversion operates over linguistic segments rather than simply replacing each syllable. Inflected verbs and adjectives combine a kanji-containing stem with kana endings, and particles help identify grammatical relations. Engines may segment a sentence into several conversion units, offering alternatives for each. Users can adjust boundaries when a plausible character sequence has been grouped incorrectly. Katakana entry, Latin letters, numerals, punctuation width, and personal names create additional mode and conversion choices. An effective interface must make these choices available without forcing the writer to interrupt every phrase.\n\nKorean input usually presents a different kind of composition problem. Hangul represents speech with component letters, or jamo, that are arranged into syllable blocks. In the widely used two-set keyboard layout, consonants and vowels occupy separate key groups. Entering ㄱ followed by ㅏ forms 가; adding ㄴ can produce 간. If a following vowel makes the final consonant function as the beginning of a new syllable, the composition engine can redistribute the components. Typing ㄱ, ㅏ, ㄴ, ㅏ consequently produces 가나. This requires stateful composition, but not necessarily the extensive lexical disambiguation characteristic of Japanese kanji conversion.\n\nOther scripts expose further distinctions between keystrokes and stored text. In Devanagari, used for Hindi and several other languages, a vowel sign may appear visually before the consonant to which it belongs even though it is stored after that consonant in logical order. Consonant combinations can form conjuncts through a virama-based sequence. A keyboard can provide direct access to script characters or accept transliteration from Latin letters, while the rendering system handles the appropriate shaping. Vietnamese input methods such as Telex and VNI instead use additional letters or digits to specify vowel modifications and tone marks. These schemes let an ordinary Latin keyboard produce Vietnamese spelling without assigning every accented form to a separate key.\n\nMultilingual text complicates all of these systems. A writer may insert English technical terms into Japanese, mix Arabic and Latin text, or use a name whose spelling does not follow the active language’s normal patterns. Automatic language detection can reduce manual switching, but it can also reinterpret intentional letter sequences. Unicode makes it possible to store mixed scripts in one document; it does not determine which language the writer intends at a given moment. Input methods therefore retain explicit language modes, literal-entry options, and controls for punctuation and conversion."
    },
    {
      "heading": "Conversion, prediction, and language models",
      "text": "A conversion engine can be understood as an algorithm that searches for intended text given incomplete or ambiguous evidence. Let \\(x\\) denote the observed input and \\(y\\) a possible output. A basic decision rule chooses\n\n\\[\\hat{y}=\\arg\\max_y P(y\\mid x).\\]\n\nUsing Bayes’ rule, this can be expressed, for a fixed input, as maximizing \\(P(x\\mid y)P(y)\\). The first term describes how likely the observations are if a candidate was intended; the second represents the candidate’s prior linguistic probability. A touch keyboard can use the first term to model finger-position errors, while a phonetic input method can use it to model pronunciation mappings.\n\nTraditional conversion systems combine pronunciation or spelling dictionaries with word frequencies and grammatical rules. Statistical systems can represent the alternatives as a lattice: each path corresponds to a possible segmentation and output sequence. Dynamic programming allows the engine to compare many paths without enumerating every complete sentence. N-gram models estimate how likely a word or character is after a limited number of predecessors. For Japanese, lexical entries can also carry information about inflection and grammatical category; for Chinese, segmentation and character selection are closely coupled.\n\nModels based on machine learning can learn richer patterns from text and interaction data. Neural networks can combine spelling, phonetic evidence, neighboring words, and longer context. A language model may rank an ordinary phrase above a rare but valid sequence because the former better matches patterns in its training material. Transformer-based models can use longer context than conventional short n-gram models, but their memory demands and response time must fit the device and interaction. Beam search is one way to retain several promising partial interpretations while limiting the amount of computation.\n\nPersonalization changes the ranking for an individual user. A system may promote recently selected names, retain custom abbreviations, or learn that a particular ambiguous input usually refers to a specialized term. Such adaptation can be implemented with a small local dictionary rather than by retraining an entire model. It must also accommodate corrections: repeatedly suggesting an unwanted candidate can make a nominally accurate system burdensome. General language frequency and personal history are useful evidence, but neither is proof of the user’s present intention.\n\nConversion, completion, and generative rewriting should therefore be distinguished. Conversion tries to recover the written form of supplied material. Completion predicts material not yet entered. Rewriting may alter vocabulary or sentence structure. A large language model can participate in all three, but its ability to generate plausible language does not guarantee faithful transcription. Names, numbers, quotations, code, and deliberately unusual wording are important counterexamples to frequency-based preferences. Input interfaces preserve user control through candidate selection, literal entry, undo, and visible distinctions between composed text and optional suggestions."
    },
    {
      "heading": "Composition and application integration",
      "text": "An input method usually maintains a composition, also called preedit text or marked text, before inserting a finalized result into the document. Composition may be underlined, highlighted, or otherwise distinguished from committed text. A candidate window displays alternative interpretations, and the user can select one by a number key, pointer action, or navigation command. Commit transfers the accepted result to the application as ordinary text. Cancel abandons the current composition without treating its unfinished form as the intended document content.\n\nThis arrangement requires cooperation between several software layers. The operating system or input framework routes relevant events to the input engine. The application supplies information such as the insertion point, selection, input purpose, and sometimes surrounding text. The engine returns composition updates, candidate information, and committed strings. An application programming interface defines this exchange. On Microsoft Windows, the Text Services Framework provides facilities for text services; macOS offers input-method support through its text system and Input Method Kit; Linux desktop environments commonly use frameworks such as IBus or Fcitx.\n\nApplications must distinguish text entry from raw key handling. A key press may update a composition rather than insert a character. Enter may confirm a candidate rather than submit a form, and Escape may cancel composition rather than close a dialog. Keyboard shortcuts can conflict with input-mode commands or candidate navigation. Games, terminal emulators, remote desktops, and applications with custom-drawn editors often require particular care because they may bypass standard text controls that ordinarily manage these interactions.\n\nThe web presents the same problem through its event system. Composition events such as compositionstart, compositionupdate, and compositionend expose the composition lifecycle, while input-related events describe changes to editable content. Browser event properties can indicate that composition is active. A site that treats every Enter key as an immediate submission command can accidentally send a message while the user is still selecting a character. Likewise, replacing a text field’s contents on every update can reset the selection or destroy the active composition.\n\nPositioning and editing operations introduce further complexity. The candidate window should appear near the relevant caret, including in scrolled documents, vertical text, or interfaces spanning displays. Reconversion may allow a user to select committed text and reopen conversion alternatives. Applications that supply surrounding text can improve disambiguation, but must define which ranges are available and how they are indexed. Unicode code points, UTF-16 code units, and grapheme clusters are not interchangeable units for these offsets. A mismatch can corrupt selections or place composition boundaries inside a multi-unit character sequence."
    },
    {
      "heading": "Touch, handwriting, speech, and accessible entry",
      "text": "Touchscreen keyboards transform text input into a spatial inference problem. Unlike a mechanical key, a screen location does not provide a sharply bounded physical action. The system estimates the intended key from touch coordinates, key geometry, neighboring letters, and language context. It may enlarge effective target areas without changing their visible appearance. Autocorrection combines this geometric evidence with likely word forms, while a candidate strip lets the user accept an alternative. Errors can arise when a common word is preferred over an intended name or when the active language differs from the language being typed.\n\nGesture typing interprets a continuous path across a keyboard rather than a series of separate taps. A path passing near the letters of a word is compared with possible lexical paths, and the engine accounts for timing, direction changes, and spatial uncertainty. The observed trace usually does not uniquely identify a word, so language information remains important. Gesture entry works especially well where spelling can be represented by a path through an alphabetic layout, although its effectiveness varies with vocabulary, layout, motor control, and the need to enter punctuation or unfamiliar terms.\n\nHandwriting recognition allows users to supply written shapes directly. Online recognition uses time-ordered pen or finger coordinates, potentially including pen lifts and pressure; offline recognition interprets an image of completed writing. Temporal information can help distinguish forms that look similar in a static image, while image-based methods can tolerate a wider range of stroke orders. For Chinese and Japanese, handwriting is particularly useful when a character’s appearance is known but its pronunciation is not. Recognition still requires candidate selection when characters are visually similar, incomplete, cursive, or absent from the system’s supported inventory.\n\nSpeech recognition converts an acoustic signal into text, introducing uncertainties involving pronunciation, word boundaries, background noise, and homophones. Dictation also has to infer punctuation and sometimes decide how to represent numbers, abbreviations, and foreign words. Spoken commands may control editing, but the interface must distinguish commands from words intended for the document. Speech is therefore not simply a faster substitute for typing: correcting a short recognition error can require a separate interaction, and speaking may be unsuitable in shared, noisy, or privacy-sensitive settings.\n\nAccessible text entry includes switch scanning, eye-gaze selection, dwell-based keyboards, alternative pointing devices, and combinations of speech with manual correction. A scanning keyboard highlights choices in sequence so that a person can select a character with a small number of reliable actions. Predictive suggestions can reduce the required selections, but a large or unstable candidate set can also increase visual and cognitive demands. Compatibility with a screen reader requires meaningful announcements of composition changes and candidate focus. These concerns belong to accessibility and interaction design rather than to recognition accuracy alone: an accurate system can remain unusable if its controls, timing, or feedback do not match the user’s means of access."
    },
    {
      "heading": "Performance, privacy, and linguistic coverage",
      "text": "Input methods are evaluated through both output quality and the effort required to obtain it. Characters per minute and words per minute measure throughput, but comparisons require a declared counting convention. A conventional “word” in many text-entry studies is five characters, including spaces, rather than a linguistic word. This convention aids comparison within some experiments but does not remove differences between scripts. A Chinese character, a Latin letter, and a Korean syllable block carry different amounts and kinds of linguistic information, making raw cross-language speed rankings difficult to interpret.\n\nKeystrokes per character, candidate-selection frequency, correction actions, and learning time provide complementary measures. Shape-based systems may require substantial training yet become efficient for experienced users. Phonetic methods may be easier to begin using while requiring more disambiguation for particular vocabulary. Top-one conversion accuracy measures how often the first candidate is correct, whereas top-\\(k\\) accuracy measures whether the desired result appears among \\(k\\) candidates. Neither captures the full interaction cost: a correct candidate hidden in a long list may take more effort to obtain than one reached through a short, predictable correction.\n\nLatency and stability also matter. A system that briefly displays one interpretation and then repeatedly replaces it may interrupt writing even if its final result is accurate. Evaluation therefore distinguishes response to a keystroke, time to produce useful candidates, and time to commit the intended text. Tests based only on copying prepared sentences can miss the demands of composing original material, switching languages, or entering names and specialized terms. Results depend on participants’ familiarity, the input device, available prediction features, and the vocabulary represented in the test.\n\nPrivacy concerns arise because input software can handle text before it reaches its destination. Depending on platform permissions and implementation, it may process private messages, search queries, names, and surrounding document content. Local processing, cloud conversion, synchronization, and telemetry create different data privacy conditions. Encryption can protect data in transit but does not by itself determine what a receiving service can inspect, retain, or use. Secure-entry controls may limit third-party keyboards, learning, or context access, although the details vary by platform. Input methods are consequently part of a system’s information security boundary rather than merely cosmetic keyboard utilities.\n\nLinguistic coverage presents a separate set of evaluation problems. A method may technically support a script while lacking a useful dictionary for a particular language, dialect, or orthography. Minority-language text, regional terms, historical characters, and mixed-language expressions can be systematically underrepresented in training data. Strong frequency-based prediction may then increase correction effort by repeatedly favoring more common forms. User dictionaries, explicit literal-entry modes, configurable layouts, and community-maintained open-source software can expand practical support. Testing such systems requires examining not just whether a character can eventually be entered, but whether ordinary writers can produce their intended language reliably and efficiently."
    }
  ],
  "links": [
    "human-computer-interaction",
    "natural-language-processing",
    "operating-system",
    "character-encoding",
    "unicode",
    "utf-eight",
    "code-point",
    "grapheme-cluster",
    "ascii",
    "personal-computer",
    "smartphone",
    "pinyin",
    "hangul",
    "algorithm",
    "dynamic-programming",
    "n-gram",
    "machine-learning",
    "artificial-neural-network",
    "language-model",
    "transformer-architecture",
    "beam-search",
    "large-language-model",
    "application-programming-interface",
    "microsoft-windows",
    "linux",
    "web-browser",
    "speech-recognition",
    "screen-reader",
    "web-accessibility",
    "data-privacy",
    "encryption",
    "information-security",
    "training-data",
    "open-source-software"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}