# Autocorrect > Confidence-gated corrections that know when not to fire. URL: https://wmkeyboard.pages.dev/smart/autocorrect/ Section: Suggestions & correction Autocorrect fixes typos as you finish typing a word, but only when one candidate is clearly the right fix. A fat-fingered slip that's obviously "world" gets corrected. A word that sits between two real words is left alone for the suggestion strip to offer instead. This page is about that confidence gate, and about everything built around it: reverting a correction, the words autocorrect never touches, and the auto-space rules that ride along with it. smart/autocorrect-confidence-fix — A mistyped word corrected inline as the next word begins. ## How a correction is chosen Space and Enter trigger autocorrect. A full stop or other punctuation does not by default: ending a word with one commits it exactly as typed. Turn on **Correct the word before punctuation** and the marks that end a word (`.` `,` `!` `?` `;` `:` and the Bengali `।`) correct it the way space does, so `teh!` lands as `the!`. A slash, a bracket or any other symbol still leaves the word alone, and one backspace straight after the mark (and the space the auto-space rule put behind it) puts the word back as typed. Enter often sends the text as well, in a search box or a chat, so a correction it makes goes out before you can read it. Turn off **Correct the word before Enter** (see [Options](#options)) and Enter commits the last word as typed, while space keeps correcting. When you press space or Enter, WM Keyboard checks the word against every word one edit away: one letter dropped, added, doubled, swapped with its neighbour, or substituted. A word that is one letter short of a longer word ("hell" for "hello") counts as that same single edit. Two-edit candidates reach the suggestion strip but are never applied silently. Two independent sources score the candidates: the word lists (bundled, downloaded, imported, and any secondary language's) and your own personal dictionary of learned words. - **Two sources agreeing is enough on its own.** If the dictionary's best guess and your personal dictionary's best guess land on the exact same word, it's applied. The confidence factor below isn't even consulted. - **Otherwise, the best candidate has to clearly win.** It's applied only if it outscores the runner-up by the confidence factor (4× by default, see [Options](#options)). A close call is left alone rather than guessed at. With no runner-up at all, the candidate still has to be a reasonably common word: an unknown word one slip away from a rare one is left as typed. Every word list is measured on the same scale for this, so a downloaded list, whose word counts run into the millions, is no quicker to correct than the built-in English one. - **Two letters the wrong way round get the benefit of the doubt.** When no word clearly wins, a word that is what you typed with one neighbouring pair of letters swapped back is applied anyway. It must not be more than twenty times rarer than the best candidate, and no other swap may read about as well. So `wnat` becomes *want* even though *what*, a slipped `h` away, is the commoner word, `adn` becomes *and*, and `soemthing` becomes *something*, while `hwo`, which could be *who* or *how*, stays as typed. A swap keeps every letter you typed, which no other kind of slip can claim. This holds with the learned gate on or off, at every confidence setting but the most careful, 10×. - **The edit itself is weighted by how it happens.** Cheapest, and so likeliest, are three: a swapped pair of letters, a doubled letter (the hold-repeat slip in "helllo"), and a substitution toward a key right next to the one you meant. A dropped letter, or a stray one typed next to where your finger landed, costs noticeably more. A substitution or an insertion nowhere near the key you hit is the most expensive of all and rarely survives. The neighbour test uses the adjacency map for your active layout, so the same typo resolves differently on QWERTY than on AZERTY or Dvorak, and where the keyboard has your real tap coordinates it uses those instead of the map. - **A missing accent is not a typo.** Typing `z` where the word has `ż`, `e` for `é`, or `l` for `ł` costs almost nothing and does not count as an edit, because the accented letter is on the same key. So "juz" becomes "już", and a word with every accent left off ("zolw" for "żółw") is found as easily as a word with one. The strip agrees: when the letters you typed spell a word once its accents are back, that word comes first, ahead of commoner words that would need a letter changed or dropped, the way a word you typed in full leads its own slips. Portuguese "chale" offers *chalé* before *chave*, and "caminhao" offers *caminhão* before *caminho*. Turkish's dotless `ı` counts as an accent on `i`, along with `ş`, `ğ`, `ç`, `ö` and `ü`, so "haklisin" becomes "haklısın" and "guzel" becomes "güzel". Since 0.6.4 the same goes for any other letter on the key you pressed, the one its Shift types, the one in its corner or one behind its hold, in any script. On the Arabic layout `أ` and `إ` sit behind `ا`'s hold and `ؤ` behind `و`'s, so "اخبار" finds "أخبار" and "مسوول" finds "مسؤول" as surely as "juz" finds "już", and the same rule decides whether space puts them in. It runs one way only: a letter you reached with Shift or a hold is taken as meant. Marks such as the harakat on Arabic's Shift layer don't count, since a mark never stands in for a letter you tapped. - **The fix keeps your capitalization.** Typing "hte" mid-sentence corrects to "the". Typing "Hte" at the start of one corrects to "The." - **A word the list spells with a capital gets its capital.** Some downloaded word lists write words with a capital letter: every German noun ("Haus", "Zeit"), and the names of places and people. Type or swipe one in small letters and it is written with its capital, in the strip and when space commits it. A word the list has both ways ("essen" and "Essen") stays as you typed it. Backspace right after puts back what you typed, and the undo is remembered like any other. This is **Capitals from the word list** (see [Options](#options)). The built-in English list is all small letters, so the keyboard carries the capitals for it separately: days and months ("Monday", "January"), countries, cities and languages ("London", "English"), common first names, brands such as "iPhone", and acronyms such as "DNA" and "USA", about 2,400 in all. The word "I" is among them, so a lone "i" is written "I" even with **Fix missing apostrophes** off. A word English also uses in small letters, such as "may", "will" or "mark", is not among them. A downloaded English list adds its own on top. A capital you keep on a word in your personal dictionary, or wrote into Android's, is applied the same way (see [Personal dictionary](https://wmkeyboard.pages.dev/smart/personal-dictionary/#capitals)). A word your personal dictionary learned in small letters, the way you happened to type it, doesn't count as keeping it small, so a learned "i" never outvotes "I". A list you downloaded before this existed is converted on the device the next time the keyboard starts. The two candidates have to be far apart in score, which keeps autocorrect conservative by design. "helo" is evenly split between "hello" and "help", and "tesr" between "test" and "tear", so both are left for you to resolve yourself. An unambiguous slip like "wprld" resolves immediately. ## The learned gate The rules above are how the decision used to be made, and still are with **Learned correction gate** (see [Options](#options)) turned off. With it on, which is the default, the same candidates reach a single judgement instead of a chain of rules: a small model fitted offline that weighs everything at once and answers one probability, that the best candidate is the word you meant. What it weighs is what the rules weighed one at a time, and a few things they could not. The lead over the runner-up. What kind of slip explains the typo: a letter swapped with its neighbour, a tap a little wide of its key, a dropped letter, a letter no finger slip explains. How many of them, and how long the word is. Whether the word list and your own dictionary agree. What the [context model](https://wmkeyboard.pages.dev/smart/suggestions/#the-context-model) thinks, when one is downloaded: of the candidate, of what you typed as it stands, how many words it would put ahead of your spelling here, how sure it is of the next word at all, and how far its favourite among the candidates leads the next. How fast the word was typed, when **Typing rhythm** is on. Whether what you typed is a listed spelling the keyboard reads as a stand-in for another word. It was fitted on about nineteen thousand words from real sentences, typed by a finger that scatters around each key at three widths from careful to sloppy, with and without a context model in reach, and on words that had been taken out of the dictionary and typed right, which is what a name, a new word or a bit of slang looks like to the keyboard. Those last rows are the point of the exercise. Measured on sentences the fit never saw, the old rule rewrote 22 to 23% of such correctly typed new words; the gate rewrites under 1% of them on careful or fast typing and 2% on the sloppiest. It also fixes more of the real typos: on careful typing it applies 81% of them where the rule applied 60%, and the fixes it applies are right 99.4% of the time, against 99.7%. On fast typing recall goes from 50% to 67% and precision from 95.3% to 98.0%; on sloppy typing from 40% to 51% and 90.3% to 96.2%. With the context model downloaded the gate reads its view too, and that is where it earns its keep: on the same sentences it then applies 84% of the real typos on careful typing at 99.7% precision, 72% at 99.4% on fast typing and 58% at 97.5% on sloppy typing, and it rewrote none of the correctly typed new words at any width (0 of 300, 300 and 94). The **Autocorrect confidence** slider still rules it. The probability a fix has to reach is the slider's ratio against one: at the default ×4 a fix needs four chances in five, at ×10 ten in eleven, at ×1.5 three in five. A fix that falls short of that bar but clears about six tenths of it is offered as a chip rather than applied, as before. Everything else on this page holds under the gate: a known word is never corrected, a rejected pair stays rejected, a blacklisted word is never a target, and backspace undoes a fix the same way. The one rule that changes is two-source agreement: under the gate it is one of the things weighed rather than a bypass, since the fit found it a strong sign but not an infallible one. ## Words it never touches A word is never a correction target, whatever the confidence factor is set to, if any of these apply: smart/autocorrect-skip-allcaps — ALL-CAPS words pass through untouched next to a corrected lowercase one. - **It's shorter than three letters.** Too little signal to guess at safely. The one fix a two-letter word does get is its accents put back, when the spelling without them is no word of its own or is only that word typed without the long-press: Romanian "in" becomes "în" and "si" becomes "și". When two accented spellings are both common, they are offered on the strip and neither is applied. - **It's already a known word.** Anything in the active dictionary, a downloaded or custom wordlist, a secondary-language dictionary, or your own personal dictionary is left exactly as typed. A known word is never "corrected." There is one exception: a spelling that the word list holds only because people type another word without its accents. The Polish list contains "juz", but "już" is more than fifty times as common, so "juz" is corrected. When both spellings are common words, such as Polish "ze" and "że", the one you typed stays. The French list holds "cest", "jai" and "quil" as words for the same reason (real text is full of elisions typed without their apostrophe), and those are corrected the same way, to "c'est", "j'ai" and "qu'il"; Italian "cera" against "era" goes to "c'era" on the same terms, and so do the other eliding languages. The larger downloaded word lists also hold common typos, because the text they are counted from has typos in it: the Medium English list holds "wheee", "thw" and "teh". A spelling is treated as one of those typos when two things are true. First, it is further down its list than the 50,000 words the Small download keeps. Second, a word one slip away is at least a thousand times as common. So "wheee" is corrected to "where" and "thw" to "the", on any download size. A real word that is only rare, such as "cress" next to "dress", is left as typed. A word you added to Android's personal dictionary is never treated this way. A word nothing recognises doesn't become known just by being typed once: it has to be typed and left alone three times before it joins your dictionary, which is what stops a typo shielding itself from the fix it needed. See [Personal dictionary](https://wmkeyboard.pages.dev/smart/personal-dictionary/#words-wait-their-turn) for that, and **Learn a word after** under Typing / Suggestions for a further threshold on top of it. - **It's an "-s", "-ed" or "-ing" form of an English verb the word list knows.** The bundled English list leaves out some verb forms. It has "corrected" but not "corrects" or "correcting", and "fixed" but not "fixes". So a form like "corrects", "correcting", "fixes", "carried" or "hoping" counts as a word whenever the list holds the verb along with another of its forms. That other form is the proof it is a verb: "thes" ends in "s" too, but no list holds "theed" or "theing", so "thes" is still corrected to "the". For "-ed" and "-ing" the proof has to be the other one of the two, because nouns take "-s" as well. Misspellings of a form the list does have are still corrected: "admited" next to "admitted", "fixs" next to "fixes", "stoped" for "stopped", and "begined", because "begin" has no "-ed". This only applies while English is part of your language mix. - **It's a contact's name or an installed app's label**, if [contact and app-name suggestions](https://wmkeyboard.pages.dev/smart/contacts/) have indexed it. - **It's in your [suggestion blacklist](https://wmkeyboard.pages.dev/smart/blacklist/), or offensive-word filtering catches it.** A blacklisted or filtered word is dropped from the candidate pool before scoring, so it can never be silently forced in as a fix. - **It's typed in ALL CAPS.** Acronyms and shouted words (ASAP, NOOO) are usually capitals on purpose. This is its own toggle, on by default (see [Options](#options)). A leading capital on an otherwise-lowercase word ("Wprld") is still corrected normally; only a fully-capitalized word is spared. - **The active language isn't English and has no bundled dictionary of its own.** The bundled English dictionary feeds autocorrect only while your active language is English, or has English configured as a secondary language. Type in French, German, or another language and corrections come from that language's own dictionary and whatever you've personally taught the keyboard. - **The field is a password field, or any structured field**: email, web address, number pad, phone pad. Autocorrect, like the rest of typing intelligence, is off in all of them. Missing apostrophes ("thats" → "that's") are fixed by a separate lookup that runs before autocorrect even looks at the word, so it's a known-word fix rather than a confidence-scored guess, and it wins whenever both could apply. The word with its apostrophe also leads the suggestion strip while you type, so what the strip shows is what the space bar is about to commit. Anything that ends a word applies it: the space bar, enter, and the full stop, comma, question mark and their family. English reads a fixed table of contractions. The spellings that are also words of their own, such as "id", "its", "were" and "well", are never rewritten, but the contraction ("I'd", "it's", "we're", "we'll") is offered on the strip right behind the word you typed, one tap away. Where the contraction is the commoner of the two, as "I'd" is next to "id", the word you typed is held up to its standing, so the pair stays on a three-slot strip ahead of completions such as "idea" and "identify". A glided or two-thumb word gets the same offer: swipe "id" and it is typed as "id", with "I'd" right behind it. "ill" is the exception: it is typed for "I'll" far more often than for the word, so it becomes "I'll" like the rest of the table. If you did mean "ill", one backspace right after puts it back, and from then on "I'll" is only offered behind it. German reads a table of its own for the *es* worn down to *'s* on a verb: "Wie gehts" becomes "Wie geht's", and "gibts", "habs" and "wars" take their apostrophe the same way. German words that only look like one, such as "wies" and "nichts", are left alone, and so are "aufs", "ins" and "fürs", which German writes without it. Seven languages that elide get the same fix from their word list instead of a table: French, Italian, Catalan, Occitan, Romansh, Corsican, Sardinian and Piedmontese: "cest" becomes "c'est", "lalbero" becomes "l'albero", "unamica" becomes "un'amica", "lhome" becomes "l'home", "lostal" becomes "l'ostal" and "sistadu" becomes "s'istadu". The keyboard knows which prefixes elide and which short words each one takes, so French "jet" is never split into "j'et" and Italian "sono" never into "s'ono". That table is deliberately thinner than a grammar book would write it, because a one-letter prefix in front of a short word usually spells a word: Occitan "ma" and "ta" are "my" and "your", Corsican "se" and "sa" are words in their own right, and each table was swept against its language's full word list to find them. A real word that happens to split, such as French "lune" or Italian "allora", stays as typed; "l'une" and "all'ora" sit behind it on the strip instead. It has its own toggle, "Fix missing apostrophes," in the same settings group, and no other language is read this way. Every language in the current mix is asked, not only the one in front: with Italian and English set as each other's secondary, "thats" becomes "that's" and "lalbero" becomes "l'albero" whichever of the two you are typing in. The word after an elided prefix still has to be a word of the language whose grammar allowed the split, so an Italian "d'" never reaches across the mix to make "dart" into "d'art". The same goes the other way for the English table: it only knows which spellings are English words, so when the field is being written in another language of your mix and that language has the word you typed, the contraction is offered on the strip instead of committed. With German and English set up together, "im" stays "im" in a German sentence, with "I'm" one tap away behind it, and an English sentence on the same keyboard still gets "I'm". Which language the field is in comes from the language you have in front, or from [language detection](https://wmkeyboard.pages.dev/smart/mixed-language/) when it is on. Offensive-word filtering and the suggestion blacklist also keep those words out of the plain suggestion strip, not only out of autocorrect. See [Suggestion blacklist](https://wmkeyboard.pages.dev/smart/blacklist/) for the full mechanism. Hyphenated words are one word while you type them. A hyphen straight after a letter stays in the word being composed, so "well-pai" completes to "well-paid" and "что-" goes on to "что-то", instead of the strip starting over on the part after the hyphen. A hyphen the word ends on is only punctuation: "well-" then space leaves "well- " as typed, and a second hyphen in a row is a dash that ends the word. Putting the caret back after a compound picks up all of it, not only the last part. A compound whose parts are all known words, such as "hello-world", is never corrected, even when no word list holds it whole. The other way round, a compound typed without its hyphen is offered with it on the strip: "wellpaid" shows "well-paid". That holds even when the word list counts the fused spelling as a word, as the big Russian list does with "чтото", as long as the hyphenated form is at least fifty times as common; "online" is never offered as "on-line". Being on the strip does not mean the space bar will write it: that is still autocorrect's call, made the same way as for any other word. ## Undoing a correction smart/autocorrect-backspace-undo — Backspace right after a correction restores what you originally typed. ⌫ right after an autocorrected word undoes it, as long as nothing else has touched the text since. The cursor has to be sitting exactly where the correction left it, and the text right before it has to still read as the corrected word plus the space or line break that ended it. Backspace then deletes both and retypes what you originally typed instead. Move the cursor, tap elsewhere, or keep typing first and the undo is gone. Only the immediate next backspace can trigger it. A missing apostrophe the keyboard filled in ("dont" → "don't") and a lone "i" it made into "I" are undone the same way, and remembered the same way below: after the undo, the next "i" stays lower case instead of being capitalised straight back, and the repair waits on the suggestion strip behind what you typed instead. One undo is enough for an apostrophe, for as long as that undo is remembered: a repair has no confidence to handicap the way a guessed correction does, so where a correction undone once only fights uphill, a repair undone once stops being made by itself at all. A capital from the word list, the lone "I" among them, is the exception: one undo holds it back for the rest of that run of typing, and only a second undo retires it. That way a single stray undo can't leave every "i" in lower case for months, and a capital you let stand afterwards buys the undo back the way a kept correction does. A capital retired by two undos can't fire to earn that back, so if "i" has stopped becoming "I", open [Learned corrections](#learning-from-your-own-fixes) and delete `i → I` under **Corrections you undid**. Set it to **Never** there if you want "i" left alone for good. The same word won't be "corrected" again next time either way: undoing a correction retires that exact pair as soon as you keep the word you typed, and a second undo of it blocks the pair for good. That part is unconditional, because a rejection has to hold even with learning switched off. The undo only counts once you keep your word, by typing on after it or leaving the field. Holding backspace to clear the text also starts with that undo, but the next presses delete the restored word too, so nothing is remembered and "i" still becomes "I" next time. Reverting also counts double towards teaching the original word to your personal dictionary, which is the strongest of the signals that feed [that count](https://wmkeyboard.pages.dev/smart/personal-dictionary/#words-wait-their-turn). It doesn't save the word outright any more. Undoing a correction is also what you do when the fix simply wasn't the word you wanted, and saving on the first undo turned out to be the shortest path from one stray swipe to a misspelling stuck in your dictionary. This follow-on teaching only happens if [learning from typing](https://wmkeyboard.pages.dev/smart/personal-dictionary/) is on, which it is by default. It's skipped in [incognito mode](https://wmkeyboard.pages.dev/privacy/incognito/) (when incognito is set to pause learning) and in a secure field. One related behavior is easy to mistake for this toggle. Arming Shift live re-cases every chip in the suggestion strip, not only an autocorrect candidate, to match what would actually be committed if you tapped it. Shift is a latch rather than a hold here, so the chips stay re-cased until the shift state clears. That's a strip-wide display rule rather than a way to reject a correction. See [Suggestions & prediction](https://wmkeyboard.pages.dev/smart/suggestions/) for how it works. ## What counts as rejecting a correction Backspace is the fastest way to reject a correction, but it is not the only one, and for a long time it was the only one the keyboard could see. Fixing a word three words later, selecting it and retyping, or tidying the sentence before sending all rejected the correction just as clearly and taught the keyboard nothing. Worse, they counted as successes, so the adaptive gate read a better record than autocorrect was earning and loosened where it should have tightened. A correction is now judged once the text around it has settled, on the same signals the [personal dictionary](https://wmkeyboard.pages.dev/smart/personal-dictionary/#words-wait-their-turn) uses: you close the keyboard, send or clear the field, move to another field, or simply type far enough past it. - **You never went back into that text.** The correction stands, and counts as accepted. - **You did go back into it.** The keyboard reads the field once, at that point only, and looks for which spelling is there now. Your original word standing where the fix was is a rejection. The corrected word still there is an accept. This reading counts for less than a backspace, and it is thrown away entirely when your word is not a word the keyboard knows. That case is the trap it exists to avoid: you glance back, decide you mistyped, fix it by hand without noticing the keyboard already fixed it, and make the same slip again. The field then looks exactly like a rejection while nothing was rejected at all. A word that really is yours, a name or a nickname, joins your [personal dictionary](https://wmkeyboard.pages.dev/smart/personal-dictionary/) after a few sightings, and from then on its undos count in full. - **Neither is there, or the text is gone.** No verdict at all. Deleting the sentence, or sending a message before anything could be checked, teaches nothing rather than something invented. The read only ever happens at one of those settling points, never while you are typing. ## Taking a correction back later Backspace only reaches a correction in the moment it happens. One more letter and it is out of reach, which is awkward, because that is usually when you notice it. The word looks right at a glance, you read the sentence back a beat later, and by then the only way out is to select the word and retype it. So the keyboard puts the word you typed on a chip at the start of the suggestion strip. Press it and your word goes back, and the keyboard reads that exactly as it reads a backspace: the pair is retired, and your word counts towards your [personal dictionary](https://wmkeyboard.pages.dev/smart/personal-dictionary/). It shows between words rather than in the middle of one, because putting the word back means editing text behind where you are typing. The chip remembers the last five corrections that earned one, not just the latest. Slips tend to come in runs, so when autocorrect has changed three words in a sentence, three presses put all three back, newest first: after each press the chip shows the next word it can restore. There is no counter on it; the word it names is the next one it will put back. Before each press rewrites anything, the keyboard finds the corrected word again and checks it is still the one it changed: still spelled the same, still sitting after the same few words it followed when it was corrected. Words you typed after it don't matter, and neither do the ones the chip already put back. If you edited the word yourself, or changed the text just in front of it, that correction is quietly skipped and the press goes to the next one down, so the chip never rewrites a word it can't be sure of. The same word appearing twice is fine as long as the two stand after different words. Each correction also has to stay within about a hundred characters of where you are typing, and moving the cursor back past one drops it along with any newer ones. The chip and everything it remembers are cleared when you end the sentence, select text, or move to another field. A correction that doesn't earn a chip of its own (see below), or a fix that only adds a capital such as "i" becoming "I", leaves the remembered ones in place. Backspacing a correction away the moment it lands drops it from the chip too, and leaves the older ones alone. There's a second way back, one that outlasts the sentence. Every autocorrected word also carries a mark the app itself can read, naming the word you typed. In an app that supports it, this draws the same brief underline other keyboards use. Tap the word anywhere in the document, however long after, and it offers your original spelling back. It has no expiry, because it lives in the text rather than on the strip. Not every app reads the mark, so where it doesn't, the chip above is the only way back. Not every correction gets a chip, and that is the point. A chip after every correction is one more thing to look past, and by the time the one that matters arrives you have stopped reading the strip. So the keyboard scores each correction it applies on two things: - **How sure it was.** A correction that only just cleared the confidence gate scores low. One that both the dictionary and your own lexicon named scores high. - **How far it moved the word.** A short word with one neighbouring letter changed scores high, because you can see what happened at a glance. A letter no finger slip explains, or a word split into two, scores low. A correction that scores under the bar gets a chip. **How often to offer the undo** under Typing / Automatic corrections is that bar: at the lowest setting almost nothing gets a chip, at the highest every correction does. **Undo a correction from the strip**, directly above it, turns the whole thing off. A listed spelling far rarer than a word one letter away, like `verg` next to `very`, is never rewritten, but it gets a chip as soon as you press space. A real word that only the next word proves wrong, like `Thus` in "Thus bug", can't be caught before that word lands, so **Re-check the previous word** asks then. Each fix is offered once per field: pass over the chip and it doesn't come back. The chip shares its slot with the join, revision and near-miss chips, and comes last of the four. All four wear the theme's selected-chip colour, the same fill a highlighted suggestion gets. Those three are about the word you are typing now. This one is about a word you have already left behind. ## How long an undo lasts Undoing a correction does two things. It puts your word back, which is immediate and never in doubt. It also tells the keyboard something about that exact pair of words, and **Remember my undos** under Typing / Automatic corrections sets how long that second part lasts. Only the pair is affected. Other fixes for the same typo carry on as before. | Level | What an undo costs the correction | | --- | --- | | Off | Nothing. The keyboard corrects the word again next time. | | Light | The pair needs far more confidence from then on. It is never retired. | | Normal | One undo stops the pair for the rest of that run of typing. Two retire it, and a retired pair is offered as a chip once more after a long quiet spell. | | Strict | The first undo retires the pair for good, however the keyboard read it, and it is never offered again. | Normal is the default and the level the rest of this page describes. Under it, a backspace on the correction stops that pair for the next twenty corrections and until you move to another field, whichever comes first. After that the counts on disk take over: a pair undone once fights uphill, a pair undone twice does not fire at all. Corrections you let stand count too, and three of them buy back one undo, so a pair you undid in a hurry is not sentenced for the six months the expiry clock takes. A retired pair is not gone forever. Once it has sat quiet for about forty saves of the learning file, it is let out on probation: it can reach the suggestion chip again, though it still never rewrites your word on its own. Accept it three times and it is an ordinary correction once more. This is what stops a single bad undo from silently retiring a fix you wanted, with nothing on the screen ever saying why. Pick **Light** if you find the keyboard gives up on corrections too easily. Pick **Strict** if you want an undo to be final. **Off** keeps the undo itself and forgets everything else. ### When you keep deleting the same fix Backspace right after a correction is not the only way to say no to it. Often the correction goes unnoticed for a moment, and you delete it letter by letter or with a word delete, type your word again, and get the same correction again. **Stop after I refuse a fix** under Typing / Automatic corrections ends that loop. Every undo or deletion of a correction counts as one refusal for that word at that place. Once a place has collected the set number of refusals (2 by default, up to 5), the word you type there goes in as you typed it, and the fix is not offered on the strip either. It is a local truce, not a verdict on the word: the same typo anywhere else in the text is corrected as usual, nothing is saved, and the count is gone when you move to another field. Set it to **Never** to turn it off; **Remember my undos** above still applies either way. ## Learning from your own fixes Most typos autocorrect misses end the same way: you notice the word, go back, and fix it by hand. That fix used to teach the keyboard nothing. Now it teaches two things. **The pair.** The keyboard remembers what you typed and what you changed it to, once the text around the fix has settled the way learned words do (see [Words wait their turn](https://wmkeyboard.pages.dev/smart/personal-dictionary/#words-wait-their-turn)). Fix the same typo a second time and autocorrect makes that fix for you from then on, with the undo chip showing the first few times so you can see it happen. After one fix it offers the fix on the strip instead of applying it, and it will not apply a different guess of its own over a word you have already shown it the answer to. If autocorrect had changed the word to the wrong thing and you fixed that by hand, the pair it learns starts from your original typo, and the wrong correction is marked as rejected. A typo that is itself a real word ("form" for "from") is held to a higher bar: three fixes, and the words before it have to agree that the other word was meant. Otherwise every "form" would turn into "from". A word you have put on **Never suggest** doesn't count as real here: you have already said you never mean it, so two fixes are enough, as for any typo. **The slip.** Each pair is also read letter by letter, and the difference is counted as a habit of your hands on this layout: a `3` typed for an `e`, a `b` where the space bar was, a doubled letter missed. Once a layout has taught eight of those, autocorrect treats the slips you make as cheaper, so the same slip in a word you never fixed is understood too. A habit never makes a correction fire on its own; it only changes which words are in the running, and the confidence gate decides as before. Habits are learned only from typos you typed yourself, never from a real word swapped for another, from a swiped word, or from a word picked off the strip. **Where your taps land.** Separately, every word you type and leave standing records where your finger landed on each of its letters, and later taps are read against keys moved to match. This is the tapping twin of the glide typing hand model, and it learns from kept autocorrects as well: a correction you let stand is the plainest statement of which letter a tap was meant for. The keyboard learns a fix in three situations: you backspace into a word you just committed and retype it, you tap into a word and edit it in place, or you select a word and type over it. It follows only the edits it makes itself, and checks the word against the field once, when you leave it. A learned fix you then undo, by backspace or the undo chip, counts against the pair, and a pair undone twice is retired exactly like any other correction. Everything learned here ages out on the same clock as the rest of the personal dictionary. **Learned corrections** under Typing / Automatic corrections lists everything above one entry at a time, and each entry can be changed on its own: - **Fixes you taught** shows every pair with how often you made it. Tap a pair to change either spelling or the count, or use **Add a fix** to write one the keyboard never saw. The count decides what happens, the same as if you had typed it: at 1 the fix is offered on the strip, at 2 it is made for you, and a typed word that is itself a real word needs 3 and the words before it have to agree. A fix you set here doesn't age out, and saving it forgives any undo of it. If you have taught two fixes of one spelling, neither is made until one has at least twice the count of the other, and the row says so. - **Corrections you undid** shows each correction you backed out of and what the keyboard does about it now. Tap one to choose **Only when very sure**, **Stop for now** (it comes back on the strip after a long quiet spell, never applied) or **Never**, or delete it to forgive it. **Stop a correction** adds one you never had to undo, for a word the keyboard keeps changing into another. Editing this list doesn't change the revert rate behind the confidence gate, and [Remember my undos](#how-long-an-undo-lasts) set to Off ignores the list. - **Slips the keyboard has noticed** shows each slip with its layout and count, since a slip belongs to where the keys sit under your hand. Tap one to change its count, or delete it. A higher count makes that slip cheaper, and a layout still has to reach eight slips in total before any of them count. **Forget all learned corrections** clears the fixes and slips at once. **Learn from my fixes** turns the whole thing off. **Learn where my taps land** turns the tap model off on its own, with its own Forget button underneath. Both stores travel with the Dictionary section of an export, and are deleted with the rest of the learned data. ## Corrections it offers instead of applying Applying a correction and offering one are not the same question. Applying has to be nearly certain, because being wrong rewrites what you wrote and you may not notice. Offering costs you a chip you can ignore. So everything that came close to the bar without clearing it, which used to be discarded silently, is now offered as a chip at the start of the suggestion strip instead. Tap it to apply the fix; carry on typing and it goes away. The bar for a chip is about a third of the bar for a silent replacement, and it moves with every knob above it: raise the confidence slider and both go up together. A correction you have already rejected once is not offered, because being asked twice is worse than not being helped. The one exception is a retired pair that has sat quiet for a long time: it comes back as a chip rather than staying invisible forever. See [How long an undo lasts](#how-long-an-undo-lasts). Turn the chips off with **Offer corrections it isn't sure about** under Typing / Suggestions. Tapping the chip is itself evidence that the gate is too tight for that pair, so it feeds back the same way an accepted correction does. Backspace undoes it like any other correction. ## Auto-space and punctuation Two related rules ride along with autocorrect and share its "sentence in progress" bookkeeping. Each has its own toggle: - **Double space inserts a period.** Type two spaces in a row within a fraction of a second and the first space becomes `. `. Deleting a space and retyping it "undoes" nothing here; a following [Shift](#shift-cancels-a-pending-auto-space) is what cancels it. A separate, off-by-default setting can make a double space insert a tab instead, which takes priority over the period rule when both are on. - **Punctuation auto-inserts the space after it.** Off by default. When it's on, a sentence-ending or clause mark inserts a trailing space automatically: period, exclamation point, question mark, comma, semicolon, colon, and the Bengali `।`. You don't need a separate spacebar tap before the next word. A mark typed straight after a digit is part of the number and gets no space, so `5,000`, `3.14` and `5:00` stay whole. A full stop inside an email address gets none either, so `test@pm.me` doesn't come out as `test@pm. Me`; a comma or question mark after the address still does. A run of marks like "..." or "?!" isn't pulled apart into "... !", because the space from the previous mark is taken back before the next one lands. A closing mark does the same thing: type `"hi.` and the closing quote hugs the full stop rather than landing a space past it. This is also gated off in password and structured fields, same as autocorrect itself. ### A space that is already there Every rule that types a space after something, the space bar after a word, the space after a mark and the space after a glided word, checks first whether the text already goes on with a space. If it does, the cursor steps over that space instead of typing a second one, so it lands at the start of the next word. Put the cursor at `auto| space`, type `matic` and a space, and you get `automatic |space`, ready for the next word. The same goes for a word tapped from the strip. Before, the cursor stayed in front of the old space, so the next word ran into the one after it and every space and mark after that landed in the same wrong place. Web pages and app screens built on one are the exception: there the space is always typed. A page can show text after the cursor that isn't really there, such as Gmail's grey Smart Compose suggestion, and the keyboard has no way to tell the two apart. Stepping over that suggestion's first space made Gmail close the keyboard. A word the cursor only landed on is not a word you ended, so a space pressed there with nothing typed into the word is an ordinary space. ### Shift cancels a pending auto-space Right after either rule above inserts a space and auto-capitalization raises Shift for the next sentence, the very next Shift press does something different from lowering it. It deletes that trailing space, as long as nothing has changed the text since, and cancels that auto-capitalization too. When Shift wasn't raised for you, because the mark was a comma or auto-capitalization is off, the press arms Shift as usual and the space stays, so you can still capitalize the next word by hand. It's a one-shot. Press any other key first and the pending state clears, after which a plain space press only confirms the space already there rather than adding a second one. ### A mark takes the keyboard's space back Whenever the keyboard types a space for you rather than you typing it, a mark typed straight after it takes that space back so it hugs the word it belongs to. That covers the space after a glided word, the space after a word tapped from the suggestion strip, and the space the punctuation rule above inserts: `word:` and not `word :`. A space you typed yourself is yours, and no mark removes it. The marks that do this are the ones that end a word or build a longer one: the full stop and its family, the closing brackets, the percent sign, and the slash, backslash, apostrophe, dashes and underscore that spell "and/or", "hello's", "well-known" and "snake_case". `#` and `@` are not among them, because a hashtag and a mention attach to the word after them: `check this #cool` wants the space in front of the hash kept. In a web address field `#` and `@` join the list, along with `&`, `=`, `+` and `~`, since an address has no spaces anywhere in it. The rule runs before the keyboard decides what else the mark means, which matters for two of them. A colon on a word boundary also opens an emoji search, and an apostrophe goes into the word being corrected so that "hello's" stays one word. Both still hug the word first. If the emoji search does complete, the space comes back, since an emoji stands off the word in front of it: a swiped "party" then `:tada:` gives `party 🎉`. The straight double quote is the one mark that has to look at what came before it, because it is both ends of a quotation. The keyboard counts the quotes already on the line: an even count means this one opens, so the space in front of it stays, and an odd count means it closes, so the space goes. `he said "hello"` comes out right either way. The apostrophe is left out of this on purpose, since it is a letter inside a word and counting it would say nothing. Getting to the mark does not spend the space. A colon and a slash live on the symbols page, so reaching either one means pressing `?123` first, and that press changes only what is drawn. The same goes for shift, the Fn and number pages, and the globe key. Any key that puts text in the field does spend it, panels included, because what comes out of a panel is text like any other. ### A mark takes your own space back The rule above never touches a space you typed. **Remove a space before punctuation** is the setting that does, and it is on by default: with it on, `Hey .` lands as `Hey.` and `yes , no` as `yes, no`, the moment the mark is typed. It is narrow on purpose. The mark has to come after a word, a number or something that closes one (a bracket, a quote), so a mark at the start of a line or after another mark keeps its space, and a line break is never treated as a slip. A space in a password, an address or a number pad is left alone, same as every other rule here. One backspace straight after puts the space back. Since 0.6.6 so does a smiley: when the key after a `;` or `:` turns it into an emoticon, as in `;)`, `:(`, `:D`, `;P` or `:-)`, the space you typed comes back in front of it, so `nice ;)` stays `nice ;)`. If the keyboard put a space after the mark, only a closing mouth such as `)` counts, because a letter or an opening bracket there starts your next word. Which marks do this is yours to set. The list under the switch takes one character per mark with nothing between them, and starts out as the sentence and clause marks: `.,?!;:`, the Bengali `।`, and the Arabic comma, semicolon, question mark and full stop (`،؛؟۔`), which hug their words exactly as the Latin ones do. You do not have to edit it for French: the languages that keep a space in front of a mark are handled on their own, below, and are never hugged whatever the list says. ### The space in front of a mark French does the opposite of everything above. `!`, `?`, `;`, `:` and the guillemets are double marks there, and they take a space on both sides: `Bonjour !`, `Quoi ?`, `voici :`. **Space before French punctuation** is the switch for that, on by default, and it types the space for you and keeps every other rule from swallowing it again. It is a no-break space, so the mark can never wrap onto the next line on its own. That is why the rule exists in print. Type the space yourself and it is replaced with the no-break one; type none and you get one anyway; let the keyboard put one there after a swipe or a strip pick and it stays. One backspace straight after takes it out again, for the times you are quoting code rather than writing a sentence. The same guards apply as everywhere else on this page. The mark has to follow a word, a number or a closing bracket, so a mark at the start of a line, after a line break, or after another mark is left exactly as you typed it, and passwords, addresses and number pads are untouched. One knock-on: in these languages a colon after a word is punctuation rather than the start of an emoji shortcode, so `:tada:` opens the emoji search at the start of a line but not in the middle of a sentence. French quotation marks get the same treatment from both ends. `»` takes its space in front like any other mark, and `«` takes one behind, typed with the mark, so `«` then a swiped word gives `« oui` rather than `«oui`. Quoting in French is `« oui »` with no spacebar taps of your own. Seven languages are written this way and carry the rule: French, Breton, Occitan, Walloon, Picard, Norman and Franco-Provençal. Every other language, Haitian Creole and Catalan included, types exactly as it did before, because the switch has nothing to act on. ### A glided word joins an opening bracket Glide typing types a space in front of each word as well as after it, so two swiped words do not run together. That space is skipped when the character in front of it is one the word belongs against: an opening bracket, an opening quote, or the start of the line. `he said "` then a glided "hello" gives `he said "hello`. The double quote is read the same way as above, by counting the quotes on the line, so a closing quote still gets its space. In a web address field there is no leading space at all, since an address has no spaces in it. The joining marks work the same way, with one extra test. A slash, a backslash, a dash, an underscore, `&`, `=`, `+` and `~` hold two words together when they are up against the word behind them, so `The/` then a glided "And" gives `The/And`. The same marks stand between two words when they have a space in front of them, and then the glided word gets its space: `hello -` gives `hello - world`, while `well-` gives `well-known`. `#` and `@` are openers rather than joiners, because they attach to the word after them wherever they sit. `check this #` then a glided "cool" gives `check this #cool`. ## Brackets close themselves **Close quotes for me** is off by default and does the same for `"` and `'`, except right after a letter or number, where a quote is closing something or is an apostrophe. With it on, a `'` at the start of a word is always a quote, so it pairs instead of joining the word as its first letter, and typing `'` in front of the closing one steps over it. Inside a word, as in "don't", it is still an apostrophe. **Close brackets for me** is off by default. Turn it on and an opening bracket types its closing half behind the cursor, with the cursor left between the two, so you carry straight on inside the pair: press `(` and you get `()` with the caret in the middle, ready for what goes in it. Three presses behave differently once it's on: - **The opening bracket** types the pair. `(` `[` `{` do it, and so do the CJK and fullwidth brackets: `（` `［` `｛` `〈` `《` `「` `『` `｢` `【` `〔` `〖` `〘` `〚` `⟨` `⟦`. The pair only goes in where nothing follows the cursor but a space, a line break, the end of the text, a closing bracket or a mark like `.` or `,`. In front of anything else, a word, `@name`, `#tag`, `$5`, an emoji or a quote, you're putting a bracket around that text by hand, so only the opener is typed: `he (was`, not `he ()was`. - **The closing bracket**, pressed when that very character is already the next one in front of the cursor, steps over it instead of typing a second one. Typing both halves out of habit gives you `()`, not `())`. - **Backspace** on an empty pair takes both halves out in one press, so undoing the bracket undoes the closer that came with it. A pair with anything inside it deletes one character at a time, as always. Two kinds of character are deliberately left out. **Quotes** (`"`, `'`, `` ` ``, `«`), because the apostrophe in "don't" is the same key, and a keyboard that closed it would be wrong far more often than right; select some text and press the quote instead, which [wraps the selection](https://wmkeyboard.pages.dev/tools/text-editing/) in the pair. **`<`** for the same sort of reason: outside code it is a less-than sign, and `5 <` is nobody opening a bracket. The rule also stands down when the bracket lands in front of a word. `(` typed immediately before `world` is you putting brackets around that word by hand, and a closer dropped into the middle of it would only have to be deleted again. A space, a mark, another bracket or the end of the text all leave room for the pair. Passwords, email fields and number pads are untouched. Web addresses are not: a browser's address bar is a search box as often as an address box, and a bracket typed there pairs the same as anywhere else. The pair works the same in apps and web pages that handle typing their own way, Discord, browser-based editors and the like, where the cursor used to land outside the closing bracket. With **Automatic space after punctuation** on, a closing `)` gets the space after it too, typed or stepped over: `(see below)` then a word gives `(see below) word`. Only when nothing but a space or the end of the line follows it, so `((a))` and `(a).` don't come apart. `]` and `}` get no space, because `[text](link)` is a Markdown link and the space would break it. A closing quote gets the same space: `"exact phrase"` then a word gives `"exact phrase" word`. The curly `”` always closes. The straight `"` is counted the way the rule above counts it, so only the quote that closes a quotation gets the space, and the one that opens it stays up against the next word. In an app that turns your opening `"` into a curly `“` as you type, the straight quote that ends the quotation still counts as closing it. A full stop typed after the quote takes the space back, the same as after any other mark. A web address or a file name typed into a message closes back up. The space after a full stop goes in before the keyboard can tell a sentence from `google.com`, so when the word you type next is a domain ending or a file extension, the space comes back out as the word finishes: `google. com` becomes `google.com`, `notes. txt` becomes `notes.txt`, and `bbc.co. uk` becomes `bbc.co.uk`. The capital the full stop put on the word goes too. Endings that also start sentences (`it`, `in`, `me`, `us`, `go`, `log`) are left alone, and so is a dot that doesn't sit straight on a letter or digit, like `Wait... com`. One backspace puts the space back. In a browser's address bar the punctuation rule stays out, because a full stop or a colon there is part of an address. Once what you type there has a space in it, it is a search and not an address, and the closing `)` and closing quotes get their space as in a message. ## Lists carry on **Continue lists** is off by default. Turn it on and Enter on a list line starts the next line with the next marker, in any app, not only the [Notes](https://wmkeyboard.pages.dev/tools/notes/) editor. Type `1. milk`, press Enter, and the new line already reads `2. `. The markers it knows: - `-`, `*`, `+` and `•` carry on unchanged. - `1.` and `1)` count up, keeping whichever delimiter you used. - A task box, `- [ ]` or `- [x]`, carries on as an empty `- [ ]`; `☐` and `☑` carry on as `☐`. Indentation in front of the marker is kept, so a nested list stays nested. Enter on an item with nothing after its marker ends the list: the marker comes off and no new line is typed, the way a word processor lets you out of one. A number has to be three digits or fewer, so a line that opens with `2024.` is not read as a list item. The rule only runs where Enter makes a new line. In a chat box whose Enter key sends, Enter still sends; Shift+Enter there makes the line break, and that line break carries the list on. Passwords, email fields, web addresses and number pads are left alone. Bold, italic and the other inline styles are not converted. A plain text field has nowhere to draw them, and the chat apps that read `*bold*` or `**bold**` already do that themselves; select the text and the [chat formatting](https://wmkeyboard.pages.dev/smart/selection-actions/#chat-formatting) chips wrap it in the markers that app reads. ## Reducing typos before they happen Autopilot nudges which key a borderline tap resolves to, biasing toward whichever neighboring letter is more likely to continue the word you're typing. Fewer boundary mis-taps happen in the first place, before autocorrect would ever need to fix them. It has its own screen under the Suggestions settings group rather than sitting alongside autocorrect, since it needs suggestions on to have anything to bias toward. Its Strength slider sets how far a favoured letter reaches, and two optional views draw the touch areas it has claimed. See [Suggestions & prediction](https://wmkeyboard.pages.dev/smart/suggestions/) for the rest of how the suggestion engine ranks candidates. **Mistype tolerance** (100% by default, 50% to 200%) sets how far into a neighbouring key a tap may land and still be read as a slip of the key you meant. Every tap is scored by where it landed, so a tap near a key's edge can already count as its neighbour; raise this if you type fast and loose and want the keyboard to look further, lower it if you type carefully and want the key you hit trusted. It moves both the strip's candidates and autocorrect's pick, so it stays on the Automatic corrections screen, along with **Learn where my taps land**, when Autocorrect is turned off. **Fix several missed keys** (Careful by default) applies that reading to every letter of a word at once. Without it, each tap read as the key next door counts as one mistake, and autocorrect fixes one mistake per word. With it, a word typed fast with three keys a little wide, `rgw` with each finger just left of the key meant, is read as `the`. Only keys within reach of where your finger landed qualify (about one and a quarter keys at 100% tolerance, further as you raise it). **Careful** fixes those words, but a fix that also needs a letter added or removed is only offered in the strip. That mix is what most often turns a correctly typed word the keyboard hasn't learned yet, a new name or a bit of slang, into some other word; held back, such rewrites stay about as rare as they were without this setting. A word you keep typing is learned after a few uses, and from then on it's never changed. **Eager** applies it as well, for when your dictionary already holds every word you type. **Off** goes back to one fix per word. A word the keyboard knows is never changed, and typing with no tap positions, from a hardware keyboard or a paste, is corrected as before. ## Spell checking in other apps Android has a spell checker of its own, separate from the keyboard: it draws the red underline under a misspelt word in apps that ask for one, and offers fixes when you tap it. WM Keyboard can be that spell checker. Open the phone's **Settings**, search for **Spell checker** (usually under System, Languages & input), and pick **WM Keyboard spell checker**. It then checks words against the same word lists the suggestion strip uses: a word list you downloaded for the language, the built-in list for English, and the words the keyboard has learned from you. The fixes it offers are the ones autocorrect and the strip would give. A language with no word list on the phone gets no underlines at all, rather than every word marked wrong. For English it adds Harper's grammar marks on top. Nothing runs until you choose it there, and switching back is the same setting. See [System spell checker](https://wmkeyboard.pages.dev/smart/spell-checker/) for the details. ## Options Typing / Automatic corrections smart/autocorrect-options — The Automatic corrections group in Typing settings, including the confidence slider. | Setting | Default | Shown when | | --- | --- | --- | | Autocorrect | On | always | | Autocorrect this language (per language, under Languages & layouts) | On | Autocorrect on | | Autocorrect confidence | 4.0× (range 1.0×–10×) | Autocorrect on | | Adaptive confidence | On | Autocorrect on | | Typing rhythm | 0% (range 0%–100%) | Autocorrect on | | Undo autocorrect with backspace | On | Autocorrect on | | Undo a correction from the strip | On | Autocorrect on | | How often to offer the undo | 50% (range 0%–100%) | Autocorrect on, and Undo a correction from the strip on | | Remember my undos | Normal (Off / Light / Normal / Strict) | Autocorrect on | | Learn from my fixes | On | always | | Learned corrections | (a screen) | always | | Learn where my taps land | On | always | | Learned correction gate | On | Autocorrect on | | Mistype tolerance | 100% (50–200%) | | | Fix several missed keys | Careful (Off / Careful / Eager) | | | Skip words in capital letters | On | Autocorrect on | | Correct the word before Enter | On | Autocorrect on | | Correct the word before punctuation | Off | Autocorrect on | | Capitals from the word list | On | always | | Block offensive words | On | always | | Context-aware suggestions | On | always | | Context model | On | always | | Re-check the previous word | On | always | | Phrase suggestions | Off | always | | Add missing spaces | On | Autocorrect on | | Detect the language you type | On | always | | Detection strength | Balanced (Gentle / Balanced / Aggressive) | Detect the language you type on | | Fix number row slips | On | the number row is shown | | Fix missing apostrophes | On | always | | Double space | Full stop (Two spaces / Full stop / Tab) | always | | Double space speed | 400 ms (range 200–800 ms) | Double space is Full stop or Tab | | Automatic space after punctuation | Off | always | | Remove a space before punctuation | On | always | | Marks that pull the space out | `.,?!;:।،؛؟۔` | Remove a space before punctuation on | | Space before French punctuation | On | always | | Close brackets for me | Off | always | | Close quotes for me | Off | always | | Continue lists | Off | always | The table covers the rows this page is about. The same group also carries **Adapt to app tone** and **Space after a suggestion** (both described on [Suggestions & prediction](https://wmkeyboard.pages.dev/smart/suggestions/)), **Automatic capital letters**, and the two selection rules, wrap-with-a-pair and shift-re-cases-the-selection. The **Autocorrect** toggle is the master switch for the eighteen rows marked "Autocorrect on" above, from the confidence slider down to Fix number row slips. It is not a switch for the whole group. The apostrophe fix, both double-space rules, the auto-space after punctuation and the space-before-punctuation fix carry on working with autocorrect off, which is the point of them having their own toggles. Autocorrect is also reachable as a one-tap toolbar tool that flips the same switch without leaving the keyboard, showing a brief "Autocorrect on"/"Autocorrect off" confirmation. The tool is lit only when the language you're typing is corrected, so on a language switched off by itself (below) it shows off, and a tap turns autocorrect back on for that language rather than off for all of them. ### One language at a time Languages & layouts / your language / Autocorrect / Autocorrect this language Each language has its own switch, on by default. Turn it off for one language and words typed in it are never replaced, while every other language keeps being corrected. This is for typing two languages side by side where only one should be corrected, such as English next to romanized Bangla or a language whose word list doesn't know your spellings. The language follows the keyboard you're on, not the language [detected](https://wmkeyboard.pages.dev/smart/mixed-language/) in the field. Suggestions still show on the strip, and you can tap one. The switch only covers autocorrect itself: a phonetic layout's known spellings and dictionary words have their own switches in the same place (see [Phonetic typing](https://wmkeyboard.pages.dev/languages/phonetic/)). On a phonetic layout it does govern typos: a slip like `vako` for `valo` is corrected only while the switch is on. The main **Autocorrect** switch above still rules every language. While it's off, the per-language rows are greyed out and keep their own setting for when it comes back on. **Autocorrect confidence** is the ratio the top candidate must beat the runner-up by. It's a continuous slider from 1.0× to 10×, labeled with the exact multiplier (for example "×4.0"). Below 1.5× it also accepts words two letters away from what you typed, and at 1.0× the best candidate wins whatever the runner-up scores. A word already in a dictionary is still left alone, and **Adaptive confidence**, when on, can raise the bar again after corrections you undo. Lower makes autocorrect fire more eagerly, on less-certain calls. Higher restricts it to only the most unambiguous typos. Two-source agreement (see [How a correction is chosen](#how-a-correction-is-chosen)) always bypasses this slider, whatever it's set to, unless the learned gate is on, which weighs it instead. Under the gate the slider sets the probability a fix has to reach, the ratio against one; see [The learned gate](#the-learned-gate). **Learned correction gate** (on) is that gate. Off, the keyboard decides by the rules in [How a correction is chosen](#how-a-correction-is-chosen) alone. **Context model**, **Re-check the previous word** and **Phrase suggestions** are the neural context model's three rows; they are described on [Suggestions & prediction](https://wmkeyboard.pages.dev/smart/suggestions/#the-context-model), and the gate reads the model's scores when it is downloaded. Three more rows change what autocorrect does without you touching the slider: - **Adaptive confidence** (on) watches how often corrections get rejected and raises the bar when a lot of them do. It stays out of the way until twenty corrections have been judged, and it can move the gate anywhere from 0.85× the slider (a spotless record) up to 2.5× it, with the result always held inside the slider's own 1.5×–10× range. That is the whole of this row: it moves one global gate. The memory of individual corrections you undid is a separate setting, **Remember my undos**, described in [How long an undo lasts](#how-long-an-undo-lasts). - **Remember my undos** (Normal) sets how long the keyboard keeps an undo. It is the row to reach for if autocorrect either forgets a fix you rejected or refuses to fix a word you want fixed. See [How long an undo lasts](#how-long-an-undo-lasts). - **Stop after I refuse a fix** (2) leaves a word alone at the place where you have undone or deleted its correction that many times. See [When you keep deleting the same fix](#when-you-keep-deleting-the-same-fix). - **Learn from my fixes** (on) and **Learn where my taps land** (on) are the two halves of [Learning from your own fixes](#learning-from-your-own-fixes): the first remembers the typos you repair by hand and the slips behind them, the second where your finger lands on each key. **Learned corrections** opens the list of what has been learned, where each entry can be added, changed or removed. - **Typing rhythm** (0%, so off until you move it) measures how fast you typed the word. A quick sloppy burst makes autocorrect a bit braver. Slow deliberate typing, as with an unusual name or a word from another language, makes it hold back. The slider is how much the rhythm is allowed to sway things. - **Detection strength** decides how hard the language the keyboard reads the field as leans on ranking, from a light nudge at Gentle through Balanced to a heavy tilt at Aggressive. It reweights the word lists rather than moving the confidence gate, so it changes which word autocorrect reaches for, not how sure it has to be. See [Mixed-language typing](https://wmkeyboard.pages.dev/smart/mixed-language/). The other new rows are corrections in their own right rather than gate tuning: - **Add missing spaces** (on) splits a word you typed without its space when both halves are known words, the two are a pair the keyboard has seen together, and nothing else explains it. Off, the suggestion strip stops offering such two-word splits as candidates too. "ofthe" becomes "of the", and a letter next to the spacebar can stand in for the space itself, so "amibtomake" becomes "ami tomake". Two known halves alone are not enough, because the word lists carry every short fragment a corpus produced and an unlisted word ("config", "inbox", a name) that happens to break into two of them is far commoner than a missed space. So the pair has to be in the language's downloaded word pairs, or one you have typed yourself at least twice, and a word in your personal dictionary is never split. The second reading also needs the tap to have landed low on its key, toward the spacebar. Its first half can be a single letter only when that letter is a word at least as common as the one after it, which `i` and `a` are, so `ibwant` with the `b` tapped low becomes "i want". Since 0.6.6 a tap in the lower half of the key that didn't land that far down still counts for something: the split goes on the strip and on a chip you can tap, but is never applied on its own, so `tonthe` with the `n` tapped just below its middle offers "to the" where it used to offer nothing. A tap in the top half of the key is never read as a missed space. Until the pair is known a split stays a suggestion on the strip. Neither reading will ever end on a single letter: a downloaded word list is built from a corpus tokenised at the apostrophe, so it carries a bare "s", "t" and "don" as ordinary words, and without that rule "thats" reads as "that s". The first half may still be one letter, because "alot" really is "a lot". Backspace right after puts your text back, like any other correction. A space that took the place of a letter goes the other way: with `e` before the space and `ough` being typed, the strip offers *enough* as a chip that replaces both. That's a chip only, never applied on its own, and only while what you're typing is at least ten times rarer than the joined word, since a space before a real word was most likely meant: `i to` stays two words. Before 0.6.6 the fragment had to be no word at all, which a downloaded word list (some count `ough`) or a few sightings in your personal dictionary was enough to break. Two missed letters can turn into a full stop: both `b`s of *lobby* land on the space bar, the double space becomes `. `, and the field reads `lo. y`. Since 0.6.6 the word typed after a full stop that a double space put in gets the same chip, here *lobby*, when two of the letters beside the space bar would join the halves into a word. Tapping it takes the full stop out too. - **Fix number row slips** (on) treats a lone digit inside a word as a tap that landed one row too high, so "as3" can commit as "ase". The row is the one on your screen: a layout with a number row of its own (Eastern Arabic digits, say) has its own keys checked against the letters under them, since 0.6.4. So does the custom number row you set for every layout under Layout, since 0.6.6; before that a typed slip was read against the built-in digits even when your row put other keys there. Only a same-length, single-digit swap is ever trusted: a word starting with a digit, or one with two or more digits, is left alone. The letter has to be one the digit sits over or beside, so a `3` is read as `w`, `e` or `r` and nothing else. Before 0.6.6 any letter could stand in, and "ton3" stayed as typed because "tony", four keys from the `3`, was too close behind "tone" for autocorrect to choose. Chinese Pinyin and Jianpin read a digit in the reading the same way since 0.6.6: `niha9` converts as *nihao*. The row only appears while the [number row](https://wmkeyboard.pages.dev/reference/settings/layout/) is on, since that's the only time the slip is possible. - **Context-aware suggestions** (on) reorders the top candidates using the words before them, drawing on your own word pairs, common English pairs and the words already in this conversation. It only reorders where there's real evidence, and it never changes which word autocorrect applies. ## Details & edge cases - **Structured and secure fields are a hard gate, not a per-setting one.** Autocorrect, both auto-space rules, and the autopilot bias all share one underlying check: the field must be a plain text field, not a password field or a keypad (email, web address, phone, number). There's no way to enable autocorrect specifically in a password field. - **An autocorrected word earns no personal-dictionary credit** at the moment it's committed, so the engine's own guess isn't reinforced as if you'd typed it deliberately. Reverting it with backspace teaches the original word instead (see [Undoing a correction](#undoing-a-correction)). - **The revert window is exact, not fuzzy.** It only fires if the caret is still precisely where the correcting commit left it and the text immediately before it is still `"corrected word" + " "`, unchanged. Any cursor movement, or any edit elsewhere in the field, silently disarms it. Older corrections are reached through the [undo chip](#taking-a-correction-back-later), which keeps the last five. - **Two-source agreement bypasses the slider.** If your personal dictionary and the standard dictionary happen to name the same fix for a typo, it's applied even below the confidence slider's threshold. The slider only governs cases where the two disagree, or where only one source has an opinion. It can't resurrect a rejected fix, though: a blacklisted, filtered or retired candidate is dropped from the pool before this test ever runs. - **The confidence check is symmetric with the engine's internal default.** The slider's default position (4.0×) matches the value the underlying suggestion engine falls back to if a setting were ever missing, so a fresh install and an explicitly-set default behave identically. For the rest of the suggestion strip, including completions, next-word prediction, and how learning ranks your own words over time, see [Suggestions & prediction](https://wmkeyboard.pages.dev/smart/suggestions/). To keep a word out of both suggestions and autocorrect entirely, use the [suggestion blacklist](https://wmkeyboard.pages.dev/smart/blacklist/).