# overview: Key Terms
URL: https://generaltranslation.com/en-US/docs/overview/key-terms.mdx
---
title: Key Terms
description: A guide to the key terminology used by General Translation
---

<TOC />

## Locale

A locale is **a language or dialect**. 

In these docs, the term "locale" usually refers to the "locale code", which is a BCP 47 language tag representing a particular locale.
For example, `en-US` is a locale code, which refers to the English language as spoken in the United States of America.

* [Read more about locales](/docs/core/locales)
* [List of supported locales](/docs/platform/supported-locales)

## Translation

<Callout>Who does translation? **Human translators, language model APIs**</Callout>

Translation means to converting content from one language or dialect, represented by a locale code, into another language or dialect, represented by another locale code.

For example:
- Translating `es` into `en-US` means "rewriting Spanish content into US English".
- Translating `es` into `en-GB` means "rewriting Spanish content into British English".
- Translating `en-US` into `en-GB` means "rewriting this US English into the British English dialect".

```javascript
// es -> en-US
gt.translate("Tenemos un ascensor", "en-US") // -> "We have a elevator"

// es -> en-GB
gt.translate("Tenemos un ascensor", "en-GB") // -> "We have a lift"

// en-GB -> en-US
gt.translate("We have a lift", "en-US") // -> "We have an elevator"
```

## Internationalization (i18n)

<Callout>Who does internationalization? **Software engineers, AI coding agents**</Callout>

Internationalization, also called i18n, is the process of transforming a codebase so that it can support multiple locales.
This is usually done with an internationalization library like [gt-next](/docs/next) or [gt-react](/docs/react).

Internationalization is not the process of translation itself.
Technically, you can have an *internationalized* codebase *translated* into only one language.

## Localization (l10n)

Localization, also called l10n, is the process of adapting a product for a particular locale.
This involves both internationalization **and** translation. 

In some cases, localization requires more than just internationalization and translation.
For example, you might need to be able to accept payments in a different currency or follow data regulations in a different region.

{/* BELOW HIDDEN BUT KEPT FOR REFERENCE */}

{/*

## Dictionary file

A dictionary file is a JSON file that contains a set of possibly nested key-value pairs.

The keys are used as references, and the values are strings, either in the original language or in a translated language.

```json
{
  "greeting": "Hello, world!",
  "farewell": "Goodbye, World!",
  "dashboard": {
    "title": "Dashboard",
    "description": "Welcome to the dashboard"
  }
}
```

The keys are human-readable references which are used to look up the translated content within your app.

These dictionaries are conventional in structure and usage, similar to translation files in other i18n libraries.

<Callout type='info'>
  A source dictionary can also be a `.js` or `.ts` file, meaning it can import
  from other files. A dictionary containing translated content can only be a
  `.json` file.
</Callout>

#### Source Dictionary

A source dictionary is a dictionary that contains content in the default locale for your app.

#### Translated Dictionary

A translated dictionary is a dictionary that contains content in a specific locale that is different from the default locale.

The keys are the same as the source dictionary, and the values are the translated strings.

If you have your own translated dictionaries, you can load them using the `loadDictionary` function.

### In-line content

In-line content is content that is written directly in your app's code, and not stored separately in something like a JSON or dictionary file.

This includes:

- `<T>` components
- `useGT` hooks
- `getGT` function

### Source content

Source content is the content in the default locale for your app. It includes anything written in your app's default language.

Specifically for `gt-next`, and `gt-react`, source content includes all of the translatable content for your app, including your app's source dictionary and
any in-line content.

### Source template

Source template refers to the specific data format for storing source content.

```json
{
  ["Unique identifier for the source content"]: "...Content..."
}
```

The unique identifier for the source content is either a hash of the source content, or a user-defined unique identifier.

Depending on the type of the source content, the corresponding value can be a string, array, or an object. (Strings and arrays for dictionaries, and objects for `<T>` components)

### Translations

Throughout these docs, we use the noun "translations" to refer to the translated content obtained from translating source content.

Translations are generated directly from your source template.

The `loadTranslations` function allows you to customize the location where these translations are stored. This function expects the JSONs to be of the same format as the source template.

Use the [CLI `generate` command](/docs/cli/generate) to generate these data files from your source content.

<Callout type="warn">
  **Note:**

It's important to note that a translation is _different_ from a translated dictionary. Dictionaries are potentially nested, and contain human-readable references as keys.

Translations, on the other hand, are flat, and likely contain non-human-readable hashes as keys.

</Callout>

**Translations** are what is stored on the GT CDN.

If we use translations in reference to JSON, MDX, or MD files, we are referring to the direct translations of the original source files.
*/}