GDPR-compliant organization

ISO 27001 certified organization

SOC II compliant organization

Software localization that ships every language with each release

Smartcat is an AI software localization platform for product and engineering teams that ship web, mobile and desktop software in many languages. Strings move from your repository, API or CLI into AI translation with your glossary and translation memory, your reviewers approve them, and files return to the build with keys, placeholders and plurals intact. Only new and changed strings are billed.

Book a demo

Book a demo

Our expert gives you a tailored demo

Importing keys into a Smartcat software localization project with the smartcat import command from the CLI

More than 80 of the world’s largest companies have chosen Smartcat

What is software localization?

Software localization is the process of adapting web, mobile and desktop software for users in another language and market: its interface strings, error messages, help text and store listings. It goes further than software translation, because the translated strings must fit the UI and merge back into the build with keys, placeholders and plural rules intact.

Smartcat runs that loop as one connected flow. You import keys through the UI, REST API or CLI, AI translates them with your glossary, your reviewers approve them in the browser, and you export the files your build already reads. Approved strings are reused next sprint, so each release pays only for what changed. Format guides: JSON translator, XML translator, gettext PO translation and XLIFF editor.

92%

of AI-translated words accepted unedited

92% of words translated by Smartcat AI are accepted without a single human edit.

280+

languages

Smartcat translates your product into 280+ languages, from German, Spanish and French to Japanese and Chinese.

80+

file formats

80+ file formats, including JSON, YAML, XML, PO and XLIFF.

Interactive demo: review a software localization project, confirm segments, check QA and export keys.

Why does software localization slow down every release?

Software localization slows releases down when it runs as a separate, manual loop: strings are exported, emailed, fixed and re-imported by hand for every language. Product teams ship every sprint, so each release either waits for translation or ships with untranslated strings.

  1. Export strings

    Pull strings out of the repository, one file per platform.

  2. Email locale files

    Email files or upload them to a vendor portal, then wait.

  3. Fix placeholders

    Repair broken placeholders, keys and plural forms by hand.

  4. Re-import translations

    Merge translations back and rebuild for every locale.

  5. Chase review

    Chase reviewers in other time zones for sign-off.

× every language× every platform× every release

The result is a growing gap between the product you ship and the product users in other markets can read, and engineers spend sprint time on files instead of features.

70%

lower localization costs at Kaseya

“We’re coding with AI, so we’re releasing product updates every day, a couple times a day. There’s no way to keep up with that. This rate of change is one of the reasons why Smartcat is so necessary.”

Kaseya’s product documentation team moved UI localization into its development cycles with Smartcat and reinvested the savings in 8+ additional languages.

Kaseya case study
Ellen Kelly
Ellen KellyDirector of Product Documentation, Kaseya

What it costs when localization lags the release

When software localization lags the release, the cost rarely shows up as a translation problem. It shows up in staggered launches, engineering time, support load and revenue from new markets, and it grows with every language you add.

Launches in one language at a time

New features reach other markets weeks after English, so every launch lands in stages.

Engineering time spent on files

Developers export, merge and debug locale files instead of building the product.

Broken strings in production

A changed placeholder or a missing plural form breaks a screen, and users find it first.

Support load in every market

Untranslated or half-translated screens send users to support in their own language.

Paying twice for the same strings

Without a shared memory, vendors quote again for strings you have already translated.

No single source of truth

Strings live in repositories, spreadsheets and vendor portals, so nobody knows which version is current.

How a software localization platform keeps up with your releases

A software localization platform such as Smartcat connects your string files to translation and back. Keys, placeholders and plurals stay intact, AI coworkers translate with your glossary and memory, your reviewers approve, and approved strings are reused in the next sprint.

Before: a manual string loop

× every language× every release

With Smartcat: one connected flow

Every language together

Export by hand

Someone pulls locale files from each repository and platform.

Sync from the repository

Import keys through the UI, REST API or CLI, including from CI/CD.

Email files

Files travel to a vendor without keys, comments or screenshots.

Context travels with strings

Key IDs, comments and length limits reach the translator.

Fix placeholders

Broken variables and plural forms surface in QA or production.

Placeholders locked

Variables and tags are protected, and plurals keep their forms.

Chase review

Reviewers get spreadsheets and send feedback by email.

Approve in the browser

Your reviewers and linguists approve each language in one editor.

Re-send and pay again

Unchanged strings are sent and billed again next release.

Export and reuse

Files return in their format, and approved strings are reused next release.

Keep JSON, XML, PO and XLIFF files intact

Smartcat parses each format on its own terms: JSON and YAML keys, Android XML, iOS .strings, PO entries with msgid_plural and msgctxt, XLIFF 1.2 and 2.0, RESX, and XML with XPath rules for translatable nodes. Placeholders and tags are locked, plural forms stay plural, and every file exports back in the structure your build expects. See the supported file formats.

Sync strings from GitHub, GitLab, Bitbucket, the REST API or CLI

Connect a GitHub, GitLab or Bitbucket repository through Smartcat’s Git integrations, push keys through the REST API, or run the Smartcat CLI from your CI/CD pipeline. Designers send Figma text, keys and variants through the Figma plugin. Strings arrive in a software localization project, organized into collections, and go back the same way once they are approved.

Give translators key IDs, comments and length limits

Key IDs, developer comments and length limits travel with every string, so a translator knows a label is a button with little room, not just a word. XML files can carry comments and @max length limits (see the XML translator), and LocJSON can carry a maximum length. Automated QA checks flag tag, number and terminology errors before export.

Pay only for new and changed strings with translation memory

Every approved string goes into your translation memory, and your glossary keeps product terms consistent across web, mobile and desktop. Next sprint, unchanged strings are filled in from memory, so reviewers work on the new text and the cost of a release follows the size of the change. Plans and Smartwords are on Smartcat pricing.

See software localization on one of your own repositories

How AI software localization works with human review

In AI software localization with Smartcat, AI handles the first pass and people make the call. AI coworkers translate each string with your glossary and translation memory, your reviewers and linguists check it in context, and your team approves it before it ships.

AI coworkers prepare

Routine strings move without waiting in a queue.

  • Content Translator Coworker

    Translates new and changed strings with your glossary and translation memory.

  • Reviewer Coworker

    Pre-reviews each language for fluency, tone and terminology.

  • Quality Assurance Coworker

    Checks terminology, tags and formatting and classifies each issue by severity.

People review

Judgment where the product needs it.

  • Product and UX writers

    Check that UI copy reads right in context and fits the screen.

  • In-country reviewers

    Approve each language in the browser, with no software to install.

  • Smartcat Marketplace linguists

    Add professional review for regulated or high-stakes copy when you need it.

You approve

Nothing ships without sign-off.

  • Your localization owner

    Approves each language before files are exported to the build.

  • Translation memory

    Keeps every approved edit, so the next release starts from your reviewers’ corrections.

How software teams manage translations in one project

Software teams manage translations best in one shared project: in Smartcat, developers, product managers, linguists and reviewers work on the same strings instead of passing files around. Every approved edit grows your translation memory and glossary, so the next release moves faster.

Developers

Push and pull keys through the REST API or CLI, or connect a repository, and get files back in the format your build reads.

  • smartcat import
    Send new keys from a pipeline step
  • REST API
    Build custom import and export
  • GitHubGitLabBitbucket
    Sync a repository

Product managers

See every language’s progress in one project and decide what ships with the release.

  1. ImportNew keys from the sprint
  2. TrackProgress per language
  3. ShipExport approved files

Linguists

Translate in an editor with translation memory, glossary, QA checks and the developer’s comment beside each string.

Beside every string

Key IDDeveloper commentLength limitTranslation memoryGlossaryQA checks

Reviewers and vendors

Approve or edit strings in the browser instead of a spreadsheet. Freelancers and vendors work from their own Smartcat accounts.

Without Smartcat
  • A spreadsheet of strings
  • Feedback by email
In Smartcat
  • Strings with keys and comments
  • Their own Smartcat account

Software localization tools vs services: TMS, in-house scripts or an agency?

The right setup depends on how often you ship: in-house scripts suit one language, software localization services from an agency suit occasional large projects, and localization software (a TMS) suits continuous releases. Most product teams combine a platform with linguists for copy that carries risk.

In-house scripts + machine translationLocalization agencySmartcat
Who translatesMachine translation, checked by whoever is freeAgency linguistsAI translation with your glossary, plus your reviewers or Marketplace linguists
String filesYour scripts parse each formatFiles sent per projectJSON, YAML, Android XML, iOS .strings, PO, XLIFF, RESX and XML, with keys and placeholders intact
Developer workflowCustom code to maintainEmail or a vendor portalUI, REST API, CLI and GitHub, GitLab or Bitbucket
Context for translatorsRarely passed onScreenshots on requestKey IDs, comments and length limits with every string
UpdatesRe-run the scriptsNew quote per changeOnly new and changed strings are billed
ReviewEngineers or product managersAgency QAYour reviewers approve in the browser
Best forOne language, low volumeOccasional large projectsContinuous releases in many languages

Need linguists to run a whole language? Smartcat Marketplace linguists work inside the same project, memory and glossary as your team.

How to localize software: the software localization process in 5 steps

To localize software in Smartcat, create a software localization project, import your keys, translate them with AI, have reviewers approve each language and export the translated files. These software translation steps repeat every release, so set them up once in the UI and run them through the REST API or CLI.

  1. Create a software localization project

    Name the project, choose one source language and add your target languages. You can add or remove target languages at any time.

    The Create a software localization project form in Smartcat, with project name, source language and target languages
  2. Import your keys

    Upload JSON, YAML, Android XML, iOS .strings or LocJSON files in the UI, or import them with the REST API or the Smartcat CLI from your CI/CD pipeline. Group keys into collections.

    Imported keys such as hello_world and file_menu in the Smartcat editor, translated from English into German
  3. Translate with AI

    AI translates every key with your glossary and translation memory. Strings already in translation memory are filled in automatically.

    A Smartcat task list with automatic translation completed for German, Spanish, French, Italian and Russian
  4. Review and approve

    Your reviewers or Smartcat Marketplace linguists check each language in the editor, with QA checks for tags, numbers and terminology.

    The Smartcat editor with source and target segments and editing actions
  5. Export translated files

    Export JSON or YAML (flat or structured), Android XML or iOS .strings per language, with a file name template such as strings-{LANGUAGE}.json, from the UI, API or CLI.

    Export settings in Smartcat: target languages and the file name template strings-{LANGUAGE}.json

Try this software localization process on your own string files

Software localization platform for product teams

Smartcat handles software localization management in one workspace: keys and collections, AI translation with memory and glossary, QA checks, review and linguists on demand. Developers, product managers and linguists use the same project, so every language ships from one place.

See the software localization platform on your own string files

Which software file formats does Smartcat translate?

Smartcat translates the resource files your build already uses, including JSON, XML, gettext PO, XLIFF, YAML, Android XML and iOS .strings. Each guide below covers what is kept, how to translate the file and what to check before you ship.

Software localization, explained: i18n vs l10n, continuous localization and APIs

Software internationalization (i18n) prepares code for any language; software localization (l10n) adapts it for each market. The localization of software also involves continuous localization, localization engineering and APIs. Smartcat sits on the localization side: it reads the files your i18n setup produces and returns them translated.

Internationalization (i18n)Localization (l10n)
What it isDesigning and coding software so it can support any language and regionAdapting an internationalized product for one language and market
Who does itDevelopersLocalization managers, linguists and reviewers, with developers
WhenOnce, early in development, then maintainedEvery release, for every target language
Typical workExtract strings into resource files, use locale-aware date and number formats, leave room for longer textTranslate strings, adapt dates, currencies and examples, review UI copy in context
Where Smartcat fitsReads the resource files your i18n setup producesTranslates, reviews and returns them every release

i18n and l10n are numeronyms: 18 and 10 letters sit between the first and last letter of each word.

How localization fits into engineering

Continuous localization

Continuous localization, also called agile localization, translates strings as they change, sprint by sprint, instead of in one batch before a launch. New keys flow from the repository into translation and back without a manual hand-off.

  1. CommitNew or changed keys
  2. TranslateAI with memory and glossary
  3. ApproveYour reviewers
  4. MergeFiles back to the repository

Localization engineering

Localization engineering is the technical side of localization: preparing resource files, parsing formats, protecting placeholders, handling plurals and wiring translation into the build. Smartcat takes on the parsing and protection.

What Smartcat handles

  • A parser per file format
  • Placeholders and tags locked
  • Plural segments or ICU MessageFormat
  • Comments and length limits passed on

Localization automation

Localization automation replaces manual exports with integrations: a repository connection, a CLI step in CI/CD, or a REST API call that imports and exports keys.

  • smartcat import
    Send new keys from a pipeline step
  • CLIREST API
    Pull translated files back
  • GitHubGitLabBitbucket
    Sync a repository

Localization API

A localization API lets your systems create projects, import keys and export translations without anyone opening the UI. Smartcat’s REST API covers the same import and export as the UI and CLI.

What the API covers

Create projectsImport keysExport translationsRun from CI/CD

What gets localized

UI localization

UI localization adapts every string users see in the interface: buttons, menus, errors and empty states. Short strings need context most, so Smartcat passes key IDs, comments and length limits to translators.

Strings in scope

ButtonsMenusError messagesEmpty statesOnboarding

Plurals and ICU messages

Languages have different plural rules. Smartcat handles plurals as native plural segments or as ICU MessageFormat, and export converts them to ICU-compatible strings. Gettext msgid_plural and msgctxt are supported.

An ICU plural message

{count, plural, one {# file} other {# files}}

LocJSON imports can parse ICU into segments or keep it raw, with an ICU previewer and validator.

JSON and XML in one workspace

Many products ship strings in more than one format: JSON for the web app, Android XML for mobile, XML for documentation. Smartcat keeps them in one workspace with one translation memory and glossary, so a string is translated once across formats.

One memory across

.jsonstrings.xml.xml.strings.yaml

Product localization

Product localization goes beyond UI strings to the help center articles, release notes and web pages around the product. Smartcat translates them in the same workspace, with the same memory and glossary, through integrations such as Zendesk and Contentful.

One glossary for all of it

UI stringsHelp centerRelease notesProduct pages

The AI coworkers that localize your software

Smartcat’s AI coworkers each take one part of software localization: coordinating a release, translating strings, finding changed content, pre-reviewing and checking quality. Your team and reviewers approve every string before it ships.

Software localization integrations for your dev stack

Sync strings from repositories, design files and the platforms around your product. See all integrations

Software localization results from Huel, Babbel and Kaseya

Software and product teams use Smartcat to ship every language with the release. Kaseya launches in 10+ languages on day one, Babbel saves 31 hours of manual work a month, and Huel cut localization costs by about 50% compared with agencies.

50%

lower costs than agencies

Huel cut localization costs by about 50% compared with agencies.

31 h

of manual work saved every month

Babbel’s localization team saves 31 hours of manual work a month with Smartcat.

10+

languages at launch, alongside English

Kaseya launches releases in 10+ languages on day one; UI strings sync to Smartcat when developers commit them.

9

languages Huel localizes across web, CRM and creative

“Smartcat is more than a translation tool for us; it’s integrated with our tech stack.”

Huel localizes its website through Smartcat’s Contentful integration and its email campaigns through its CRM integration, with one glossary of about 500 entries. Translations are reused across ad sizes from translation memory, so designers don’t rebuild every variant.

Huel case study
Magdalena Tumulka
Magdalena TumulkaLocalization Lead, Huel

Book a software localization demo for your next release

How to start with software localization: one project first

Start software localization with one project: the product or platform that is late today. As volume grows, Smartcat takes on more of the loop, from importing keys through the API or CLI to routing approvals for every language.

  1. One collection

    One app or platform needs a new language, and files still go back and forth by hand.

    Software localization projectContent Translator CoworkerYour reviewers

    Which product is waiting on translations right now?

  2. API or CLI in CI/CD

    New keys arrive every sprint, and manual exports become the bottleneck.

    REST APISmartcat CLIGit repositories

    How many hours a sprint go into exporting and merging locale files?

  3. Continuous localization in every release

    Strings, help content and release notes ship together in every language.

    Reviewer CoworkerQuality Assurance CoworkerContent Update Coworker

    When a feature ships, how long until every market can read it?

  4. Localization governance across teams

    Several product teams localize on their own, within one glossary and approval model.

    Chief of StaffEnterprise governance

    Can a team add a language without a new vendor contract?

What changes when you switch to a software localization platform

Switching to a software localization platform changes how strings move, not your stack. Your repository, i18n framework, build and vendors stay. Exporting files, fixing placeholders, routing review and paying for repeated strings move into Smartcat.

Your repository, framework and vendors stay

Smartcat works between your repository and translation, so your codebase, i18n library and build don’t change. Your translation vendor’s linguists can work inside Smartcat, next to your own reviewers.

Stays as it is
Repositoryi18n frameworkBuild pipelineTranslation vendor
Moves into Smartcat
Exporting filesFixing placeholdersReview routingPaying for repeats

Start with one project, not a migration

Pick the product that is late today, import its keys and run one release through Smartcat with your own reviewers. Nothing else has to move first.

  1. Import keysIn the UI, API or CLI
  2. Review with your teamIn the browser
  3. Export to the buildIn the same format

Bring the translations you already have

Import keys together with their existing translations, so approved strings are in memory from the first sprint and you pay only for what is missing.

  • Existing translations imported with keys
  • Memory filled from day one
  • Only missing strings translated

When switching isn’t worth it yet

If your product ships in one or two languages, rarely changes and a script already handles it, a platform may not pay off yet. Measure how long releases wait for translation first.

Count the days between code freeze and the last language shipping, for your last three releases.

What product and localization teams say on G2

What engineering teams ask before switching software localization tools

Product and engineering teams usually ask four things before they move strings to Smartcat. Do our scripts still work? Will AI break placeholders and plurals? Do translators get context? Which formats are supported?

“Our scripts already push strings to a vendor.”

Keep the scripts and point them at Smartcat. The REST API and CLI import and export the same files, so the pipeline stays yours, and your vendor’s linguists can work inside Smartcat.

“Will AI break our placeholders and plural forms?”

Placeholders and tags are locked in the editor, plurals are handled as plural segments or ICU MessageFormat, and QA checks flag tag and number errors before export.

“Translators never see where a string appears.”

Key IDs, developer comments and length limits travel with every string, and designers can translate Figma text, keys and variants before they reach code.

“Does Smartcat support every string format we use?”

Not every one. Flutter ARB files are not on Smartcat’s supported format list, and .stringsdict and .xcstrings files work as file uploads rather than in key collections. Send us a sample before you scope a project.

Software localization security: how Smartcat protects your strings

Strings often describe features that haven’t shipped yet. Smartcat protects that content at every step; see how on the Smartcat security page.

Role-based access controls

Set who can view, translate, review and approve strings by team, role or language on enterprise plans.

Single sign-on (SSO)

Sign in through your existing identity provider on enterprise plans.

SOC 2 Type II and ISO 27001

Smartcat is SOC 2 Type II compliant, ISO 27001 certified and isolates every workspace.

Never used to train public AI models

Your strings and product content are never used to train public AI models.

Audit trails

See who changed what and when across translation and review on enterprise plans.

Encryption and deletion on request

Content is encrypted in transit and at rest, and deleted or returned within 30 days of a written request.

Resources for software localization

Guides from the Smartcat blog on planning software localization, internationalization and the file formats developers ship.

Software localization FAQ

What does computer software localization include?

Computer software localization, or software localisation, covers everything a desktop or web application shows users, and Smartcat handles it through the resource files behind the app: UI strings, menus and dialogs, error messages, help text, and the dates, numbers and currencies they display. Smartcat returns JSON, XML, RESX, .properties and PO files in the same structure for your build.

What is the best software localization tool?

Smartcat suits product teams that release often in many languages, but the best software localization tool depends on how you ship. Check that it parses your formats without breaking placeholders or plurals, connects to your repository or CI/CD, gives translators context, lets your own reviewers approve and bills only for changed strings. A team shipping one language a year may not need a platform.

Does Smartcat offer software localization services?

Yes. Smartcat combines its software localization platform with professional linguists from Smartcat Marketplace, so you can hire translators or reviewers for any language or stage inside the same project. Your team keeps the repository, the glossary and the final approval. If you want a whole language handled by people, assign it to Marketplace linguists; otherwise AI translates and your reviewers approve.

What is the difference between software translation and software localization?

Software translation converts the text strings of an app into another language. Software localization, the job Smartcat is built for, also makes those strings work in the product. Keys and placeholders stay intact, plural forms follow each language, text fits the UI, and dates, currencies and examples suit the market. Translation is one step inside localization.

How do I localize software?

In Smartcat, create a software localization project, import your keys from JSON, YAML, Android XML or iOS .strings files through the UI, REST API or CLI, and let AI translate them with your glossary and translation memory. Your reviewers approve each language in the browser, then you export the files your build reads. First, make sure strings are extracted from code into resource files.

What is the difference between internationalization and localization?

Internationalization (i18n) prepares software to support any language; localization (l10n) adapts it for one language and market. Smartcat covers the localization side: it reads the resource files your i18n setup produces and returns them translated. Developers internationalize once, by extracting strings and using locale-aware formats, while localization repeats every release for every language.

Which file formats does Smartcat support for software localization?

Smartcat software localization projects import keys from JSON, YAML, Android XML, iOS .strings and LocJSON, and export JSON or YAML (flat or structured), Android XML and iOS .strings. As file uploads, Smartcat also translates RESX, XML, Java .properties, .stringsdict, .xcstrings, PO and POT, XLIFF 1.2 and 2.0, SDLXLIFF and MQXLIFF. Flutter ARB files are not on the supported list.

Does Smartcat integrate with GitHub, GitLab and Bitbucket?

Yes. Smartcat connects to GitHub, GitLab and Bitbucket repositories to sync strings from pull to push, and the Smartcat CLI and REST API cover pipelines that need custom steps, including CI/CD. Designers can send text, keys and variants from Figma through the Smartcat plugin. Translated files return in the same structure, so developers don’t merge locale files by hand.

Can I automate localization with an API or CLI?

Yes. Smartcat’s REST API and command-line tool import and export keys the same way the UI does, so you can run them from scripts or CI/CD on every commit or release. The CLI runs on Windows, macOS and Linux and supports a per-folder configuration file. Imports can resolve conflicts and add labels, and exports can use a file name template per language.

What is software localization management?

Software localization management, which Smartcat runs in one project, is planning, running and tracking the translation of an app’s strings across languages and releases: which keys changed, who translates and reviews them, and when each language ships. Smartcat tracks it with key collections, per-language progress, review stages, a shared glossary and translation memory.

How much does software localization cost with Smartcat?

Smartcat charges by Smartwords, its single usage unit: one source word processed by an AI action uses one Smartword per target language. Plans include a Smartwords allowance shared by unlimited users. Approved strings are reused, so after the first release you pay only for new and changed strings, and 100%+ translation-memory matches use no Smartwords on current plans. See current plans on the pricing page.

Can our own reviewers and translators work in Smartcat?

Yes. Smartcat lets you invite your own reviewers, product writers or your current vendor’s linguists into the project, and they approve or edit strings in the browser with no software to install. Users are unlimited on every plan, so adding reviewers adds no seat costs. You can also hire vetted linguists from Smartcat Marketplace for a language or a review stage.

Is our product content secure in Smartcat?

Yes. Smartcat is ISO 27001 certified and SOC 2 Type II compliant, encrypts content in transit and at rest, and isolates every workspace, with role-based access, SSO and audit trails on enterprise plans. Strings for unreleased features are never used to train public AI models, and content is deleted or returned within 30 days of a written request.

Didn’t find your answer? Talk to a localization specialist

Start software localization for your next release, in every language

See Smartcat localize one of your own string files, from import to an export your build reads, or start a 15-day free trial with no credit card.