Keyman Glossary

Users and People

[Keyboard] Authors

People using Keyman Developer, keyboard language, creating keyboard layouts. 'Keyboard authors' in full, 'authors' for short

Developers

People on the Keyman core team creating Keyman products.

Integrators

People using Keyman Engine to build apps, people working with Keyman APIs online, using schemas.

[End] Users

People who use Keyman on their device to type, that is: Keyman for Windows, Keyman for macOS, Keyman for Linux, Keyman for Android, Keyman for iOS, KeymanWeb users. 'End users' in full, 'users' for short

Technical Glossary

See more file types here:

Caps Lock

A key on computer keyboards that causes all letters of bicameral scripts (e.g. Latin) to be generated in capital letters.

Letters of non-letter characters and non-bicameral scripts (e.g. Arabic, Hebrew, Hindi) generate unshifted output

Chirality

Chirality in general means that an object is not identical to its mirror image. In Keyman context chirality means that data from one key on a keyboard is different from its mirrored key’s data. For example the left control key might behave differently than the right control key. In the KeymanWeb core module the isChiral() function may be used to test if a given keyboard recognizes chiral modifiers.

Client Application

The application that is receiving and applying the text input. The application could be a word processor or a browser or the system settings app -- any application that supports text input. Client Applications can be either Compliant or Non-Compliant.

Compliant Client Application

A Client Application which implements system APIs for making the Text Store available, and where Engine can manipulate the Text Store directly without resorting to pushing keystrokes such as Backspace to the application.

Context

The existing text in the Text Store that immediately precedes the insertion point. The context can impact what text will be produced by the next keystroke.

For example, a user is editing a document containing the text "abc123", and the user has clicked between the letters b and c so that the insertion point is after the second character in the document. The context in this scenario would be simply "ab".

Note that the context is not the entire text preceding the insertion point, but just a window that moves with the insertion point, for performance reasons. In Keyman Core, currently this window is 80 characters wide.

Deadkey

(Or Dead Key, shorthand dk) On a keyboard, a key that does not produce text output on its own but impacts the text produced by the next keystroke.

For example, if the apostrophe key is defined as a dead key, then typing the apostrophe followed by the letter e, could produce the output é.

In Keyman keyboard language, the deadkey statement represents a marker, and is Keyman's implementation for supporting deadkeys.

See Marker

Encoding

A technique for detecting keystrokes and identify which key has been pressed through translating keystrokes from physical keyboards into digital signals for further processing.

Gesture

A gesture is a finger motion like long press, flick, and multitap that can be used in Keyman. see

Infrastructure

A software development infrastructure typically consists of tools, processes, and services used to develop, test, deploy, and manage software applications. The most common components of a software development infrastructure include source control management systems, build servers, testing frameworks, and deployment pipelines.

Input Method

A software component that is invoked by the operating system to support text input. An input method may support a single language and a single script, or it may support many scripts and languages with a single input method as Keyman does.

Key Code

(Or Virtual Key Code) The value used by the operating system to identify the physical key that was pressed.

For example, Microsoft Windows identifies the S key with key code 0x53 and macOS identifies the S key with key code 0x01.

Keyboard

Several discrete things are referred to as a keyboards. In the context of Keyman, 'keyboard' often refers to the Keyman Keyboard, a dynamic keyboard implemented in software and designed to support text input for one or more scripts.

Keyboard may also mean:

Physical Keyboard - the hardware keyboard used for text input with a computer
On-screen Keyboard - or OSK, a keyboard displayed graphically which represents the layout of the keys on the physical keyboard and what characters they will produce
Touch Keyboard - the keyboard displayed for text input on a mobile device with a touchscreen such as a smartphone or tablet

Keyboard Layout

A keyboard layout is any specific physical, visual, or functional arrangement of the keys of a computer. In general every key on a keyboard can be identified by either its position on the keyboard or the character it would print out. In Keyman a key can be referenced by its position on the US English Keyboard ( K_A, K_B, etc.). In this case a positional keyboard layout is used. A key can also be referenced by its output ( “A” , “B”, etc.). In this case a mnemonic keyboard layout is used.

Keyboard Processor

Keyboard Processors within Core act as the primary interfaces and objects for processing Keyman keyboard rules. Within Core, there are multiple types - one for .kmn keyboards, one for LDML XML keyboards, and a mock variant for unit tests.

Keyboard Processors are designed to be platform independent and are completely stateless. Their only role is to transform preprocessed input events, given a Context and state token, into a set of 'actions' in response. Their primary process_event function is idempotent.

Keyboard Processors implement the km::core::abstract_processor class in Keyman Core.

Note: the Web Engine currently implements a legacy keyboard processor, but as of 17.0, all other engines have removed the legacy keyboard processors.

Keyman Application

The User Interface integration, e.g. keyboard install, config dialog, etc, that end users install, and contains the Engine and everything else, for a given platform, e.g. Keyman for Windows, Keyman for Android, etc. Also known as Keyman App.

Keyman Core

The km_core_ set of functions, platform agnostic, which contains Keyboard Processors and liaises between Engine and Keyboard Processor to manage context and actions.

Keyman Engine

A consumer of Keyman Core's functionality, providing platform-level integration. This will be bundled inside a Keyman Application

Keyman Keyboard

A software component that accepts incoming keystrokes and produces text output appropriate to a certain script. A Keyman Keyboard is built using Keyman Developer and contains rules that determine what text to output for a given keystroke and context.

Lexical Model

A data structure that represents the words in use for a language and their relative frequency of occurrence. A lexical model is required to support predictive text for a given language.

Marker

Mnemonic Keyboard Layout

In a mnemonic keyboard layout keys are identified by the character it prints out. For example the key that prints out the character 'z':

on a US engl. Keyboard 'z' is printed out by pressing K_Z (labeled 'Z' : the leftmost character key on the bottom row)
on a German Keyboard 'z' is printed out by pressing K_Y (labeled 'Z' : a key somewhat in the middle of the first row)
on a French Keyboard 'z' is printed out by pressing K_W (labeled 'Z' : the second key to the left of the first row)

If we, for example specified a Keyboard rule in Keyman Developer for a US layout (+ K_Z > 'z') and used that mnemonic layout with a German physical keyboard for key K_Y (where the keycap is labeled 'Z'), still a 'z' will be printed out.

This means when we specify a key in a mnemonic layout we talk about a key that produces a certain output (e.g. 'z') no matter where it is positioned at in different keyboard layouts

See also Keyboard Layout, Positional Keyboard Layout

Modifier Keys

Keys on a Computer Keyboard like Shift, Ctrl, Alt, AltGr, Option etc. Modifier Keys may be pressed simultaneously with certain other keys to activate predefined functions. They may also be used to produce different characters. For example on a German keyboard pressing the Q-Key produces 'q', Shift + Q-Key produces 'Q' whereas AltGr + Q-Key produces '@'

Non-Compliant Client Application

A Client Application which does not make the Text Store directly available, so Engine must emit output characters and keystrokes through system-level keyboarding APIs, to simulate the behaviour of a Compliant Client Application. Typically this includes emitting backspace keystrokes to delete characters from context. Importantly, as Engine cannot read the Context from the Text Store, Core maintains a cached context which is lost whenever the user moves the insertion point.

Platform

Android, iOS, Linux, macOS, Web, Windows

Positional Keyboard Layout

In a positional keyboard layout keys of a keyboard are identified by the position on the keyboard. For example the leftmost character key on the bottom row is always called K_Z:

on a US engl. Keyboard the key is called K_Z, the keycap is labeled 'Z' and it prints out 'z'
on a German Keyboard the key is called K_Z, the keycap is labeled 'Y' and it prints out 'y'
on a French Keyboard the key is called K_Z, the keycap is labeled 'W' and it prints out 'w'

If we, for example specified a Keyboard rule in Keyman Developer for a US layout (+ K_Z > 'z') and used that positional layout with a German physical keyboard for key K_Z (where the keycap is labeled 'Y') will print out 'z'.

This means when we specify a key in a positional layout we talk about a certain position (e.g. K_Z) no matter may be written on a keycap for a specific keyboard layout

See also Keyboard Layout, Mnemonic Keyboard Layout

Predictive Text

A keyboard feature that attempts to predict what words the user is typing, offering suggestions as the user types and also corrections in case the user has misspelled a word. To implement predictive text for a given language, a lexical model is required.

Scan Code

The key code emitted by a hardware keyboard, usually translated to a Key Code by the operating system. For example, S on a US ANSI keyboard has scan code 32. The codes tend to be numbered roughly from top-left of the keyboard, for common scan code mappings. Scan Codes are not usually the same as Key Codes.

Shift Lock

A key on some computer keyboards that causes all letters of bicameral scripts (e.g. Latin) to be generated in capital letters.

Letters of non-letter characters and non-bicameral scripts (e.g. Arabic, Hebrew, Hindi) generate shifted output

Text Store

The entire text of the document, where the Context is just the segment preceding the insertion point.

Virtual Key Code

See Key Code

Platform Domain Keyman Glossaries

Keyman Core Glossary

Windows Domain Glossary