# Smart chips > Inline answers above the keys: calculations, conversions, and useful bits pulled from your clipboard. URL: https://wmkeyboard.pages.dev/smart/chips/ Section: Suggestions & correction Smart chips watch the last 48 characters before your cursor. The moment that text looks like something a tool can answer, the answer lands on the suggestion strip in place of word candidates. Tap the chip to type the answer, or its gear button to open the full tool with the same numbers already loaded. A few chips have nothing to type and only ever open a tool. Those carry no gear, and the whole chip is the door. The gear also stays hidden while its tool is switched off under Tools, since there would be nothing for it to open. The gear takes the text it answered out of your message on its way into the tool, because the tool types its own result in that spot. If you change your mind, close the tool without inserting anything and press backspace once: the first backspace puts `150 usd`, or `calculator`, back where it was. Typing anything first, or moving the cursor, gives up that undo. To keep the text every time, turn on **Keep the text when a chip opens its tool**; the tool's result then lands after your text. ## Doing the math Type an expression like `12*8` and the strip offers `96` as a tappable chip. It recognizes `+ - * / × ÷ − ^ % ( )`, `√`, `π`, and `e`, along with implicit multiplication (`2π`, `3(4+1)`). A plain division counts on its own, so `1/2` offers `0.5`. Tap the chip and the result replaces what you typed. Type `=` yourself and the answer is appended instead, leaving your sum in place, so `12*4=` becomes `12*4=48`. Permutations and combinations use the shorthand a calculator keypad uses: `5p3` offers `60` and `4c2` offers `6`. Both letters have to sit tight between two digits, so `page 5 c 2` stays a sentence. A few things deliberately don't trigger a chip. A bare number on its own isn't a sum, and `100%` on its own reads as "percent" rather than a sum to evaluate. A `%` with arithmetic around it does count, and reads as it does in the [Calculator](https://wmkeyboard.pages.dev/tools/utilities/#doing-the-math): `100+20%` offers `120`. Named functions and word-operators like `sin`, `sqrt`, `log`, or `mod` never show up as an inline chip either. Apart from `p` and `c`, the symbol scanner only looks for digits, operators, and the two symbols `π`/`e`. Anything with more letters than that works only by opening the Calculator tool itself. Some arithmetic gets written as a sentence, though, and a second scanner catches three shapes of it: a share of an amount (`15% of 200`, `15% on 200`, `15% tip on 4500`), a discount (`20% off 1500`, `20% off of 1500`), and a bill split (`split 4500 between 3`, `split 4500 3 ways`, `4500 split 3 ways`; `among` and `by` work as well as `between`, and `people`, `persons` or `friends` as well as `ways`). Each one produces an ordinary calc chip, and the gear opens the Calculator on the equivalent sum. ### Sums in number fields An amount, quantity or price box works too. Those fields only take digits, so a `×` typed into one would be dropped before the chip could read it. Instead the keyboard holds the sum itself. Type the first number, then an operator from the hold on the `-` key (or the minus itself): the number stays in the field, and the rest of the sum appears on the chip as you type it, `120 × 3 → 360`. Tap the chip, or press Enter or `=`, and the answer replaces the number in the field. Backspace edits the sum, and taking out its operator leaves the field as it was. Moving the cursor or leaving the field drops the sum unchanged. A field that only takes whole numbers gets the answer rounded, shown as `~3`, rather than losing its decimal point. PIN fields and phone fields are left alone. The chip's gear icon opens **Calculator** with your expression prefilled. Result precision (decimal places) is shared with the unit converter, and there's a separate degrees/radians switch for trig, set below in [Options](#options). ## Converting currencies and units smart/currency-chip — A currency chip: amount and source on the left, the converted amount on the right, gear button to open the full converter. Type an amount next to a currency (`150 usd`, `150$`, `$150`, or `150 dollars`) and the strip converts it into your other currency. Symbols, spelled-out words and 3-letter codes all work. Big amounts can be written the short way or the long way: `1.5k usd`, `2m dollars`, `3 crore taka`, `2 million dollars`, even `1 thousand 500 dollars`. `k`, `m` and `b` are thousand, million and billion, and `lakh` and `crore` work as well. If what you typed is already in your target currency, the chip flips and converts the other way, so either side of your currency pair gets an answer. The result shows a currency's name rather than its code (`Taka`, not `BDT`), unless you pick the symbol (`৳18,000.00`) or the code under **Write the result as** in the [Currency converter](https://wmkeyboard.pages.dev/tools/utilities/) options. If exchange rates haven't loaded yet, the chip shows a brief spinner while they fetch. In the F-Droid edition it reads **Get the rate** instead and fetches only when you tap it, unless **Fetch rates as you type** is on in the [Currency converter](https://wmkeyboard.pages.dev/tools/utilities/) options. Coins work the same way, and they're on out of the box. `1 btc`, `0.5 ETH`, `2 bitcoin`, `100 doge` and `100000 sats` all convert into your currency. Point your pair at a coin and the conversion runs the other way, so `1000000 bdt` becomes a fraction of a bitcoin, with enough digits to read. Tickers that double as ordinary English words, such as `DOT`, `LINK` and `NEAR`, only count in capitals, so "meet me in 1 near future" stays a sentence. Coin prices load the first time you type a coin amount, not before. Units follow the same shape. Type `1 ft` (or `1ft`) and the chip offers the same length in meters, across 14 categories: length, mass, temperature, area, volume, speed, time, data, energy, power, pressure, angle, frequency, and fuel economy. Spelled-out magnitudes work here too, so `1 thousand miles` converts as 1000 miles and `2 lakh km` as 200,000 km. Only the words, though: `5m` is five meters and `1.5k` stays out of unit territory, since the single letters already mean something metric. Short, easy-to-confuse abbreviations (`c`, `f`, `in`, `s`, and a couple dozen others) only count glued directly to the number, so `30c` triggers and `30 c` doesn't, and ordinary sentences don't turn into unwanted chips. The unit it converts into is whichever one you paired it with last time you used the converter. The first time, it falls back to a sensible default: feet to meters, kilograms to pounds, and so on. To pick the unit it answers in, name it after `in`, `to`, `into` or `as`: `1 mile in cm` gives `160934.4 cm`, and `30c to f` gives `86 °F`. The unit you name can be any spelling the converter knows, short ones included. One that measures something else, like `1 mile in kg`, gets no chip. Anything landing in feet is read as feet plus inches, since that's how people say it. `1m` becomes `3 ft 3.37 in`, not `3.2808399 ft`. The chip answers in the same style you asked in, so `1m` gets symbols back while `1 meter` gets `3 feet 3.37 inches`. **Feet and inches** under Tools / Unit converter / Options turns this off if you'd rather have the decimal. ### The chip fits itself to the strip A conversion chip prefers to echo what you wrote: type `100 dollar` and the left side reads `100 Dollar`, not `100 USD`. When the full answer doesn't fit the strip, the chip gives things up one at a time instead of cutting the number off mid-digit. First to go is a `.00` tail on the result, then exact decimals (a rounded preview wears a `~`, as in `~৳122,001`), then names shrink to codes and codes to symbols, then the font steps down a size. Only as a last resort does a spelled-out amount flatten to digits, so `1 thousand` becomes `1000`. Unit chips walk the same ladder. `1609.344 km` rounds to `1609.34 km` and then `~1609 km`, and a spelled-out unit shrinks to its symbol (`miles` to `mi`) before the amount gives up its words. A feet-and-inches answer walks its own version: it drops the spelled-out names first (`3 feet 3.37 inches` to `3 ft 3.37 in`), then the fraction of an inch (`~3 ft 3 in`), and finally the units themselves, for the prime marks everyone reads as feet and inches anyway (`~3'3"`). None of this changes what a tap types. The inserted amount is always the exact, full-precision result. Both chip types share the same wide look (`[icon] query → result [gear]`) and take the full width of the strip, since a recognized calculation or conversion is a better use of that space than word candidates. The date and weather chips further down this page are drawn the same way. ## Grouping long numbers Type a long run of digits on its own, like `1234567`, and the strip offers it back with separators in place. Tap the chip and the grouped number replaces what you typed. Which grouping you get follows the language you're typing in. English and most other languages get thousands, so `1234567` reads as `1,234,567`. Bangla, Hindi, Urdu, Nepali, Tamil and the other South Asian languages get the lakh and crore grouping, where only the last group holds three digits: `1,00,000`, `10,00,000`, `1,00,00,000`. **Grouping style** in [Options](#options) fixes one of the two if you'd rather not have it follow the language. A number typed in Bangla digits comes back in Bangla digits, and a decimal point you've already typed carries its fraction through untouched, so `1234567.89` offers `1,234,567.89`. The chip is drawn like the calculation and conversion chips, and its gear opens the Calculator with the number loaded. This chip is deliberately hard to trigger, since most long digit runs are not amounts. See [Why a chip stays quiet](#why-a-chip-stays-quiet) for the rules. ## Keyword chips open a tool Type a tool's keyword on its own (`wiki`, `calc`, and so on) and a narrower chip offers to open that tool, dropping the word you typed. The text-editing tool is the one exception: `edit` stays in the field, since that tool works on the text that's already there. This chip stays narrow instead of filling the strip, because the word you're typing might be meant as that word, and word candidates keep the rest of the row. smart/keyword-chip — Typing wiki offers a narrow chip to open Wikipedia, leaving room for word candidates. Each tool's own settings list the words that open it, and let you change or clear them. Matching ignores capitals by default, and a per-tool **Match capitals** switch makes that tool compare literally instead, which is how `AI` can open the AI tool without every auto-capitalised "Ai" doing the same. ## Chips that read the sentence Five more families watch for text that isn't a sum or a keyword but still sounds like a job a tool does. They ride the same master switch and each has its own toggle in [Options](#options). - **Resolve dates.** A forward-pointing phrase (`tomorrow`, `next friday`, `aug 14`, `the 15th`) gets a wide chip showing the date it lands on. A tap keeps your phrase and appends the date in brackets, so "next friday" becomes "next friday (21 Aug)". The gear opens the Calendar on that day. Only forward dates count, because "last friday" needs no annotating. **Date chip formats** (advanced) writes the date your own way: type one or more [date patterns](https://developer.android.com/reference/java/text/SimpleDateFormat), separated by `|`, such as `EEE d MMM | yyyy-MM-dd`. The chip shows the first and a tap writes it, so "tomorrow" becomes "tomorrow (2026-11-04)" with `yyyy-MM-dd`. With more than one, hold the chip to switch to the next. Month and day names follow the phone's language. A pattern that doesn't read leaves the chip's own wording. - **Answer weather questions.** `will it rain`, `how's the weather`, `how hot is it` and similar get a wide chip with the conditions on it. This one never types into your field, since the question was probably meant for the person you're writing to. Tapping it opens the Weather tool instead. It needs a weather location set, and shows a spinner while the forecast fetches. In the F-Droid edition it reads **Get the forecast** instead, and the first tap fetches the forecast rather than opening the tool, unless **Fetch the forecast as you type** is on in the Weather tool's options. - **Offer lookups.** `define serendipity` or `what does X mean` offers the Dictionary; `who is Tesla`, `what is X` or `tell me about X` offers Wikipedia. Narrow chip, and it leaves your question alone. - **Translate hints.** `how do you say`, `translate this`, or `in spanish` (sixteen language names are recognised) offers the Translate tool. Tap it after a sentence, as in `good morning in spanish`, and the hint words go from the field, the words before them on that line are selected, and Translate opens on them, already translated into the language you named, which also becomes its target. **Replace** then puts the translation where those words were. With nothing before the hint, it opens the tool and leaves your text alone. Turn on **Translate "in …" where it stands** under Tools / Translate to skip the panel: the tap puts the translation in place of the words and the hint, and the chip's Translate button still opens the tool. - **Ask home.** With a Home Assistant on the [Smart home tool](https://wmkeyboard.pages.dev/tools/home-assistant/)'s list, a sentence that reads like a command for the house (`turn off the lights`, `dim the bedroom to 30%`, `lock the front door`, `open the blinds`) gets a chip that sends it to Home Assistant's Assist instead of leaving it in your message. Off with **Suggest commands as you type** on the tool's page. - **Location hints**, part of **Translate hints**. `I'm at`, `my location`, `where I am` or `here is my location` offers the [Location tool](https://wmkeyboard.pages.dev/tools/location/), so the place goes in right after your words. Narrow, and it leaves your text alone. - **GIFs for celebrations.** `happy birthday`, `congrats`, `eid mubarak`, `শুভ জন্মদিন` and a handful more offer a GIF search already pointed at the occasion. It falls back to the sticker panel when the GIF tool is off. Your own stickers work differently: they turn up by themselves when you type their title, a keyword or an emoji, and you send one with a single tap. See [Stickers as you type](https://wmkeyboard.pages.dev/emoji/stickers/#stickers-as-you-type). Each only fires when the tool it would open is switched on under Tools. If one of these switches is on while its tool is off, a note under the switch names the tool, with a **Turn on** button that switches it back on. The narrow ones are hints rather than answers, so each gets one shot per field: once you type past a lookup or intent chip, that tool won't hint again until you move to another field. One wiring quirk is worth knowing. **GIFs for celebrations** sits inside **Translate hints** rather than beside it, so turning the translate hints off takes the celebration GIFs with them, while turning the GIFs off leaves translate alone. ## Calling or texting a contact Typing / Smart chips / Call or text a contact Type the name of someone in your contacts and a narrow chip with their name and a phone icon comes up beside the word candidates. Tap the name and your phone app opens with their number already in the dialer, ready for you to press call. Tap the message button on the chip's right and your messages app opens addressed to them. The keyboard never places the call or sends anything itself, and the name you typed stays in your text, since you may have been writing it for the person you're chatting with. What counts as a name: - **The whole name, in any case.** `jane doe`, `Jane Doe` and `Mom` all work, so long as that's how the contact is saved. - **The first name alone, with its capital**, and only when no one else in your contacts shares it. `Jane` finds Jane Doe, but `jane` doesn't, and with two Marks saved `Mark` finds neither: a chip that has to guess who to ring would be worse than none. This is also what keeps `Will` the contact apart from `will` the word. - **The name right before the cursor**, or followed by one space. Type on and the chip moves on; punctuation straight after the name (`Mom,`) ends it too. A contact with several numbers is offered on the one you've marked as default in your contacts, and otherwise on the first one Android lists. Like the lookup and intent hints, each name gets one offer per field: once you type past it, that contact won't come up again until you're in another text box. The switch is **off** by default because it reads your address book. Turning it on asks for the contacts permission, after a screen explaining what's read. Names and numbers are held in memory only while the keyboard runs, are never written to a file, and never leave the phone. The chip doesn't show in password fields, or anywhere the strip is switched off. ## Repeated text Typing / Smart chips / Repeated text Type the same thing a few times in a row, `no no no`, `ok` on three lines, `hahaha`, and a narrow chip reads **Repeat "no"** with a small **×3** beside it. Keep typing the same word and the number ticks up instead of the chip reappearing. Tap the chip and the [Text repeat](https://wmkeyboard.pages.dev/tools/utilities/#repeating-text) tool opens on that text, with the same separator you used and a count ready that at least doubles what you typed (three becomes ten). The copies you typed stay in the field until you press **Insert** there. What Insert does with them is the tool's own setting: by default it takes them out and writes the whole count in their place, so the field ends with exactly that many; **Add after them** leaves them and writes the count after, with the separator between. What counts as a run: - **The same text, three times or more, ending at the cursor.** The number is a setting, 2 to 6. One trailing space or line break is fine, since a finished word usually has one; type anything else and the chip moves on. - **With a space, a comma or a new line between** any text counts, a single letter or emoji included: `a a a`, `5, 5, 5`, `😂 😂 😂`. - **With nothing between** the text has to be at least two characters and not itself a repetition: `hahaha` and `lollollol` fire, `!!!!!!`, `aaaaaa` and `😂😂😂` don't. A stretched letter or a doubled emoji is a message, not a request, and the tool's Stretch mode is a tap away. - **The shortest reading wins**, so `no no no no` is four of `no`, never two of `no no`. - **It has to start at the beginning of the text or after a space**: `xhahaha` is not a run. Like the other hints, each text gets one chip per field: type past it and `no` won't come up again until you're in another box. A keyword chip beats it (`wiki wiki wiki` still opens Wikipedia), and it beats a contact's name typed three times. The chip stays off in password fields and while the Text repeat tool is disabled. ## Pulling fragments out of your clipboard Open the [Clipboard](https://wmkeyboard.pages.dev/tools/clipboard/) tool and a row of dashed-outline chips sits above the grid of copied items. It surfaces one-time codes, phone numbers, and links found buried inside your clipboard history, not only in your latest copy. The scan covers your recent clips, sorts codes before phone numbers before links, and shows up to a dozen chips at once. Long-press a chip to see the fragment highlighted inside the clip it came from. Tap it to paste only that fragment, leaving the full clip in history untouched. smart/clipboard-entity-strip — The Clipboard panel: dashed entity chips above the history, pulled out of several different clips. One fast path doesn't need the panel at all. Copy a bare one-time code, then tap into a box that asks for a code, and the strip offers it as a dashed **Code** chip in place of the usual "paste your last copy" chip. It's deliberately that narrow. A copied code counts as a secret, so it stays off the strip in an ordinary message field, and a code quoted inside a longer message never becomes a chip there at all: pulling a fragment out of a message is what the Clipboard panel above is for. The fast path is also OTP-only, so a freshly copied phone number or link shows as the ordinary full-clip paste chip until you open the panel for the fragment version. smart/otp-fresh-copy-chip — Copying a verification text offers only the code, not the whole message, right on the suggestion strip. Both surfaces are covered by the same setting (see [Options](#options)), and neither one scans a clip you've marked sensitive, or an image or file clip. A code you never copied has its own route to the strip. If you let the keyboard watch notifications, a verification code that arrives in one raises its own chip above the keys with no copy-paste step at all. That's a separate, off-by-default feature with its own page: see [One-time codes](https://wmkeyboard.pages.dev/smart/one-time-codes/). ## AI suggestions An optional chip, off by default, that comes from your [AI provider](https://wmkeyboard.pages.dev/tools/ai/#suggestions-in-the-strip) rather than from the text before the cursor. It offers one short continuation of what you're typing, in front of the word suggestions, and is marked with a sparkle so you can tell it from a word. A smart chip takes the strip over it. Tap it to insert the continuation, or hold it to hide AI suggestions in this field. It sends text without a tap, which is why it lives with the AI settings and says there exactly what each request carries. ## Why a chip stays quiet Each detector has guards against the shapes of text that look like a trigger but usually aren't: - **Dates** (`12/04`, `12/04/2025`, `2024-07`) never read as arithmetic. A zero-padded pair reads as a date. A lone `-` between two plain numbers is a sum (`12-4` offers `8`) unless either side has four digits or a leading zero, since `555-1234`, `2024-25` and `2024-07` are a phone number, a season and a month. Either way, an explicit `=` forces the answer. - **Order numbers and prices** don't turn into phone numbers. A leading `#`, `$`, `£`, or `€` rules a run of digits out. - **Years** don't turn into codes. A bare 4-digit value between 1900 and 2099 is rejected even next to a code-sounding word. - Google's `G-123456` SMS prefix is stripped before the code check, since it's branding rather than part of the code. - A code needs a nearby keyword (`otp`, `verification`, `code`, `pin`, `2fa`, and similar) within 40 characters. A deny-list (`zip`, `postal`, `hex`, `swift`, `ifsc`, and others) stops things like "zip code 90210" from qualifying anyway. - **`try`** in lowercase reads as the English verb, not Turkish lira. Type `TRY` in capitals to convert it. - Short unit abbreviations (`c`, `f`, `in`, `s`, `k`, and others) only count glued to the number, so "meet me in 5" or "about 30 c out" stay quiet. - **Long numbers** are only offered grouped when they read as a quantity. The run needs five digits at least and fifteen at most, and a leading zero rules it out, since that marks a phone number, an account or a PIN. It also has to stand on its own: anything joined to a letter, a `.`, `-`, `/`, `:`, `#` or `+` on its left is a version, a date, a ratio or an identifier, and a number that already carries separators is left as it is. Currency, unit and calculation chips all win over it, because a number that means something is worth more than a number that is merely long. And it stays out of fields that ask for a number at all, such as an amount box, a card form or a PIN, since those want the digits they asked for. - **Repeated text** needs three copies (or whatever the setting says) ending right at the cursor, and never reads a single stretched letter or a doubled emoji as a run. See [Repeated text](#repeated-text). - Unpunctuated digit runs longer than 11 digits aren't treated as phone numbers unless they start with `+`. That shape rule is what stands in for knowing where you live, so it steps aside once you've listed your own [phone formats](https://wmkeyboard.pages.dev/reference/settings/phone-formats/) and the masks decide the length instead. ## Options Typing / Smart chips smart/options — Smart chips settings under Typing: master switch and the four per-family toggles. - **Smart chips**: the master switch, default **on**. Turn it off and all twelve chip families below go at once. - **Calculate as you type**: default **on**. - **Convert currencies**: default **on**. - **Convert units**: default **on**. - **Tool keywords**: default **on**. - **Resolve dates**: default **on**. - **Answer weather questions**: default **on**. - **Offer lookups**: default **on**. - **Translate hints**: default **on**. - **GIFs for celebrations**: default **on**. - **Group long numbers**: default **on**. - **Grouping style**: **Automatic**, **Thousands** or **Lakh and crore**, default **Automatic**, which follows the language you're typing in. - **Call or text a contact**: default **off**. Needs the contacts permission. See [Calling or texting a contact](#calling-or-texting-a-contact). - **Repeated text**: default **on**. See [Repeated text](#repeated-text). - **Chip after this many repeats**: 2 to 6, default **3**. Shown while Repeated text is on; the same row lives on the Text repeat tool's page. - **Keep the text when a chip opens its tool**: default **off**. Leaves the typed amount, sum or tool keyword in place when the gear opens the tool. Each tool's own page (Calculator, Unit converter, Currency converter) links back here with a **Suggestion chip** row that shows whether its chip is on. The switches themselves live only under Smart chips. A few related settings live under each tool instead: - **Degrees** (Calculator, default **on**) and **Result precision** (0–12 decimal places, default **8**). Precision also shapes the unit converter's output. - **Decimal places** for currency (0–6, default **2**), **Write the result as** (Name, Symbol or Code, default **Name**) and **Refresh the rates every** (1–48 hours, default **6**), under Tools / Currency converter / Options. - **Convert coins** (default **on**), **Coin decimal places** (Auto to 12, default **Auto**), **Refresh coin prices every** (1–60 minutes, default **5**) and the **Coins** chip grid, under Tools / Currency converter / Cryptocurrency. The same screen picks which source each kind of rate is fetched from. - **Detect codes, numbers and links** (default **on**), under Clipboard, governs the Clipboard panel's entity strip. The fresh-copy code chip is a separate pair of settings on that same screen: **Suggest the last copy** (default **on**), since the code chip is a variant of that chip, and **Suggest copied codes** (default **Any field**), which is what allows a copied code onto the strip at all. ## Details & edge cases - A chip won't reconsider text it just inserted. After you tap one, the strip mutes until you edit the field again, so converting 150 USD to Taka doesn't immediately offer to convert the Taka amount right back. - Smart chips step aside for secure fields, fields that ask for no suggestions, any open panel, and CJK-style conversion composing, since a chip would otherwise steal the space a pinyin reading needs for its own candidates. A reading that spells a tool's keyword still offers that tool, as a chip behind all the candidates with an arrow after its name, unless **Shortcuts while converting** is off. - **Chips on the far side**, under Typing › Automatic corrections, moves the chips that share the strip with the words to the end of the strip, where a right thumb reaches them: a one-time code, a copied clip, a keyword, and the chip that joins two words or fixes an earlier one. The words stay in their order beside them. A sum or a date fills the strip either way. - On a conversion layout, every chip comes back once the reading is committed, so `12*4` answers on Pinyin as it does on English. A wide chip (a sum, a date, a conversion) covers the next words until you carry on typing. Every tool's keywords include Chinese, Japanese and Korean words, and a Chinese or Japanese keyword counts at the end of a longer run of text, so 我的笔记 offers Notes. - They're independent of word prediction. Turning off suggestions elsewhere doesn't turn off any of the smart chips. - [Power saving mode](https://wmkeyboard.pages.dev/typing/power-saving/) can flip the master switch off (its own **Smart chips** toggle lives under Power saving, off by default), so every chip family goes at once, but it leaves clipboard entity detection alone. Codes, numbers, and links keep getting pulled out of your clips even while chips elsewhere are dimmed. - Exchange rates come from open.er-api.com (about 160 currencies, updated daily), with frankfurter.dev (European Central Bank, about 30 currencies) as a fallback. Coin prices come from Coinbase with the jsDelivr currency-api behind it. The F-Droid edition starts both from currency-api, which is open data, with Frankfurter behind the currency rates. None of them needs an account or a key, and any of them can be swapped for another under the tool's settings. See [network policy](https://wmkeyboard.pages.dev/privacy/network/) for what else touches the network. - A coin chip shows the ticker (`BTC`) where a currency chip shows a name (`Taka`), because coin names shorten badly. It also keeps five meaningful digits rather than two decimals, so a small fraction of a coin still reads as a number instead of `0.00`. - The currency and unit pair a chip converts into isn't set from a Settings screen, unless you name the unit in the text (`5 kg to lb`). It's remembered from whichever pair you last used inside the [Currency converter](https://wmkeyboard.pages.dev/tools/utilities/) or [Unit converter](https://wmkeyboard.pages.dev/tools/utilities/) panel itself. - Chips answer what you typed. [Selection actions](https://wmkeyboard.pages.dev/smart/selection-actions/) answer what you selected: a different bar, a different trigger, and its own switch under Advanced. The two never share the strip, because nothing is being typed while text is selected.