Glide typing

Glide typing lets you write a word by sliding one finger from letter to letter without lifting it. WM Keyboard watches the shape of the stroke rather than which keys it happens to cross, so a loose, fast swipe still lands the right word.

hello

Slide from letter to letter; lift to commit the word.

Screenshot pending

A glide in progress: the comet-style trail follows the stroke and fades behind it.

Turning it on

WM Keyboard › Typing › Gestures › Glide typing

Glide typing is on by default, and it isn’t tied to one language. What it needs is a layout that types the letters you press rather than converting them, plus a word list covering enough of that layout’s alphabet. English gets it on every layout registered under English, QWERTY or otherwise: AZERTY, Dvorak, Colemak, Workman and Halmak all glide, because the word list comes from the language and every one of those grids can spell it. Other languages glide as soon as their word list is installed and covers the keys. French, German, Spanish and the rest ship no built-in list, so until you download one under Dictionaries a swipe on them has nothing to decode against and lands as taps. The keyboard says so rather than leaving you guessing: the first time you type in such a language with glide typing on, a chip on the suggestion strip reads “Glide typing needs a French word list”. Tap it to open the language’s page, where the list downloads, or ✕ to dismiss it. It shows once per language, for good rather than once each time the keyboard opens, and goes away as soon as you type.

Only languages that can actually gain a list from a download are ever asked. English and Bangla carry theirs inside the app, so they never raise the chip, and neither does a language you have set to your own imported lists alone, because a download would not be read while that is on. If glide typing does nothing on English or Bangla, the word list is switched off rather than missing: see Dictionaries.

A swipe only turns into a glide when several things line up at once:

• You’re on the letters layer. Glide typing doesn’t apply to the symbols or number pages.
• The swipe has somewhere to land. With no panel open that’s your field. With a panel open it’s that panel’s own text box, if it has one: emoji and clipboard search, the dictionary lookup, a media panel’s search bar (GIF, sticker, web, image, Wikipedia, Translate, App launcher, Vocabulary, QR), the AI prompt, Find and replace, the Learn-from-text speller, a plugin’s text field, and the word card’s spelling bar all take a swiped word at their own caret. See Panels and captured keys. The keypad boxes (the calculator’s expression and the converters’ amount) take none, since a word list means nothing on a keypad.
• The layout types letters rather than converting them. Hangul, Vietnamese and the CJK input methods all turn keystrokes into something other than the keys pressed, so a stroke over them spells a reading, not a word. The phonetic layouts are the exception: Avro for Bangla and Hindi phonetic. They convert too, but the grid is Latin and the output is another script, so a stroke is decoded against a romanized vocabulary rather than the native one: the language’s known-spellings map, joined by its downloaded romanized word list (Banglish, Hinglish) if you have one. Without that spelling map there’s nothing to read the stroke against, and the layout quietly stops gliding rather than guessing. Khipro is the other exception: its strokes are read against the Khipro spelling of every word in your Bangla lists, which the keyboard works out on the phone the first time and keeps. Khipro Dark glides on those same Classic spellings, so a stroke never has to cross the / key to join consonants. The fixed Bengali layouts, Probhat and Jatiya, shape clusters instead of converting, so a stroke over them is decoded against the Bengali word list on the ordinary path. Full Pinyin and Japanese Kana JIS glide too, in their own way: a stroke spells a reading, which joins the text being composed for the candidate strip to convert.
• The active word list covers enough of the layout’s letters. Edit a layout in the layout editor and drop letters the language needs, and glide typing quietly turns itself off for that layout rather than guessing at a key that isn’t there. It’s worth checking first if swiping stops working after an edit. A finished dictionary download re-asks the same question, so a language can start gliding a minute after you add it. Only the language’s own list is asked: a language you’ve added under Also suggest from doesn’t count against the layout, so English with Polish mixed in still glides on QWERTY, and Polish words that need letters the grid lacks just aren’t offered from a swipe. The same goes for lists you import under Custom dictionaries. While the language has a bundled or downloaded list, that list alone answers, so an English list kept under Arabic can’t switch Arabic glide off, and a few imported Latin words can’t switch it on for a grid that can’t spell Arabic either. Imported words the grid can draw are swiped like any others. Your imports only get the say when they’re all the language has: no list downloaded, or the language set to read its imported lists alone.
• You’re not in the middle of a typing-test tool run, unless the test’s own glide switch is on.
• The field allows it at all. Secure fields (password boxes) and structured keypads (email, number, phone, date/time) skip glide typing the same way they skip autocorrect: there’s no dictionary word to guess on a PIN pad. A URL bar is the exception: it gets a swipe like a text field does, since a browser’s address bar is typed as often as it’s searched, even though autocorrect and learning still skip it.

The word list behind a glide is whatever dictionary is active for the language you’re typing. That’s the bundled one, or a bigger downloaded list if you’ve installed one under Dictionaries, since a larger downloaded list always takes over from the bundled copy. Words you’ve typed and had WM Keyboard learn are folded in too, and weighted heavily, so a word you’ve typed even once becomes an easy swipe target next time.

Note

A letter-area swipe can do something other than glide a word: outside the F-Droid build Not on F-Droid you can set it to handwrite instead, drawing letters over the keys for on-device recognition. That’s a separate feature with its own page: see Handwriting. Glide typing itself, the “Type words” mode, ships in every build.

The trail

While you swipe, a comet-style trail follows your finger: thick and opaque at the head, thinning and fading toward the tail, so the stroke dissolves behind you instead of leaving the whole path drawn on screen. It takes its color from your theme’s accent color by default, or from a color the theme sets specifically for it. Lifting your finger doesn’t clear it instantly. The trail stays where it is and finishes fading on its own.

Three sliders under the same Gestures group tune it (trail width, how long it lingers, and its opacity). See Options for their ranges and defaults.

Tip

Power Saving mode drops the trail’s opacity to zero to save battery while leaving glide typing itself working: see Details & edge cases.

Live preview while you swipe

You don’t have to wait until you lift your finger to see what WM Keyboard thinks you’re writing. Partway through a swipe, the suggestion strip already fills in with the current best guesses, and it updates as you keep moving. Those guesses are decoded against the same word list used for the final commit, so the word you see mid-swipe is never a preview of something different from what lands when you lift.

Screenshot pending

Mid-swipe: the suggestion strip already shows the leading candidate before the finger lifts.

Watching the candidates reshuffle under your finger isn’t for everyone. One word on the strip (WM Keyboard › Typing › Gestures, off by default) holds the strip to a single word for as long as the stroke is down: the same word the floating preview shows, and the same word a lift commits. The emoji, punctuation and rewrite chips left over from the word before the stroke stand down with the extra candidates, so the row carries one thing. Lift your finger and the alternates fill the strip as they always have, and the ambiguity picker still offers them mid-stroke if you hold still.

If you also use words on the keys, that feature has its own answer for what a stroke does to the keys, under While gliding. It ships set to Nothing, so the keys stay bare for as long as your finger is down and the words come back when you lift. The other two choices put the decoder’s alternatives on the keys so you can steer into one, or put the next word on the keys while you’re still drawing this one, ready to flick the moment the swipe ends. See During a glide.

Finishing a long word early

A swipe is normally read from end to end: the first letter goes where you started and the last where you stopped, so “dictionary” can’t be offered until you have glided all ten letters. Finish long words early (WM Keyboard › Typing › Gestures, off by default) lets the keyboard offer a word your stroke has only started, the way tapping four letters of it would. The guess shows in the floating preview and on the strip like any other reading, and lifting your finger types it. It’s colored rather than only bolded when the keyboard is sure of it, under Color the word a lift will type.

Two rules keep it from running ahead of you:

• A word you have drawn in full keeps its place. Gliding “thing” all the way to the g reads “thing”, not “things”, and “that” stays “that” even when “that’s” is a word you use a lot. A longer word only takes over when it’s clearly the likelier one, letter for letter, over what you have actually spelled. “When sure” asks for a wide lead; “Eager” offers the longer word as soon as it’s ahead at all.
• Under “Prefer my words” and “Only my words”, a guess is always one of your own words. The dictionary still reads a stroke you finish, but it never finishes one for you, so a rare dictionary word can’t jump in ahead of a word you have written a hundred times. Guessing the rest of a word is about twice as accurate out of one person’s vocabulary as out of a dictionary, which is why the two settings belong together. Up to 0.5.11 the first rule stopped applying under “Prefer my words”: a guess at one of your own words pushed the whole dictionary reading aside before the lead was measured, so “exam” came back “example” and “When sure” behaved exactly like “Eager”. Your own words are still preferred, but only a word your stroke really spells can set that comparison now.

Lifting early on a guessed word is a choice, much like tapping a suggestion, so the strip treats it as one. Instead of the stroke’s other readings (words that end where your finger stopped, which is nowhere useful), it fills with the word’s neighbours: the plural, the possessive, the verb form, the shorter word the guess ran past. Lift on “dictionary” and “dictionary’s” and “dictionaries” sit beside it; lift on “functionality” and “functional” is one tap away. Not available on phonetic layouts such as Avro and Hindi phonetic, where a stroke spells a romanization rather than the word itself.

A word you finish early teaches your swipe style only what you actually drew. Lift on “dictionary” after “d-i-c-t” and the keyboard learns where your finger landed on those four keys, not on the six it never reached. No shape is kept for the word either: the shapes are of whole words, and yours was only the start of one. The word itself is still learned like any other.

Alternates, and fixing a wrong guess

The moment you lift your finger, the best-scoring word commits to the field. The decoder hands back as many candidates as the suggestion strip has slots for, and the strip fills them from that list. The word that just committed is bolded in the center slot by default, following the same “best suggestion in the middle” layout that autocorrect and normal typing use, with its next-best rival to the left and a third option to the right. Tap any of them to swap it in for the word that just landed. Widen the strip (WM Keyboard › Typing › Suggestions, Number of suggestions, three by default and up to six) and every extra slot gets a candidate too.

From the third slot on, the strip also keeps up to two words one key off the word that went in, the same slips a typed word keeps: glide “is” and “us” is offered too. A swipe is read from the key where your finger went down to the key where it lifted, so a start or finish one key over is the miss the decoder ranks lowest, and on a confident stroke its own readings used to fill every slot first. These words are only ever offered. A lift never types one, and they stay out of the ambiguity picker’s decision of whether a stroke is a close call. They aren’t added under Only my words, after a word finished early, or on phonetic layouts. A swipe down or up on the strip right after a glide now pages through the stroke’s own readings; up to 0.6.3 it showed the openers or next words left over from before the swipe.

Screenshot pending

After the swipe lands, alternates sit either side of the committed word in the suggestion strip.

Tap-to-replace only works while your cursor is still sitting exactly where the glide left it. Move the caret away, or type something else first, and the alternates for that word retire. The same guard governs a plain backspace: press it right after a glide and it deletes the whole swiped word in one go rather than a character at a time, since a wrong swipe shouldn’t cost a letter-by-letter cleanup. That takes the trailing space with it, so one press puts the cursor back where the swipe found it. If your swipes tend to come out one or two letters off, turn off Backspace removes a glided word (see Options) and backspace after a glide deletes one character at a time, the same as after a word typed on the keys.

When a swipe is a genuine toss-up

Some strokes have no single right answer. On a fixed Bangla layout ক and খ share a key, so a word and its aspirated twin are drawn in exactly the same shape, and on any layout a hurried stroke can fit two words equally well. Rather than commit the likelier one and leave you to notice, Ask when a glide is unclear (on by default) offers the choice while your finger is still down.

When a stroke’s best candidate barely leads its runner-up, keep your finger down and hold it still. After Time to hold still (350 ms by default) the closest words appear just above your fingertip, in their own window, so a stroke that ends on the top row floats them over the suggestion strip rather than hiding them under the keys. The keyboard’s own first choice wears a thin outline, so you can see what a lift anywhere else will type. Slide onto a word and lift to type it. Lift without choosing and the keyboard commits its best guess exactly as it always did, and the same words are on the suggestion strip either way, so ignoring the picker costs nothing.

The moment the words appear, the stroke is finished. Sliding to a word does not redraw it, so the word you land on is the word that lands in the field. Change your mind about the whole swipe and slide down, more than a key below where you stopped: the words fade, a small “Lift to cancel” note appears, and lifting there types nothing at all. Slide back up and the words come back.

Four settings under the toggle tune it:

• When to ask decides how close a call a stroke has to be. Near ties asks only when the two words fit almost equally well. Close calls, the default, asks when the best word barely beats the next one. Any doubt asks whenever another word comes close. Every pause asks each time you hold still, whatever the keyboard thinks.
• Time to hold still is the pause before the words appear, from 150 ms to 1 s. Small movements do not count, so a finger resting on the glass still counts as still.
• Hold longer to always ask (on by default) lets a stroke the keyboard is sure of ask anyway: keep holding for twice the time and the words appear. Turn it off and a confident stroke never asks, however long you hold.
• Words to choose from sets how many words appear, from two to five. Up to three share a row above your finger; four or five add a second row above the first.

The picker appears only in the “Type words” swipe mode, since a handwritten stroke resolves through a different path. It works on a chained stroke too: pause on the last word of a swipe that crossed the spacebar and the choice is for that word. A word that is a snippet trigger or a personal dictionary shortcut shows what it expands to, like omw = on my way, since that is what lifting on it types.

The space after a glided word

Lifting your finger commits the word and a space, so you can glide the next word or tap it out without the two running together. The space belongs to the keyboard rather than to you, which is what makes the next three things work:

• Punctuation takes it back. Type . , ? ! ; : straight after a glide, or a closing ) ] } ", and the space steps aside, so you get “hello.” and not “hello .”. Opening brackets keep it, because “hello (world)” is what you meant.
• A space press is spent on it. Reaching for the spacebar out of habit doesn’t leave a double gap. The press confirms the space that’s already there. Press space again and you get the usual double-space full stop, exactly as if you’d typed the word out.
• Backspace still undoes the whole thing. The word and its space come out together.

A word glided back into the middle of a sentence, where a space already follows, doesn’t get a second one, except in web pages, where the space is always typed (why). A word swiped over a highlighted one is the exception to that exception: nothing on the page is a suggestion while a word is highlighted, so the space already after it is kept and no second one is added. The space is skipped in structured fields too: passwords, email addresses, web addresses and number pads, the same set that turns off every other typing courtesy.

Glide a word in front of a mark that closes up onto it, such as a full stop, a comma, a question mark or a closing bracket or quote, and the space waits. Put the cursor after “done” in “Is it done?” and glide yet, and you get “Is it done yet?”, not “Is it done yet ?”. The first letter you type there brings the space with it, and a mark, a space or a cursor move drops it.

A browser’s address bar spaces a glided word when what you’ve typed reads as a search: a line that already has a space, or plain letters with no dot, slash or digit in them. Type weather and glide today and you get “weather today”. After example. or github.com/ the word still joins on, as an address needs.

For one word at a time, put No space somewhere you can reach it: a key, a flick or a long-press alternate in the layout editor, a key of the text editing panel, a multi-finger swipe or a ?123 chord. Like Nintype’s spaceless key, it takes back the space the keyboard just put after a glided or picked word, and the next word you glide joins straight on: glide foot, No space, glide ball, and you have “football”. Tapped while a word is still being typed, two-thumb words included, it leaves the word open and the key lit: you can keep typing or swiping it, the strip still works, and when the keyboard ends it, with the all-thumbs-up pause or a pick from the strip, no space follows and autocorrect stays out of it. Press Space yourself and you get the space anyway. Tap again to call it off. A double tap ends the word on the spot, exactly as written. Right after a word and a space you typed yourself, it takes that space back too: type foo, Space, No space, glide ball, and you have “fooball”. A space after a punctuation mark stays, and a word ending in a vowel point or other combining mark counts as a word. With nothing to take back, a tap still joins the next glide: after foot, No space, glide ball, and you have “football”. Moving the cursor, Space, Enter or a backspace calls the joining off.

No space also works like Shift, for the one key after it. Double-tap it, or hold it, and the key lights up: the next key you type gets no space from the keyboard, before or after it. That is the . in github.com typed in an ordinary text field, where Space after punctuation would otherwise make it github. com. A space already in front of that key stays, so best then the armed . gives best .tld rather than best. tld. Holding the key only arms it: the word you are typing stays open and its suggestions stay on the strip. A word picked from the strip counts as the next key, so with the key lit, picking specific leaves no space after it and you can type on to specifically. Type the ., and the key goes dark again, so the next full stop is spaced as usual. Space, Enter, a new field or another tap of the key call it off, and a glided word counts as the next key, joining on with no space in front. On a flick, the arm does both: flick to No space and let go for the tap, or flick and hold your finger out on the arm until the key lights to arm it, so one flick up on the space bar carries the two. Flicking it twice quickly arms it as well. The arm on its own is also an action, No space after the next key, offered only for a gesture, where there is no hold; a key or flick arm picks No space and holds it. A key set to the arm-only action by an older version keeps working.

Turn this off with Space after a glided word (see Options) and a glided word commits bare. Words chained in one stroke are still spaced from each other either way. The setting only governs the space after the last one.

Gliding a whole phrase

You don’t have to lift your finger between words. Start a glide, cross the spacebar without pausing, and keep gliding straight into the next word. Each crossing ends one word and starts the next, and the whole phrase lands together when you lift. A crossing gives a small haptic tick if haptics are on, and the floating preview shows the last few words of the phrase so far. An earlier word in it can change as you draw the ones after it. If you have the context model, it has its say on the lift, so a word can change once more there.

A crossing has to reach the middle of the spacebar. Dip past its midline and come back up into the next word. A stroke that only clips the top of the bar on its way to a bottom-row letter like n or m stays part of the word it was drawing, so a long word that hugs the bottom row isn’t cut in two. Once you have crossed, the finger is on its way across until it climbs back to the middle of the bottom row: sliding off the end of the bar, running past its lower edge, or jittering along its top doesn’t start a word or cross again.

The words either side of a crossing are read knowing where they end. A word drawn alone ends on its last letter, and the decoder leans on that. A word that runs on into the spacebar ends at the bar’s edge instead, after a straight walk from its last letter, and the next word begins with the walk back up. The walk can be diagonal: the bar spans only the middle of the board, so a word ending on p heads for its near end. Those walks are read as walks, not as letters: the decoder may put the last letter anywhere on the way down and the first anywhere on the way up, so “I want to by a car” no longer comes out with “by” read off the key the finger passed on its way to the bar, and “the” followed by a walk no longer vanishes because no word ended there. This holds in the keyboard’s own text boxes and the typing test too, and when another swipe engine is reading the stroke, the walks are cut off for it. Measured on 30,999 real swipes joined into the sentences they were drawn for, with walks that curve toward the bar’s real extent, a word in a chain is read right 78% of the time, against 85% drawn alone. A word in a chain teaches the keyboard the word, but not where your finger goes for its letters: its ends are the bar, not the keys.

The stroke is read as a phrase, so each word is judged by the words after it as well as those before. “by a car” loses to “buy a car” once you have drawn “a car”, and the first word takes the two already in the field into account. The evidence is what you have typed yourself, then the word-pair list for your language if you have downloaded it, then the context model if you have that too. Measured on sentences the strokes were not fitted on, with the English word-pair list, words read right go from 77% to 83%, two-word phrases from 65% to 73%, and four-word phrases from 41% to 53%. With the context model as well they reach 85%, 76% and 58%. Reading the same list one word at a time, as a chain used to, gets 81%, 71% and 50%. With neither download, only the words you have typed and a small built-in list of pairs can change a reading.

A word of one letter works too. Glide up to a or i from the bar and straight back down: a stroke that is nothing but its way there and its way back is read as that letter, where the language’s word list has it. On real strokes it reads right 80% of the time before the words around it have their say, and about one longer word in a thousand reads as a single letter by mistake.

Screenshot pending

One continuous stroke crossing the spacebar mid-glide, committing a full phrase.

Only the final word of a multi-word glide gets alternates in the suggestion strip. Backspace takes the words back whole, last first. This behavior has its own toggle, Glide across spacebar: turn it off and a swipe that crosses the spacebar is read as a single word instead (see Options).

Typing with both thumbs

Two-thumb typing (WM Keyboard › Typing › Gestures, off by default) lets both thumbs work on the same word at once, the way Nintype did. Each thumb can tap or swipe, at the same time as the other, and every tap and swipe adds to one word instead of each swipe being a word of its own.

Say you want “something”. Tap s with your left thumb, swipe from o to m with your right, tap e with your left, then swipe t h i n g with your right. The thumbs can overlap: the next one can start before the last one has lifted. The keyboard keeps each thumb’s letters in the order that thumb made them, works out how the two thumbs’ letters fit together from when each one happened, and picks the word from the dictionary that fits best.

A tap that lands while the other thumb is still swiping goes into the word at that point of the swipe. Swipe over h e l o and tap l with the other thumb just after the swipe passes the l, and you get “hello”. One tap can also stand for a doubled letter, so k e p tapped can give “keep”.

A quick tap that rolls a little before you lift still types its key, as it does with one finger. Delay after typing works per thumb: right after a thumb taps, that thumb has to travel further before its stroke counts as a swipe, but the other thumb’s taps never make it harder to start one. The keyboard tells the thumbs apart by the half of the board each one lands on.

A thumb can wait on a key while the other one types. If it stays put and the other thumb taps or swipes meanwhile, it’s resting: holding it opens no popup and runs no hold action, and lifting it after 0.4 seconds or more types nothing. A quick overlap, one thumb landing just before the other lifts, still types both keys, and a long press while the other thumb is off the screen opens the popup as it always does. A resting thumb can still start a swipe from where it is. With All thumbs up, the pause before the word ends starts once only resting thumbs are left on the keys, so you don’t have to lift them. A third finger that lands while one thumb is swiping is ignored.

A letter you gave flick arms in the layout editor keeps them. A tap types the letter, and a stroke counts as a flick for as long as it still could be one; once it travels past the flick reach or heads onto another letter where no arm points, it is a swipe, the same as with one finger. Keys whose arms repeat, such as a caret arm, keep the whole stroke for themselves.

Swipe down to type the hint and Swipe up for a capital work for each thumb, by the same rules as with one finger. A short flick down on a letter types its corner hint and adds nothing to the word. A short flick up adds that letter as a capital to the word you’re building, as a tap under a held Shift would, so you can start “Hello” with a flick and carry on with both thumbs.

The word is read again after every tap and swipe, so the word in the text field and the alternates on the suggestion strip change as you go. A word you are still building often isn’t a word yet: the s and o-m of “something” spell nothing on their own. Then the field shows the start of a word they fit, here “som”, or the letters under your gestures if nothing in the dictionary starts that way. Nothing you did is dropped. The next tap or swipe reads the whole word again, and tapping space types whatever the field shows, after reading the last gesture if it was still being read. A space, a mark or Enter pressed while that reading is still running waits for it, along with anything you type after it, so the word, then its space, then your next letters land in that order. Up to 0.6.1 the keyboard read the whole word again on the spot instead, which could hold up the key press for a long word. Backspace takes back your last tap or swipe, not the last letter, and the word is read again without it. When no swipe is left, what remains is the letters you tapped, as typed. That holds just after the word is typed too: swipe car and pet, let “carpet ” go in, and the first Backspace takes out “pet” and the space, leaving “car” open for the next swipe. A word of a single swipe still comes out whole, with its space. And when a letter or swipe takes back the space All thumbs up typed, the word opens again as the taps and swipes it was, so a Backspace after that takes back a swipe rather than a letter.

Finish a two-thumb word decides what types the word:

• Space (the default). The word stays open while you tap and swipe. Tap space or punctuation to type it. Ordinary one-thumb glides work the same way in this mode: a swiped word waits for the space instead of getting one automatically.
• All thumbs up. The word is typed, with its space, once no thumb has touched the keyboard for a short pause, like ordinary glide typing with a moment’s grace. A thumb that lands before the pause is over carries on the same word, so your thumbs can take turns on “movement” or put the second e of “heed” on the other thumb without having to overlap. Words you only tap end the same way: tap T, lift, tap o, and “To” is typed with its space once you stop, corrected the way a space would correct it. A word you have just backspaced into waits for your next letter instead. A finger on the suggestion strip or the toolbar counts as a thumb on the keys, so you can reach up for another reading without the first one being typed under your finger: the word stays open until you lift, the reading you tap replaces it, and a touch you drag off without picking starts the pause again. Up to 0.6.1 only the keys held the pause.

Four sliders and a switch, shown with All thumbs up, tune that pause:

• Pause after a swiped word is the pause for a word with a swipe in it, from 100 to 1500 ms, 350 ms by default. Raise it if words end before you have finished them, and lower it if you find yourself waiting for the space.
• Pause after a tapped word is the same pause for a word you only tapped. Tapping leaves longer gaps inside a word than swiping does, and stopping to think halfway through a tapped word is normal, so you may want more time here. It starts at the swiped-word pause.
• Pause after a one-letter word is the least a single letter waits, whichever pause it would otherwise get. A lone letter is far more often the start of a word than a word. It starts at the shorter of the two pauses above, so it changes nothing until you raise it.
• Take the space back handles a space that came too early. A letter you tap, or a swipe you start, within this time after the space takes it back and carries the word on, as long as the two still lead to a word in the dictionary. Type car, let the space land, then type pet, and you get “carpet”. Type car, let the space land, then type dog, and it stays “car dog”. If the letters stop leading anywhere partway, the space goes back where it was: car, then d, o, g reads “card” for a moment and splits back into “car dog”. A letter typed after this time always starts a new word, and so does a capital. The time is counted to when your thumb lands, so a swipe you began in time still joins. It starts at twice the swiped-word pause, 700 ms by default, and goes up to 3 seconds. At the left end it is off. Twice the pause comes from the measurements published with Kinetica, another two-thumb keyboard: about one change of word in eight came that soon after a space, and the dictionary check kept 70% of those apart. A full stop or comma after the space still takes the space and sits against the word (“car.”), as before.
• Show the pause on the strip (on by default) draws a thin line along the bottom of the suggestion strip while your thumbs are up. It shrinks towards the middle over the pause, and the word is typed with its space when it is gone. A thumb that lands before then takes the line away and carries on the word. With reduced motion on, the line stays whole until the pause is over.

Up to 0.6.1 there was one pause for every word, nothing took the space back, and nothing showed the wait. These settings start where that one pause was, so the timing only changes once you move a slider. The tapped-word, one-letter and take-back rows follow the swiped-word pause until you move them; Reset on one of them makes it follow again.

When the next word’s swipe joins a word because it began before the space, “car” and “pet” coming out “carpet”, the strip offers the two apart: car pet, beside the joined word but never in its place, so Space still types “carpet”. Tap it and “car” goes in with its space, and “pet” is the start of the next word, open for more taps and swipes. The chip stays on offer after the all-thumbs-up pause has typed the joined word, and picking it then takes that word and what it taught back out first. Undo the last swipe with Backspace and the strip offers it back as ↪ pet, the start of the next word; anything else you type, swipe or move takes that chip away.

While a word is still being built, the floating word over the keys follows the stroke you are drawing, including the start of a word (“som”) when the gestures so far finish none. A tap from one thumb while the other is still swiping joins the preview of that swipe instead of replacing it, and when the field shows only the start of a word, the suggestion strip offers the words it could become, as it does for typed letters.

Some glide features read one stroke as a whole word, so they are off while two-thumb typing is on: gliding across the spacebar, glide over Shift to capitalize, the picker for a toss-up, Hold to ask included. The settings screen’s note on Two-thumb typing lists them too, and while two-thumb typing is on each of their rows says it is off. Their values stay as you set them for when you turn two-thumb typing off. Pause, loop and wiggle marks all count in a word that is one swipe and nothing else. In a swipe that is part of a bigger word only the loop counts: tap m, then swipe e t with a small circle on the e, and “meet” moves up the suggestions instead of trailing “net”. Two-thumb typing works in the app you are typing in, and in the keyboard’s own text boxes that have the keys: the searches, the AI prompt, a plugin’s text field. There a swipe that lands right after letters joins them into one word, read again whole, and Space ends it; All thumbs up doesn’t end a word in those boxes. The typing test and the word card’s spelling bar keep one-finger glide. Phonetic layouts such as Avro, and keypads that guess, read every swipe as a word of its own.

A two-thumb word teaches the keyboard the way a glided word does. Each swipe in it teaches your swipe style where your finger landed on the letters it drew, and a word that is one swipe and nothing else also files its shape. Backspacing the word straight after it is typed takes those lessons back. Fixing a two-thumb word later teaches only that you wanted the other word, never a typing mistake, since the decoder chose the letters and not your fingers. Letters the keyboard falls back to when your gestures finish no word, like “qy” for a swipe from q to y, are typed as shown but never counted towards learning a new word. A word you only tap is learned like any other typed word. Up to 0.6.1 two-thumb words were learned as if you had typed every letter.

Statistics counts a two-thumb word once, as a glided word, when it ends, and a word with more than one tap or swipe in it also goes towards the Two-thumb typing achievement. The keystrokes it saved are its letters less one for each tap and swipe.

Finishing typed letters with a swipe

You can also do this with one thumb. Swipe finishes typed letters (WM Keyboard › Typing › Gestures, off by default) makes a swipe right after typed letters finish them as one word: type t o, then swipe g e t h e r, and “together” is typed with a space, as a glided word is. With the setting off, the typed letters are a word of their own and the swipe types the next one. Two-thumb typing always works this way, so the setting is only shown while two-thumb typing is off.

A word you only put the caret back on doesn’t count as typed letters. Tap at the end of “Hello” and swipe, and the swipe is a new word with its own space, with two-thumb typing on or off. Type or delete a letter in that word first and the swipe finishes it as usual. Up to 0.6.1 the swipe joined the word the caret landed on and came out glued to it.

How it picks a word

The decoder scores every dictionary word that could plausibly match your stroke and returns the best one, weighing three things:

• Shape. How closely the drawn path matches the ideal path through that word’s letters. Both are resampled to the same number of points, so a fast, loose swipe compares fairly against a careful one.
• Start and end anchoring. How close your stroke actually started and ended to that word’s first and last letter keys. A word is thrown out early if the stroke doesn’t begin and end near its endpoints at all.
• Word frequency, as a small tiebreaker. It’s what makes “the” win out over similarly-shaped rivals like “they” or “them” when the early part of the stroke looks the same.

How much that tiebreaker counts depends on the language, not on you, so the keyboard sets it per language rather than offering a slider. With another language’s words mixed in through Also suggest from, the shipped English weights apply instead, since the language’s own were measured on its list alone. The decoder’s weights were fitted on English swipes, where the words people swipe are also the common ones in the list. German is different: its compounds are rare in any word list, so a frequency weight fitted on English lets a common short word outvote a well-drawn long one. Since 0.6.4 a German layout decodes with frequency at half its English weight and a stiffer charge for a detour between two keys. On 2,588 real German swipes that read 2.9 more in every hundred right, and 10.6 more on a corpus of rare words; the same weights would cost English about one in a hundred, which is why they apply to German alone. Everything you set under Advanced tuning stays yours on every language; the per-language weights are the two no setting reaches. Other languages that build long compounds (Finnish, Dutch, Swedish, Norwegian) are the next candidates once their swipes are measured the same way.

A word list can’t hold every compound a language builds as it goes, and German builds them constantly. On real German swipes, 36 in every 100 words of fifteen letters or more were missing from a 150,000-word list, and a bigger list wouldn’t help: generating compounds into a list adds far more non-words than words. Since 0.6.4 a German layout reads a compound the list lacks from its parts. When a stroke has passed through a listed word of four letters or more and keeps going, the decoder may read what follows as a second listed word, or a third, on the same stroke, as if the list held the joined spelling. “Haushalt” is read from “Haus” and “Halt” when only the parts are listed. A word list says which words exist, not which pairs of them make a compound, so the joined spelling also has to appear in the full German frequency list, which the keyboard fetches once (5.5 MB, when Download data automatically is on and the connection isn’t metered). Until it has, nothing is joined. That is what keeps “fragenroot” off the strip when you swipe “Garagentor”. Every part needs four letters, so a short common word can’t end a compound: “hast” and “alt” never make “hastalt”. The joined reading ranks by its rarest part and pays a charge for each join, and a part the reading joins past pays more the commoner it is, so a word the list holds whole still wins over the same letters joined from two common ones. Without that last charge, two common parts outbid real words often enough to lose about 3.5 swipes in a hundred; with it, the same 2,588 German swipes read half a point better than with no joining at all. Linking letters between parts (the s in “Arbeitszeit”) aren’t read yet, so a compound built with one still needs to be in the list, or learned once you’ve typed it.

How forgiving those gates are is yours to set. Start error radius, End error radius and Path error radius live in the Advanced tuning fold (WM Keyboard › Typing › Gestures) and are all measured in key widths. The first two are how far the ends of your stroke may sit from a word’s first and last letter, and the third is how close the stroke has to pass a key on the way for that letter to still be available. They ship at 1.6×, 2.0× and 1.9×. Raise them when your swipes run wide or cut corners and the word you wanted keeps missing, and lower them to hold the keyboard to the keys you really crossed, which prunes the search a little as well. Going much under 1.3× is where words start dropping out, so move down in small steps and swipe a few sentences before you decide. They’re also the quickest way to compare how a layout behaves under your thumb, since a fixed layout with crowded keys wants a different tolerance than a roomy one. Past 1.6×, the two end radii also change how a word scores. Whatever you add above 1.6× is distance the decoder forgives between where your finger went down (or lifted) and the word’s first (or last) key, so a word that starts 2.5 keys from your touch-down competes on shape and frequency with one that starts right under it. That is the setting for thumbs that habitually land low or lift early. The end radius ships at 2.0× for that reason: on thousands of real recorded swipes, lifts stopped short of the last letter often enough that forgiving the last 0.4 of a key read more words right. At 1.6× or below, nothing is forgiven and the radii only decide which letters a word may start and end on.

A language can keep its own radii. One value rarely suits every layout: Kana JIS packs about fifty keys into the grid, so a radius that forgives a sloppy English stroke on QWERTY lets a Japanese stroke reach keys it never went near. Open the language in WM Keyboard › Languages, and its Glide typing group (shown at the Advanced depth, while glide typing is on) has the same three sliders. Each one starts at the global value. Move it and that language decodes with its own value from then on, whichever layout of it is on screen, while every other language keeps the global one. A radius you leave alone keeps following the global slider, and the row’s reset hands it back. Error radius by language, under the three global sliders, lists the languages that have their own with the values they use, and opens each language’s page. The marks for a doubled letter below aren’t per language, because they describe your hand, which is the same in every language.

None of those three looks at the word that came before. The stroke decoder is deliberately context-free: it reads the path and the candidate’s own frequency, nothing else. Context arrives one step later. Where the language has a context model downloaded (English and romanized Bangla do), the model first nudges each word on the shortlist up or down by how much likelier it finds that word than the decoder’s first choice after the words already in the field, within a fixed limit, so a close call between two strokes goes to the word that fits the sentence. Since 0.6.4 that counts for more on a swipe than on taps, because a stroke says less about its letters than taps do: on 2,294 German swipes with a word before them, measured with a simple word-pair model standing in for a real one, it took the decoder’s first choice from 71 to 81 right in a hundred. The shortlist is then reordered by the same n-gram reranker the suggestion strip uses, and it’s the top word after that reorder that commits. That step is Context-aware suggestions (WM Keyboard › Typing › Automatic corrections, on by default and gated on autocorrect being on). Turn it off and the decoder’s own order stands, so a glide commits purely on shape, anchoring and frequency. A word the model holds only in pieces, such as a long compound, gets a say too, and German weighs the sentence on its own scale.

Long words are read the same way as short ones, all the way to the 32-letter limit. The limit was 24 up to 0.6.4, which left a 26-letter compound like “Qualitätsmanagementsystem” unreadable however well it was drawn. A big word list holds thousands of short words that fit the first few keys of any stroke, so the search judges each partial word on how well it could still explain the stroke left ahead of it, not only on how well its own letters fit. Up to 0.6.0 it judged only the letters so far, and on a large list it ran out of room before reaching a long word at all: a German compound like “Computertomographie” or “Qualitätsmanagement” came back as a short word that fit a third of the stroke. On the 205,000-word German list, strokes of 15 to 17 letters went from about 1 in 7 read right to nearly all of them. A stroke that crosses the keyboard many times over is also read in finer steps than a short one, so the corners of a twenty-letter word don’t blur together: drawn the way a finger really draws it, “internationalization” went from about 1 in 3 read right to 5 in 6. Since 0.6.4 the steps keep getting finer the longer the stroke runs, so a 30-letter word is read at about the same detail per letter as a 15-letter one rather than at half of it. Shorter words are read exactly as before.

A couple of shape quirks are worth knowing. Double letters only need one pass over the key, so “good” traces g-o-d, because drawing a letter twice in a row adds nothing a shape comparison can see. A small circle on the key says you meant the letter twice, and it has a section of its own below, with the two marks that say a letter is in the word at all. And a word needing a character with no key on your current layout, an accented letter your layout doesn’t have, say, is quietly left out of the running rather than causing an error.

Every letter a key carries counts as that key for a swipe, not only the one it types: the letter on its Shift, the one in its corner and the ones behind its hold all sit where the key does, which is how a Bengali aspirate on Shift or a German ü behind u can be drawn. Since 0.6.4 that reaches keys that type no letter themselves. A digit on a custom number row with a letter behind its hold, or a punctuation key whose Shift is a letter, puts that letter on the grid at its own spot. It does so only for a letter no letter key already carries, so a letter key keeps its own letters and a digit holding the same letter adds nothing.

A stroke that strays above the letters is read as the top row it was reaching for. Going for i, a finger overshoots onto the 8 above it as easily as it dips into the spacebar below n, and nothing above the top row spells a word. Since 0.6.4 every point of a stroke above the top row is moved straight down onto that row’s upper edge before the stroke is read, so drawing m, a, 8, n gives “main”. The ends gained the most. A stroke that starts on the digit above its first letter used to start further from that letter than the start error radius allows, and gave nothing at all: twenty common words started that way on test strokes, a row and a fifth up, were read none of the time before and every time now. When a number-row key carries a letter of its own (above), the number row is part of the grid and the stroke is only moved down from above it. There is no setting for this, because a swipe can’t type a digit: no stroke through the number row ever meant one.

Punctuation inside a word is the exception to that last rule. Hyphens, dots, at signs, underscores, ampersands, plus signs and slashes aren’t on the keyboard’s letter grid, so you can’t draw them, and words are spelled with them all the time. Swipe the letters and leave the punctuation out: fdroid for “f-droid”, coop for “co-op”, wasime for “wasi.me”. The word comes back punctuated the way your dictionary spells it. Where both spellings exist, the unpunctuated one goes first on the strip and the punctuated one sits right beside it, so “email” wins over “e-mail” on a tie and loses to it when your dictionary says “e-mail” is much the commoner of the two.

Some entries in a downloaded or imported word list are never offered for a swipe. The big English download is built from film subtitles, which spell out speech as people said it. That gives you cut-off words (“that-”, “can-”), words with the full stop still on them (“no.”), and stutters (“n-no”, “c-c-can”). Each one draws the same as the real word, so all they could ever do was take the strip’s other slots. A word list entry that ends on punctuation, or whose part before the hyphen starts the part after it again, is skipped. That rule also catches a handful of real words such as “D-Day” and “t-test”. Words you added yourself or the keyboard learned from you are never skipped, however they’re spelled.

The apostrophe is the one piece of punctuation left out of this, because contractions are exactly where guessing goes wrong. “its” against “it’s”, “were” against “we’re” and “shed” against “she’d” are all one stroke each, and picking between them on word frequency alone would be a coin toss. It has its own answer instead: set Apostrophe in a glide to a key and swipe through that key. Without that key, the drawn word goes in and its contraction sits right behind it on the strip, with one exception: where the word before says a clause is starting, a pronoun’s contraction goes in instead. Draw hell at the start of a sentence, or after words like and, but, so, if, when, because, said or think, and you get “he’ll”, with “hell” right behind it on the strip. The same goes for “she’ll”, “she’d”, “we’d” and “I’d”.

The contractions that are not ambiguous are swiped without it. Draw doesnt, isnt, wasnt or shouldnt and the keyboard reads the stroke as the contraction and writes “doesn’t”, the same repair Fix missing apostrophes makes when you type. This holds for every contraction in that repair’s table, whether or not the word list has the bare spelling, and it goes away when that setting is off. Where the bare spelling is a rarer word of its own, such as ill, cant or wont, the stroke is weighed as the contraction it is far more often drawn for, so drawing ill gives “I’ll”.

Words you saved yourself with an apostrophe in them work the same way: save “Jenny’s” and drawing jennys gives “Jenny’s”, no apostrophe key needed. That holds only where the spelling without the apostrophe is not a word in its own right. A spelling a word list holds only because people leave the apostrophe off doesn’t count as a word of its own: German lists count gehts far more often than “geht’s”, and since 0.6.6 a “geht’s” you’ve typed in place of a wrong swipe is learned for the stroke like any other word, so the next gehts you draw gives “geht’s”. Before, the word and the shape of your stroke were kept under the spelling with the apostrophe, which the swipe never asked for, so correcting it taught nothing.

The FUTO Swipe engine

Everything above describes the keyboard’s own decoder, which reads every language and layout. For English on a QWERTY layout there is a second one to choose from. Glide engine (WM Keyboard › Typing › Gestures, Built-in by default) can be set to FUTO Swipe, which reads a swipe with two small neural networks published by FUTO: an encoder that reads the stroke and an English QWERTY decoder that turns it into letters, trained on about a million swipes people drew on real phones. The keyboard then spells words out of your own word lists from those letters, the same lists, added words and learned words the built-in decoder uses, and the result goes through the same context reranking, ambiguity picker and alternates on the strip.

On 5,000 swipes from FUTO’s public test set (real people’s English swipes, not drawn by a program), against the keyboard’s bundled English list:

	Right word first	Right word in the top four
Built-in decoder	80%	94%
FUTO Swipe	96%	99%

Against the 160,000-word downloadable English list the built-in decoder scored 82% and 92%, FUTO Swipe 95% and 99%. Both figures count only swipes whose word is in the list, since neither engine can type a word it doesn’t know. The built-in decoder stays the default until the same comparison has been made on phones.

Picking it asks you to accept the FUTO Model Weights License, then downloads the two models, 3.9 MB together, from FUTO’s Hugging Face page, pinned to one version and checked against their SHA-256 checksums. On a build that leaves the ExecuTorch runtime out of the APK (the Play Store, GitHub and F-Droid builds fetch it on first use, the same runtime offline Asr4All, Parakeet and Moonshine run on), that comes down too. The models run on the phone, so your swipes never leave it. The licence asks that the keyboard say it is powered by FUTO Swipe, which the setting does under its row and the About screen does in its list of components.

FUTO Swipe only reads English on a QWERTY layout. Another language, another layout (AZERTY, QWERTZ, Dvorak, Colemak and the rest all move some letter to another row), a phonetic layout such as Avro, and any swipe before the models are on the phone all go to the built-in decoder, with nothing to switch. Two-thumb words are always read by the built-in decoder.

Three of the built-in decoder’s features carry over to FUTO Swipe, each measured on FUTO’s own test swipes before it was kept:

• Finishing long words early. Lift part way through a long word and the strip can offer the word you were spelling, the commonest one that starts with the letters you drew. On swipes cut at 70% of their length the right word came first 12 times in 100 instead of 7, and on fully drawn swipes a guess took the place of the word you drew 17 times in 38,000. FUTO Swipe scores words on a narrower scale than the built-in decoder, so When sure almost never offers a guess with it; use Eager.
• A loop for a doubled letter. FUTO Swipe reads “god” and “good” off the same keys, and a small circle on the o settles it for “good”. The loop only decides between spellings that differ by doubling that key, so a curl drawn at a corner moves no other word. Without a loop the more common spelling leads, rather than the single one.
• Your swipe style’s shapes. A word you have swiped before gets a little credit when you draw it the same way again. On words a person had already swiped earlier in their session, the right word came first 98.4 times in 100 instead of 98.1.

A pause or a wiggle on a key does not mark a letter with FUTO Swipe. The model reads the timing of your stroke for itself, and counting pauses on top of that made it less accurate on real swipes.

Google’s gesture library

The third choice under Glide engine is Google’s gesture library (imported). This is the closed-source glide engine from Google’s own keyboard, the same file HeliBoard and other open keyboards based on AOSP can load. WM Keyboard doesn’t include it, host it or download it, because it belongs to Google and isn’t licensed for anyone else to hand out. You bring the file yourself.

The file is called libjni_latinime.so. GApps packages (the bundles of Google apps that custom Android builds install separately) carry it as libjni_latinimegoogle.so, usually inside a folder or zip called “swypelibs”; rename it or not, the keyboard accepts either name. There is one build for each processor type, and the keyboard takes only the exact builds HeliBoard accepts, checked by their SHA-256:

Processor (ABI)	SHA-256
arm64-v8a	b1049983e6ac5cfc6d1c66e38959751044fad213dff0637a6cf1d2a2703e754f
armeabi-v7a	442a2a8bfcb25489564bc9433a916fa4dc0dba9000fe6f6f03f5939b985091e6
x86_64	c882e12e6d48dd946e0b644c66868a720bd11ac3fecf152000e21a3d5abd59c9
x86	bd946d126c957b5a6dea3bafa07fa36a27950b30e2b684dffc60746d0a1c7ad8

Almost every phone sold in the last several years is arm64-v8a, and the Gesture library row names the one your phone needs. Any other file is refused with a reason: a build for another processor says which one it is, and anything else is “not a build this keyboard knows”. The check is strict on purpose. The library is machine code that runs inside the keyboard, written against one exact set of entry points, and a different build would crash it or behave in ways nobody has looked at. Turning off Verify downloaded files in Privacy doesn’t relax it. Import a file only from a source you trust.

To set it up, pick Google’s gesture library (imported) under Glide engine, tap Import on the Gesture library row and choose the file in the system file picker. The Storage screen’s import (WM Keyboard › About › Storage › Import downloaded files) also recognises it, by its name or by its checksum if it was renamed on the way; see Importing instead of downloading. So does opening the file from a file manager or a chat app: WM Keyboard asks Import the gesture library? and runs the same import. The file is copied into the keyboard’s private storage, read-only, and it is never backed up. It loads the next time you swipe. Android can’t unload a library, so replacing one that is already running takes effect after the keyboard restarts. Remove gesture library deletes the file and the dictionaries built for it, and glide typing goes back to the built-in decoder straight away. A library that was already loaded stays in memory until the keyboard restarts, because Android can’t unload it, and the Gesture library row says so (Removed) instead of Loaded.

The library needs a dictionary in its own format. The keyboard builds one on the phone from the word lists of the language you’re typing in, its commonest 120,000 words, and has the library write it so the format is always the library’s own. That takes a few seconds the first time and is kept for later; a new or changed word list triggers a rebuild. Words you have added or the keyboard learned from you go into it as well. Until the dictionary is ready, and in a language with no word list, swipes are read by the built-in decoder as usual. The words it returns then go through the keyboard’s own blocked-words list, context reranking, capitals and ambiguity picker, the same as with the other engines.

It works in any language whose layout has one letter per key; HeliBoard notes that keys with several letters or the same letter twice confuse it. Finishing long words early, the marks in the next section and the shapes your swipe style keeps don’t apply while it reads a swipe, and two-thumb words stay with the built-in decoder.

If the keyboard closes while the library is loading, building a dictionary or reading its first swipe, it is switched off and the row says so. Try again turns it back on. Nobody has yet measured how well it reads swipes on this keyboard, so the built-in decoder stays the default.

The Google Play version can’t load it at all. Play doesn’t allow an app to run code that didn’t come from Play, so that build leaves the import out and the choice doesn’t appear.

Marking a letter as you glide

Some words are the same stroke. “good” and “god” are: the o is one key and your finger crosses it one time, so the shape of the path has nothing to say about which word you meant. So are “write”, “wire” and “wrote”, which all draw the same straight line along the top row of a QWERTY keyboard. Without a mark, the commoner word wins on frequency alone. There are two kinds of mark you can make on a key, and they mean different things:

• Stay on the key: “this letter is in the word”. Slow to a stop on the i and carry on, and every word with no i there loses, so “wrote” drops away and “write” and “wire” are left. The stop counts for the key you stop on, not the keys next to it. The keyboard measures the pause against your own speed in that same stroke rather than in seconds, so it works the same whether you glide quickly or carefully. This one can’t be switched off.
• Rub back and forth on the key: the same thing, without stopping. A wiggle is the moving way to make a pause, for when stopping feels slow. It’s off out of the box, because a slow turn drawn with an unsteady finger looks much the same to the keyboard, and reading it marks keys you only went past. Turn it on if it’s the mark you naturally make.
• Draw a small circle on the key: “this letter, twice”. Swype’s mark, and the only one that doubles a letter. Go around on the o once and carry on for “good”. The circle costs the word nothing: the loop is taken back out of the distance your finger travelled, so “god” is no worse off for having been drawn with one. The circle belongs to the one key nearest its middle, so the keys its edge passes over stay out of the word, and a circle on the f of “off” can’t turn into “odd”. A circle on the last letter, with nothing after it but the lift, also says the word ends there, so with Finish long words early on a circle closing “see” stays “see” and isn’t read as the start of a longer word.

A pause or a rub never doubles a letter. Without a circle, the two spellings tie on shape and the more common word leads: a plain “al” stroke reads as “all”, “ben” as “been”, and “ill” or “I’ll” come up for a stroke from i to l. Only when the two are about as common does the single spelling keep a slight edge, and a circle on the key is how you settle that one. The circle also no longer draws in neighbouring letters, so a looped “need” stays “need” rather than turning into “needed”, and “bee” doesn’t become “bede”. If you always pick the same word from the strip for a stroke, the keyboard learns that too.

Each has a row in the Advanced tuning fold (WM Keyboard › Typing › Gestures). Pause to mark a letter sets how long a stop has to be. Loop to double a letter turns the circle on and off, and under it Loop sensitivity sets how much of a circle a curl has to be, Biggest loop that counts keeps a wide sweep through a ring of keys (the way “murderer” is drawn) from reading as a mark, and Loop centring sets how near the letter the middle of the circle has to sit. Wiggle to mark a letter does the same for the rub, with a strength and a size of its own.

These are worth moving because they’re about your hand, not your layout: a careful glide pauses everywhere and a quick one barely pauses at all, and the same curl is a deliberate circle from one person and a shaky corner from another. If words lose letters you only went past, raise the pause; if your stops don’t seem to count, lower it. If doubled letters keep appearing on their own, raise the loop sensitivity; if your circles don’t count, lower it.

Autocorrect and learning

Going back to a misread swipe

Putting the cursor back on a swiped word puts that stroke’s other readings on the strip, ahead of the strip’s own answer. This matters more than it sounds. The strip normally reads the letters standing in the field, so a stroke misread as “form” offers “forms” and “fort”: respellings of the wrong word, never the word you drew. The readings the stroke actually produced do contain it, so those go first, and taking one is both the fix and a lesson: it counts as a correction of that stroke, the same as re-picking straight after the swipe.

The readings are kept for the last 500 swiped words in the field and go when the field does. Each set is tied to the spot its word sits in, so the same word typed somewhere else in the text never picks up that stroke’s readings.

Sometimes the readings don’t contain it either. Under Only my words a swipe is answered out of the words the keyboard has learned from you, so a word it has never seen you write cannot come back however you draw it. That is the trade the setting makes. The stroke itself is still there, though, and it is the only record of what you meant: the letters left in the text are the keyboard’s guess, not your finger’s path. So hold any word on the suggestion strip while the cursor sits in the wrong word and pick Search all words. The stroke is read again against every word list you have, past the sandbox and past the vocabulary limit, and the strip fills with what the full dictionary makes of it. Take the right word and it both fixes the text and teaches the stroke: the hand model, the shape for that word and the pair, exactly as though you had picked it the moment you swiped. This is the proofreading pass a swipe otherwise doesn’t get; tap typing has it for free, one letter at a time.

The search is asked for rather than automatic, because it is the slow, noisy decode that the vocabulary limit and Only my words exist to avoid, and running it on every word you read back would undo the setting. If you’d rather not go through the menu, Offer a full search while proofreading puts a small search button on the strip whenever the cursor lands in a swiped word whose stroke is still kept. Tap it to run the search; hold it to send it away. It is an icon rather than a sentence on purpose: the words beside it are the ones the search is offering to improve on, and a chip that spelled the offer out took half a phone’s strip with it. It’s still off until you turn it on.

Paths are much heavier than readings, so by default only the newest 24 swiped words in the field keep theirs. Past that the readings remain and the full search is no longer offered. Swiped words a full search can reach (WM Keyboard › Typing › Gestures, beside Offer a full search while proofreading) changes that number, from 0 to 500. Each path is a few kilobytes, so 500 can take a few megabytes while you write a long text; 0 keeps none, and the full search is never offered.

Autocorrect never runs a second pass over a glided word. The decoder only ever returns real dictionary words in the first place, so there’s no typo to fix. What glide typing does share with normal typing is learning: every word a glide commits goes through the same learning path a tapped-out word does. It’s reinforced in your personal dictionary and recorded as following whatever word came before, which is what powers next-word prediction later. It works the other direction too. A word you’ve recently typed or had autocorrected becomes swipeable right away, since learning a word immediately refreshes the list glide typing decodes against.

Learning from a glide follows the same rules as any other typing. It respects the “Learn from typing” toggle, pauses under incognito, and skips entirely in fields that don’t allow typing intelligence. There’s no glide-specific exception.

What a swipe teaches

A kept swipe teaches three more things besides the word, all under Learn my swipe style. The first is where your finger actually lands. Nobody swipes through the exact middle of every key: a thumb cuts the far keys short and lands low on the near ones, and every swipe used to pay for that. Each swipe you keep records where your finger really passed each letter, and later swipes are read against keys moved to match, so a consistent miss stops costing anything, and so does a hand that draws every word a little smaller than the keyboard and never quite reaches the far keys. The second is how you draw each word. The decoder compares a stroke against the textbook path through a word’s keys, and nobody draws that either: you cut the same corners the same way every time. So a few of your own shapes are kept per word (three, unless you change Shapes kept per word under Advanced tuning), and a word you have swiped before is read against them as well as the textbook path. The shape only lands once the word has settled as a learned word, never at the moment you swipe it, so a swipe you take back or replace teaches nothing, and one you replace marks the shape that read it wrongly. The third is what you do about a wrong reading. Take a different word off the strip, lift on a picker word that wasn’t the leader, or backspace a swiped word straight away, and the keyboard remembers it against that pair of words. One or two corrections are a nudge that tips a close call. Three the same way are a rule: the same stroke then reads your word first without asking, even over a word the lists count a few dozen times as often, so a German machst you keep putting right stops coming out as macht. A word the lists barely hold is still never forced in, and one correction the other way takes the rule back to a nudge. Backspacing a swiped word takes its lessons back. If you then swipe or type the word you meant within ten seconds, the stroke teaches that word instead, but only when it started and ended within about two keys of that word’s first and last letters. Delete a swiped “the” and type “a” and nothing is learned, since that is an edit of the sentence rather than another go at the swipe. Up to 0.6.2 any word typed next took the stroke.

Only the shapes are filed under words, and only under words already in your personal dictionary. The finger positions are numbers on a grid, and the corrected readings are scrambled fingerprints of the words, so those files say nothing readable about what you wrote. All three travel in a backup under Swipe style, which is off until you turn it on, for the same reason the dictionary is: the shapes are filed under the words you drew them for. Forget my swipe style deletes all three and starts over, and leaves your learned words alone; the word card a held suggestion opens can also forget the shapes of one word.

Since 0.6.6 the shapes are stored in a compact binary file (learning/glide_shapes.bin) rather than JSON, about half the size, and quicker to read when the keyboard starts. Your existing shapes move over the first time the keyboard saves after the update. The file carries a SHA-256 checksum, so a file damaged on disk is noticed rather than misread: the keyboard puts it aside, reads the version before it, which it keeps beside the live one, and starts without learned shapes only if both are unreadable. A backup still carries the shapes as JSON, so it restores on older versions too. Going back to 0.6.5 or older by installing it over this one doesn’t carry them, because those versions can’t read the binary file: make a backup with Swipe style in it first, and restore it after the downgrade.

Your hand is allowed to change its mind. A word you start drawing from a different place, or hold at a different angle, is a new shape: keep drawing it the new way and the new shape settles in and the old one fades out, rather than the first way you ever drew it holding the slot for good.

It also no longer matters how you make the correction. Taking the right word off the strip, backspacing the wrong word and picking off the strip that comes back, and backspacing it and drawing again all teach the keyboard the same three things. Backspacing first used to teach nothing at all: the stroke was thrown away the moment the word came off, so there was nothing left to attach the right answer to, and the same correction could be made over and over without the reading ever moving. Now the stroke waits a few seconds for whatever you put in its place.

One more shift-related detail: only the first word of a multi-word glide honors a held Shift, capitalizing it or, under caps lock, the whole word. Words chained afterward in the same stroke always land lowercase.

Capitalizing without leaving the stroke

Tapping Shift and then swiping is two gestures for one word, and it breaks the flow that makes gliding worth using. That’s why most people stop capitalizing swiped names. So the stroke can say it itself: draw through the Shift key on your way and the word comes out capitalized. Cross it twice in one stroke and the whole word is in capitals, the same ladder tapping the key walks up.

The detour spells nothing. The walk out to the Shift key and the walk back are cut from the path before the word is read, not only the key itself, so going out to the key and back never adds a letter: a stroke drawn t→Shift→h→e→r→e reads as “there”, not as whatever lies between t and the key. Nothing happens unless the key is actually crossed, so ordinary swipes near it are unaffected, and the switch (Glide over Shift to capitalize) turns it off entirely. The preview keeps up: from the moment the stroke crosses the key, the word floating above your finger and the candidates on the strip show the capital the lift will type.

What a pass over Shift capitalizes chooses what a crossing means. Whole word is the ladder above. One letter reads each crossing as a capital for the letter your finger just left, so a stroke can write HeLLo or LeanType: glide to the letter, out to Shift, and on to the next letter, as many times as the word needs. Under that reading a whole-word shout is one trip rather than two: end the stroke on the Shift key and every letter is a capital. A capital the keyboard armed itself at a sentence start still stands, so a drawn capital and an automatic one can be different letters of the same word.

This is also the one way a swipe can teach a capital. A capital the keyboard chose is never evidence of how you spell a word (see Personal dictionary); a capital you drew is.

The glide check-up

Two of the numbers behind a swipe depend on what you write, not on the keyboard: how much of the dictionary a swipe may answer with (Words a glide can produce) and how much a word’s commonness counts against the shape you drew. The second has no slider. It is set per language, because a word list’s frequencies mean different things in different languages, and the right value also moves with the person: someone who writes rare words wants shape to count for more than someone whose words are the common ones. The check-up (WM Keyboard › Typing › Gestures › Glide typing › Glide check-up) finds both from your own swipes instead of asking you to guess. It is off until you open it and turn Measure my swipes on.

While it measures, each word you swipe is read again in the background under a few candidate values, and only the words that come out are kept, never the stroke. If you later fix that word, by taking another reading off the strip, running a full search, or backspacing it and drawing again, the record is updated with the word you meant. After 30 swipes the screen proposes one change at a time, and only one that would have read more of your own swipes right. It says so in those terms: “On your last 60 swipes this would have read 56 right instead of 52: 5 more, 1 fewer.” The proposal is judged on swipes the fit never saw, so a value that happens to suit half your words and not the other half is not offered. The vocabulary limit is tried first, then the frequency weight; the radii and the other geometry are not on the ladder, because on thousands of real swipes they were already at their best and a per-person fit had nothing to win.

Apply sets the value, Not now puts that candidate aside until you start over, and Undo puts the old value back. A proposal measured against a value you have since changed by hand is refused rather than applied over it, and measuring starts again from the new value. After you apply a change the check-up watches the next 40 swipes and compares how often you corrected a swiped word before and after. It then says which way it went and offers Keep or Undo; nothing is ever undone for you. The screen also shows what it learned about your hand, in key widths: how far inside a corner you cut, where your finger sits relative to the letters, how much of a word’s span a stroke covers, and how far from the first and last letters it lands and lifts. A fitted frequency weight is listed at the bottom of the screen with a reset back to the language’s own; Start over forgets everything measured.

Options

WM Keyboard › Typing › Gestures

The Gestures group on the Typing settings screen.

Setting	Default	Notes
Glide typing	On	Master switch for glide typing.
Glide across the spacebar	On	Only shown while glide typing (not handwriting) is the active swipe mode. A crossing has to reach the bar’s midline; clipping its top edge doesn’t count. Turn off to treat a spacebar-crossing swipe as one word.
Two-thumb typing	Off	Only shown while glide typing is the active swipe mode. Both thumbs can tap and swipe at once, and every tap and swipe adds to one word. See Typing with both thumbs.
Finish a two-thumb word	Space	Only shown while Two-thumb typing is on. Space: the word stays open until space or punctuation. All thumbs up: the word is typed with its space once no thumb has touched the keyboard for the pause below, tapped words included.
Pause after a swiped word	350 ms	Only shown with All thumbs up. How long both thumbs have to stay up before a word with a swipe in it is typed, from 100 to 1500 ms. A thumb that lands sooner carries on the same word.
Pause after a tapped word	Same as the swiped-word pause	Only shown with All thumbs up. The same pause for a word you only tapped, from 100 to 1500 ms.
Pause after a one-letter word	Same as the swiped-word pause	Only shown with All thumbs up. The least a single letter waits before it is typed as a word, from 100 to 1500 ms.
Take the space back	Twice the swiped-word pause (700 ms)	Only shown with All thumbs up. How soon after the space a letter can still take it back and carry the word on, when the two lead to a dictionary word. 0 to 3000 ms, off at 0. See Typing with both thumbs.
Show the pause on the strip	On	Only shown with All thumbs up. A line along the bottom of the suggestion strip shrinks over the pause.
Swipe finishes typed letters	Off	Only shown while Two-thumb typing is off. A swipe right after typed letters finishes them as one word. See Finishing typed letters with a swipe.
Glide over Shift to capitalize	On	Only shown while glide typing is the active swipe mode. Draw through the Shift key mid-swipe for a capital, twice for all capitals. See Capitalizing without leaving the stroke.
What a pass over Shift capitalizes	Whole word	Only shown while Glide over Shift to capitalize is on. Whole word: one pass for a capital, two for all capitals. One letter: each pass capitalizes the letter the finger came from, and ending the stroke on Shift makes the whole word capitals.
Ask when a glide is unclear	On	Only shown while glide typing is the active swipe mode. When a stroke’s best word barely beats its runner-up, hold still without lifting to pick between them. See When a swipe is a genuine toss-up.
When to ask	Close calls	Only shown while Ask when a glide is unclear is on. How close a call a stroke has to be: Near ties, Close calls, Any doubt or Every pause.
Time to hold still	350 ms	Only shown while Ask when a glide is unclear is on. How long the finger rests before the words appear. Range 150 ms to 1000 ms.
Hold longer to always ask	On	Only shown while Ask when a glide is unclear is on, and hidden under Every pause. A stroke the keyboard is sure of still asks after twice the hold time.
Words to choose from	3	Only shown while Ask when a glide is unclear is on. How many words the picker offers, 2 to 5.
Learn my swipe style	On	The keyboard learns where your finger really lands on each key, how you draw each word, and which words you take over a swipe’s reading, and reads later swipes by it. See What a swipe teaches. Off freezes what has been learned.
Forget my swipe style		Deletes what the switch above learned, after a confirm. Learned words are not affected.
Glide check-up		Opens the screen that measures your own swipes and proposes one change at a time. See The glide check-up.
Space after a glided word	On	Only shown while glide typing is the active swipe mode. A glided word is followed by a space; punctuation typed next takes it back. Turn off to commit the word bare.
Backspace removes a glided word	On	Only shown while glide typing is the active swipe mode. One backspace right after a glide deletes the whole word and its space. Turn off to delete one character at a time instead.
Swipe start distance	2.0×	How far a touch has to travel, as a multiple of the system’s touch slop, before it’s read as the start of a glide rather than a tap. Range 0.5×–4×; lower is more sensitive but can mistake a stationary tap for a glide. A stroke that starts a glide but never gets more than about two-thirds of a key from where it landed still types the key you pressed, so a tap that rolls a little during fast typing isn’t lost.
Delay after typing	160 ms	A brief window right after a tap where a glide needs to travel further before it takes over, so fast tapping doesn’t misfire into an accidental swipe. Range 0–500 ms; 0 turns it off. Two more guards against a finger skidding on the glass come with it. In the middle of a word you are tapping out, within about 0.6 seconds of the last letter, a glide has to cover a key and a half before it starts, and a shorter skid types the key you pressed. And during a burst of typing, a stroke that is over in under 0.15 seconds and never gets more than about a key and a quarter from where it landed types its key instead of being read as a word, so a quick glide of two neighbouring letters only works away from typing. Swipe finishes typed letters, and a key with a hint, capital or word flick, keep the mid-word guard off. 0 turns all three off.
Trail width	10 dp	Thickness of the trail at the head (the tail tapers to about 30% of this). Range 2–24 dp.
Trail length	350 ms	How long a point on the trail lingers before fading out. Range 100–1200 ms.
Trail opacity	55%	Peak opacity of the trail. Range 0%–100%; set it to 0 to glide with no trail at all. Power saving drives the same value to 0 on its own, see Details & edge cases.
Word preview	On	Only shown while glide typing is the active swipe mode. The word decoded so far floats above your finger and updates as you draw. It rides in its own window, so near the top row it rises over the suggestion strip instead of sitting on the keys. Off leaves it to the suggestion strip.
Preview distance above finger	56 dp	How far above the fingertip the floating word sits. Range 0–160 dp. Raise it when your hand covers the word.
Preview sideways shift	0 dp	Moves the floating word left (negative) or right (positive) of the fingertip. Range −80–80 dp.
Preview text size	18 sp	Size of the floating word. Range 12–32 sp.
Preview color / Preview text color	Automatic	Background and text of the floating word, and of the words offered when a stroke stops on a key. Automatic follows the keyboard theme’s popup colour. Whichever it is, a fill too close to the colour of the keys gets a thin outline so it stands out from them.
One word on the strip	Off	Only shown while glide typing is the active swipe mode. While the stroke is down, the suggestion strip carries only the word the keyboard reads at that moment instead of the whole candidate list. The alternates come back when you lift.
Whose words a glide can produce	Every word	Every word, Prefer my words, Only my words or Automatic. Only my words answers a swipe out of the words the keyboard has learned from you and nothing else, so downloaded and imported word lists sit out. Automatic starts at Every word and asks on the suggestion strip before moving up (tap the question to say yes, tap its cross to say never, or hold it to open this setting first); once you say yes it works like that option, and the line under the setting says which. Picking any other option puts Automatic back at the start. Backspacing a glided word always searches the whole dictionary, and so does Search all words on a word you come back to.
Offer a full search while proofreading	Off	Puts a small search button on the suggestion strip when the cursor lands inside a swiped word whose stroke is still kept, for searching that stroke against every word list. Tap it to search, hold it to dismiss. The same search is always available from a held word on the strip; this only saves the hold. See Going back to a misread swipe.
Swiped words a full search can reach	24	How many of the newest swiped words in the field keep their stroke for the full search, from 0 to 500. Each stroke is a few kilobytes of memory.
Finish long words early	Off	Off, When sure or Eager. Lets a swipe be read as a word it has only started, and lifting types it. A word you have drawn in full is never overtaken by a longer one unless the longer one is clearly likelier; under Prefer my words and Only my words the guess is always one of your own words. See Finishing a long word early.
Color the word a lift will type	When sure	Never, When sure, Any early word or Always. Which word on the strip and in the preview gets the strip’s own colour, meaning “this is what a lift types”, not just bold.
Glide engine	Built-in	Built-in, FUTO Swipe (English, QWERTY) or Google’s gesture library (imported). FUTO Swipe reads English swipes on a QWERTY layout with FUTO’s neural models, downloaded under their own licence. Google’s gesture library reads every language once you import the file yourself. Everything else stays on the built-in decoder. See The FUTO Swipe engine and Google’s gesture library.
Gesture library		Imports Google’s libjni_latinime.so through the file picker, if it is one of the pinned builds for your phone, and shows whether it is loaded. Appears while Google’s gesture library is the engine or a file is imported. Not in the Google Play version. See Google’s gesture library.
Remove gesture library		Deletes the imported library and the dictionaries built for it. Glides use the built-in decoder at once; a loaded library leaves memory when the keyboard restarts.

Advanced tuning

A fold further down the same screen, closed until you open it, holding the weights the decoder reads a stroke with. The first three decide which words a stroke may be read as at all; the next eight decide how a stroke marks a letter, as in the word or as written twice, and the last is how many of your own shapes are kept for a word. Every row has its own reset, so you can move one, glide a few sentences, and put it back if it was worse. The whole group is hidden while glide typing is off or the swipe mode is Handwrite.

Setting	Default	Notes
Start error radius	1.6×	How far from a word’s first letter your finger may go down and still get that word, in key widths. Raise it if your swipes start off the key, lower it to be stricter about where a word begins. Above 1.6× the extra distance is also forgiven in the score, so a word starting that far off can still win. Range 0.5×–4×.
End error radius	2.0×	The same for where you lift. It’s separate because the end of a swipe is only where a movement stopped, so it tends to be looser than the start. Range 0.5×–4×.
Path error radius	1.9×	How close the stroke has to pass to a key for that letter to still be available to a word, in key widths. Raise it to cut corners freely, lower it to keep the keyboard to the keys you actually crossed. Range 0.5×–4×.
Error radius by language	None	The languages that glide with radii of their own in place of the three above, each with the values it uses. Tap one to open its page in Languages, where the radii are set. See How it picks a word.
Pause to mark a letter	2.0×	How long a stop on a key has to be to say the letter is in the word. Words without that letter lose; the stop never writes a letter twice. A multiple of your own speed in that same stroke, not a number of seconds, so it reads a quick glide and a careful one alike. Lower it if your stops don’t seem to count, raise it if a careful glide marks keys it only went past. Range 1×–8×.
Loop to double a letter	On	Reads a small circle drawn on a key as that letter twice, Swype’s mark, and the only mark that doubles a letter. The circle costs the word nothing, and it belongs to the one key nearest its middle, so the keys around it stay out of the word. Turn it off if your swipes curl on the way and you get doubled letters you didn’t ask for.
Loop sensitivity	1.0×	How much drawn path a curl needs, in key widths, before it counts as a circle. Low catches a small curl and also the shake of a slow turn; high asks for a circle drawn on purpose. Range 0.5×–2×.
Biggest loop that counts	0.8×	How wide a circle may be and still be a mark on one key, in key widths. A word like “murderer” goes around a ring of neighbouring keys and draws a wide circle meaning nothing of the sort, so this stays under one key’s width. Range 0.4×–1.2×.
Loop centring	0.60×	How near the letter’s key the middle of the circle has to sit, in key widths. A circle drawn through a key sits about a third of a key to one side, so very low finds no letter for the mark. The circle only ever goes to the one nearest key, so high only accepts circles drawn further off centre. Range 0.35×–1×.
Wiggle to mark a letter	Off	Reads a rub back and forth over a key the way it reads a pause: the letter is in the word. It never writes the letter twice. Off because a slow turn drawn with an unsteady finger looks much the same, and the cost is keys marked that you only went past.
Wiggle strength	50%	What a rub is worth against a full stop on the key. 100% makes the two equal; lower leaves the rub as a hint a much commoner word can still win against. Only shown while the switch above is on. Range 10%–100%.
Biggest wiggle that counts	0.50×	How far the finger may travel in a rub, in key widths. Stays under one key’s width, or a word drawn back and forth between two neighbouring keys reads as a rub on one. Only shown while the switch above is on. Range 0.2×–0.9×.
Shapes kept per word	3	How many of your own ways of drawing one word your swipe style keeps apart. Raise it if you swipe some words several different ways and one of them keeps being forgotten; the shapes travel in a backup under Swipe style, so you can see how many your words really use. Lowering it takes the extras out of use at once, and they’re only deleted when that word next learns a new shape, so moving it back up before then loses nothing. Only shown while Learn my swipe style is on. Range 1–20.
Seed candidates from learned shapes	Off	Offers a word whose saved shape matches your stroke even when the stroke starts or ends off that word’s keys, at the same rank as the decoder’s best reading. Swipe “can” a few times starting near V and pick it, and the same stroke offers “can” alongside “van”. Only shown while Learn my swipe style is on.

The three marks have a section of their own: Marking a letter as you glide.

What a swipe does lives in this same settings group and decides what a letter-area swipe means in the first place. Type words is glide typing. Handwrite draws ink instead: see Handwriting. Slide to a key types no words at all. Put a finger down, slide it to the key you meant, and only that key is typed when you lift. The key under your finger lights up with its preview bubble while you slide, and the keys you pass over type nothing. It’s for a finger that keeps landing one key off: slide to the right key instead of typing the wrong one and deleting it.

Details & edge cases

Power Saving mode splits glide typing into two independent switches. By default, power saving drops only the trail: it forces trail opacity to zero, so nothing is drawn while you swipe, and decoding and committing carry on as normal. Turning glide typing off altogether under power saving is a separate option, and it’s off by default. Decoding a swipe really is the most expensive thing the keyboard does, but it’s also why many people installed a gesture keyboard, so the cheap fix ships on and the expensive one is opt-in. See Power saving.

A layout that can’t spell the language turns glide typing off rather than breaking it. The decoder throws out any word holding a character the grid can’t produce, so a layout covering only a fraction of a language would never fail loudly. It would decode against that fraction and commit confident nonsense. Instead, WM Keyboard takes the language’s most common words, counts how many the layout can draw end to end, and wants at least 90% of them before it will glide. The threshold sits short of 100% on purpose: real word lists carry a few loanwords and proper nouns in other scripts, and demanding every one of them would fail layouts that handle everything people actually type. Words spelled with an apostrophe or a hyphen the layout has no key for, such as French c'est, d'un and lui-même, aren’t counted either way, since no layout can draw them. Up to 0.6.0 they counted as misses, and in French they are about one common word in eleven, so a layout carrying é, è, ê, à, ù and ç on its keys but not â, î and ô (an imported Unexpected Keyboard AZERTY, say) scored just under 90% and lost glide typing entirely. The common words come from the language’s own bundled or downloaded list. Up to 0.5.10 an imported list was counted alongside it with an equal share, so one import the grid couldn’t spell (an English list under Arabic, or a compiled .dict that 0.5.9 had copied in without unpacking it) halved the score and every swipe landed as taps, with nothing on screen to say why. Imports no longer count while the language has a list of its own, and those old .dict copies are repaired automatically.

Only the final word of a multi-word glide has alternates on the strip. Backspace takes the final word back whole, then the one before it, and so on back through the stroke, each leaving its own other readings on the strip. Typing or moving the caret ends that walk, as it does after a single swipe.

The bigram context updates correctly when you swap an alternate. Tap an alternate to replace a glide’s word and the “what word came before” tracking re-links to the word before the one you just replaced, rather than to the discarded guess. Next-word prediction stays accurate after a correction.

See also the gesture cheat sheet for every gesture on one page, and Reference → Settings → Typing for the full Typing screen.