Everything the native keyboard does, and a switch for every bit of it.

Key fills, key shape, the shadow under a key, the typeface and the proportions of the rows come off the system keyboard in both light and dark, and the default style reproduces them. Nothing here was eyeballed from a screenshot at the wrong scale, and every value is a named constant with a test behind it.

Not the bubble most reimplementations draw. The real one is a detached square that floats above the key you are holding, the same size whichever key that is, and the pressed key stays visible underneath with its letter still on it. Several details of it are the opposite of what they look like until you measure them on a device, which is what we did.

Backspace, return, space, emoji, 123, globe and shift darken while held, the way the native ones do — letters do not, because there the key-pop is the feedback. The held tint is measured rather than guessed at, in both appearances.

On the native keyboard, aiming at space and getting a "c" never happens — the bar quietly claims a margin of the row above it. It is specific to the space bar, not a general downward nudge: the boundary between two letter rows measured as exactly where it is drawn. The engine reproduces both, and the margin is a parameter you can take back to zero.

The plain, un-accented character sits directly above the key you are holding and starts selected, so your finger never travels to pick it. Keys with many variants (e, u, o) overflow the bar to both sides, as native does, which keeps the outer accents reachable instead of jammed against the edge of the screen.

The engine plays the system key clicks directly, so key sound needs no host setup and works without Full Access, and it respects the silent switch. Haptics do need Full Access, which is an iOS rule rather than ours.

Parity is measured against one iOS release, and Apple redraws the keyboard between releases. So each round of measurement is stored as a named snapshot, and the engine renders the newest one no newer than the device it is running on. When a future iOS changes the drawing, a new snapshot lands beside the old one rather than replacing it — your users' keyboard does not change shape underneath them, and you can pin a look deliberately if you need to.

The keyboard is a SwiftUI view with a toolbar slot above the keys, a buttonContent slot that overrides the content of any key, and an emojiKeyboard slot. Widths are solved by KeyboardWidthSolver, which reproduces native alignment: letters share one width and the flexible keys divide what is left.

NativeKeyboardStyle is the default and carries the measured native look. A host implements the protocol only for what it wants to change and inherits the rest, so restyling one key colour does not mean re-deriving the whole keyboard.

Native, Midnight, Ocean, Sunset, Forest and Graphite. A theme is a single ThemePalette (light and dark) that recolours the whole keyboard — keys, text, accent, callouts, the key-pop and the suggestion bar all read their colour from the style, so nothing is left behind on the old palette. Your own theme is a ThemePalette plus ThemedKeyboardStyle.

The modern iOS keyboard is not an opaque block: it floats on a translucent backdrop and blends with the app behind it. The engine draws itself so that backdrop shows through, with keys translucent on the glass, which is the difference between a keyboard that belongs to the system and one that was pasted over the screen. Non-native themes are solid by design and switch the glass off.

Gives shift, backspace, return, globe, mic and 123 the letter-key colour instead of the darker native control colour. Off by default, because off is native; on in the kit's own recommended preset.

Turn the word "space" off to leave the bar blank — useful when you would rather show only a language badge in the corner, as native does with several keyboards enabled.

A locale's table holds the letter rows, the 123 and symbol pages, and the per-locale long-press callouts. The resolver assembles the full layout from it — shift and backspace row, bottom row, and the application of shift to both letters and callouts.

QWERTY, AZERTY, QWERTZ, Dvorak and Colemak, with authentic letter rows rather than a permuted QWERTY. Leave it nil and each locale uses its own default: English QWERTY, Czech and German QWERTZ, French AZERTY.

Every key in the bottom row shares an edge with a letter above it, and the same holds on the numeric and symbol pages — which is why the native keyboard reads as a grid rather than as five rows that happen to be the same width. Regression tests hold the alignment in place, because this is exactly the kind of thing that drifts a point at a time and is never noticed until it looks wrong.

A URL or web-search field gets a .com key whose callouts lead with the country TLD of every language you have enabled — a Czech keyboard offers .cz, a German one .de, both enabled offers both — followed by the generic list. Languages that map to no single country add none. The key never inserts on key-down even when key-down insertion is on: a multi-character key is not pressed by accident, and inserting on press made holding it useless.

Email fields get "@" and ".", number fields get a digit pad, and the return key becomes Go, Search, Send and so on. Turn it off and you get the plain letters layout and a "return" key in every field.

Characters and the space bar commit the instant the key goes down rather than on release, so typing reads as immediate. A long-press for accents replaces what was inserted, a glide undoes it, dragging off the key cancels it. Off by default because native commits on release.

Press and hold the native space bar and nothing is typed until you lift — that is how it can still tell a tap from a cursor drag. The engine does the same, and a held space is flushed the moment another key commits, so fast typing keeps its order.

Fast typing with two thumbs is where naïve keyboards fall apart: overlapping presses get reordered, buffered or dropped outright. The engine runs every touch through one state machine that resolves them into the order they were actually made — and that same machine owns key-down commit, the accelerating backspace, long-press callouts, the spacebar cursor drag and slide-to-type, so no two gestures ever fight over a finger. On in .pressboardDefault, off in .standard.

A touch on the line between two neighbouring letters leans toward the one that keeps the word you are typing a real word — which is a thing the native keyboard does, and can be demonstrated on a device. It only ever settles a tie: a touch comfortably inside a key is never reassigned, and with no word in progress or no dictionary for the language it does nothing at all.

A tap toggles shift, a quick double-tap engages caps lock, and a single shift falls back to lowercase after one character. The shift key shows its state with the filled glyph and the light fill, as native does. Turn auto-shift off for a sticky shift.

A capital at the start of the field, after a full stop, exclamation mark or question mark followed by a space, and after a newline.

Two spaces after a word become a full stop and a space. What most reimplementations miss is that native gives you a window: the second space has to arrive promptly, so a space pasted in, or typed a minute ago, never expands into a sentence the user did not write. The engine has the window too, measured rather than invented, and exposed as a parameter if your app wants a different one.

Typing one of . , ! ? ; : after a stray space moves the space to the other side of the mark, turning " ." into ". " the way native does.

: and ; open smileys, so the fixup above would mangle "ahoj :)" into "ahoj: )". The mouth cannot be predicted at the moment the colon is typed, so the move is undone as soon as a mouth character follows immediately. A space between mark and mouth closes the window; switching page or pressing shift does not, so "hi :D" survives.

If the user backspaces a spacing fixup all the way back to the word it moved a space past and retypes it their way, the fixup does not fire there again — whatever mark they type. It survives retyping the space itself, and is cleared once the cursor moves elsewhere.

A space or a newline on the 123 or symbol page flips back to letters — and so does one further key, which nobody would guess and which we found by working through the native page one key at a time. It makes sense once you see it, and it is the kind of detail that separates a keyboard people keep from one they switch off.

Straight quotes become locale-aware curly ones — English opens and closes high, Czech opens low — the apostrophe is typographic, and a double hyphen becomes an em dash.

Holding backspace accelerates and then starts deleting whole words, at the native cadence.

The keys shrink and move to one side, with a chevron in the gap to return to full width. How far it shrinks is a parameter rather than a constant. The whole bottom row, globe and mic included, moves with the keyboard as one block, as native does.

Holding globe opens a menu with the system keyboard switcher on top and a left / off / right one-handed picker below it. The system's own menu cannot be extended with custom rows, so the engine draws its own.

Native animates the press feedback, so animating is the default. Turning it off applies those transitions instantly — an experiment for checking whether already-instant key-down insertion only reads as slow because of what is animating on top of it.

The word being typed is replaced with the correction when you commit it, drawing on the same system spell checker the native keyboard uses.

The system spell checker is not equally good in every language — in some it will tell you cheerfully that every word you type is spelled correctly, which is how a keyboard ends up silently correcting nothing at all. The engine does not take that at face value. It layers the system's judgement with its own, falls back where the system has no data, and restores the accents nobody bothers to type in the same pass, so "delas" becomes "děláš". A word that is valid in any language you have enabled is never rewritten.

Native never corrects a single letter — "Add 100 g of flour" has to survive — and neither does this, nor H2O or a flight number. The handful of deliberate per-language rules are exempt: a lone "i" is capitalised in English, and left alone in Czech, where it is a word in its own right.

Backspace into a corrected word to change it and autocorrect leaves it alone until you move on — space, return, or the cursor going elsewhere. Native reads that edit as "I rejected the correction", and so does this.

Once a word is finished the bar offers continuations instead of going blank. Two sources: pairs learned from what the user actually types, ranked first, and seed bigrams the host can supply. Learning is what makes it useful with no data shipped at all. It is bounded, so it cannot grow into the extension's memory limit, and the host persists it so it survives the process being killed. With nothing learned and no seed data it offers nothing, because guessing would be worse.

A field nobody has typed into yet gets three opening words rather than an empty bar, as native does. Which three is the provider's call, and the host can pass its own.

SuggestionBar is the native three-slot layout — what you typed in quotes, the highlighted primary completion, and an alternative — dropped into the toolbar slot. Over a number, phone or decimal pad there is no bar at all, because native has none there and drawing one would make the keyboard taller for nothing.

The autocomplete module bundles 39 word-frequency lists, loaded lazily per language, so suggestions and swipe typing work before you have supplied anything. They are built from a conversational corpus rather than a news one, because people type to each other, not to a newsroom. Pass your own list to override, or no provider at all for no suggestions.

A raw frequency list carries the misspellings of the corpus it came from — in Czech, for instance, a shadow copy of half the language with its accents stripped off. Those were cleaned out where they are not themselves real words, which is what lets "cas" correct to "čas" while genuine words that merely look like accent-free spellings survive untouched.

Type 12*3 in a field and the bar offers the expression, the expression with its result, and the result on its own; picking any of them replaces the expression.

The word being typed is mapped to an emoji and offered as the highlighted slot — bilingually (EN and CS), ignoring case and diacritics.

Drag across the keys to write a word; the decoder resolves the path against the host's dictionary. A glide beats a long-press callout: a letter key yields to the swipe once the finger is travelling, while holding still keeps the accents. Candidates are ranked by word frequency, with length only as a weak correction — ranking by length used to hand the win to longer, rarer words. Multiple enabled languages are compared fairly, by rank within their own list rather than by position in a merged array.

The bar updates while the finger is still moving; on lift the best word is inserted and the alternatives stay in the bar, so a tap swaps the inserted word the same way a completion does. Mid-glide candidates are decoded first-pass, so a half-finished path suggests less well than a finished one.

A glide can only ever cross the base letters, so an accented word has to be inferred. Measured on a device, native inserts the un-accented form. The engine defaults to inserting the correct one — "máš" rather than "mas" — because it already knows which word you traced. This is one of the few places we knowingly differ from native, and it is one flag back to exact parity.

Holding a key opens the bar of secondary characters — complete diacritics for every letter, native iOS plus Czech — selected by dragging and inserted on release. The bar is clamped to stay on screen at the edge keys.

Dragging along the space bar moves the caret without typing a space. It moves at the measured native rate and then accelerates for a long run, so it stays precise for a one-character correction and quick across a sentence. All keys blank during the drag and neither predictions nor letter case update, exactly as native does.

A keyboard extension cannot see where a line of text visually breaks — it has no access to the field's width, font or wrapping, and sees only a window of text around the caret. So an up or down drag jumps by sentence instead of pretending to know about lines. Nothing is guessed, and the threshold is set high enough that an ordinary wobble during a sideways drag does not trigger it.

Every caret move is a call across a process boundary, and a drag on a high-refresh display produces far more of them per second than the app you are typing into can repaint. Push them all and the caret simply vanishes mid-drag. The engine batches them instead, which is why the caret you are dragging stays on screen.

Native gives this one even when keyboard haptics are off, because it signals a mode change rather than a keystroke, and so does the engine. In an extension any haptic still requires Full Access.

Categories, recents, a four-row grid, and a skin-tone bubble on long press with slide-to-select. Recents come from an injected store, and a host that has its own panel can drop it into the slot instead.

Hand-curated keywords in English and Czech, insensitive to case and accents, with a search mode where typing goes into the query and results update live.

The "ABC" key, the active category marked the way native marks it, and icon sizes and shades measured off the system panel rather than approximated. One honest gap: a few of the native category icons are Apple's own artwork, which is not available to anyone else, so those are the nearest system equivalents.

The mic key and its action and hook are in the engine; the speech-to-text is yours to supply, because microphone and speech access belong to the host app.

The core engine and the layout tables are the minimum. Autocomplete and emoji are separate Swift package products precisely so an app that does not use them never links them, and the engine's footprint is measured inside a real extension rather than estimated from the code.

Drawing three dozen keys is not free, so the engine keeps that work off the keystroke path entirely: typing a letter mid-word redraws the suggestion bar and nothing else, verified by counting renders on a device rather than by reasoning about it. The integration guide covers the other half — how to keep your own toolbar's state from dragging the keys back into every keystroke.

The bundled provider indexes its word list, so the call that runs on every single keystroke stays far below the cost of a frame even against a full-size dictionary.

Measured from lifting a finger to the character appearing, the engine is at the floor of what the platform's own gesture path allows.

The keyboard can log its own footprint every N keystrokes while you investigate. Off by default; it costs one system call per interval and nothing else.

Each key is a single accessibility element carrying its character in the current case — or space, delete, shift, return, letters, next keyboard, dictate — with the keyboard-key trait and its own activation action. Assistive activation delivers no touch at all, so without that action a key could be focused but never pressed. A host-supplied overlay, such as a language badge on the space bar, is hidden from accessibility so it cannot turn the key into a container and take its name away.

Each suggestion is its own element named by the word it will insert, and the highlighted correction announces itself as a suggestion. Verified in a real extension.

The engine's logic — hit-test geometry, the touch state machine, callouts, the cursor drag, autocorrect, prediction, layout solving — is covered by unit tests run on the simulator rather than on the host Mac, because building for macOS silently compiles the iOS-only half of the suite away.

A keyboard extension is hosted out of process, and behaviour that works in an in-app preview can fail there completely — we have lost days to exactly that. So the UI tests tap exact coordinates inside the really rendered key rectangles, read back from the running keyboard rather than from a second copy of the engine's own maths, and the important ones run against the real extension while typing into another app.

Where iOS exposes no value to read, we measure it: a test class drives the real native keyboard and our own extension through the same harness in the same app, so the two are directly comparable and our constants are answers rather than plausible guesses. It is slow and exploratory, and is re-run when those constants are retuned.

The key identifiers are public API and the geometry helper is plain XCTest, so you can point a UI test target at whatever app you type into and assert on real key positions, with nothing PressboardKit-specific required.