A tiny friend in your Mac's notch and on your iPhone that keeps an eye on your AI coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more. Approve from the notch or your Lock Screen.
Swift ai-agentsanthropicantigravityclaudeclaude-codecodexcursordynamic-islandgemini-cliiosiphonlinuxmacosmacos-appmenubar-appnotchopen-sourceswiftswiftuiwindows
// Interface language for what Rust shows: the tray menu, the settings window
// title and the errors the webviews display. Same tables and same lookup as
// src/i18n/i18n.ts: strings keyed by their English text, from the Mac's catalog
// (strings.json, generated by scripts/gen-strings.mjs) and the Windows/Linux
// only ones (extra.json). A string missing in a language shows in English.
//
// The language is Settings.language when it is one of ours; "" follows the
// system: the languages the island's webview reports at launch, else (Linux)
// the LANGUAGE / LC_ALL / LC_MESSAGES / LANG variables, else English.
use serde_json::{Map, Value};
use std::collections::HashMap;
use std::sync::{OnceLock, RwLock};
pub const LANGUAGES: [&str; 14] = ["en", "zh-Hans", "hi", "es", "ar", "fr", "bn", "pt-BR", "ru", "id", "de", "tr", "ko", "ja"];
static MAC: &str = include_str!("../../src/i18n/strings.json");
static EXTRA: &str = include_str!("../../src/i18n/extra.json");
type Table = HashMap<String, Map<String, Value>>;
fn table() -> &'static Table {
static TABLE: OnceLock<Table> = OnceLock::new();
TABLE.get_or_init(|| {
let mut out = Table::new();
// extra.json goes last: it wins where both have a string.
for source in [MAC, EXTRA] {
let Ok(Value::Object(root)) = serde_json::from_str::<Value>(source) else { continue };
let Some(Value::Object(strings)) = root.get("strings") else { continue };
for (key, entry) in strings {
if let Value::Object(langs) = entry {
out.insert(key.clone(), langs.clone());
}
}
}
out
})
}
struct Current {
picked: String,
system: Vec<String>,
resolved: &'static str,
}
fn state() -> &'static RwLock<Current> {
static STATE: OnceLock<RwLock<Current>> = OnceLock::new();
STATE.get_or_init(|| {
let system = env_languages();
let resolved = resolve("", &system);
RwLock::new(Current { picked: String::new(), system, resolved })
})
}
/// LANGUAGE (a list), then LC_ALL, LC_MESSAGES and LANG, as gettext reads them.
fn env_languages() -> Vec<String> {
let mut out = Vec::new();
if let Ok(list) = std::env::var("LANGUAGE") {
out.extend(list.split(':').filter(|s| !s.is_empty()).map(str::to_string));
}
for name in ["LC_ALL", "LC_MESSAGES", "LANG"] {
if let Ok(v) = std::env::var(name) {
if !v.is_empty() && v != "C" && v != "POSIX" {
out.push(v);
}
}
}
out
}
/// The language to show: `picked` when it is one of ours, else the first of
/// the system's languages we have, else English. Same rules as resolveLanguage
/// in src/i18n/i18n.ts.
pub fn resolve(picked: &str, system: &[String]) -> &'static str {
if let Some(code) = LANGUAGES.iter().find(|c| **c == picked) {
return code;
}
for raw in system {
// "fr_FR.UTF-8" → "fr-fr"
let tag = raw.split('.').next().unwrap_or("").replace('_', "-").to_lowercase();
let base = tag.split('-').next().unwrap_or("");
if base.is_empty() {
continue;
}
if base == "zh" {
let traditional = ["zh-hant", "zh-tw", "zh-hk", "zh-mo"].iter().any(|p| tag.starts_with(p));
if traditional {
continue;
}
return "zh-Hans";
}
if base == "pt" {
return "pt-BR";
}
if let Some(code) = LANGUAGES.iter().find(|c| c.to_lowercase() == base) {
return code;
}
}
"en"
}
/// Records Settings.language. Returns true when the shown language changed.
pub fn set_picked(picked: &str) -> bool {
let mut s = state().write().unwrap_or_else(|e| e.into_inner());
s.picked = picked.to_string();
let next = resolve(&s.picked, &s.system);
std::mem::replace(&mut s.resolved, next) != next
}
/// Records the system's languages as the webview sees them. Returns true when
/// the shown language changed.
pub fn set_system(languages: Vec<String>) -> bool {
let mut s = state().write().unwrap_or_else(|e| e.into_inner());
if !languages.is_empty() {
s.system = languages;
}
let next = resolve(&s.picked, &s.system);
std::mem::replace(&mut s.resolved, next) != next
}
/// The language shown now.
pub fn current() -> &'static str {
#[cfg(test)]
return TEST_LANG.with(|c| c.get());
#[cfg(not(test))]
state().read().unwrap_or_else(|e| e.into_inner()).resolved
}
// Tests run in parallel and many check English text: each test thread has its
// own language, English unless the test picks another.
#[cfg(test)]
thread_local! {
static TEST_LANG: std::cell::Cell<&'static str> = const { std::cell::Cell::new("en") };
}
fn interpolate(text: &str, vars: &[(&str, &str)]) -> String {
let mut out = text.to_string();
for (name, value) in vars {
out = out.replace(&format!("{{{name}}}"), value);
}
out
}
fn lookup_in(lang: &str, key: &str) -> Option<&'static Value> {
if lang == "en" {
return None;
}
table().get(key)?.get(lang)
}
/// CLDR plural category of `n` (whole numbers) in `lang`.
fn plural_category(lang: &str, n: u64) -> &'static str {
match lang {
"zh-Hans" | "id" | "ko" | "ja" => "other",
"fr" | "pt-BR" | "hi" | "bn" => {
if n <= 1 { "one" } else { "other" }
}
"ru" => {
let (m10, m100) = (n % 10, n % 100);
if m10 == 1 && m100 != 11 {
"one"
} else if (2..=4).contains(&m10) && !(12..=14).contains(&m100) {
"few"
} else {
"many"
}
}
"ar" => match (n, n % 100) {
(0, _) => "zero",
(1, _) => "one",
(2, _) => "two",
(_, 3..=10) => "few",
(_, 11..=99) => "many",
_ => "other",
},
_ => {
if n == 1 { "one" } else { "other" }
}
}
}
fn pick_plural(forms: &Map<String, Value>, category: &str) -> Option<String> {
forms
.get(category)
.or_else(|| forms.get("other"))
.or_else(|| forms.values().next())
.and_then(Value::as_str)
.map(str::to_string)
}
/// Marks an English key for a table built before it is shown (the tray's
/// labels): the code translates it with `t` when it shows it. The i18n test
/// (tests/i18n.test.mjs) finds the keys through it.
pub const fn n_(key: &'static str) -> &'static str {
key
}
/// `key` (English text) in the shown language, else the English text.
pub fn t(key: &str) -> String {
tf(key, &[])
}
/// `t` with `{name}` placeholders filled in.
pub fn tf(key: &str, vars: &[(&str, &str)]) -> String {
let lang = current();
let text = match lookup_in(lang, key) {
Some(Value::String(s)) => s.clone(),
Some(Value::Object(forms)) => pick_plural(forms, "other").unwrap_or_else(|| key.to_string()),
_ => key.to_string(),
};
interpolate(&text, vars)
}
/// A count with its words: `tn("{count} file", "{count} files", n, &[])`.
#[allow(dead_code)]
pub fn tn(one: &str, other: &str, count: u64, vars: &[(&str, &str)]) -> String {
let lang = current();
let n = count.to_string();
let mut all: Vec<(&str, &str)> = vars.to_vec();
all.push(("count", &n));
let text = match lookup_in(lang, other) {
Some(Value::Object(forms)) => pick_plural(forms, plural_category(lang, count)),
Some(Value::String(s)) => Some(s.clone()),
_ => None,
};
let text = text.unwrap_or_else(|| if count == 1 { one.to_string() } else { other.to_string() });
interpolate(&text, &all)
}
#[cfg(test)]
pub(crate) fn set_for_test(lang: &str) {
TEST_LANG.with(|c| c.set(resolve(lang, &[])));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolves_like_the_webview() {
let sys = |v: &[&str]| v.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert_eq!(resolve("fr", &sys(&["ru"])), "fr");
assert_eq!(resolve("", &sys(&["fr_FR.UTF-8"])), "fr");
assert_eq!(resolve("", &sys(&["pt-PT"])), "pt-BR");
assert_eq!(resolve("", &sys(&["zh-CN"])), "zh-Hans");
assert_eq!(resolve("", &sys(&["zh-TW", "it", "es-MX"])), "es");
assert_eq!(resolve("", &sys(&["it-IT"])), "en");
assert_eq!(resolve("xx", &[]), "en");
}
#[test]
fn looks_up_both_tables_and_falls_back_to_english() {
set_for_test("fr");
// From the Mac's catalog.
assert_eq!(t("Allow"), "Autoriser");
// From extra.json.
assert_eq!(t("Open Coucou"), "Ouvrir Coucou");
assert_eq!(t("A string nobody translated"), "A string nobody translated");
assert_eq!(tf("Open {name}", &[("name", "Vercel")]), "Ouvrir Vercel");
set_for_test("en");
assert_eq!(t("Allow"), "Allow");
assert_eq!(tf("Open {name}", &[("name", "Vercel")]), "Open Vercel");
}
#[test]
fn plurals_follow_the_language() {
set_for_test("en");
assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 1, &[]), "✓ Connected · 1 model");
assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 3, &[]), "✓ Connected · 3 models");
set_for_test("es");
assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 1, &[]), "✓ Conectado · 1 modelo");
assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 4, &[]), "✓ Conectado · 4 modelos");
assert_eq!(plural_category("ru", 21), "one");
assert_eq!(plural_category("ru", 23), "few");
assert_eq!(plural_category("ru", 25), "many");
assert_eq!(plural_category("ar", 2), "two");
set_for_test("en");
}
#[test]
fn every_extra_string_has_every_language() {
let Value::Object(root) = serde_json::from_str::<Value>(EXTRA).unwrap() else { panic!() };
let Some(Value::Object(strings)) = root.get("strings") else { panic!("no strings") };
for (key, entry) in strings {
for lang in LANGUAGES.iter().filter(|l| **l != "en") {
assert!(entry.get(*lang).is_some(), "{key:?} has no {lang}");
}
}
}
#[test]
fn german_resolves_translates_and_selects_singular_only_for_one() {
for tag in ["de", "de-DE", "de-AT", "de-CH", "de_DE.UTF-8"] {
assert_eq!(resolve("", &[tag.to_string()]), "de");
}
assert_eq!(resolve("de", &["fr-FR".to_string()]), "de");
assert_eq!(resolve("fr", &["de-DE".to_string()]), "fr");
set_for_test("de");
assert_eq!(t("Allow"), "Zulassen");
assert_eq!(t("Deny"), "Ablehnen");
assert_eq!(t("Open the chat"), "Chat öffnen");
assert_eq!(tf("Uploading {name}", &[("name", "Grüße.pdf")]), "Grüße.pdf wird hochgeladen");
assert_eq!(t("A string nobody translated"), "A string nobody translated");
for count in [0, 1, 2, 21] {
assert_eq!(plural_category("de", count), if count == 1 { "one" } else { "other" });
let repo = if count == 1 { "Repository" } else { "Repositorys" };
let model = if count == 1 { "Modell" } else { "Modelle" };
assert_eq!(tn("{count} repo", "{count} repos", count, &[]), format!("{count} {repo}"));
assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", count, &[]),
format!("✓ Verbunden · {count} {model}"));
}
set_for_test("en");
}
#[test]
fn turkish_resolves_translates_and_preserves_counted_nouns() {
let system = |tag: &str| vec![tag.to_string()];
assert_eq!(resolve("tr", &system("en-US")), "tr");
for tag in ["tr", "tr-TR", "tr_TR.UTF-8"] {
assert_eq!(resolve("", &system(tag)), "tr");
}
set_for_test("tr");
assert_eq!(t("Allow"), "İzin ver");
assert_eq!(t("Deny"), "Reddet");
assert_eq!(t("Open the chat"), "Sohbeti aç");
assert_eq!(tf("Uploading {name}", &[("name", "öğrenci.pdf")]), "öğrenci.pdf yükleniyor");
assert_eq!(t("A string nobody translated"), "A string nobody translated");
for n in [0, 1, 2, 21] {
assert_eq!(plural_category("tr", n), if n == 1 { "one" } else { "other" });
assert_eq!(tn("{count} repo", "{count} repos", n, &[]), format!("{n} depo"));
assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", n, &[]),
format!("✓ Bağlı · {n} model"));
}
set_for_test("en");
}
}