tauri-plugin-sys-locale-api
v0.1.2
Published
JS/TS bindings for tauri-plugin-sys-locale
Readme
tauri-plugin-sys-locale
A Tauri v2 plugin that reads the current operating system locale/language.
Works cross-platform (Windows, macOS, Linux, and thanks to the
sys-locale crate also iOS/Android), without needing any custom native
Swift/Kotlin code.
1. Installation (Rust side)
In your Tauri app's Cargo.toml (src-tauri/Cargo.toml):
[dependencies]
tauri-plugin-sys-locale = tauri-plugin-sys-locale = "*"In src-tauri/src/main.rs:
fn main() {
tauri::Builder::default()
.plugin(tauri_plugin_sys_locale::init())
.run(tauri::generate_context!())
.expect("error while running tauri application");
}2. Enable the capability
In src-tauri/capabilities/default.json (or whichever capability file
applies), add the permission:
{
"identifier": "default",
"windows": ["main"],
"permissions": ["sys-locale:default"]
}3. Installation (frontend side)
npm install tauri-plugin-sys-locale-api4. Usage in the frontend
import { getLocale, getLocaleInfo } from "tauri-plugin-sys-locale-api";
const locale = await getLocale();
console.log(locale); // e.g. "de-DE"
const info = await getLocaleInfo();
console.log(info.language); // e.g. "de"5. Using the functions directly from Rust (no JS/invoke needed)
The core logic lives in plain pub fns in src/api.rs (not tagged with
#[tauri::command]), so you can call them from any Rust code — inside a
Tauri command, a background task, setup(), etc. — without going through
the frontend at all:
use tauri_plugin_sys_locale::api;
fn some_backend_logic() {
match api::get_locale() {
Ok(locale) => println!("System locale: {locale}"),
Err(e) => eprintln!("Could not determine locale: {e}"),
}
// or with locale + language split apart:
if let Ok(info) = api::get_locale_info() {
println!("locale={}, language={}", info.locale, info.language);
}
}You can even call it directly inside main.rs, e.g. to set an initial
window title or pick a translation file before the app finishes starting:
fn main() {
let locale = tauri_plugin_sys_locale::api::get_locale()
.unwrap_or_else(|_| "en-US".into());
println!("Starting app with locale: {locale}");
tauri::Builder::default()
.plugin(tauri_plugin_sys_locale::init())
.run(tauri::generate_context!())
.expect("error while running tauri application");
}The commands.rs module just wraps these same functions with
#[tauri::command] so the frontend can reach them via invoke() — both
paths call identical logic.
Why sys-locale instead of custom native code?
The sys-locale crate already wraps the platform-specific APIs:
- Windows:
GetUserDefaultLocaleName - macOS/iOS:
NSLocale - Linux: environment variables (
LANG,LC_ALL, ...) - Android: JNI call to
Locale.getDefault()
That means you don't need a separate android/ or ios/ directory with
Kotlin/Swift code, unlike many other Tauri plugins.
Building the JS bindings
npm install
npm run buildThis compiles guest-js/index.ts into dist-js/index.js,
dist-js/index.cjs, and the corresponding .d.ts type declarations.
