Languages & Localization

Athena's console text — labels, menus, and messages — is served from JSON language packs. English ships out of the box, and Hebrew is offered in the language picker. Because language packs are plain files, you can also translate the console into any language you like by adding your own pack. This page explains where language packs live, the format they use, how to register and select one, how the automatic right-to-left layout works, and how the server behaves when a translation is missing.

How localization works#

Athena keeps every piece of console text in a language pack: a single JSON file named after the language's two-letter code — en.json for English, he.json for Hebrew, and so on. When the server starts it reads the pack for the currently selected language from its Resources folder and uses those strings everywhere in the console.

• English (en) is the built-in language and always ships with a complete pack.
• The selected language comes from the Localization:Language configuration value (see Configuration → Localization). The default is en.
• The language picker under Settings → General offers English and עברית (Hebrew), and writes your choice to that same configuration value.

The language pack is read once when the server starts. That means a change to the selected language — or a change to a pack's contents — takes effect after the server is restarted (see Applying changes).

Language packs#

Language packs live in the Resources directory alongside the server. Each file is named <code>.json, where <code> is the language code you reference in configuration and in the picker:

Translation file format#

A language pack is a nested JSON object. Keys are grouped into sections (for example Common, Settings, Search), and each leaf value is the translated string. Athena reads the nested structure and turns each entry into a dotted key — so Common.Save below refers to the "Save" value inside the Common object:

{
  "App": {
    "Name": "Athena",
    "Description": "Software Deployment & Inventory"
  },
  "Common": {
    "Save": "Save",
    "Cancel": "Cancel",
    "Delete": "Delete",
    "Loading": "Loading..."
  },
  "Settings": {
    "General": {
      "Language": "Language Settings",
      "CurrentLanguage": "Current Language"
    }
  }
}

When you translate a pack, change only the values (the text to the right of each colon) and keep the keys exactly as they appear in en.json. The keys are how the console looks each string up; renaming or removing one means that string will fall back to English (or, in some places, show the key itself). A few practical rules:

• Start from en.json. Copy it to your new <code>.json and translate the values in place. This guarantees every key exists.
• Preserve placeholders. Some strings contain numbered placeholders such as {0} that are filled in at runtime (for example a count or a name). Leave the placeholder tokens intact and only translate the surrounding words. If a placeholder is removed or malformed, Athena safely shows the untranslated template rather than erroring.
• Valid JSON only. The file must parse as JSON (mind the commas, quotes, and braces). If a pack fails to parse, the console keeps the strings it already had rather than loading a broken file.
• UTF-8. Save the file as UTF-8 so accented and non-Latin characters render correctly.

Adding a new language#

To translate the console into a language that isn't shipped — say French (fr) — follow these steps on the server:

1. Copy the English pack. Duplicate Resources/en.json to Resources/fr.json.
2. Translate the values. Edit fr.json and translate each string value, leaving the keys and any {0}-style placeholders unchanged.
3. Register the language. Add the code to the Localization:SupportedLanguages list so Athena treats it as an available language. See Configuration keys.
4. Select it. Set Localization:Language to fr — either by editing configuration directly or, for a shipped language, by choosing it in Settings → General.
5. Restart the server so the new pack is loaded (see Applying changes).

Configuration keys#

Two keys under the Localization section of appsettings.json control language behaviour (also summarised on Configuration → Localization):

// appsettings.json — offer English, Hebrew, and a custom French pack,
// with French selected as the active language
"Localization": {
  "Language": "fr",
  "SupportedLanguages": [ "en", "he", "fr" ]
}

The selected language can also be changed through the console and the API as part of the General settings — those simply write the Localization:Language value for you. See General Settings → REST API and PowerShell.

Right-to-left languages#

Athena knows that some languages read right-to-left. When the active language is Hebrew (he) or Arabic (ar), the console automatically switches to a right-to-left layout — text alignment and the flow of the interface flip to match. You don't need to configure anything extra: adding an ar.json pack and selecting ar gives you an Arabic, right-to-left console, just as Hebrew does today.

Every other language code is treated as left-to-right. If you translate into another right-to-left script, you can still ship the pack; the layout direction is driven specifically by the he and ar codes.

Missing translations & fallback#

Athena is designed to keep the console usable even when a pack is incomplete or absent:

• No pack for the selected language. If Resources/<code>.json doesn't exist, Athena logs a warning and falls back to the English pack, so the console still loads in English rather than failing to start.
• Individual missing keys. Because a custom pack may lag behind new strings, any key that isn't present simply resolves to its identifier — the console never shows a blank space. Re-copying the latest en.json keys into your pack fills these in.
• Broken JSON. If a pack can't be parsed, the load is skipped and the console retains the previously loaded strings; check the server log for a localization warning and fix the file.

Applying changes#

The active language pack is loaded when the server starts. Whenever you:

• add or replace a <code>.json language pack, or
• change the Localization:Language value,

restart the server so the console picks up the change consistently for everyone. For this reason, plan language-pack updates during a maintenance window, the same way you would for other server-configuration changes. See Configuration and General Settings.

Related#

• General Settings — selecting the display language and other console-wide preferences.
• Configuration → Localization — the Language and SupportedLanguages keys in context.
• Report Branding & Layout — customising the look of generated reports.
• Server Logging — where to confirm a language pack loaded.
• Installation — persistent-directory layout for keeping custom packs across upgrades.