A standard Comma-Separated Values table.

Here's the deal: there is no standard for INI files and no agreed upon way of representing multi-line text in values.

Therefore I'm offering two separate options for generating INI files.

[Menu]
Start=Start
# Shown in a corner
About=A good
About=videogame
Exit=Exit

[Settings]
Volume=Volume: {0}%
Back=Back

[Menu]
Start=Start
# Shown in a corner
About="A good\nvideogame"
Exit=Exit

[Settings]
Volume=Volume: {0}%
Back=Back

The output is about what you'd expect, group ➜ key ➜ value:

{
    "Menu": {
        "Start": "Start",
        "About": "A good\nvideogame",
        "Exit": "Exit"
    },
    "Settings": {
        "Volume": "Volume: {0}%",
        "Back": "Back"
    }
}

There's a little caveat though: there's no context information because JSON standard does not include comments.

{
    "Start": {
        "message": "Start",
        "description": ""
    },
    "About": {
        "message": "a good\nvideogame",
        "description": "Shown in a corner"
    },
    "Exit": {
        "message": "Exit",
        "description": ""
    }
}

{
    "Volume": {
        "message": "Volume: {0}%",
        "description": ""
    },
    "Back": {
        "message": "Back",
        "description": ""
    }
}

Loads a language from a JSON file containing group ➜ key ➜ value associations.

That means an object of objects.

Returns a language reference (cmn_loc_lang).
If the file does not contain valid JSON, returns undefined.

For example, if in your Included Files you've had a file called Ukrainian.json containing the following:

{
    "Menu.Main": {
        "Multiplayer": "Мережева гра",
        "Singleplayer": "Одиночна гра",
        "Options": "Налаштування",
        "Exit game": "Вийти з гри"
    },
    "Menu.Options": {
        "SoundVolume": "Гучність звуків: {0}",
        "MusicVolume": "Гучність музики: {0}",
        "Back": "Назад"
    }
}

You could do

cmn_loc_current = cmn_loc_lang_load_json_file("Ukrainian.json");

to load it.

Loads a language from a JSON string, using the same format as cmn_loc_lang_load_json_file.

If the string does not contain valid JSON, returns undefined.

This function loads a language from a ds_map.

The map should have a group ➜ key ➜ value structure like shown in cmn_loc_lang_load_json_file.

If takeOwnership is true, the map will be associated with the language and destroyed along with it.
Note: if you are creating the map yourself (rather than decoding it), make sure to add sub-maps using ds_map_add_map so that they are associated with the parent map.

Loads a language from a folder of .json files.

Files containing invalid JSON will be ignored.

The file name (without extension) will be used for the group name and the contents will be used for key-value pairs within.

For example, if you have a folder called Ukrainian containing

• Menu.Main.json

  {
      "Multiplayer": "Мережева гра",
      "Singleplayer": "Одиночна гра",
      "Options": "Налаштування",
      "Exit game": "Вийти з гри"
  }
  

• Menu.Options.json

  {
      "SoundVolume": "Гучність звуків: {0}",
      "MusicVolume": "Гучність музики: {0}",
      "Back": "Назад"
  }
  

You can do

cmn_loc_lang_load_json_folder("Ukrainian");

To achieve the same result as with the cmn_loc_lang_load_json_file example above.

Loads a language from an INI file at path.

The content should be formatted roughly as per generated format.

If the first section of the file contains a comment reading cmnLoc:json, the file is presumed to use JSON strings with escape characters.

Like above, but loads from an INI file stored in a string instead.

Loads one or more translations from a ds_grid.

Columns (optional) is an array of column names (case-sensitive!) or indexes (0-based, includes prefix columns like Group/Key/Context) to load.
Missing names and out-of-bounds indexes are ignored.
If omitted, all available languages will be loaded.

Returns an array of language references.
If you have specified columns to load and none were found, this can be an empty array.

Indicates whether your CSV table contains a "context/comment" column after the "Key" column.

false:

Indicates whether the group is stored inside the "context/comment" column, as per CSV Alternative format.

false:

If the group names end with this string, it will be trimmed off.

For example, when downloading "Preview translations" CSV from Crowdin, group names include the source file extensions ("Menu.json"), so you would want to do

cmn_loc_csv_group_suffix = ".json";

This chooses a plural form for the provided quantity.

The syntax is as following:

{index, plural,
category {text}
}

Placeholder value at index should be a number;

The message can contain one or more categories and should generally contain an other category (which acts as a catch-all if nothing else matches).

For example, you might have the following

menu_skip(L("EntryCount", "{0} public {0, plural,\n"
    + "one {game}\n"
    + "other {games}\n"
+ "}:", n));

to have "0 games", "1 game", "2 games" in English, and a translation could use the categories that are available for the language, for example:

{0} онлайн {0, plural,
one {гра}
few {гри}
other {ігор}
}:

which would produce "1 гра", "2 гри", ..., "5 ігор" as the Ukrainian pluralization rules have it.

# can be used inside the messages to insert the input quantity, like so:

menu_skip(L("EntryCount", "{0, plural,\n"
    + "one {# game}\n"
    + "other {# games}\n"
+ "}:", n));

If necessary, both the base language and translations can also use =number for special cases, like so:

menu_skip(L("EntryCount", "{0, plural,\n"
    + "one {# game}\n"
    + "other {# games}\n"
    + "=0 {no games}\n"
+ "}:", n));

Category rules are set up by calling set_plural_rules and cmn_loc_lang_set_default_plural_rules.

Outputs one or other string based on what the argument currently is:

{index, select,
value1 {text 1}
value2 {text 2}
other {catch-all}
}

This is typically used to pick appropriate gender-based inflections for the language, but you can use it for whatever else that might need one-of-N options depending on the language.

• -a
• a + b
• a - b
• a * b
• a / b
• a div b: integer division (14 div 5 is 2)
• a % b: remainder of division, can be fractional (alt: a mod b)

Comparisons:

• a = b: equals (alt: a == b)
• a != b: not equals (alt: a <> b)
• a < b
• a <= b
• a > b
• a >= b

The result of comparisons and boolean operations is 1 (true) or 0 (false).

Boolean operators:

• a and b: boolean AND (alt: a && b)
• a or b: boolean OR (alt: a || b)
• not a: boolean NOT (alt: !a)

A value is considered "truthy" if it's larger than 0.5.

Range checks:

• val in (min .. max)
• val not in [min .. max] (alt: val !in [min .. max])

Start/end of the range can be parentheses (exclusive) or square brackets (inclusive).

For example,

• 5 in [3, 7] is 1 (in range)
• 1 in [3, 7] is 0 (out of range)
• 7 in [3, 7] is 1 (edge of inclusive range)
• 7 in [3, 7) is 0 (edge of exclusive range)

Set checks:

• val in {a, b, c}
• val not in {a, b, c}

Set items can be values or ranges:

• # in {4, 5, 6} returns 1 if value is 4, 5, or 6
• # in {4, [5, 6]} returns 1 if value is 4 or between 5 and 6 (incl.)

The following few are supported:

TLDR: it's like GML priorities, but with in / not in sandwiched between comparisons and boolean AND/OR.

From highest to lowest:

1. Unary operators (not val, -val)
2. *, /, %, div
3. +, -
4. ==, !=, <, <=, >, >=
5. in, not in
6. and
7. or