Fix DockerRun.sh failing when the host UID already exists in the image (#16373)

The ubuntu:24.04 base image has a built-in ubuntu user with UID 1000, so the Dockerfile skips creating the host user and `docker run -u "$USER"` cannot find it. Run the container with the numeric UID and GID instead, and set HOME and the working directory to the bind-mounted home.

.claude/skills/orca-translations/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: orca-translations
+description: Use when updating, filling, reviewing or fixing OrcaSlicer translations in localization/i18n — running scripts/run_gettext --full, translating empty or new msgids in the .po catalogs, AI translation passes and their "# AI Translated" / "# Needs human review" comments, plural forms, msgctxt homonyms, and keeping catalogs consistent with the localization glossary (OrcaSlicer_WIKI localization_glossary.tsv), including adding new glossary terms. Also use for msgfmt or run_gettext failures, placeholder or line-break mismatches, and reviewing a translation PR against the glossary.
+---
+
+# OrcaSlicer translations
+
+The UI strings live in gettext catalogs: `localization/i18n/OrcaSlicer.pot` is the template, and
+`localization/i18n/<lang>/OrcaSlicer_<lang>.po` holds each language. The `en` catalog is empty on
+purpose, so skip it. Recurring terms are fixed by the
+[localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/developer_reference/localization_glossary.md),
+whose source is `developer_reference/localization_glossary.tsv` in the **OrcaSlicer_WIKI** repository.
+A translation pass therefore touches two repositories: the catalogs here, and the glossary there.
+
+All catalog editing goes through [`scripts/po_tool.py`](scripts/po_tool.py) (standard library only).
+It lists empty entries with the glossary terms they contain and validates each translation. It writes
+only the entries it changes, in the layout `msgmerge --no-wrap` produces, and adds the AI comments.
+Run commands from the repository root, with `python3` (`python` or `py -3` on Windows):
+
+```bash
+T=.claude/skills/orca-translations/scripts/po_tool.py
+python3 $T --help
+```
+
+Read [translation-rules.md](references/translation-rules.md) before translating. It holds the
+mechanical rules, how to pick words, style, and when to flag an entry for review. To find hard-coded
+English, strings that need a plural form or a context, or files missing from the extraction list, read
+[source-audit.md](references/source-audit.md); that work changes C++ and comes before a translation pass.
+
+## Workflow: fill every empty translation
+
+Unless the user asks for something narrower, a translation pass means the steps below, in order.
+
+### 1. Find the glossary
+
+The tool looks for an `OrcaSlicer_WIKI` clone in `--wiki`, then `$ORCA_WIKI_DIR`, then next to this
+repository.
+- **A clone is found:** `git -C <wiki> fetch` and make sure it is on an up-to-date `main`. The tool
+  notes when it reads another branch, or a clone that is behind.
+- **No clone:** the tool reads the published glossary read-only. That is enough to translate, but not
+  to add terms (see step 3).
+
+### 2. Run the full gettext
+
+This comes first, always. It regenerates the template from the sources and merges it into every
+catalog:
+
+```bash
+./scripts/run_gettext.sh --full          # Linux/macOS: needs gettext and python3 on PATH
+scripts\run_gettext.bat --full           # Windows (PowerShell: & .\scripts\run_gettext.bat --full)
+```
+
+It must exit 0. New msgids arrive empty, and removed ones become obsolete `#~` entries. A msgid that
+comes back gets its old translation revived from `#~`, which is one reason never to purge obsolete
+entries. It also compiles the `.mo` files (gitignored). The bundled Windows gettext may re-wrap a long
+`#:` reference line. That churn is harmless.
+
+Then take stock: `python3 $T status`.
+
+### 3. Settle new glossary terms before translating anything
+
+Terms are decided once, for every language, so all the catalogs agree.
+
+1. `python3 $T candidates` lists recurring phrases in the empty entries that the glossary lacks. Read it
+   together with the new msgids themselves.
+2. Pick the real terms: feature and mode names, labels that tooltips repeat, and anything translators
+   would otherwise render in several ways.
+3. Brand names and acronyms belong in the glossary page's hand-written *Kept in English* table instead.
+4. Skip ordinary words.
+5. For each term, choose a rendering per language: check `lookup` for existing usage, and follow each
+   language's conventions. Then record it:
+
+   ```bash
+   python3 $T glossary-set --term "Belt printer" \
+       --description "One sentence saying what it is, and what it is not." \
+       --set de=... --set es=... --set pt_BR=...
+   ```
+
+   The command adds or updates the row, keeps the TSV's BOM and line endings, and regenerates the page.
+   - **An established cell:** it refuses to change it without `--replace`. Changing an established term
+     also means fixing every catalog entry that uses it, so do that only on request.
+   - **An empty cell:** fill it the same way when a pending string establishes the term for that
+     language.
+
+**No clone, and a new term is needed: stop.** Tell the user the glossary must be updated with these
+terms, and list each one with its description and proposed renderings (`glossary-set` prints them too).
+Ask them to clone `https://github.com/OrcaSlicer/OrcaSlicer_WIKI` next to this repository, or to give
+its path. Translate nothing that uses those terms until they answer.
+
+### 4. Translate, language by language, in batches
+
+For each language:
+
+1. Read its glossary column and notes once: `python3 $T glossary --lang <L>`.
+2. Loop over the empty entries:
+
+   ```bash
+   python3 $T pending --lang <L> --limit 60 --out <scratch>/<L>.json
+   # write <scratch>/<L>-tr.json: [{"id": "...", "msgstr": "..."}, ...], "msgstr_plural" for plurals,
+   # plus "review": "<what to check>" where unsure
+   python3 $T apply --lang <L> --input <scratch>/<L>-tr.json
+   ```
+
+   - **Batch files go in a scratch directory, not the repository.**
+   - **Each entry's `id` identifies it,** so the translation file need not repeat the English. `apply`
+     also accepts `msgid` with `msgctxt`, or the pending file itself with its `msgstr` fields filled.
+   - **Translate every entry in the batch.** A blank `msgstr` is skipped, not cleared.
+   - **Next batch:** applied entries leave the list, so run `pending` again at offset 0. Use `--offset`
+     only to step past entries you deliberately leave blank.
+   - **What each entry carries:**
+     - `glossary`: the terms it contains, with the language's rendering.
+     - `note`: the developer's `TRN` comment.
+     - `flags`: `c-format` or `boost-format`.
+     - `description`: present when a sense has to be chosen.
+3. Read every apply message:
+   - **REJECTED:** a hard rule broke. Fix the translation and apply the corrected items again.
+   - **WARNING:** something worth a second look, such as a glossary rendering not found, ending
+     punctuation, or snake_case. A glossary warning on an inflected form you checked is fine.
+     Otherwise correct the translation (`apply --overwrite` replaces your own entry), or add a
+     `review` reason.
+
+`apply` adds `# AI Translated` to every entry it writes, and `# Needs human review: <reason>` where an
+item has `review`. On an `--overwrite`, `"review": ""` removes an earlier note. Never add either to a translation a person wrote. `--human` is for applying their
+text.
+
+**The work is large:** every new string, times every language. When subagents are available, give each
+one a language or a few. Each agent only touches its own catalogs, so they can run
+in parallel. Settle step 3 first. Give each agent the language list, this skill's path, the rules file,
+and these instructions:
+- Fill every empty entry.
+- Don't add glossary rows.
+- Report what it could not translate, the review notes it added, and any term it thinks the glossary
+  still lacks.
+
+Add the terms they report yourself, then have the affected languages revisit the entries.
+
+### 5. Verify
+
+```bash
+python3 $T check --lang <L> --warnings   # every AI-translated entry, plus msgfmt --check-format
+```
+
+- **Run the full gettext again.** It must exit 0 and leave the catalogs as the pass left them.
+- **Run `python generate_glossary.py --check` in the wiki clone.**
+- **Errors on entries you didn't write predate the pass.** Report them rather than fixing them in the
+  same change.
+
+### 6. Report
+
+Report:
+- the entries filled, per language;
+- the review notes added;
+- anything left empty, and why;
+- the glossary rows added or filled.
+
+The catalogs (and `OrcaSlicer.pot`) and the glossary (`localization_glossary.tsv` and `.md`) are
+separate changes in separate repositories. The wiki change should land with, or before, the catalog
+change. Commit or open PRs only when asked.
+
+## Rules
+
+1. **Run the full gettext first.** Translate against the regenerated template, never a stale one.
+2. **The glossary is binding.** Use the language's rendering for each term, in the right sense. When a
+   rendering looks wrong, use it and flag the entry. Then raise the change with the user, rather than
+   deviating in one string.
+3. **New recurring terms go into the glossary before the translations that use them.** Without a wiki
+   clone, stop and tell the user (step 3).
+4. **Fill, don't rewrite.** A fill pass writes only empty and fuzzy entries.
+   - Existing translations, human or AI, change only on request (`--overwrite`).
+   - A glossary violation in a human translation is reported, not changed.
+5. **Machine output is labelled.** Every AI translation gets `# AI Translated`; uncertain ones also get
+   `# Needs human review: <reason>`. Never use `fuzzy`.
+6. **Never edit `msgid`, `msgctxt`, the header, or obsolete `#~` entries,** and never fix the English in
+   a translation. Report source problems (see the rules file).
+7. **Write catalogs only through `po_tool.py` or gettext.** PO libraries such as polib reflow unrelated
+   entries, and hand edits skip the validation.
+
+## Changing an established term
+
+A glossary cell is usually copied from the catalog's own label. When the label is wrong, the glossary
+inherits the mistake, so fix both in the same change:
+
+1. **Check the catalog's usage first.** `lookup --lang <L> "<term>"` searches the English, and with
+   `--msgstr` it searches the translations.
+   - When most entries already use the correct form, move the cell to it.
+   - When the wrong form is used consistently throughout, leave both as they are and ask a
+     translator.
+2. **Update the cell:** `glossary-set --term "<Term>" --replace --set <L>=<value>`.
+3. **Rewrite the entries that still use the old form,** only where the term has that meaning.
+   - Write `[{"id": "<id from lookup>", "msgstr": "<full corrected text>"}]` and run
+     `apply --overwrite`.
+   - The rewritten entries are marked `# AI Translated`.
+
+## Reviewing a translation change
+
+Review it for these:
+- glossary compliance (`check --scope all --warnings` on the language, then read the hits);
+- placeholders and line breaks (`check` errors);
+- `# AI Translated` kept on text a person rewrote, or added to text a person wrote;
+- purged obsolete entries;
+- reflowed unrelated entries;
+- plural forms short of `nplurals`.
+
+When a reviewer disputes a term, compare it with the glossary first. A machine translation that follows
+the glossary is correct even if the term itself is debatable. Then the fix is a glossary change, made
+with the translators, followed by the catalogs.
+
+## Source of truth
+
+When this skill and the checkouts disagree, the checkouts win:
+- `scripts/run_gettext.sh` / `.bat` for extraction and merging;
+- `localization/i18n/list.txt` for the scanned sources;
+- the wiki's `localization_guide.md` and `localization_glossary.md` / `.tsv` for the rules and terms;
+- `AGENTS.md` (Localization & translations) for the repository's conventions.
+
+## Editing this skill
+
+State rules and procedures, not the state of the catalogs: no counts, lists of untranslated strings or
+per-language defects. Language-specific terminology belongs in the glossary's *Language specifics*
+section, not here.

.claude/skills/orca-translations/references/source-audit.md

@@ -0,0 +1,64 @@
+# Auditing the source for translatable text
+
+Use this when asked to find hard-coded English, strings that need a context, or strings that need plural
+forms. It changes C++ and the `.pot`, so it runs before a translation pass and is followed by one.
+
+## How a string reaches translators
+
+- `xgettext` reads only the files named in `localization/i18n/list.txt`, and only the macros
+  `L`, `_L`, `_u8L`, `L_CONTEXT`, `_L_CONTEXT`, `_u8L_CONTEXT` and `_L_PLURAL`.
+  - A file that marks strings but is missing from `list.txt` is silently never extracted. Find such
+    files by comparing `grep -l` for the macros with the list.
+  - `_()`, `_utf8()` and `wxGetTranslation()` do not extract. Calls that rely on them need an `L()`
+    or `_L()` somewhere xgettext sees.
+- **GUI code:** `_L` gives a `wxString`, `_u8L` a UTF-8 `std::string` (use it for ImGui). `L` only
+  marks the string; the display site must translate it.
+- **libslic3r:** the macro is whatever the file defines. Some files `#define L(s)
+  Slic3r::I18N::translate(s)`, so `L()` translates at runtime there. Others, such as `PrintConfig.cpp`,
+  define it as a no-op marker, and the GUI translates the text later. Read the top of the file before
+  judging a `format(L(...))` call. libslic3r has no plural or context lookup at runtime.
+- The libslic3r translate callback is installed in `GUI_App::on_init_inner`. Text produced before it
+  is installed stays in English.
+
+## What to look for
+
+1. **Visible English with no macro:** labels, tooltips, menu items, dialog text, notifications and
+   ImGui text. `scripts/find_untranslated.py OUT_DIR` lists candidates; most are noise, so trace each
+   one to the place it is shown.
+2. **Sentences built from translated pieces:** `_L("A") + name + _L(" is B")`, or a translated word
+   spliced into another sentence. Translators cannot reorder or inflect these. Replace each with one
+   msgid with placeholders. A spliced fragment with a leading or trailing space is the usual sign.
+3. **Counts next to words that must agree:** `(s)`, "%d objects", a verb that follows a number. Use
+   `_L_PLURAL(singular, plural, n)`. If the singular and plural are identical on purpose, translators
+   still inflect each form.
+4. **One English word with several meanings:** a short msgid used in files with different meanings
+   (a verb in one place, a noun in another, a mode name, a CAD term). Generate locations with
+   `xgettext` *without* `--no-location` and list short msgids that occur in two or more files.
+5. **Code that compares translated text with English,** or decides behaviour from a message text.
+   Translation breaks it. Compare ids or flags instead.
+6. **Tests that quote message text:** `grep` the tests for a message before rewording it.
+
+## What not to translate
+
+Keys, config values and identifiers; log and debug output; assertion and check messages; developer-only
+UI behind debug switches; undo/redo snapshot names (the history is never shown); text returned to a
+plugin's code; HTML, JS and desktop-file content in string literals; brand, printer-model and format
+names.
+
+## Adding a context
+
+- Keep the most common sense without a context, so its existing translations stay valid. Give the
+  other senses a short, readable context.
+- A context cannot be carried through code that translates generically: enum labels that
+  `Field.cpp` translates with `_()`, tables translated by a loop, and anything in libslic3r. Leave that
+  sense on the plain entry and give the contexts to the other uses.
+
+## After the edits
+
+1. Build and run the tests (`libslic3r_tests` in particular).
+2. Run `run_gettext --full`. Reworded strings become new empty entries and the old ones become
+   obsolete, which keeps their translations as a memory. Strings that gain a plural form leave a fuzzy
+   entry.
+3. Run the translation pass from SKILL.md. `po_tool.py pending` suggests the closest earlier translation
+   for each entry.
+4. Fix English typos *before* the translation pass; fixing one afterwards orphans every translation.

.claude/skills/orca-translations/references/translation-rules.md

@@ -0,0 +1,102 @@
+# Translation rules
+
+The rules a translation must follow, condensed from the wiki's
+[Localization guide](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/developer_reference/localization_guide.md),
+the [glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/developer_reference/localization_glossary.md)
+and the localization section of `AGENTS.md`. `po_tool.py apply` rejects the mechanical violations it
+can detect; everything else is on the translator.
+
+## Mechanical: enforced by `apply`
+
+A rejected entry is not written. Fix it and apply again.
+
+- **Placeholders stay exactly as written:** `%s`, `%d`, `%.1f`, `%1$d`, `%1%`, `%%`. Never `%1 %`, never
+  `%` for `%%`. Plain printf placeholders keep their order; only positional ones (`%1$s`, `%1%`) may move.
+  A broken placeholder crashes the app.
+- **Line breaks:** the same number of `\n`, with the same leading and trailing ones. Don't add breaks to fit
+  text, least of all in parameter names.
+- **Leading and trailing spaces** are kept. A leading space usually means the string is appended to another.
+- **HTML tags** are kept, and the text between them is translated: `Click <a>here</a> to install it.`
+- **`℃`** (U+2103) stays one character, written exactly as in the source: `%d℃`, never `°C`, `° C` or
+  `%d ℃`.
+- **Tokens stay verbatim:** `{placeholders}`, `[macros]`, G-code commands (`M141`, `G28`). Setting keys
+  in snake_case (`use_relative_e_distances`) are flagged as warnings, because a few snake_case msgids
+  are really labels (`top_front`). Keep a key unless the string uses it as a display name.
+- **Plural entries** need every form from the catalog's `Plural-Forms` header (`nplurals`: 1 for
+  ja/ko/zh/th/vi, 3 for ru/cs/pl/lt, 4 for uk). Each form is really inflected for its quantity. Repeating
+  one sentence is a bug in Slavic and Baltic languages, but correct in Turkish and Hungarian.
+
+## Mechanical: not detectable, still required
+
+- Edit only `msgstr`. Never change `msgid`, `msgctxt`, the header or another entry's text.
+- **Ending punctuation follows the source:** no added period, and no dropped one. `apply` warns.
+- Units follow the SI convention of the language: `s`, not `sec`. A parameter description holds no
+  unit, because the field shows it.
+- **A button or short label holds one translation:** no alternatives in parentheses. They widen the
+  control.
+- Don't use `fuzzy` for uncertainty. Fuzzy entries are hidden, and users then see English.
+
+## Choosing the words
+
+- **The glossary is binding.** Use the language's rendering for every glossary term the `pending`
+  output lists, inflected as the sentence needs.
+    - **Rows that share a base term are different senses:** `Seam` (the print seam) versus `Seam (UV)`
+      (the unwrap cut), and `Instance` versus `Instance (application)`. Pick by the description.
+    - **A qualified row may be a false match.** `Feature (Design)` does not apply to "features of the
+      app".
+    - **A cell marked ⚠ (or holding two renderings) is unsettled.** Use the form the catalog already
+      uses for that sense (`lookup`), and flag the entry for review.
+- **Kept in English:** brand and product names (OrcaSlicer, Bambu Lab, Orca Cloud, AMS, Micro-Lidar),
+  acronyms (FDM, LAN, HTTPS), file formats, material codes (PLA, PETG-CF), G-code, macros and variables
+  stay as written. In "Adaptive Pressure Advance", only "Pressure Advance" stays English. See the
+  glossary page's *Kept in English* table.
+- **Language specifics** on the glossary page (`po_tool.py glossary --lang L` prints them) override
+  general habits for that language.
+- **Consistency beyond the glossary:** before translating a label, or a tooltip that names a setting,
+  run `lookup` for the setting name. Quote the label's existing translation exactly, so the tooltip and
+  the field match. Reuse obsolete (`#~`) entries as a translation memory.
+- **`msgctxt` separates homonyms.** `Back` in *Camera View* is the rear view, and `Back` in
+  *Navigation* is the go-back button. Translate each context on its own.
+- **Overloaded English: translate the meaning.**
+    - *Flow ratio* is a multiplier, *Flow Rate* is throughput, and *Flow Dynamics* is pressure
+      compensation. These are three different terms.
+    - *Extruder* can mean the toolhead, the feeder motor ("High extruder current on filament swap") or
+      the nozzle ("all extruders must have the same diameter").
+    - When a short label is ambiguous, grep `src/` for the msgid to see the widget it labels.
+- **Boilerplate stays uniform.** `Failed to connect to …`, `Are you sure you want to …?` and
+  `If expressed as a %, it will be computed over …` each get one template in the language, even where
+  the English varies.
+
+## Style
+
+- **Localize, don't translate word-for-word.** Know what the string controls before translating it.
+- **Simplify developer phrasing** when the meaning survives. *"This option determines whether
+  OrcaSlicer should apply the retract reduction on infill"* reads better as *"Disable retractions while
+  printing infill."* Introduce nuances in following sentences, not in one packed clause.
+- **Don't expand.** A machine translation adds no facts the English doesn't state. Expanding
+  descriptions is for human translators, who can confirm the extra content.
+- **Write for both audiences:** professionals and people with a printer at home. Keep the established
+  terminology, used as plainly as the string allows.
+
+## When to add a review note
+
+Add `"review": "<what to check>"` to an item when the translation is probable but unconfirmed. It
+becomes `# Needs human review: …`, and the entry still ships. Typical reasons:
+
+- The English is ambiguous out of context: "Tile" as a verb or a noun.
+- A short label's role only shows in the app.
+- Two established terms compete, or the glossary cell is unsettled.
+- The string's grammar depends on a value substituted at runtime: `%zu %s` counts with no plural entry.
+
+Say exactly what to look at and where: *"Row name in the Design tab tool-offer menu; check it reads
+right for the whole row."*
+
+## Problems that belong in the source, not the translation
+
+Report these; don't work around them in a catalog.
+
+- **The English is wrong.** Never "fix" it in the translation only.
+- **One msgid needs two translations.** The source needs `_L_CONTEXT` / `_u8L_CONTEXT` (a code change).
+- **A literal `%` in a string xgettext flagged `possible-c-format`** fails `msgfmt`. The fix is a
+  `// xgettext:no-c-format, no-boost-format` comment above the string in the source, not `%%` in the
+  translation.

.claude/skills/orca-translations/scripts/find_untranslated.py

@@ -0,0 +1,113 @@
+"""List C++ string literals that look like user-facing English but are not marked for translation.
+
+Usage: find_untranslated.py OUT_DIR   (one hits file per source area; each line is file:line: [call] "text" | code)
+Works on whole files, so literals continuing a translation macro call from an earlier line are
+recognised. Skips comments, log/assert/check calls, includes, printer model lists and markup."""
+import re, sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[4]
+OUT = Path(sys.argv[1]); OUT.mkdir(parents=True, exist_ok=True)
+MACROS = {"_L", "_u8L", "L", "_L_CONTEXT", "_u8L_CONTEXT", "L_CONTEXT", "_L_PLURAL", "_devL", "_omitL",
+          "_CHB", "_utf8", "_", "translate", "translate_utf8", "wxGetTranslation", "T"}
+NOISE_CALLS = {"BOOST_LOG_TRIVIAL", "wxCHECK", "wxCHECK_MSG", "wxCHECK_RET", "wxASSERT", "wxASSERT_MSG", "wxFAIL_MSG",
+               "assert", "static_assert", "printf", "fprintf", "sprintf", "snprintf", "wxLogDebug", "wxLogTrace",
+               "wxLogMessage", "wxLogError", "wxLogWarning", "OutputDebugStringA", "OutputDebugStringW", "DEBUG_LOG",
+               "glsafe", "GLShaderProgram", "find", "count", "contains", "starts_with", "ends_with", "get_value",
+               "has", "opt_bool", "opt_int", "opt_float", "opt_string", "option", "get", "set_key_value", "at",
+               "boost_log", "LOGD", "LOGE", "LOGI", "LOGW", "SPDLOG", "CLI_LOG"}
+LIT = re.compile(r'"((?:[^"\\\n]|\\.)*)"')
+WORD = re.compile(r"[A-Za-z]{2,}")
+
+def strip_comments(text):
+    # Replace comments with spaces, keeping offsets and string literals intact.
+    out, i, n = [], 0, len(text)
+    while i < n:
+        c = text[i]
+        if c == '"' or c == "'":
+            j = i + 1
+            while j < n and text[j] != c and text[j] != "\n":
+                j += 2 if text[j] == "\\" else 1
+            out.append(text[i:j + 1]); i = j + 1
+        elif text.startswith("//", i):
+            j = text.find("\n", i); j = n if j < 0 else j
+            out.append(" " * (j - i)); i = j
+        elif text.startswith("/*", i):
+            j = text.find("*/", i + 2); j = n if j < 0 else j + 2
+            out.append(re.sub(r"[^\n]", " ", text[i:j])); i = j
+        else:
+            out.append(c); i += 1
+    return "".join(out)
+
+def enclosing_call(text, pos):
+    depth = 0
+    i = pos - 1
+    while i >= 0:
+        c = text[i]
+        if c == '"':  # skip over a literal backwards
+            i -= 1
+            while i >= 0 and not (text[i] == '"' and text[i - 1] != "\\"):
+                i -= 1
+        elif c in ")]}":
+            depth += 1
+        elif c in "([{":
+            if depth == 0:
+                if c != "(":
+                    return None
+                m = re.search(r"([A-Za-z_][\w:]*)\s*$", text[max(0, i - 80):i])
+                return m.group(1).split("::")[-1] if m else None
+            depth -= 1
+        elif c == ";" and depth == 0:
+            return None
+        i -= 1
+    return None
+
+def looks_user_facing(s):
+    if len(WORD.findall(s)) < 2 and not re.fullmatch(r"[A-Z][a-z]{2,}[.!?:]?", s):
+        return False
+    if " " not in s and re.fullmatch(r"[\w./\\:#%-]+", s):
+        return False
+    if re.search(r"https?://|<\w+[^>]*>|\.(png|svg|json|ini|3mf|stl|gcode|bbl|js|html|css|txt|xml|zip)\b|=\s*\w+;|^\s*[-\w]+\s*:\s*[\w#]", s):
+        return False
+    if re.fullmatch(r"[a-z0-9_ ]+", s) and "_" in s:
+        return False
+    return bool(re.search(r"[A-Za-z]{2,} [a-z]{2,}|^[A-Z][a-z]{2,}", s))
+
+groups = {}
+for path in sorted((REPO / "src").rglob("*.[ch]pp")):
+    rel = path.relative_to(REPO).as_posix()
+    if "/dev-utils/" in rel or "/libvgcode/" in rel or rel.startswith("src/libnest2d") or "/tests/" in rel:
+        continue
+    raw = path.read_text(encoding="utf-8", errors="replace")
+    text = strip_comments(raw)
+    line_starts = [0] + [m.end() for m in re.finditer("\n", text)]
+    lines = raw.splitlines()
+    hits = []
+    for m in LIT.finditer(text):
+        s = m.group(1)
+        if not looks_user_facing(s):
+            continue
+        call = enclosing_call(text, m.start())
+        if call in MACROS or call in NOISE_CALLS:
+            continue
+        ln = next(k for k in range(len(line_starts) - 1, -1, -1) if line_starts[k] <= m.start()) + 1
+        src = lines[ln - 1].strip()
+        if re.search(r"BOOST_LOG|#\s*include|<<\s*\"|\"\s*<<|std::cerr|std::cout", src):
+            continue
+        # printer model / vendor tables
+        if len(LIT.findall(src)) >= 4 and not re.search(r"_L|_u8L", src):
+            continue
+        hits.append(f"{rel}:{ln}: [{call or '-'}] \"{s[:150]}\"    | {src[:170]}")
+    if hits:
+        parts = rel.split("/")
+        if parts[1] == "slic3r":
+            key = f"GUI/{parts[3] if len(parts) > 4 else 'root'}" if parts[2] == "GUI" else f"slic3r/{parts[2]}"
+        else:
+            key = parts[1].replace(".cpp", "")
+        groups.setdefault(key, []).extend(hits)
+total = 0
+for key, hits in sorted(groups.items()):
+    (OUT / (key.replace("/", "_") + ".txt")).write_text("\n".join(hits) + "\n", encoding="utf-8")
+    total += len(hits)
+    print(f"{len(hits):5}  {key}")
+print("total", total)

.claude/skills/orca-translations/scripts/po_tool.py

@@ -0,0 +1,870 @@
+#!/usr/bin/env python3
+"""Translation helper for the OrcaSlicer gettext catalogs and the wiki glossary.
+
+Standard library only. Edits a catalog in place, rewriting just the entries it
+changes in the layout `msgmerge --no-wrap` writes, so every other byte stays put.
+
+    status     [--lang L ...]                  per-catalog counts
+    pending    --lang L [--offset N --limit N] [--out FILE] [--no-include-fuzzy]   (adds similar earlier translations)
+    apply      --lang L --input FILE [--overwrite] [--dry-run]    adds "# AI Translated"
+    check      [--lang L ...] [--scope ai|all] [--warnings]
+    lookup     --lang L PATTERN [--msgstr]     existing translations with ids, obsolete ones included
+    glossary   --lang L [TERM]                 the language's glossary column and notes
+    candidates [--min-count N] [--limit N]     recurring untranslated phrases not in the glossary
+    glossary-set --term T [--description D] --set L=VALUE ... [--replace]
+
+The glossary is read from an OrcaSlicer_WIKI clone (--wiki, $ORCA_WIKI_DIR, or a
+sibling of this repository). Without one it is downloaded read-only, and
+glossary-set refuses to run.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import time
+import unicodedata
+import urllib.request
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[4]
+I18N = REPO / "localization" / "i18n"
+SKIP_LANGS = {"en"}  # the English catalog is intentionally empty
+GLOSSARY_TSV = Path("developer_reference") / "localization_glossary.tsv"
+GLOSSARY_MD = Path("developer_reference") / "localization_glossary.md"
+MISSING = {"", "—"}
+RAW_URL = "https://raw.githubusercontent.com/OrcaSlicer/OrcaSlicer_WIKI/main/"
+AI_TAG = "AI Translated"
+REVIEW_TAG = "Needs human review:"
+
+
+# ---------------------------------------------------------------------------
+# PO parsing and writing
+
+_UNESCAPE = {"n": "\n", "t": "\t", "r": "\r", "a": "\a", "b": "\b", "f": "\f", "v": "\v", '"': '"', "\\": "\\"}
+_ESCAPE = {v: "\\" + k for k, v in _UNESCAPE.items()}
+
+
+def unescape(s):
+    return re.sub(r'\\(.)', lambda m: _UNESCAPE.get(m.group(1), m.group(0)), s)
+
+
+def escape(s):
+    return "".join(_ESCAPE.get(c, c) for c in s)
+
+
+def format_field(keyword, value, prefix=""):
+    """Lines for `keyword "value"` as msgmerge --no-wrap writes them."""
+    parts = value.split("\n")
+    segments = [p + "\n" for p in parts[:-1]] + ([parts[-1]] if parts[-1] else [])
+    if len(segments) <= 1:
+        return [f'{prefix}{keyword} "{escape(value)}"']
+    return [f'{prefix}{keyword} ""'] + [f'{prefix}"{escape(s)}"' for s in segments]
+
+
+class Entry:
+    """One blank-line-delimited block of a PO file."""
+
+    def __init__(self, lines, first_line):
+        self.lines = lines
+        self.first_line = first_line  # 0-based index in the file
+        self.obsolete = all(l.startswith("#~") for l in lines if not l.startswith("#") or l.startswith("#~"))
+        self.tcomments, self.xcomments, self.flags = [], [], []
+        self.fields = {}  # keyword -> [value, start, end)
+        self.order = []
+        current = None
+        for i, raw in enumerate(lines):
+            line = raw
+            if self.obsolete and line.startswith("#~"):
+                line = line[2:].lstrip(" ")
+                if line.startswith("|"):
+                    current = None
+                    continue
+            elif line.startswith("#"):
+                current = None
+                if line.startswith("#."):
+                    self.xcomments.append(line[2:].strip())
+                elif line.startswith("#,"):
+                    self.flags += [f.strip() for f in line[2:].split(",") if f.strip()]
+                elif line == "#" or line.startswith("# "):
+                    self.tcomments.append(line[2:])
+                continue
+            m = re.match(r'^(msgctxt|msgid_plural|msgid|msgstr(?:\[\d+\])?)\s+"(.*)"\s*$', line)
+            if m:
+                current = m.group(1)
+                self.fields[current] = [unescape(m.group(2)), i, i + 1]
+                self.order.append(current)
+            elif line.startswith('"') and current:
+                self.fields[current][0] += unescape(line.strip()[1:-1])
+                self.fields[current][2] = i + 1
+
+    def get(self, key, default=None):
+        f = self.fields.get(key)
+        return f[0] if f else default
+
+    @property
+    def msgctxt(self):
+        return self.get("msgctxt")
+
+    @property
+    def msgid(self):
+        return self.get("msgid", "")
+
+    @property
+    def msgid_plural(self):
+        return self.get("msgid_plural")
+
+    @property
+    def is_header(self):
+        return self.msgid == "" and "msgid" in self.fields and not self.msgctxt
+
+    def msgstrs(self):
+        if self.msgid_plural is None:
+            return [self.get("msgstr", "")]
+        idx = sorted(int(k[7:-1]) for k in self.fields if k.startswith("msgstr["))
+        return [self.get(f"msgstr[{i}]", "") for i in range(max(idx) + 1)] if idx else []
+
+    @property
+    def fuzzy(self):
+        return "fuzzy" in self.flags
+
+    @property
+    def ai(self):
+        return any(c.strip() == AI_TAG for c in self.tcomments)
+
+    @property
+    def review(self):
+        return [c for c in self.tcomments if c.startswith(REVIEW_TAG)]
+
+    def key(self):
+        return (self.msgctxt, self.msgid)
+
+    def id(self):
+        """Short stable handle, so a translation file need not repeat the English."""
+        return hashlib.sha1(f"{self.msgctxt or ''}\x04{self.msgid}".encode("utf-8")).hexdigest()[:10]
+
+    def rewrite(self, msgstrs, ai=True, review=None):
+        """Replace the translation; add the AI and review comments; clear fuzzy."""
+        lines = list(self.lines)
+        # translations
+        keys = [k for k in self.order if k.startswith("msgstr")]
+        start = min(self.fields[k][1] for k in keys)
+        end = max(self.fields[k][2] for k in keys)
+        if self.msgid_plural is None:
+            new = format_field("msgstr", msgstrs[0])
+        else:
+            new = [l for i, s in enumerate(msgstrs) for l in format_field(f"msgstr[{i}]", s)]
+        lines[start:end] = new
+        # flags and previous-msgid lines of a fuzzy entry
+        out = []
+        for line in lines:
+            if line.startswith("#,"):
+                flags = [f.strip() for f in line[2:].split(",") if f.strip() and f.strip() != "fuzzy"]
+                if flags:
+                    out.append("#, " + ", ".join(flags))
+                continue
+            if line.startswith("#|") and self.fuzzy:
+                continue
+            out.append(line)
+        lines = out
+        # translator comments go first, before #. #: #,
+        pos = 0
+        while pos < len(lines) and (lines[pos] == "#" or lines[pos].startswith("# ")):
+            pos += 1
+        add = []
+        if review is not None:  # "" clears an earlier note, a reason replaces it
+            lines = [l for l in lines if not l.startswith("# " + REVIEW_TAG)]
+            pos = 0
+            while pos < len(lines) and (lines[pos] == "#" or lines[pos].startswith("# ")):
+                pos += 1
+        if ai and not any(l == "# " + AI_TAG for l in lines[:pos]):
+            add.append("# " + AI_TAG)
+        if review:
+            add.append(f"# {REVIEW_TAG} {' '.join(review.split())}")
+        lines[pos:pos] = add
+        return lines
+
+
+class Catalog:
+    def __init__(self, path):
+        self.path = Path(path)
+        data = self.path.read_bytes()
+        self.bom = data.startswith(b"\xef\xbb\xbf")
+        text = data.decode("utf-8-sig")
+        self.newline = "\r\n" if "\r\n" in text else "\n"
+        self.trailing = text.endswith(("\n", "\r"))
+        self.lines = text.splitlines()
+        self.entries = []
+        block, first = [], 0
+        for i, line in enumerate(self.lines + [""]):
+            if line.strip() == "":
+                if block:
+                    self.entries.append(Entry(block, first))
+                block = []
+            else:
+                if not block:
+                    first = i
+                block.append(line)
+        self.header = next((e for e in self.entries if e.is_header), None)
+        m = re.search(r"nplurals\s*=\s*(\d+)", self.header.msgstrs()[0] if self.header else "")
+        self.nplurals = int(m.group(1)) if m else 2
+        self.changes = {}  # entry index -> new lines
+
+    def active(self):
+        return [e for e in self.entries if not e.obsolete and not e.is_header]
+
+    def index(self):
+        return {e.key(): i for i, e in enumerate(self.entries) if not e.obsolete and not e.is_header}
+
+    def save(self):
+        lines = list(self.lines)
+        for i in sorted(self.changes, reverse=True):
+            e = self.entries[i]
+            lines[e.first_line:e.first_line + len(e.lines)] = self.changes[i]
+        text = self.newline.join(lines) + (self.newline if self.trailing else "")
+        self.path.write_bytes((b"\xef\xbb\xbf" if self.bom else b"") + text.encode("utf-8"))
+
+
+def needs_translation(e, nplurals, include_fuzzy=False):
+    strs = e.msgstrs()
+    if e.msgid_plural is not None and len(strs) < nplurals:
+        return True
+    return any(s == "" for s in strs) or (include_fuzzy and e.fuzzy)
+
+
+def catalog_path(lang):
+    p = I18N / lang / f"OrcaSlicer_{lang}.po"
+    if not p.exists():
+        sys.exit(f"no catalog for '{lang}': {p}")
+    return p
+
+
+def all_langs():
+    return sorted(d.name for d in I18N.iterdir() if (d / f"OrcaSlicer_{d.name}.po").exists() and d.name not in SKIP_LANGS)
+
+
+# ---------------------------------------------------------------------------
+# Glossary
+
+def find_wiki(arg):
+    for cand in [arg, os.environ.get("ORCA_WIKI_DIR"), REPO.parent / "OrcaSlicer_WIKI", REPO.parent / "OrcaSlicer.wiki"]:
+        if cand and (Path(cand) / GLOSSARY_TSV).exists():
+            return Path(cand)
+    return None
+
+
+def _download(rel):
+    cache = Path(tempfile.gettempdir()) / ("orca_glossary_" + rel.name)
+    if not cache.exists() or time.time() - cache.stat().st_mtime > 3600:
+        with urllib.request.urlopen(RAW_URL + rel.as_posix(), timeout=30) as r:
+            cache.write_bytes(r.read())
+    return cache
+
+
+class Glossary:
+    def __init__(self, wiki_arg=None, quiet=False):
+        self.wiki = find_wiki(wiki_arg)
+        if self.wiki:
+            self.tsv, self.md = self.wiki / GLOSSARY_TSV, self.wiki / GLOSSARY_MD
+            if not quiet:
+                self.report_clone_state()
+        else:
+            if not quiet:
+                print("note: no OrcaSlicer_WIKI clone found; using the published glossary read-only", file=sys.stderr)
+            self.tsv, self.md = _download(GLOSSARY_TSV), _download(GLOSSARY_MD)
+        self.load()
+
+    def report_clone_state(self):
+        git = lambda *args: subprocess.run(["git", "-C", str(self.wiki), *args], capture_output=True, text=True).stdout.strip()
+        try:
+            branch = git("rev-parse", "--abbrev-ref", "HEAD")
+            behind = git("rev-list", "--count", "HEAD..origin/main")
+        except OSError:
+            return
+        if branch and branch != "main":
+            print(f"note: glossary read from wiki branch '{branch}', not main", file=sys.stderr)
+        if behind and behind != "0":
+            print(f"note: the wiki clone is {behind} commits behind origin/main (as of its last fetch)", file=sys.stderr)
+
+    def load(self):
+        rows = [l.split("\t") for l in self.tsv.read_text(encoding="utf-8-sig").splitlines() if l.strip()]
+        self.header = rows[0]
+        # "—" marks a language with no established rendering yet
+        self.rows = [[c if c.strip() not in MISSING else "" for c in r] + [""] * (len(rows[0]) - len(r)) for r in rows[1:]]
+        self.matchers = []
+        for row in self.rows:
+            base = re.sub(r"\s*\([^)]*\)\s*$", "", row[0]).strip()
+            alts = [a.strip() for a in base.split(" / ") if a.strip()]
+            pats = [re.compile(r"(?<![\w-])" + r"[\s-]+".join(map(re.escape, a.split())) + r"(?:s|es)?(?![\w-])", re.I) for a in alts]
+            self.matchers.append((row, pats))
+
+    def column(self, lang):
+        return self.header.index(lang) if lang in self.header else None
+
+    def matches(self, text):
+        """Glossary rows found in text, without terms only seen inside a longer match."""
+        spans = []
+        for row, pats in self.matchers:
+            for p in pats:
+                spans += [(m.start(), m.end(), row) for m in p.finditer(text)]
+        keep = []
+        for row in {id(r): r for _, _, r in spans}.values():
+            mine = [(s, e) for s, e, r in spans if r is row]
+            if any(not any(s2 <= s and e <= e2 and (e2 - s2) > (e - s) for s2, e2, r2 in spans if r2 is not row) for s, e in mine):
+                keep.append(row)
+        return keep
+
+    def hints(self, text, lang):
+        col = self.column(lang)
+        return [{"term": r[0], "translation": (r[col] if col is not None else "") or None, "description": r[1]} for r in self.matches(text)]
+
+    def language_notes(self, lang):
+        text = self.md.read_text(encoding="utf-8-sig")
+        m = re.search(r"^### [^\n]*\(" + re.escape(lang) + r"\)\s*$(.*?)(?=^##|\Z)", text, re.M | re.S)
+        return m.group(0).strip() if m else None
+
+
+def _norm(s):
+    s = unicodedata.normalize("NFD", s.casefold())
+    return "".join(c for c in s if unicodedata.category(c) != "Mn")
+
+
+def glossary_ok(msgstr, translation):
+    """Loose check that a glossary rendering appears in msgstr, tolerating inflection."""
+    target = _norm(msgstr)
+    for alt in re.split(r"\s*/\s*", re.sub(r"\([^)]*\)|⚠", "", translation)):
+        words = [w for w in re.findall(r"\w+", _norm(alt)) if len(w) > 2] or re.findall(r"\w+", _norm(alt))
+        if not words:
+            return True
+        if all(w in target or (len(w) > 4 and w[:max(4, len(w) * 2 // 3)] in target) for w in words):
+            return True
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Validation
+
+C_FMT = re.compile(r"%(?:(\d+)\$)?[-+ #0']*(?:\d+|\*)?(?:\.(?:\d+|\*))?(?:hh|h|ll|l|L|q|j|z|Z|t)?[diouxXeEfFgGaAcspn]")
+BOOST_FMT = re.compile(r"%\d+%")
+TAG = re.compile(r"</?[A-Za-z][^<>]*>")
+SNAKE = re.compile(r"[a-z][a-z0-9]*(?:_[a-z0-9]+)+")
+IDENT = re.compile(r"\b[a-z][a-z0-9]*(?:_[a-z0-9]+)+\b|\b[GM]\d{1,4}\b|\{[A-Za-z_][\w.\[\]]*\}|\[[a-z_]+\]")
+END = re.compile(r"[.:?!。：？！]$")
+
+
+def _placeholders(s, flags):
+    s = s.replace("%%", "")
+    boost = BOOST_FMT.findall(s)
+    s2 = BOOST_FMT.sub("", s) if "boost-format" in flags or boost else s
+    c = [m.group(0) for m in C_FMT.finditer(s2)] if "no-c-format" not in flags else []
+    return boost, c
+
+
+def validate(e, msgstrs, nplurals, glossary=None, lang=None):
+    """Return (errors, warnings) for a proposed translation of entry e."""
+    errors, warnings = [], []
+    flags = set(e.flags)
+    if e.msgid_plural is not None and len(msgstrs) != nplurals:
+        errors.append(f"plural entry needs {nplurals} forms, got {len(msgstrs)}")
+    for i, s in enumerate(msgstrs):
+        src = e.msgid if (e.msgid_plural is None or (i == 0 and nplurals > 1)) else e.msgid_plural
+        tag = f"[{i}] " if e.msgid_plural is not None else ""
+        if not s:
+            errors.append(f"{tag}empty translation")
+            continue
+        b1, c1 = _placeholders(src, flags)
+        b2, c2 = _placeholders(s, flags)
+        positional = any("$" in p for p in c1)
+        c_bad = sorted(c1) != sorted(c2) if positional else c1 != c2
+        bad = []
+        if sorted(b1) != sorted(b2):
+            bad.append(f"boost placeholders {b1} -> {b2}")
+        if c_bad:
+            bad.append(f"printf placeholders {c1} -> {c2}" + ("" if positional else " (order must match)"))
+        if bad:
+            strict = flags & {"c-format", "boost-format"} and not (e.msgid_plural is not None and i == 0 and nplurals > 1 and not c2 and not b2)
+            (errors if strict else warnings).extend(tag + b for b in bad)
+        if s.count("%%") != src.count("%%") and "c-format" in flags:
+            errors.append(f"{tag}'%%' count differs")
+        if src.count("\n") != s.count("\n"):
+            errors.append(f"{tag}line breaks: {src.count(chr(10))} in source, {s.count(chr(10))} in translation")
+        else:
+            lead = lambda t: len(t) - len(t.lstrip("\n"))
+            trail = lambda t: len(t) - len(t.rstrip("\n"))
+            if lead(src) != lead(s) or trail(src) != trail(s):
+                errors.append(f"{tag}leading/trailing line breaks differ")
+        ls = lambda t: re.match(r"[ \t]*", t.strip("\n")).group(0)
+        ts = lambda t: re.search(r"[ \t]*$", t.strip("\n")).group(0)
+        if ls(src) != ls(s) or ts(src) != ts(s):
+            errors.append(f"{tag}leading/trailing spaces differ")
+        if sorted(TAG.findall(src)) != sorted(TAG.findall(s)):
+            errors.append(f"{tag}HTML tags {TAG.findall(src)} -> {TAG.findall(s)}")
+        if src.count("℃") != s.count("℃"):
+            errors.append(f"{tag}'℃' count differs (keep U+2103, not °C)")
+        missing = [t for t in set(IDENT.findall(src)) if t not in s]
+        tokens = [t for t in missing if not SNAKE.fullmatch(t)]
+        if tokens:
+            errors.append(f"{tag}tokens must stay verbatim: {tokens}")
+        if len(tokens) < len(missing):  # snake_case is usually a setting key, sometimes a label
+            warnings.append(f"{tag}snake_case kept? {[t for t in missing if SNAKE.fullmatch(t)]}")
+        e1, e2 = END.search(src.rstrip()), END.search(s.rstrip())
+        if bool(e1) != bool(e2) and lang != "th":  # Thai has no sentence-final period
+            warnings.append(f"{tag}ending punctuation: source {'ends with ' + repr(e1.group(0)) if e1 else 'has none'}, translation {'ends with ' + repr(e2.group(0)) if e2 else 'has none'}")
+        if s == src and len(src.split()) >= 3:
+            warnings.append(f"{tag}identical to the English")
+        if glossary and lang:
+            # Rows sharing a base term ("Seam", "Seam (UV)") are competing senses; one is enough.
+            # A match on qualified rows only ("Feature (Design)") may be another sense entirely.
+            for base, senses in group_senses(glossary.hints(src, lang)).items():
+                if all(h["term"] != base for h in senses) or not strong_match(src, base):
+                    continue
+                if not any(glossary_ok(s, h["translation"]) for h in senses):
+                    wanted = " or ".join(f"'{h['translation']}' ({h['term']})" for h in senses)
+                    warnings.append(f"{tag}glossary: expected {wanted}")
+    return errors, warnings
+
+
+def strong_match(src, base):
+    """Whether a term is surely meant as the glossary term, not as everyday English
+    ("each part of a frame"): a multi-word term, a short label, or capitalised mid-sentence."""
+    if any(" " in alt for alt in base.split(" / ")) or len(src.split()) <= 5:
+        return True
+    for alt in base.split(" / "):
+        for m in re.finditer(r"(?<![\w-])" + re.escape(alt) + r"(?:s|es)?(?![\w-])", src, re.I):
+            if m.group(0)[0].isupper() and not re.search(r"(^|[.!?:]\s+|\n)$", src[:m.start()]):
+                return True
+    return False
+
+
+def base_term(term):
+    return re.sub(r"\s*\([^)]*\)\s*$", "", term).strip()
+
+
+def group_senses(hints):
+    groups = {}
+    for h in hints:
+        if h["translation"]:
+            groups.setdefault(base_term(h["term"]), []).append(h)
+    return groups
+
+
+# ---------------------------------------------------------------------------
+# Commands
+
+def out_json(obj, path):
+    text = json.dumps(obj, ensure_ascii=False, indent=1)
+    if path:
+        Path(path).write_text(text + "\n", encoding="utf-8")
+        print(f"wrote {path}")
+    else:
+        sys.stdout.write(text + "\n")
+
+
+def cmd_status(a):
+    print(f"{'lang':7} {'active':>7} {'empty':>6} {'plural':>6} {'fuzzy':>6} {'AI':>6} {'review':>6}")
+    for lang in a.lang or all_langs():
+        c = Catalog(catalog_path(lang))
+        act = c.active()
+        empty = sum(1 for e in act if needs_translation(e, c.nplurals) and e.msgid_plural is None)
+        plural = sum(1 for e in act if needs_translation(e, c.nplurals) and e.msgid_plural is not None)
+        print(f"{lang:7} {len(act):7} {empty:6} {plural:6} {sum(e.fuzzy for e in act):6} {sum(e.ai for e in act):6} {sum(bool(e.review) for e in act):6}")
+
+
+def similar_entries(c, e, pool, cutoff=0.72):
+    """The closest earlier translation of a similar English text: obsolete entries and translated
+    active ones. A reworded or split string usually still has one, and reusing it keeps the wording."""
+    import difflib
+    sm = difflib.SequenceMatcher(autojunk=False)
+    sm.set_seq2(e.msgid)
+    best = []
+    for other, msgstr, obsolete in pool:
+        sm.set_seq1(other)
+        if sm.real_quick_ratio() < cutoff or sm.quick_ratio() < cutoff:
+            continue
+        r = sm.ratio()
+        if r >= cutoff and other != e.msgid:
+            best.append((r, other, msgstr, obsolete))
+    best.sort(key=lambda t: -t[0])
+    return [{"msgid": o, "msgstr": s, "obsolete": ob, "similarity": round(r, 2)} for r, o, s, ob in best[:2]]
+
+
+def cmd_pending(a):
+    c = Catalog(catalog_path(a.lang))
+    g = Glossary(a.wiki)
+    todo = [e for e in c.active() if needs_translation(e, c.nplurals, a.include_fuzzy)]
+    batch = todo[a.offset:a.offset + a.limit] if a.limit else todo[a.offset:]
+    pool = [(x.msgid, x.msgstrs()[0], x.obsolete) for x in c.entries
+            if not x.is_header and x.msgstrs() and x.msgstrs()[0] and not x.fuzzy and 8 < len(x.msgid) < 600]
+    items = []
+    for e in batch:
+        item = {"id": e.id(), "msgctxt": e.msgctxt, "msgid": e.msgid}
+        if e.msgid_plural is not None:
+            item["msgid_plural"] = e.msgid_plural
+            item["msgstr_plural"] = (e.msgstrs() + [""] * c.nplurals)[:c.nplurals]
+        else:
+            item["msgstr"] = e.msgstrs()[0]
+        if e.xcomments:
+            item["note"] = " ".join(e.xcomments)
+        flags = [f for f in e.flags if f != "fuzzy"]
+        if flags:
+            item["flags"] = flags
+        if e.fuzzy:
+            item["fuzzy"] = True
+            if e.msgstrs()[0]:
+                item["previous_translation"] = e.msgstrs()[0]
+        if len(e.msgid) > 8:
+            sim = similar_entries(c, e, pool)
+            if sim:
+                item["similar"] = sim
+        hints = g.hints(e.msgid + "\n" + (e.msgid_plural or ""), a.lang)
+        if hints:
+            # Descriptions only where the sense must be chosen or no rendering exists yet.
+            bases = [base_term(h["term"]) for h in hints]
+            item["glossary"] = [{k: v for k, v in h.items() if k != "description" or not h["translation"] or bases.count(b) > 1 or b != h["term"]}
+                                for h, b in zip(hints, bases)]
+        items.append({k: v for k, v in item.items() if v is not None})
+    out_json({"lang": a.lang, "nplurals": c.nplurals, "plural_forms": re.search(r"Plural-Forms: ([^\n]*)", c.header.msgstrs()[0]).group(1) if c.header else None,
+              "total_pending": len(todo), "offset": a.offset, "count": len(items), "entries": items}, a.out)
+
+
+def cmd_apply(a):
+    c = Catalog(catalog_path(a.lang))
+    g = None if a.no_glossary else Glossary(a.wiki, quiet=True)
+    data = json.loads(Path(a.input).read_text(encoding="utf-8"))
+    items = data["entries"] if isinstance(data, dict) else data
+    idx = c.index()
+    by_id = {c.entries[i].id(): i for i in idx.values()}
+    applied, skipped, rejected, warned = 0, 0, [], []
+    for it in items:
+        if "msgid" in it:
+            key = (it.get("msgctxt"), it["msgid"])
+            i = idx.get(key)
+            label = (f"[{key[0]}] " if key[0] else "") + key[1][:70].replace("\n", "\\n")
+        else:
+            i = by_id.get(it.get("id"))
+            label = f"id {it.get('id')}" if i is None else c.entries[i].msgid[:70].replace("\n", "\\n")
+        if i is None:
+            rejected.append((label, ["no such entry in the catalog (give its id, or msgid and msgctxt)"]))
+            continue
+        e = c.entries[i]
+        if e.msgid_plural is not None and "msgstr_plural" not in it:
+            rejected.append((label, [f"plural entry: give msgstr_plural with {c.nplurals} forms"]))
+            continue
+        strs = it["msgstr_plural"] if e.msgid_plural is not None else [it.get("msgstr", "")]
+        if not strs or all(not s for s in strs):
+            skipped += 1
+            continue
+        if not a.overwrite and not needs_translation(e, c.nplurals, include_fuzzy=True):
+            rejected.append((label, ["already translated (pass --overwrite to replace)"]))
+            continue
+        errors, warnings = validate(e, strs, c.nplurals, g, a.lang)
+        if errors:
+            rejected.append((label, errors))
+            continue
+        if warnings:
+            warned.append((label, warnings))
+        c.changes[i] = e.rewrite(strs, ai=not a.human, review=it.get("review"))
+        applied += 1
+    if not a.dry_run and c.changes:
+        c.save()
+    for label, msgs in rejected:
+        print(f"REJECTED {label}\n    " + "\n    ".join(msgs))
+    for label, msgs in warned:
+        print(f"WARNING  {label}\n    " + "\n    ".join(msgs))
+    print(f"{'would apply' if a.dry_run else 'applied'} {applied}, rejected {len(rejected)}, warnings {len(warned)}, blank skipped {skipped}")
+    return 1 if rejected else 0
+
+
+def find_msgfmt():
+    exe = REPO / "tools" / "msgfmt.exe"
+    if os.name == "nt" and exe.exists():
+        return str(exe)
+    from shutil import which
+    return which("msgfmt")
+
+
+def cmd_check(a):
+    g = None if a.no_glossary else Glossary(a.wiki, quiet=True)
+    msgfmt = find_msgfmt()
+    status = 0
+    for lang in a.lang or all_langs():
+        c = Catalog(catalog_path(lang))
+        errs = warns = 0
+        for e in c.active():
+            if a.scope == "ai" and not e.ai:
+                continue
+            strs = e.msgstrs()
+            if all(s == "" for s in strs) or e.fuzzy:
+                continue
+            errors, warnings = validate(e, strs, c.nplurals, g, lang)
+            if errors or (warnings and a.warnings):
+                label = (f"[{e.msgctxt}] " if e.msgctxt else "") + e.msgid[:70].replace("\n", "\\n")
+                print(f"{lang} line {e.first_line + 1}: {label}")
+                for m in errors:
+                    print(f"    ERROR {m}")
+                for m in warnings if a.warnings else []:
+                    print(f"    warn  {m}")
+            errs += bool(errors)
+            warns += bool(warnings)
+        if msgfmt:
+            fd, mo = tempfile.mkstemp(suffix=".mo")  # Windows msgfmt cannot write to "nul"
+            os.close(fd)
+            r = subprocess.run([msgfmt, "--check-format", "-o", mo, str(c.path)], capture_output=True, text=True)
+            os.unlink(mo)
+            if r.returncode:
+                print(f"{lang}: msgfmt --check-format failed\n{r.stderr.strip()}")
+                status = 1
+        print(f"{lang}: {errs} entries with errors, {warns} with warnings (scope: {a.scope})")
+        status |= bool(errs)
+    if not msgfmt:
+        print("note: msgfmt not found; skipped --check-format", file=sys.stderr)
+    return status
+
+
+def cmd_lookup(a):
+    c = Catalog(catalog_path(a.lang))
+    rx = re.compile(a.pattern, re.I)
+    n = 0
+    for e in c.entries:
+        strs = [s for s in e.msgstrs() if s]
+        if e.is_header or not strs:
+            continue
+        texts = strs if a.msgstr else [e.msgid, e.msgid_plural or ""]
+        if not any(rx.search(t) for t in texts):
+            continue
+        mark = "obsolete " if e.obsolete else f"{e.id()} " + ("AI " if e.ai else "")
+        ctx = f"[{e.msgctxt}] " if e.msgctxt else ""
+        print(f"{mark}{ctx}{json.dumps(e.msgid, ensure_ascii=False)}\n    -> {json.dumps(strs[0] if len(strs) == 1 else strs, ensure_ascii=False)}")
+        n += 1
+        if n >= a.limit:
+            print("... (limit reached)")
+            break
+
+
+def cmd_glossary(a):
+    g = Glossary(a.wiki)
+    col = g.column(a.lang)
+    if col is None:
+        print(f"'{a.lang}' has no glossary column yet; add one with glossary-set --set {a.lang}=...")
+    rx = re.compile(a.term, re.I) if a.term else None
+    for r in g.rows:
+        if rx and not rx.search(r[0]):
+            continue
+        val = r[col] if col is not None and r[col] else "—"
+        print(f"{r[0]}  =>  {val}\n    {r[1]}")
+    notes = g.language_notes(a.lang)
+    if notes and not a.term:
+        print("\n" + notes)
+
+
+STOP = set("""a an and are as at be been but by can could do does for from has have how if in into is it its
+may more most must no not of on once one only or other out over same set should so some such than that the
+their them then there these this those to too two up use used uses using very was when where whether which
+while will with without would you your yet all any each every per both also between before after first last
+off new now get gets let lets just already instead still even back down here make makes made via""".split())
+
+
+def _singular(key):
+    return " ".join(re.sub(r"(?<=[a-z]{3})(es|s)$", "", w) for w in key.split())
+
+
+def kept_in_english(g):
+    """Names from the glossary page's "Kept in English" table."""
+    text = g.md.read_text(encoding="utf-8-sig")
+    m = re.search(r"^## Kept in English.*?$(.*?)(?=^## )", text, re.M | re.S)
+    names = set()
+    for row in re.findall(r"^\| (.*?) \|", m.group(1) if m else "", re.M):
+        for piece in re.split(r"[,/:]|\bplus\b", row.replace("**", "").replace("`", "")):
+            if piece.strip():
+                names.add(_norm(piece.strip()))
+    return names
+
+
+def cmd_candidates(a):
+    g = Glossary(a.wiki)
+    known = kept_in_english(g)
+    for row, _ in g.matchers:
+        known |= {_norm(x.strip()) for x in base_term(row[0]).split(" / ")}
+    known |= {_singular(k) for k in known}
+    known |= {w for k in known if " " in k for w in k.split()}  # "tower" of "prime tower"
+    pending = {}
+    labels = set()
+    for lang in all_langs():
+        c = Catalog(catalog_path(lang))
+        for e in c.active():
+            labels.add(_norm(e.msgid))
+            if needs_translation(e, c.nplurals):
+                pending.setdefault(e.key(), set()).add(lang)
+    counts = {}  # phrase -> [strings, max langs, display, example, capitalised mid-sentence]
+    for (ctx, msgid), langs in pending.items():
+        seen = set()
+        for chunk in re.split(r"[.,;:!?()\[\]\"\n—–]+|\s-\s", msgid):
+            words = [re.sub(r"'s$", "", w) for w in re.findall(r"[A-Za-z][A-Za-z0-9-]*(?:'s)?", chunk)]
+            # Capitals only mean a name inside an ordinary sentence, not in a Title Case label.
+            sentence = len(words) >= 4 and sum(w[0].isupper() for w in words) * 2 < len(words)
+            for n in (1, 2, 3):
+                for i in range(len(words) - n + 1):
+                    gram = words[i:i + n]
+                    if gram[0].lower() in STOP or gram[-1].lower() in STOP or len("".join(gram)) < 4 \
+                            or any(w.lower() in STOP and w.lower() != "of" for w in gram):
+                        continue
+                    key = _norm(" ".join(gram))
+                    if key in seen or key in known or _singular(key) in known:
+                        continue
+                    seen.add(key)
+                    d = counts.setdefault(key, [0, 0, " ".join(gram), msgid, False])
+                    d[0] += 1
+                    d[1] = max(d[1], len(langs))
+                    d[4] |= sentence and i > 0 and all(w[0].isupper() for w in gram)
+    # A term is a phrase, or a word capitalised mid-sentence or written as an acronym.
+    keep = {k: v for k, v in counts.items()
+            if v[0] >= a.min_count and (" " in k or v[4] or v[2].isupper())}
+    # Drop fragments only ever seen inside a longer candidate ("IQEX parallel" in "IDEX IQEX parallel").
+    keep = {k: v for k, v in keep.items()
+            if not any(k != k2 and re.search(r"(^| )" + re.escape(k) + r"( |$)", k2) and v2[0] >= v[0] for k2, v2 in keep.items())}
+    rows = sorted(keep.items(), key=lambda kv: (-kv[1][0], -len(kv[0].split())))
+    print("strings  langs  phrase  [label = also a msgid of its own]  e.g.")
+    for k, (cnt, langs, text, example, _) in rows[:a.limit]:
+        ex = example.replace("\n", " ")
+        print(f"{cnt:7} {langs:6}  {text}{'  [label]' if k in labels else ''}  e.g. {ex[:70]}{'…' if len(ex) > 70 else ''}")
+
+
+def cmd_glossary_set(a):
+    wiki = find_wiki(a.wiki)
+    if not wiki:
+        print("No OrcaSlicer_WIKI clone found (looked at --wiki, $ORCA_WIKI_DIR and next to this repository).\n"
+              "The glossary must be updated with these terms before the translations that use them ship:\n"
+              f"  {a.term}: " + ", ".join(a.set) + "\n"
+              "Clone https://github.com/OrcaSlicer/OrcaSlicer_WIKI next to this repository, or pass --wiki.", file=sys.stderr)
+        return 2
+    tsv = wiki / GLOSSARY_TSV
+    lock = tsv.with_suffix(".lock")
+    for _ in range(100):
+        try:
+            fd = os.open(lock, os.O_CREAT | os.O_EXCL)
+            break
+        except FileExistsError:
+            time.sleep(0.1)
+    else:
+        sys.exit(f"could not lock {lock}; remove it if no other run is active")
+    try:
+        data = tsv.read_bytes()
+        bom = data.startswith(b"\xef\xbb\xbf")
+        text = data.decode("utf-8-sig")
+        nl = "\r\n" if "\r\n" in text else "\n"
+        lines = text.splitlines()
+        header = lines[0].split("\t")
+        values = {}
+        for s in a.set:
+            lang, _, val = s.partition("=")
+            if lang not in header:
+                sys.exit(f"no glossary column '{lang}'")
+            if "\t" in val or "\n" in val:
+                sys.exit("values cannot contain tabs or line breaks")
+            values[header.index(lang)] = val.strip()
+        row_i = next((i for i, l in enumerate(lines[1:], 1) if l.split("\t")[0] == a.term), None)
+        new = row_i is None
+        if new:
+            if not a.description:
+                sys.exit("a new term needs --description (one sentence saying what it is)")
+            row = [a.term, a.description] + [""] * (len(header) - 2)
+            lines.append("")
+            row_i = len(lines) - 1
+        else:
+            row = lines[row_i].split("\t")
+            row += [""] * (len(header) - len(row))
+            if a.description:
+                row[1] = a.description
+        conflicts = [f"{header[i]}: '{row[i]}' -> '{v}'" for i, v in values.items() if row[i].strip() not in MISSING and row[i] != v]
+        if conflicts and not a.replace:
+            sys.exit("established translations differ (pass --replace, and update the catalogs to match):\n  " + "\n  ".join(conflicts))
+        for i, v in values.items():
+            row[i] = v
+        lines[row_i] = "\t".join(row)
+        tsv.write_bytes((b"\xef\xbb\xbf" if bom else b"") + (nl.join(lines) + nl).encode("utf-8"))
+    finally:
+        os.close(fd)
+        os.unlink(lock)
+    print(f"glossary: {'added' if new else 'updated'} '{a.term}'")
+    gen = wiki / "generate_glossary.py"
+    if gen.exists():
+        r = subprocess.run([sys.executable, str(gen), "--update"], cwd=wiki, capture_output=True, text=True)
+        print((r.stdout + r.stderr).strip())
+        return r.returncode
+    return 0
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--wiki", help="path to an OrcaSlicer_WIKI clone")
+    p.add_argument("--i18n", help="catalog root to use instead of localization/i18n")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("status")
+    s.add_argument("--lang", action="append")
+    s.set_defaults(func=cmd_status)
+
+    s = sub.add_parser("pending")
+    s.add_argument("--lang", required=True)
+    s.add_argument("--offset", type=int, default=0)
+    s.add_argument("--limit", type=int, default=60)
+    s.add_argument("--out")
+    s.add_argument("--include-fuzzy", action=argparse.BooleanOptionalAction, default=True,
+                   help="list fuzzy entries too (default): users never see them")
+    s.set_defaults(func=cmd_pending)
+
+    s = sub.add_parser("apply")
+    s.add_argument("--lang", required=True)
+    s.add_argument("--input", required=True)
+    s.add_argument("--overwrite", action="store_true", help="also replace existing translations")
+    s.add_argument("--human", action="store_true", help="do not add '# AI Translated' (a person wrote these)")
+    s.add_argument("--dry-run", action="store_true")
+    s.add_argument("--no-glossary", action="store_true")
+    s.set_defaults(func=cmd_apply)
+
+    s = sub.add_parser("check")
+    s.add_argument("--lang", action="append")
+    s.add_argument("--scope", choices=["ai", "all"], default="ai")
+    s.add_argument("--warnings", action="store_true", help="also print warnings")
+    s.add_argument("--no-glossary", action="store_true")
+    s.set_defaults(func=cmd_check)
+
+    s = sub.add_parser("lookup")
+    s.add_argument("--lang", required=True)
+    s.add_argument("pattern")
+    s.add_argument("--msgstr", action="store_true", help="search the translations instead of the English")
+    s.add_argument("--limit", type=int, default=40)
+    s.set_defaults(func=cmd_lookup)
+
+    s = sub.add_parser("glossary")
+    s.add_argument("--lang", required=True)
+    s.add_argument("term", nargs="?")
+    s.set_defaults(func=cmd_glossary)
+
+    s = sub.add_parser("candidates")
+    s.add_argument("--min-count", type=int, default=3)
+    s.add_argument("--limit", type=int, default=80)
+    s.set_defaults(func=cmd_candidates)
+
+    s = sub.add_parser("glossary-set")
+    s.add_argument("--term", required=True)
+    s.add_argument("--description")
+    s.add_argument("--set", action="append", default=[], metavar="LANG=VALUE")
+    s.add_argument("--replace", action="store_true")
+    s.set_defaults(func=cmd_glossary_set)
+
+    a = p.parse_args()
+    if a.i18n:
+        global I18N
+        I18N = Path(a.i18n)
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+    sys.exit(a.func(a) or 0)
+
+
+if __name__ == "__main__":
+    main()

.github/actions/deploy-nightly/action.yml

@@ -0,0 +1,29 @@
+name: 'Deploy Nightly'
+description: 'Upload a file to a release, replacing the asset of the same name'
+inputs:
+  asset_path:
+    description: 'Path of the file to upload'
+    required: true
+  asset_name:
+    description: 'Asset name on the release'
+    required: true
+  content_type:
+    description: 'Content type of the uploaded file'
+    required: false
+    default: 'application/octet-stream'
+  tag:
+    description: 'Tag of the release to upload to'
+    required: false
+    default: 'nightly-builds'
+runs:
+  using: 'composite'
+  steps:
+    - name: Replace release asset
+      shell: bash
+      env:
+        GH_TOKEN: ${{ github.token }}
+        ASSET_PATH: ${{ inputs.asset_path }}
+        ASSET_NAME: ${{ inputs.asset_name }}
+        CONTENT_TYPE: ${{ inputs.content_type }}
+        RELEASE_TAG: ${{ inputs.tag }}
+      run: bash "$GITHUB_ACTION_PATH/deploy.sh"

.github/actions/deploy-nightly/deploy.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+# Replaces one asset of a GitHub release, uploading under a temporary name
+# first so a failed upload leaves the old asset in place.
+#
+# Environment: GH_TOKEN, ASSET_PATH, ASSET_NAME, CONTENT_TYPE, RELEASE_TAG and
+# the GITHUB_* variables Actions sets.
+
+# The $names inside the single-quoted jq programs are jq variables.
+# shellcheck disable=SC2016
+set -euo pipefail
+
+repo_api="$GITHUB_API_URL/repos/$GITHUB_REPOSITORY"
+
+if [ ! -f "$ASSET_PATH" ]; then
+  echo "::error::$ASSET_PATH does not exist"
+  exit 1
+fi
+
+# The speed limit turns a stalled transfer into an error that --retry handles.
+curl_opts=(-sS --retry 3 --connect-timeout 30 --speed-limit 1024 --speed-time 60
+  -H "Authorization: Bearer $GH_TOKEN")
+
+# Prints the response body, or reports GitHub's error body and fails.
+api() {
+  local out
+  if ! out=$(curl "${curl_opts[@]}" --fail-with-body "$@"); then
+    # A workflow command ends at the first newline.
+    echo "::error::GitHub API request failed: ${out//[$'\r\n']/ }" >&2
+    return 1
+  fi
+  printf '%s\n' "$out"
+}
+
+http_status() {
+  curl "${curl_opts[@]}" -o /dev/null -w '%{http_code}' "$@"
+}
+
+# jq prints CRLF on Windows.
+jqr() {
+  jq -r "$@" | tr -d '\r'
+}
+
+delete_asset() {
+  local code
+  code=$(http_status -X DELETE "$repo_api/releases/assets/$1")
+  case $code in
+    # A 404 means a concurrent run already deleted the asset.
+    204 | 404) ;;
+    *)
+      echo "::error::Deleting release asset $1 failed with HTTP $code" >&2
+      return 1
+      ;;
+  esac
+}
+
+list_assets() {
+  local page=1 json
+  while :; do
+    # Callers run this inside $(...), where bash ignores set -e.
+    json=$(api "$repo_api/releases/$release_id/assets?per_page=100&page=$page") || exit 1
+    printf '%s\n' "$json"
+    [ "$(jqr length <<<"$json")" -eq 100 ] || break
+    page=$((page + 1))
+  done | jq -s add
+}
+
+release=$(api "$repo_api/releases/tags/$RELEASE_TAG")
+release_id=$(jqr .id <<<"$release")
+upload_url=$(jqr .upload_url <<<"$release")
+upload_url=${upload_url%%\{*}
+
+# Unique per run attempt, so concurrent runs never upload to the same name.
+tmp_name="$ASSET_NAME.partial-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT"
+
+# Deletes leftover partials older than an hour, an age no upload in progress reaches.
+stale_ids=$(list_assets | jqr --arg prefix "$ASSET_NAME.partial-" \
+  '.[] | select((.name | startswith($prefix)) and (.created_at | fromdateiso8601) < now - 3600) | .id')
+for id in $stale_ids; do
+  delete_asset "$id"
+done
+
+name_query=$(jqr -n --arg name "$tmp_name" '$name | @uri')
+# Uploads once, since a retry after an upload that succeeded fails on the taken name.
+new_id=$(api --retry 0 -X POST -H "Content-Type: $CONTENT_TYPE" -T "$ASSET_PATH" \
+  "$upload_url?name=$name_query" | jqr .id)
+trap 'delete_asset "$new_id" || true' EXIT
+
+rename_body=$(jq -n --arg name "$ASSET_NAME" '{name: $name}')
+# Retries on HTTP 422, which a concurrent run causes by renaming its own upload
+# between this delete and this rename.
+for _ in 1 2 3; do
+  old_ids=$(list_assets | jqr --arg name "$ASSET_NAME" '.[] | select(.name == $name) | .id')
+  for id in $old_ids; do
+    delete_asset "$id"
+  done
+  code=$(http_status -X PATCH -d "$rename_body" "$repo_api/releases/assets/$new_id")
+  if [ "$code" = 200 ]; then
+    trap - EXIT
+    exit 0
+  fi
+  [ "$code" = 422 ] || break
+done
+echo "::error::Renaming $tmp_name to $ASSET_NAME failed with HTTP $code" >&2
+exit 1

.github/workflows/build_all.yml

@@ -441,14 +441,10 @@ jobs:
         path: '/__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak'
     - name: Deploy Flatpak to nightly release
       if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main'
-      uses: WebFreak001/deploy-nightly@v3.2.0
+      uses: ./.github/actions/deploy-nightly
       with:
-        upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-        release_id: 137995723
         asset_path: /__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
         asset_name: OrcaSlicer-Linux-flatpak_nightly_${{ matrix.variant.arch }}.flatpak
-        asset_content_type: application/octet-stream
-        max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
     # The asset is /app (the exes link it at runtime) plus the build tree
     # slimmed to what ctest needs.
     - name: Package flatpak test asset

.github/workflows/build_orca.yml

@@ -341,12 +341,12 @@ jobs:
           
           # Notarize main DMG
           xcrun notarytool submit "OrcaSlicer_Mac_universal_${{ env.ver }}.dmg" --apple-id "${{ secrets.APPLE_DEV_ACCOUNT }}" --team-id "${{ secrets.TEAM_ID }}" --password "${{ secrets.APP_PWD }}" --wait
-          xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
+          retry xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
 
           # Notarize profile validator DMG if it exists
           if [ -f "OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg" ]; then
             xcrun notarytool submit "OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg" --apple-id "${{ secrets.APPLE_DEV_ACCOUNT }}" --team-id "${{ secrets.TEAM_ID }}" --password "${{ secrets.APP_PWD }}" --wait
-            xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
+            retry xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
           fi
 
       - name: Create DMG without notary
@@ -397,25 +397,18 @@ jobs:
 
       - name: Deploy Mac release
         if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ${{ github.workspace }}/OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
           asset_name: OrcaSlicer_Mac_universal_nightly.dmg
-          asset_content_type: application/octet-stream
-          max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
 
+      # The DMG is only built when the validator app was.
       - name: Deploy Mac OrcaSlicer_profile_validator DMG release
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED && hashFiles(format('OrcaSlicer_profile_validator_Mac_universal_{0}.dmg', env.ver)) != ''
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ${{ github.workspace }}/OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
           asset_name: OrcaSlicer_profile_validator_Mac_universal_nightly.dmg
-          asset_content_type: application/octet-stream
-          max_releases: 1
 
 # Windows
       - name: Set Windows build variables
@@ -460,10 +453,6 @@ jobs:
       - name: Build slicer Win
         if: runner.os == 'Windows'
         working-directory: ${{ github.workspace }}
-        # Orca: Removed Netfabb STL fixing service support in favor of CGAL.
-        # env:
-        #   WindowsSdkDir: 'C:\Program Files (x86)\Windows Kits\10\'
-        #   WindowsSDKVersion: '10.0.26100.0\'
         # --tests builds the unit tests too; the unit_tests_windows_* jobs run them.
         run: |
           # cache-path is the install directory inside the deps build directory.
@@ -546,36 +535,27 @@ jobs:
 
       - name: Deploy Windows release portable
         if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}_portable.zip
           asset_name: OrcaSlicer_Windows${{ env.ARCH_SUFFIX }}_nightly_portable.zip
-          asset_content_type: application/x-zip-compressed
-          max_releases: 1
+          content_type: application/x-zip-compressed
 
       - name: Deploy Windows release installer
         if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_Installer_${{ env.ver }}${{ env.ARCH_SUFFIX }}.exe
           asset_name: OrcaSlicer_Windows_Installer${{ env.ARCH_SUFFIX }}_nightly.exe
-          asset_content_type: application/x-msdownload
-          max_releases: 1
+          content_type: application/x-msdownload
 
       - name: Deploy Windows OrcaSlicer_profile_validator release
         if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && inputs.arch != 'arm64' && !vars.SELF_HOSTED
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ${{ github.workspace }}/build/src/Release/OrcaSlicer_profile_validator.exe
           asset_name: OrcaSlicer_profile_validator_Windows_nightly.exe
-          asset_content_type: application/x-msdownload
-          max_releases: 1
+          content_type: application/x-msdownload
 
       - name: Build MSIX Store package Win
         if: runner.os == 'Windows' && !vars.SELF_HOSTED
@@ -704,14 +684,10 @@ jobs:
 
       - name: Deploy Ubuntu release
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ./build/OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_${{ env.ver }}.AppImage
           asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly.AppImage
-          asset_content_type: application/octet-stream
-          max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
       - name: Deploy Ubuntu release
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
         run: |
@@ -720,36 +696,24 @@ jobs:
 
       - name: Deploy Ubuntu OrcaSlicer_profile_validator release
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ./build/src/Release/OrcaSlicer_profile_validator
           asset_name: OrcaSlicer_profile_validator_Linux${{ env.ubuntu-ver-str }}_nightly
-          asset_content_type: application/octet-stream
-          max_releases: 1
 
       - name: Deploy Ubuntu generate_system_cache release
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ./build/src/dev-utils/Release/generate_system_cache
           asset_name: generate_system_cache_Linux${{ env.ubuntu-ver-str }}_nightly
-          asset_content_type: application/octet-stream
-          max_releases: 1
 
       - name: Deploy orca_custom_preset_tests
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
-        uses: WebFreak001/deploy-nightly@v3.2.0
+        uses: ./.github/actions/deploy-nightly
         with:
-          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
-          release_id: 137995723
           asset_path: ${{ github.workspace }}/resources/profiles/orca_custom_preset_tests.zip
           asset_name: orca_custom_preset_tests.zip
-          asset_content_type: application/octet-stream
-          max_releases: 1
 
       # The build has just touched everything it can use, so an object
       # untouched for a week is dead, usually orphaned by a flag change.

.github/workflows/check_profiles.yml

@@ -13,6 +13,7 @@ on:
     # both it and its tests live in scripts/, so a PR touching only those must still run
     # this workflow.
     - 'resources/printers/**'
+    - 'resources/info/legacy_compatible_printers.json'
     - 'scripts/**'
     # orca_profile_tool.py reads the variant key sets from PrintConfig.cpp, and its
     # tests the obsolete keys, so a PR changing either must be checked against the profiles.
@@ -59,6 +60,21 @@ jobs:
           python3 ./scripts/orca_profile_tool.py check 2>&1 | tee ${{ runner.temp }}/profile_tool.log
           exit ${PIPESTATUS[0]}
 
+      # The app migrates user filament presets made against 2.4.2 back to the printers their
+      # parent listed then, from resources/info/legacy_compatible_printers.json. A PR that
+      # renames a filament preset or narrows its compatible_printers changes what that map
+      # must say, so it has to regenerate it.
+      - name: Check the legacy compatible printers map
+        id: legacy_compat
+        continue-on-error: true
+        run: |
+          set -o pipefail
+          base="${{ runner.temp }}/v2.4.2"
+          git fetch --no-tags --depth=1 origin refs/tags/v2.4.2:refs/tags/v2.4.2
+          mkdir -p "$base"
+          git archive v2.4.2 resources/profiles | tar -x -C "$base"
+          python3 ./scripts/orca_profile_tool.py legacy-compat --base "$base/resources/profiles" --check 2>&1 | tee ${{ runner.temp }}/legacy_compat.log
+
       # download
       - name: Download
         working-directory: ${{ github.workspace }}
@@ -217,7 +233,7 @@ jobs:
           echo "${{ github.event.pull_request.number }}" > ${{ runner.temp }}/profile-check-results/pr_number.txt
 
       - name: Prepare comment artifact
-        if: ${{ always() && github.event_name == 'pull_request' && (steps.profile_tool.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
+        if: ${{ always() && github.event_name == 'pull_request' && (steps.profile_tool.outcome == 'failure' || steps.legacy_compat.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
         run: |
           {
             # Marker matched by check_profiles_comment.yml to delete prior comments.
@@ -234,6 +250,17 @@ jobs:
               echo ""
             fi
 
+            if [ "${{ steps.legacy_compat.outcome }}" = "failure" ]; then
+              echo "### Legacy Compatible Printers Map Out of Date"
+              echo ""
+              echo '```'
+              head -c 30000 ${{ runner.temp }}/legacy_compat.log || echo "No output captured"
+              echo '```'
+              echo ""
+              echo 'Regenerate it: `git archive v2.4.2 resources/profiles | tar -x -C /tmp/v2.4.2`, then `python3 scripts/orca_profile_tool.py legacy-compat --base /tmp/v2.4.2/resources/profiles`.'
+              echo ""
+            fi
+
             if [ "${{ steps.validate_system.outcome }}" = "failure" ]; then
               echo "### System Profile Validation Failed"
               echo ""
@@ -283,7 +310,7 @@ jobs:
           retention-days: 1
 
       - name: Fail if any check failed
-        if: ${{ always() && (steps.profile_tool.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
+        if: ${{ always() && (steps.profile_tool.outcome == 'failure' || steps.legacy_compat.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
         run: |
           echo "One or more profile checks failed; see the step logs above."
           echo 'Reproduce the whole run locally with scripts/check_profile.sh (scripts\check_profile.bat on Windows).'

.github/workflows/clang_tidy.yml

@@ -16,6 +16,15 @@ on:
 
 permissions:
   contents: read
+  # Listing caches and builds while waiting for a deps cache.
+  actions: read
+
+# Read by scripts/ci_deps_cache.sh.
+env:
+  REPO: ${{ github.repository }}
+  WORKFLOW: build_all.yml
+  BASE_REF: ${{ github.base_ref }}
+  JOB: build_linux (${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }})
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
@@ -35,7 +44,7 @@ jobs:
           # The PR merge commit plus its first parent, the base it is diffed against.
           fetch-depth: 2
 
-      - name: Look for changed C++ files
+      - name: Look for changed files
         id: changes
         run: |
           if git -c core.quotePath=false diff --name-only HEAD^1 -- src tests | grep -qE '\.(cpp|cc|cxx|hpp|h|hxx)$'; then
@@ -43,18 +52,75 @@ jobs:
           else
             echo "No C++ changes under src/ or tests/."
           fi
+          if ! git diff --quiet HEAD^1 -- deps; then
+            echo "deps=true" >> "$GITHUB_OUTPUT"
+          fi
+          echo "deps-key=linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}" >> "$GITHUB_OUTPUT"
 
-      # Parsing needs the dependency headers, not a build of this PR's deps/, so
-      # a PR that changes deps/ falls back to the newest cache main has.
+      # Parsing needs the dependency headers, not a build of this PR's deps/.
+      # Without an exact match the job waits for the build that saves it: this
+      # PR's own when it changes deps/, otherwise a running push build of the
+      # base branch with the same deps. With neither, a PR that keeps deps/
+      # falls back to the newest cache.
       - name: Restore cached deps
+        id: deps_cache
         if: steps.changes.outputs.cpp == 'true'
         uses: actions/cache/restore@v6
         with:
           path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
-          key: linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}
+          key: ${{ steps.changes.outputs.deps-key }}
+
+      - name: Look for a build to wait for
+        id: wait_check
+        if: steps.changes.outputs.cpp == 'true' && steps.deps_cache.outputs.cache-hit != 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: bash scripts/ci_deps_cache.sh ${{ steps.changes.outputs.deps == 'true' && 'own' || 'check' }}
+
+      # Linux Build Deps takes about 35 minutes on GitHub-hosted runners. The
+      # wait ends early when the deps job fails.
+      - name: Wait for the deps cache
+        if: steps.wait_check.outputs.wait-for != ''
+        timeout-minutes: 100
+        env:
+          GH_TOKEN: ${{ github.token }}
+          KEY: ${{ steps.changes.outputs.deps-key }}
+          CACHE_REF: ${{ steps.changes.outputs.deps == 'true' && github.ref || format('refs/heads/{0}', github.base_ref) }}
+          KEY_INPUTS: ${{ steps.wait_check.outputs.key-inputs }}
+          WAIT_FOR: ${{ steps.wait_check.outputs.wait-for }}
+          WAIT_SINCE: ${{ steps.wait_check.outputs.wait-since }}
+          WAIT_MINUTES: 90
+        run: bash scripts/ci_deps_cache.sh wait
+
+      - name: Restore the deps cache after waiting
+        id: waited_cache
+        if: steps.wait_check.outputs.wait-for != ''
+        uses: actions/cache/restore@v6
+        with:
+          path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
+          key: ${{ steps.changes.outputs.deps-key }}
+
+      - name: Fail without this PR's deps cache
+        if: steps.changes.outputs.deps == 'true' && steps.wait_check.outcome == 'success' && steps.waited_cache.outputs.cache-hit != 'true'
+        run: |
+          echo "::error::No deps cache ${{ steps.changes.outputs.deps-key }}. Check this PR's Linux Build Deps job, then rerun clang-tidy."
+          exit 1
+
+      - name: Restore the newest cached deps
+        id: newest_cache
+        if: steps.changes.outputs.deps != 'true' && steps.wait_check.outcome == 'success' && steps.waited_cache.outputs.cache-hit != 'true'
+        uses: actions/cache/restore@v6
+        with:
+          path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
+          key: ${{ steps.changes.outputs.deps-key }}
           restore-keys: linux-clang-cache-orcaslicer_deps-build-
           fail-on-cache-miss: true
 
+      - name: Warn about older deps
+        if: steps.newest_cache.outcome == 'success' && steps.newest_cache.outputs.cache-hit != 'true'
+        run: echo "::warning title=Older deps::No cache matches this PR's deps/, so clang-tidy parsed against ${{ steps.newest_cache.outputs.cache-matched-key }}. If it reports errors in code that uses a dependency, rerun clang-tidy once the base branch's Build all has saved the new deps."
+
       - name: Apt-Install Dependencies
         if: steps.changes.outputs.cpp == 'true' && !vars.SELF_HOSTED
         uses: ./.github/actions/apt-install-deps

AGENTS.md

@@ -67,6 +67,7 @@ ctest --test-dir ./tests/fff_print -C Release
 - Keep code concise and clear. Manually simplify AI generated bloated codes before review.
 - Include targeted tests or documented verification for behavior changes, especially in slicing logic, profiles, formats, and GUI defaults.
 - For profile changes (`resources/profiles/<Vendor>/**`), check that `version` in the sibling `resources/profiles/<Vendor>.json` was bumped.
+- For new or changed UI strings, check they follow [Writing translatable strings in the source](#writing-translatable-strings-in-the-source): no concatenated fragments, plural forms for counts, contexts for ambiguous words.
 - For translation changes (`localization/i18n/**/*.po`), check that recurring terms match the [Localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/developer_reference/localization_glossary.md) for that language.
 
 ## Localization & translations
@@ -74,6 +75,19 @@ ctest --test-dir ./tests/fff_print -C Release
 Catalogs live in `localization/i18n/<lang>/OrcaSlicer_<lang>.po`; the template is `OrcaSlicer.pot`.
 See the [Localization guide](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/developer_reference/localization_guide.md) for the human-facing version of these principles.
 
+### Writing translatable strings in the source
+
+Translators see one msgid at a time and cannot change the code around it, so each message must be complete in a single msgid. Use the wrapper that fits instead of assembling text from pieces:
+
+- **One msgid per sentence, with placeholders.** Never build a message by concatenating translated fragments (`_L("A") + name + _L(" is B")`) or by splicing a translated word such as `_L("left")` into another sentence: the translator can't reorder or inflect the parts. Write `format(_L("%1% is too close to others"), name)`.
+- **A count needs a plural form.** Don't write `file(s)` or leave a verb unchanged after a number. Use `_L_PLURAL("%1% object", "%1% objects", n)`. libslic3r has no plural lookup, so word the message so it doesn't depend on a count, or build it in the GUI.
+- **An ambiguous word needs a context.** When a short string means different things in different places (verb or noun, a mode name, a CAD term), give each sense its own context with `_L_CONTEXT`/`_u8L_CONTEXT`/`L_CONTEXT`. Keep the most common sense without a context so its existing translations stay valid.
+- **Mark every user-visible string** (`_L`/`_u8L`, or `L` where it is translated later) and list new source files in `localization/i18n/list.txt`: files that aren't listed are never extracted.
+- Add a `// TRN` comment above a new string whose meaning or placeholders aren't obvious.
+- Never choose behavior by comparing translated text; compare ids or flags.
+
+See `.claude/skills/orca-translations/references/source-audit.md` for the full checklist.
+
 ### Terminology
 
 - Use the [Localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/developer_reference/localization_glossary.md) as the source of truth for recurring terms, so the same English term is always rendered the same way within a language, and terms that must stay in English (brand/product names, acronyms, materials, file formats, G-code tokens, macros/variables/identifiers) are not translated.

CMakeLists.txt

@@ -497,47 +497,6 @@ endif()
 # Once we get rid of Perl and libslic3r is linked statically, we can get rid of -fPIC
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-# WIN10SDK_PATH is used to point CMake to the WIN10 SDK installation directory.
-# We pick it from environment if it is not defined in another way
-# ORCA: Removed Netfabb STL fixing service support in favor of CGAL.
-# if(WIN32)
-#     if(NOT DEFINED WIN10SDK_PATH)
-#         if(DEFINED ENV{WIN10SDK_PATH})
-#                 set(WIN10SDK_PATH "$ENV{WIN10SDK_PATH}")
-#         endif()
-#     endif()
-#     if(DEFINED WIN10SDK_PATH)
-#         #BBS: modify win10sdk_path
-#         if (EXISTS "${WIN10SDK_PATH}/winrt/windows.graphics.printing3d.h")
-#             set(WIN10SDK_INCLUDE_PATH "${WIN10SDK_PATH}")
-#         else()
-#             message("WIN10SDK_PATH is invalid: ${WIN10SDK_PATH}")
-#             message("${WIN10SDK_PATH}/winrt/windows.graphics.printing3d.h was not found")
-#             message("STL fixing by the Netfabb service will not be compiled")
-#             unset(WIN10SDK_PATH)
-#         endif()
-#     else()
-#         # Try to use the default Windows 10 SDK path.
-#         if (DEFINED ENV{WindowsSdkDir} AND DEFINED ENV{WindowsSDKVersion})
-#             set(WIN10SDK_INCLUDE_PATH "$ENV{WindowsSdkDir}/Include/$ENV{WindowsSDKVersion}")
-#         else ()
-#             set(WIN10SDK_INCLUDE_PATH "C:/Program Files (x86)/Windows Kits/10/Include/10.0.26100.0")
-#         endif ()
-#         if (NOT EXISTS "${WIN10SDK_INCLUDE_PATH}/winrt/windows.graphics.printing3d.h")
-#             message("${WIN10SDK_INCLUDE_PATH}/winrt/windows.graphics.printing3d.h was not found")
-#             message("STL fixing by the Netfabb service will not be compiled")
-#             unset(WIN10SDK_INCLUDE_PATH)
-#         endif()
-#     endif()
-#     if(WIN10SDK_INCLUDE_PATH)
-#         message("Building with Win10 Netfabb STL fixing service support")
-#         add_definitions(-DHAS_WIN10SDK)
-#         include_directories(SYSTEM "${WIN10SDK_INCLUDE_PATH}")
-#     else()
-#         message("Building without Win10 Netfabb STL fixing service support")
-#     endif()
-# endif()
-
 if (APPLE)
     message("OS X SDK Path: ${CMAKE_OSX_SYSROOT}")
     if (CMAKE_OSX_DEPLOYMENT_TARGET)

cmake/modules/ClangClShowIncludes.cmake

@@ -1,10 +1,18 @@
 # ccache does not parse the -clang: arguments CMake uses for clang-cl's gcc-style
 # depfile, so a cache hit writes the object and no depfile, and Ninja then records
 # no headers for that object. ccache reproduces /showIncludes output on a hit.
+#
+# Clang also records the modification time of every input in a precompiled header
+# and rejects the header once one differs. ccache caches the compile that creates
+# the header, so a tree that regenerates cmake_pch.cxx gets back a header stamped
+# with the old file's time, and every compile that uses it fails. The build system
+# already rebuilds the header when an input changes. This covers the dependencies,
+# such as wxWidgets; PrecompiledHeader.cmake does the same for OrcaSlicer's targets.
 foreach (_lang C CXX)
     if (CMAKE_${_lang}_COMPILER_ID STREQUAL "Clang" AND
         CMAKE_${_lang}_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
         set(CMAKE_DEPFILE_FLAGS_${_lang} "/showIncludes")
         set(CMAKE_${_lang}_DEPFILE_FORMAT msvc)
+        list(APPEND CMAKE_${_lang}_COMPILE_OPTIONS_CREATE_PCH -Xclang -fno-pch-timestamp)
     endif ()
 endforeach ()

deps_src/libnest2d/include/libnest2d/placers/nfpplacer.hpp

@@ -88,18 +88,6 @@ struct NfpPConfig {
      */
     bool explore_holes = false;
 
-    /**
-     * @brief Keep the final pile on the bin.
-     *
-     * The final alignment centres the pile on the alignment target. A target
-     * near an edge (a belt printer starts its parts at the leading end of the
-     * belt) would push part of a pile that is larger than the room around that
-     * point off the bed; with this set the pile stops at the edge instead, and a
-     * pile that does not fit along an axis is centred on it. Off by default, so
-     * the alignment of every other printer is unchanged.
-     */
-    bool clamp_to_bin = false;
-
     /**
      * @brief If true, use all CPUs available. Run on a single core otherwise.
      */
@@ -1125,22 +1113,22 @@ private:
 
         auto d = cb - ci;
 
-        // Keep the pile on the bin (see Config::clamp_to_bin). The items' boxes carry
-        // their inflation, which is the margin left at the edge.
-        if (config_.clamp_to_bin) {
-            auto on_bin = [](Coord lo, Coord hi, Coord bin_lo, Coord bin_hi, Coord shift) {
-                if (hi - lo >= bin_hi - bin_lo)
-                    return (bin_lo + bin_hi) / 2 - (lo + hi) / 2;
-                if (lo + shift < bin_lo)
-                    shift = bin_lo - lo;
-                if (hi + shift > bin_hi)
-                    shift = bin_hi - hi;
-                return shift;
-            };
-            setX(d, on_bin(getX(bb.minCorner()), getX(bb.maxCorner()), getX(bbin.minCorner()), getX(bbin.maxCorner()), getX(d)));
-            setY(d, on_bin(getY(bb.minCorner()), getY(bb.maxCorner()), getY(bbin.minCorner()), getY(bbin.maxCorner()), getY(d)));
-            cb = ci + d;
-        }
+        // Keep the pile on the bin. Centring it on a target near an edge (a belt
+        // printer starts its parts at the leading end of the belt) would push a pile
+        // larger than the room around that point off the bed, so it stops at the
+        // edge instead; a pile that does not fit along an axis is centred on it.
+        // The items' boxes carry their inflation, which is the margin left at the edge.
+        auto on_bin = [](Coord lo, Coord hi, Coord bin_lo, Coord bin_hi, Coord shift) {
+            if (hi - lo >= bin_hi - bin_lo)
+                return (bin_lo + bin_hi) / 2 - (lo + hi) / 2;
+            if (lo + shift < bin_lo)
+                shift = bin_lo - lo;
+            if (hi + shift > bin_hi)
+                shift = bin_hi - hi;
+            return shift;
+        };
+        setX(d, on_bin(getX(bb.minCorner()), getX(bb.maxCorner()), getX(bbin.minCorner()), getX(bbin.maxCorner()), getX(d)));
+        setY(d, on_bin(getY(bb.minCorner()), getY(bb.maxCorner()), getY(bbin.minCorner()), getY(bbin.maxCorner()), getY(d)));
 
         // BBS make sure the item won't clash with excluded regions
         // do we have wipe tower after arranging?
@@ -1169,9 +1157,7 @@ private:
                 return;
             }
             Item   objs_convex_hull_item(objs_convex_hull);
-            Vertex objs_convex_hull_ref = objs_convex_hull_item.referenceVertex();
-            Vertex diff                 = objs_convex_hull_ref - sl::boundingBox(objs_convex_hull).center();
-            Vertex ref_aligned = cb + diff;  // reference point when pile center aligned with bed center
+            Vertex ref_aligned = objs_convex_hull_item.referenceVertex() + d;
             bool ref_aligned_is_ok = std::any_of(nfps.begin(), nfps.end(), [&ref_aligned](auto& nfp) {return sl::isInside(ref_aligned, nfp); });
             if (!ref_aligned_is_ok) {
                 // ref_aligned is not good, then find a nearest point on nfp boundary

docs/HLSD/mesh-repair.md

@@ -0,0 +1,135 @@
+# Mesh repair — High Level Design
+
+## Purpose and scope
+
+Mesh repair turns a broken triangle mesh into closed, outward oriented shells that bound a solid, so that the
+mesh slices predictably and the other mesh tools (booleans, cut, painting) get valid input. It runs on demand:
+the *Fix Model* command of the context menu of an object or part and of the warning icon in the object list, *Fix
+All* and *Fix All Plates* in the context menu of a plate, the prompt the Cut tool shows when a cut leaves open edges,
+the *Repair and import* choice of texture import, and the `--repair` option of the command line. It is built on CGAL
+and is the only repair the application has, on every platform.
+
+`repair_mesh()` in `src/libslic3r/MeshRepair.cpp` does the work on one `TriangleMesh`, and `ModelVolume::repair()`
+applies it to a part: it replaces the mesh only when the repair changed it, and remaps or drops the painting of a
+replaced mesh. The GUI side, `fix_model_with_cgal_gui()` in `src/slic3r/Utils/FixModelByCgal.cpp`, runs it on a
+worker thread for each volume of an object, or for one volume, behind a progress dialog. `repair_mesh()` reports its
+progress between stages through a callback, which cancels the repair by throwing.
+
+## What the repaired mesh is
+
+The repair keeps what the slicer would print from the input. The slicer fills a layer where the winding number of
+the input surface is not zero (`MeshSlicingParams::SlicingMode::Regular` uses Clipper's nonzero fill rule), so:
+
+- Shells crossing each other print as their union. The repair keeps them as separate shells, as the parts of an
+  object are kept, and makes each of them an outward oriented solid.
+- A shell inside a solid that is oriented like it adds nothing, and the repair removes it.
+- A shell inside a solid that is oriented inward is a cavity, and stays one.
+- A whole mesh turned inside out prints as a solid, and the repair turns it outward.
+
+On top of that, it closes holes and cracks, gives inconsistently oriented triangles the orientation of their
+neighbours, drops degenerate, duplicate and stray flat geometry, and removes small self-intersections inside a shell,
+such as slivers and folds. Where none of this applies, it reports the mesh as unmodified and the caller keeps the
+original mesh, its painting and its object id.
+
+A volume is repaired in place and is never split into several parts: splitting by connectivity would turn a cavity
+into a separate solid part and fill it. Each solid of the result is a shell of its own, so *Split to parts* still
+separates them. Open pieces of the input whose borders meet exactly, which are pieces of one surface rather than
+solids, come out as the one shell they form.
+
+## Pipeline
+
+The input is treated as a triangle soup. Every stage after the first only runs on what the previous ones could
+not settle, so a valid mesh passes through quickly.
+
+### Valid parts first
+
+Parts of the input that are connected by vertex indices and are already closed, consistently oriented 2-manifolds
+skip the soup stages and go straight to the shell stages. Merging their points with coincident points of other
+parts would only make non-manifold junctions out of solids that touch, for example parts of an assembly exported
+together or voxels written as separate cubes.
+
+### Soup clean-up
+
+The rest of the soup has its coincident points merged. Triangles with repeated corners are dropped. Coincident
+triangles of opposite orientation are a wall between two solids touching face to face, so they cancel in pairs;
+of the remaining copies of a triangle one is kept. A connected region that would vanish entirely through
+cancelling is a two-sided export instead (every face written in both orientations), and keeps one copy of each
+triangle.
+
+Open edges then get their vertices welded within a tolerance of 1e-4 of the bounding box diagonal, which closes the
+cracks some exporters leave between triangles that should share corners. A vertex is never welded further than a
+quarter of its shortest edge, so welding cannot collapse fine detail. A soup that stays mostly open after welding has
+cracks wider than that tolerance, and is welded again with ten and then a hundred times the tolerance.
+
+### Work units
+
+The soup is cut into units repaired independently and in parallel: its connected parts, except that open parts whose
+bounding boxes touch share a unit, so that cracks and T-junctions between separately exported patches still close.
+
+### Building the mesh
+
+A unit whose edges are each shared by at most two triangles, running in opposite directions, and whose vertices each
+have a single fan of triangles, becomes a `Surface_mesh` directly. Any other unit is oriented first. Triangles are
+flipped so that neighbours across an edge shared by two of them agree, each part keeping the orientation the
+majority of its area had, which keeps inward oriented cavities inward. Edges where that is impossible or that more
+than two triangles share are cut, and each fan of triangles around a vertex gets its own copy of the vertex. If that
+still leaves an invalid mesh, CGAL's `orient_polygon_soup()` orients the unit instead, and the parts it flipped
+against their majority are reversed back. The linear pass exists because `orient_polygon_soup()` is several times
+slower on large soups that need only a few fixes.
+
+### Closing
+
+Compatible borders are stitched, parts that can be stitched once reversed are merged, and borders still open are
+snapped onto each other within the weld tolerance, which closes T-junctions. Exactly degenerate faces are removed.
+
+Holes are filled last. Planar border loops that face each other in one plane, one inside the other, bound a single
+region, such as a missing annulus at the end of a tube or a cap with features standing on it. Such a group is
+triangulated at once with a 2D constrained Delaunay triangulation that fills only the faces at odd nesting depth,
+so the openings inside the region stay open. The patch is used only if it closes every loop with the orientation
+of the triangles around it. Every other loop is filled on its own with `triangulate_hole()`, which uses a 2D
+constrained Delaunay triangulation when the loop is planar. Otherwise it searches the best triangulation among all
+triangles over the loop for loops of up to 100 edges, and among the triangles of a 3D Delaunay triangulation for
+longer ones, as the full search is cubic in the length of the loop. Beyond 200 edges the full search is not even
+used as a fallback, and a fan around the loop's centroid closes a loop nothing else could.
+
+The closed unit is split into its shells. The largest stays in place and the others are copied out, as converting
+the whole mesh again costs seconds on large models.
+
+### Shells
+
+The shells of all units, together with the valid parts set aside at the start, are handled independently and in
+parallel. Shells enclosing no volume, which hole filling makes out of stray flat patches, are dropped.
+
+Self-intersections inside a shell are removed locally with `experimental::remove_self_intersections()`, which
+remeshes the region around them. It is used only for local defects: a shell whose intersections involve more than
+5 % of its faces is left as it is, and a result that changes the enclosed volume by more than 0.1 % is undone. On
+heavily overlapping ornamental models the remeshing otherwise cuts parts down to slivers, while on genuine defects
+it changes the volume by thousandths of a percent. Overlaps left in place slice correctly. Remeshing can cut
+small pieces off a shell, so a shell it changed is split again and its pieces enclosing no volume are dropped.
+
+Shells crossing others are found through their bounding boxes and an AABB tree per shell, and are made outward
+oriented solids. For every other shell the winding number just outside it is summed from the orientation of the
+shells containing it, tested from a point on its largest face. The shell bounds the solid only if the winding
+number is zero on exactly one of its sides; it is then oriented so that the solid is inside, or dropped otherwise.
+
+Crossing shells are not united. Slicing unites them anyway, uniting them exactly costs tens of seconds on models
+made of many overlapping pieces, and it would fuse parts that *Split to parts* should keep apart.
+
+## Robustness
+
+The repair avoids `experimental::autorefine_and_remove_self_intersections()` and corefinement, which can crash on
+messy input, and uses only steps whose failures it can detect. A step that fails keeps its input. CGAL precondition
+failures surface as `repair_mesh()` returning false with the message as the error. The output is written in float,
+as every mesh in the application is.
+
+The result does not depend on thread scheduling. `libslic3r_cgal` is built with `CGAL_LINKED_WITH_TBB`. Units and
+shells are processed in parallel, but each on its own data, and their results are gathered in a fixed order;
+sorts compare complete keys, and the detected self-intersections are put in order before they are used. Snapping
+stays sequential, as its parallel version gives different results from run to run. Holes are filled with the full
+search wherever it is affordable, because the search among Delaunay triangles can choose between equally good fills
+differently from run to run, so only non-planar holes of more than 100 edges may still vary. On some inputs
+`experimental::remove_self_intersections()` itself places a few vertices differently from run to run.
+
+## Verification
+
+`tests/libslic3r/test_mesh_repair.cpp` covers each kind of defect above on small meshes with known volumes.

localization/i18n/list.txt

@@ -72,6 +72,8 @@ src/slic3r/GUI/Gizmos/GizmoObjectManipulation.cpp
 src/slic3r/GUI/Gizmos/GLGizmoCut.cpp
 src/slic3r/GUI/Gizmos/GLGizmoCut.hpp
 src/slic3r/GUI/Gizmos/GLGizmoSimplify.cpp
+src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp
+src/slic3r/GUI/Gizmos/GLGizmoUtils.cpp
 src/slic3r/GUI/Gizmos/GLGizmoSeam.cpp
 src/slic3r/GUI/Gizmos/GLGizmoSeam.hpp
 src/slic3r/GUI/Gizmos/GLGizmoEmboss.cpp
@@ -110,6 +112,7 @@ src/slic3r/GUI/Jobs/ArrangeJob.cpp
 src/slic3r/GUI/Jobs/OrientJob.cpp
 src/slic3r/GUI/Jobs/FillBedJob.cpp
 src/slic3r/GUI/Jobs/RotoptimizeJob.cpp
+src/slic3r/GUI/Jobs/RotoptimizeJob.hpp
 src/slic3r/GUI/Jobs/BindJob.cpp
 src/slic3r/GUI/Jobs/PrintJob.cpp
 src/slic3r/GUI/Jobs/SendJob.cpp
@@ -138,6 +141,7 @@ src/slic3r/GUI/DeviceErrorDialog.cpp
 src/slic3r/GUI/ExtraRenderers.cpp
 src/slic3r/GUI/EditGCodeDialog.cpp
 src/slic3r/GUI/Field.cpp
+src/slic3r/GUI/Field.hpp
 src/slic3r/GUI/GCodeViewer.cpp
 src/slic3r/GUI/GLCanvas3D.cpp
 src/slic3r/GUI/Calibration.cpp
@@ -165,6 +169,7 @@ src/slic3r/GUI/PrintOptionsDialog.cpp
 src/slic3r/GUI/SafetyOptionsDialog.cpp
 src/slic3r/GUI/ParamsPanel.cpp
 src/slic3r/GUI/IMEXModesCtrl.cpp
+src/slic3r/GUI/IMEXFilamentPickerPopover.cpp
 src/slic3r/GUI/PartPlate.cpp
 src/slic3r/GUI/Plater.cpp
 src/slic3r/GUI/Preferences.cpp
@@ -212,10 +217,14 @@ src/libslic3r/GCode/SeamPlacer.cpp
 src/libslic3r/ExtrusionEntity.cpp
 src/libslic3r/Flow.cpp
 src/libslic3r/Format/AMF.cpp
+src/libslic3r/Format/3mf.cpp
+src/libslic3r/Format/bbs_3mf.cpp
 src/libslic3r/miniz_extension.cpp
 src/libslic3r/IMEXHelpers.cpp
 src/libslic3r/Preset.cpp
 src/libslic3r/Print.cpp
+src/libslic3r/BeltPurge.cpp
+src/libslic3r/AppConfig.cpp
 src/libslic3r/PrintBase.cpp
 src/libslic3r/PrintConfig.cpp
 src/libslic3r/Zipper.cpp
@@ -253,6 +262,7 @@ src/slic3r/Utils/MKS.cpp
 src/slic3r/Utils/Moonraker.cpp
 src/slic3r/Utils/OctoPrint.cpp
 src/slic3r/Utils/Repetier.cpp
+src/slic3r/Utils/ESP3D.cpp
 src/slic3r/GUI/SendMultiMachinePage.cpp
 src/slic3r/GUI/MultiMachinePage.cpp
 src/slic3r/GUI/MultiMachineManagerPage.cpp
@@ -307,6 +317,8 @@ src/slic3r/GUI/AuxiliaryDataViewModel.cpp
 src/slic3r/GUI/AuxiliaryDialog.cpp
 src/slic3r/GUI/BBLStatusBarPrint.cpp
 src/slic3r/GUI/BBLStatusBarSend.cpp
+src/slic3r/GUI/BBLStatusBar.cpp
+src/slic3r/GUI/BeltPurgeTower.cpp
 src/slic3r/GUI/BaseTransparentDPIFrame.cpp
 src/slic3r/GUI/CloneDialog.cpp
 src/slic3r/GUI/ColorDecomposeDialog.cpp
@@ -347,11 +359,27 @@ src/slic3r/GUI/WebViewDialog.cpp
 src/slic3r/GUI/Widgets/AMSItem.cpp
 src/slic3r/GUI/Widgets/DialogButtons.cpp
 src/slic3r/Utils/NetworkAgentFactory.cpp
+src/slic3r/Utils/MoonrakerPrinterAgent.cpp
+src/slic3r/Utils/BBLNetworkPlugin.cpp
+src/slic3r/Utils/OrcaCloudServiceAgent.cpp
 src/slic3r/plugin/PluginAuditManager.cpp
 src/slic3r/plugin/PluginConfig.cpp
 src/slic3r/plugin/PluginResolver.cpp
+src/slic3r/plugin/CloudPluginService.cpp
+src/slic3r/plugin/PluginFsUtils.cpp
+src/slic3r/plugin/PluginHooks.cpp
+src/slic3r/plugin/PluginLoader.cpp
+src/slic3r/plugin/PluginManager.cpp
+src/slic3r/plugin/PythonPluginBridge.cpp
 src/libslic3r/CAD/SketchEngine.cpp
 src/libslic3r/CAD/GeometryEngine.cpp
+src/libslic3r/FilamentMixer.cpp
+src/libslic3r/Config.cpp
+src/libslic3r/Format/STEP.cpp
+src/libslic3r/Format/svg.cpp
+src/libslic3r/Extruder.cpp
+src/libslic3r/MeshBoolean.cpp
+src/libslic3r/utils.cpp
 src/slic3r/GUI/CAD/DesignOffer.hpp
 src/slic3r/GUI/CAD/DesignSketchTool.cpp
 src/slic3r/GUI/EncodedFilament.cpp

resources/images/score_star_outline.svg

@@ -0,0 +1,3 @@
+<svg width="28" height="27" viewBox="0 0 28 27" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path transform="matrix(0.9 0 0 0.9 1.4 1.35)" d="M11.9888 2.01601C12.8984 0.494662 15.1024 0.494662 16.012 2.01601L18.8677 6.79237C19.1958 7.34113 19.7339 7.73201 20.3572 7.87447L25.7821 9.11446C27.5101 9.50943 28.1913 11.6056 27.0254 12.9408L23.3652 17.1327C22.9449 17.6143 22.7394 18.2469 22.7964 18.8836L23.2936 24.4263C23.4519 26.1918 21.6687 27.4873 20.0386 26.7911L14.9209 24.6056C14.3329 24.3545 13.6679 24.3545 13.0799 24.6056L7.96209 26.7911C6.33196 27.4873 4.54887 26.1918 4.70722 24.4263L5.20434 18.8836C5.26145 18.2469 5.05595 17.6143 4.63544 17.1327L0.97533 12.9408C-0.19048 11.6056 0.490599 9.50943 2.21859 9.11446L7.64364 7.87447C8.2669 7.73201 8.80494 7.34113 9.13302 6.79237L11.9888 2.01601Z" stroke="#949494" stroke-width="2.4" stroke-linejoin="round"/>
+</svg>

resources/images/texture_displacement_map_model_uv.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M2.5,2.5h11v11h-11z" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/><path d="M8,2.5v11M2.5,8h11" style="fill:none;stroke:#949494;stroke-dasharray:1.5,1.5"/><path d="M4.5,11.5l3.5-6l3.5,6z" style="fill:#009688"/></svg>

resources/info/legacy_compatible_printers.json

@@ -0,0 +1,795 @@
+{
+    "presets": {
+        "Anycubic Generic ABS": [
+            "Anycubic Kobra 3 0.4 nozzle"
+        ],
+        "Anycubic Generic TPU": [
+            "Anycubic Kobra 3 0.4 nozzle"
+        ],
+        "Bambu ABS @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu ABS @BBL X1C": [
+            "Bambu Lab P1S 0.4 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu ASA @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PA6-CF @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PA6-CF @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PA6-CF @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PA6-CF @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PA6-CF @BBL X1C": [
+            "Bambu Lab P1P 0.6 nozzle",
+            "Bambu Lab P1P 0.8 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab P1S 0.8 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.8 nozzle"
+        ],
+        "Bambu PA6-CF @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle",
+            "Bambu Lab P1P 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab P1S 0.8 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.8 nozzle"
+        ],
+        "Bambu PAHT-CF @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PC @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PETG @0.2 nozzle": [
+            "Qidi Q1 Pro 0.2 nozzle"
+        ],
+        "Bambu PETG Basic @BBL H2D 0.6 nozzle": [
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PETG Basic @BBL H2DP 0.6 nozzle": [
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PETG Basic @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PETG Basic @BBL P2S 0.6 nozzle": [
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PETG Basic @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PETG HF @BBL P2S 0.6 nozzle": [
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PETG HF @BBL X1C": [
+            "Bambu Lab P1P 0.4 nozzle",
+            "Bambu Lab P1S 0.4 nozzle"
+        ],
+        "Bambu PETG HF @BBL X1C 0.8 nozzle": [
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PETG HF @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PETG Translucent @BBL H2D 0.6 nozzle": [
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PETG Translucent @BBL H2DP 0.6 nozzle": [
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PETG Translucent @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PETG Translucent @BBL P2S 0.6 nozzle": [
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PETG Translucent @BBL X1C 0.8 nozzle": [
+            "Bambu Lab P1P 0.6 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PETG-CF @BBL H2D 0.6 nozzle": [
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PETG-CF @BBL H2DP 0.6 nozzle": [
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PETG-CF @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PETG-CF @BBL P2S 0.6 nozzle": [
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PLA Basic @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Basic @BBL X1C": [
+            "Bambu Lab P1S 0.4 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Basic @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PLA Dynamic @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Dynamic @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Galaxy @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Galaxy @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Glow @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Glow @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Lite @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle"
+        ],
+        "Bambu PLA Lite @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PLA Lite @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Lite @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Lite @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PLA Marble @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle",
+            "Bambu Lab P1P 0.8 nozzle"
+        ],
+        "Bambu PLA Marble @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Matte @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Matte @BBL X1C": [
+            "Bambu Lab P1S 0.4 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Matte @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PLA Metal @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Metal @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Silk+ @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PLA Silk+ @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PLA Silk+ @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PLA Silk+ @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Silk+ @BBL X1C": [
+            "Bambu Lab P1S 0.4 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Silk+ @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PLA Sparkle @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Sparkle @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Tough+ @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Tough+ @BBL X1C": [
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA Tough+ @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PLA Translucent @BBL H2D 0.8 nozzle": [
+            "Bambu Lab H2D 0.6 nozzle"
+        ],
+        "Bambu PLA Translucent @BBL H2DP 0.8 nozzle": [
+            "Bambu Lab H2D Pro 0.6 nozzle"
+        ],
+        "Bambu PLA Translucent @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PLA Wood @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu PLA Wood @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu PLA-CF @BBL H2D 0.6 nozzle": [
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PLA-CF @BBL H2DP 0.6 nozzle": [
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PLA-CF @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PLA-CF @BBL P2S 0.6 nozzle": [
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PLA-CF @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu PPA-CF @BBL X1C": [
+            "Bambu Lab P1P 0.6 nozzle",
+            "Bambu Lab P1P 0.8 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab P1S 0.8 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.8 nozzle"
+        ],
+        "Bambu PVA @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu PVA @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu PVA @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu PVA @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu PVA @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu Support For PLA @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu Support For PLA @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu Support For PLA @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu Support For PLA @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu Support For PLA @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu Support For PLA/PETG @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu Support For PLA/PETG @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu Support For PLA/PETG @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu Support For PLA/PETG @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu Support For PLA/PETG @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu Support for ABS @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu Support for ABS @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu Support for ABS @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu Support for ABS @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu Support for ABS @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu TPU 90A @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu TPU 90A @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu TPU 95A HF @BBL H2D": [
+            "Bambu Lab H2D 0.4 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu TPU 95A HF @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.4 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu TPU 95A HF @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu TPU 95A HF @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu TPU 95A HF @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL H2D": [
+            "Bambu Lab H2D 0.6 nozzle",
+            "Bambu Lab H2D 0.8 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL H2DP": [
+            "Bambu Lab H2D Pro 0.6 nozzle",
+            "Bambu Lab H2D Pro 0.8 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL H2S": [
+            "Bambu Lab H2S 0.6 nozzle",
+            "Bambu Lab H2S 0.8 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL P1P": [
+            "Bambu Lab P1P 0.6 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL P2S": [
+            "Bambu Lab P2S 0.6 nozzle",
+            "Bambu Lab P2S 0.8 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL X1C": [
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 Carbon 0.6 nozzle"
+        ],
+        "Bambu TPU for AMS @BBL X2D": [
+            "Bambu Lab X2D 0.8 nozzle"
+        ],
+        "Blocks Generic ABS": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic ASA": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic ASA-CF": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PA": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PA-CF": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PC": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PETG": [
+            "BLOCKS RD50 V2 0.4 nozzle",
+            "BLOCKS RD50 V2 0.6 nozzle",
+            "BLOCKS RD50 V2 0.8 nozzle",
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PLA": [
+            "BLOCKS RD50 V2 0.4 nozzle",
+            "BLOCKS RD50 V2 0.6 nozzle",
+            "BLOCKS RD50 V2 0.8 nozzle",
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PLA-CF": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic PVA": [
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Blocks Generic TPU": [
+            "BLOCKS RD50 V2 0.4 nozzle",
+            "BLOCKS RD50 V2 0.6 nozzle",
+            "BLOCKS RD50 V2 0.8 nozzle",
+            "BLOCKS RF50 0.4 nozzle",
+            "BLOCKS RF50 0.6 nozzle",
+            "BLOCKS RF50 0.8 nozzle"
+        ],
+        "Creality Generic ABS": [
+            "Creality CR-10 SE 0.2 nozzle",
+            "Creality CR-10 SE 0.4 nozzle",
+            "Creality CR-10 SE 0.6 nozzle",
+            "Creality CR-10 SE 0.8 nozzle",
+            "Creality CR-6 SE 0.2 nozzle",
+            "Creality CR-6 SE 0.4 nozzle",
+            "Creality CR-6 SE 0.6 nozzle",
+            "Creality CR-6 SE 0.8 nozzle",
+            "Creality CR-M4 0.4 nozzle",
+            "Creality Ender-3 V2 0.4 nozzle"
+        ],
+        "Creality Generic ABS @Ender-3V3-all": [
+            "Creality Ender-3 V3 Plus 0.4 nozzle",
+            "Creality Ender-3 V3 Plus 0.6 nozzle"
+        ],
+        "Creality Generic ABS @Hi-all": [
+            "Creality Hi 0.4 nozzle"
+        ],
+        "Creality Generic ABS @K1-all": [
+            "Creality K1 SE 0.4 nozzle",
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic ABS @K2-all": [
+            "Creality K2 0.4 nozzle",
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Plus 0.6 nozzle",
+            "Creality K2 Plus 0.8 nozzle",
+            "Creality K2 Pro 0.4 nozzle"
+        ],
+        "Creality Generic ASA @Ender-3V3-all": [
+            "Creality Ender-3 V3 Plus 0.4 nozzle",
+            "Creality Ender-3 V3 Plus 0.6 nozzle"
+        ],
+        "Creality Generic ASA @K1-all": [
+            "Creality K1 SE 0.4 nozzle",
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic ASA @K2-all": [
+            "Creality K2 0.4 nozzle",
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Pro 0.4 nozzle"
+        ],
+        "Creality Generic PA-CF @Ender-3V3-all": [
+            "Creality Ender-3 V3 Plus 0.4 nozzle",
+            "Creality Ender-3 V3 Plus 0.6 nozzle"
+        ],
+        "Creality Generic PA-CF @K1-all": [
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic PA-CF @K2-all": [
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Plus 0.6 nozzle",
+            "Creality K2 Plus 0.8 nozzle"
+        ],
+        "Creality Generic PC @K1-all": [
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic PETG": [
+            "Creality CR-6 SE 0.2 nozzle",
+            "Creality CR-6 SE 0.4 nozzle",
+            "Creality CR-6 SE 0.6 nozzle",
+            "Creality CR-6 SE 0.8 nozzle",
+            "Creality CR-M4 0.4 nozzle"
+        ],
+        "Creality Generic PETG @Ender-3V3-all": [
+            "Creality Ender-3 V3 0.4 nozzle",
+            "Creality Ender-3 V3 0.6 nozzle",
+            "Creality Ender-3 V3 Plus 0.4 nozzle",
+            "Creality Ender-3 V3 Plus 0.6 nozzle",
+            "Creality Ender-3 V3 SE 0.2 nozzle",
+            "Creality Ender-3 V3 SE 0.4 nozzle",
+            "Creality Ender-3 V3 SE 0.6 nozzle",
+            "Creality Ender-3 V3 SE 0.8 nozzle"
+        ],
+        "Creality Generic PETG @Hi-all": [
+            "Creality Hi 0.4 nozzle"
+        ],
+        "Creality Generic PETG @K1-all": [
+            "Creality K1 SE 0.4 nozzle",
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic PETG @K2-all": [
+            "Creality K2 0.4 nozzle",
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Plus 0.6 nozzle",
+            "Creality K2 Plus 0.8 nozzle",
+            "Creality K2 Pro 0.4 nozzle"
+        ],
+        "Creality Generic PLA": [
+            "Creality CR-10 SE 0.2 nozzle",
+            "Creality CR-10 SE 0.4 nozzle",
+            "Creality CR-10 SE 0.6 nozzle",
+            "Creality CR-10 SE 0.8 nozzle",
+            "Creality CR-6 SE 0.2 nozzle",
+            "Creality CR-6 SE 0.4 nozzle",
+            "Creality CR-6 SE 0.6 nozzle",
+            "Creality CR-6 SE 0.8 nozzle",
+            "Creality CR-M4 0.4 nozzle"
+        ],
+        "Creality Generic PLA @Ender-3V3-all": [
+            "Creality Ender-3 V3 0.4 nozzle",
+            "Creality Ender-3 V3 0.6 nozzle",
+            "Creality Ender-3 V3 Plus 0.4 nozzle",
+            "Creality Ender-3 V3 Plus 0.6 nozzle"
+        ],
+        "Creality Generic PLA @K1-all": [
+            "Creality K1 SE 0.4 nozzle",
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic PLA @K2-all": [
+            "Creality K2 0.4 nozzle",
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Plus 0.6 nozzle",
+            "Creality K2 Plus 0.8 nozzle",
+            "Creality K2 Pro 0.4 nozzle"
+        ],
+        "Creality Generic PLA-CF @K1-all": [
+            "Creality K1 SE 0.4 nozzle",
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic PLA-CF @K2-all": [
+            "Creality K2 0.4 nozzle",
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Pro 0.4 nozzle"
+        ],
+        "Creality Generic TPU": [
+            "Creality CR-10 SE 0.2 nozzle",
+            "Creality CR-10 SE 0.4 nozzle",
+            "Creality CR-10 SE 0.6 nozzle",
+            "Creality CR-10 SE 0.8 nozzle"
+        ],
+        "Creality Generic TPU @Ender-3V3-all": [
+            "Creality Ender-3 V3 0.4 nozzle",
+            "Creality Ender-3 V3 0.6 nozzle",
+            "Creality Ender-3 V3 Plus 0.4 nozzle",
+            "Creality Ender-3 V3 Plus 0.6 nozzle",
+            "Creality Ender-3 V3 SE 0.2 nozzle",
+            "Creality Ender-3 V3 SE 0.4 nozzle",
+            "Creality Ender-3 V3 SE 0.6 nozzle",
+            "Creality Ender-3 V3 SE 0.8 nozzle"
+        ],
+        "Creality Generic TPU @K1-all": [
+            "Creality K1 SE 0.4 nozzle",
+            "Creality K1C 0.4 nozzle"
+        ],
+        "Creality Generic TPU @K2-all": [
+            "Creality K2 0.4 nozzle",
+            "Creality K2 Plus 0.4 nozzle",
+            "Creality K2 Pro 0.4 nozzle"
+        ],
+        "Cubicon ABS @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon ABS-A100 @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon ABSk @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon PA-CF @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon PC @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon PETG @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon PLA @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon PLA+ @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Cubicon PLAi21 @base": [
+            "Cubicon xCeler-Plus 0.4 nozzle"
+        ],
+        "Flashforge Generic ABS @G3U": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle"
+        ],
+        "Flashforge Generic ASA @G3U": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle"
+        ],
+        "Flashforge Generic HIPS": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle"
+        ],
+        "Flashforge Generic PETG @G3U": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle",
+            "Flashforge Guider 3 Ultra 0.8 Nozzle"
+        ],
+        "Flashforge Generic PETG-CF @G3U": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle",
+            "Flashforge Guider 3 Ultra 0.8 Nozzle"
+        ],
+        "Flashforge Generic PLA @G3U": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle",
+            "Flashforge Guider 3 Ultra 0.8 Nozzle"
+        ],
+        "Flashforge Generic PLA-CF @G3U": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle",
+            "Flashforge Guider 3 Ultra 0.8 Nozzle"
+        ],
+        "Flashforge HS PLA": [
+            "Flashforge AD5X 0.4 nozzle",
+            "Flashforge AD5X 0.6 nozzle",
+            "Flashforge AD5X 0.8 nozzle"
+        ],
+        "Flashforge PETG-CF": [
+            "Flashforge AD5X 0.4 nozzle",
+            "Flashforge AD5X 0.6 nozzle",
+            "Flashforge AD5X 0.8 nozzle"
+        ],
+        "Flashforge PLA-CF": [
+            "Flashforge AD5X 0.4 nozzle",
+            "Flashforge AD5X 0.6 nozzle",
+            "Flashforge AD5X 0.8 nozzle"
+        ],
+        "Flashforge TPU 95A": [
+            "Flashforge AD5X 0.4 nozzle",
+            "Flashforge AD5X 0.6 nozzle",
+            "Flashforge AD5X 0.8 nozzle"
+        ],
+        "FusRock Generic PAHT-CF": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle"
+        ],
+        "FusRock Generic PET-CF": [
+            "Flashforge Guider 3 Ultra 0.6 Nozzle"
+        ],
+        "Generic PETG HF @BBL X1C": [
+            "Bambu Lab P1S 0.4 nozzle",
+            "Bambu Lab P1S 0.6 nozzle",
+            "Bambu Lab X1 0.4 nozzle",
+            "Bambu Lab X1 0.6 nozzle",
+            "Bambu Lab X1 0.8 nozzle"
+        ],
+        "Generic PLA @Hi-all": [
+            "Creality Hi 0.4 nozzle",
+            "Creality Hi 0.6 nozzle"
+        ],
+        "HATCHBOX PETG @0.2 nozzle": [
+            "Qidi Q1 Pro 0.2 nozzle"
+        ],
+        "Prusa Generic PA": [
+            "Prusa MINIIS 0.25 nozzle",
+            "Prusa MINIIS 0.4 nozzle",
+            "Prusa MINIIS 0.6 nozzle",
+            "Prusa MINIIS 0.8 nozzle"
+        ],
+        "Prusa Generic PA-CF": [
+            "Prusa MINIIS 0.25 nozzle",
+            "Prusa MINIIS 0.4 nozzle",
+            "Prusa MINIIS 0.6 nozzle",
+            "Prusa MINIIS 0.8 nozzle"
+        ],
+        "Prusa Generic PLA-CF": [
+            "Prusa MINIIS 0.25 nozzle",
+            "Prusa MINIIS 0.4 nozzle",
+            "Prusa MINIIS 0.6 nozzle",
+            "Prusa MINIIS 0.8 nozzle"
+        ],
+        "QIDI PETG Basic @0.2 nozzle": [
+            "Qidi Q1 Pro 0.2 nozzle"
+        ],
+        "QIDI PETG Rapido @0.2 nozzle": [
+            "Qidi Q1 Pro 0.2 nozzle"
+        ],
+        "QIDI PETG Translucent @0.2 nozzle": [
+            "Qidi Q1 Pro 0.2 nozzle"
+        ],
+        "Sovol Zero PETG HS Nozzle": [
+            "Sovol Zero 0.4 nozzle"
+        ],
+        "Sovol Zero PLA Basic HS Nozzle": [
+            "Sovol Zero 0.4 nozzle"
+        ],
+        "Sovol Zero PLA Silk HS Nozzle": [
+            "Sovol Zero 0.4 nozzle"
+        ],
+        "re3D Greengate rPETG": [
+            "re3D GigabotX 2 1.75 nozzle",
+            "re3D GigabotX 2 XLT 1.75 nozzle",
+            "re3D TerabotX 2 1.75 nozzle"
+        ],
+        "re3D PC": [
+            "re3D Gigabot 4 0.8 nozzle",
+            "re3D Gigabot 4 XLT 0.8 nozzle",
+            "re3D Terabot 4 0.8 nozzle"
+        ],
+        "re3D PETG": [
+            "re3D Gigabot 4 0.8 nozzle",
+            "re3D Gigabot 4 XLT 0.8 nozzle",
+            "re3D Terabot 4 0.8 nozzle"
+        ],
+        "re3D PLA": [
+            "re3D Gigabot 4 0.8 nozzle",
+            "re3D Gigabot 4 XLT 0.8 nozzle",
+            "re3D Terabot 4 0.8 nozzle"
+        ],
+        "re3D rPP": [
+            "re3D GigabotX 2 1.75 nozzle",
+            "re3D GigabotX 2 XLT 1.75 nozzle",
+            "re3D TerabotX 2 1.75 nozzle"
+        ]
+    }
+}

resources/profiles/BBL.json

@@ -1,7 +1,7 @@
 {
 	"name": "Bambulab",
 	"url": "http://www.bambulab.com/Parameters/vendor/BBL.json",
-	"version": "02.08.00.14",
+	"version": "02.08.00.15",
 	"force_update": "0",
 	"description": "the initial version of BBL configurations",
 	"machine_model_list": [

resources/profiles/Qidi.json

@@ -1,6 +1,6 @@
 {
 	"name": "Qidi",
-	"version": "02.04.00.16",
+	"version": "02.04.00.17",
 	"force_update": "0",
 	"description": "Qidi configurations",
 	"machine_model_list": [

resources/profiles/Qidi/machine/Qidi Q1 Pro 0.4 nozzle.json

@@ -83,7 +83,7 @@
 	"extruder_clearance_height_to_lid": "120",
 	"layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nLOG_Z\nG92 E0\n",
 	"machine_end_gcode": "M141 S0\nM104 S0\nM140 S0\nG1 E-3 F1800\nG0 Z{min(max_print_height, max_layer_z + 3)} F600\nG0 X0 Y0 F12000\n{if max_layer_z < max_print_height / 2}G1 Z{max_print_height / 2 + 10} F600{else}G1 Z{min(max_print_height, max_layer_z + 3)}{endif}",
-	"machine_start_gcode": "PRINT_START BED=[hot_plate_temp_initial_layer] HOTEND=[nozzle_temperature_initial_layer] CHAMBER=[chamber_temperature]\nM83\nM140 S[hot_plate_temp_initial_layer]\nM104 S[nozzle_temperature_initial_layer]\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 3} Z0\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 6}\nG1 Z1 F600\n",
+	"machine_start_gcode": "PRINT_START BED=[bed_temperature_initial_layer_single] HOTEND=[nozzle_temperature_initial_layer] CHAMBER=[chamber_temperature]\nM83\nM140 S[bed_temperature_initial_layer_single]\nM104 S[nozzle_temperature_initial_layer]\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 3} Z0\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 6}\nG1 Z1 F600\n",
 	"thumbnails_format": "PNG",
 	"default_filament_profile": [
 		"Generic PLA @Qidi Q1 Pro 0.4 nozzle"

resources/profiles/Qidi/machine/Qidi X-CF Pro 0.4 nozzle.json

@@ -100,7 +100,7 @@
 	"default_filament_profile": [
 		"Generic PLA @Qidi"
 	],
-	"machine_start_gcode": "G28\nM140 S[hot_plate_temp_initial_layer]\nM190 S[hot_plate_temp_initial_layer]\nM109 S[nozzle_temperature_initial_layer]\nG92 E-19\nG0 Y5 Z0.3 F3600\nG1 X5 E0 F2400\n",
+	"machine_start_gcode": "G28\nM140 S[bed_temperature_initial_layer_single]\nM190 S[bed_temperature_initial_layer_single]\nM109 S[nozzle_temperature_initial_layer]\nG92 E-19\nG0 Y5 Z0.3 F3600\nG1 X5 E0 F2400\n",
 	"machine_end_gcode": "M104 S0\nM140 S0\n;Retract the filament\nG92 E0\nG1 E-3 F300\nG28\nM84\n",
 	"scan_first_layer": "0"
 }

resources/profiles/Qidi/machine/fdm_qidi_x3_common.json

@@ -24,7 +24,7 @@
 		"210x210/COLPIC",
 		"110x110/PNG"
 	],
-	"machine_start_gcode": "PRINT_START\nG28\nM141 S0\nG0 Z50 F600\nM190 S[hot_plate_temp_initial_layer]\nG28 Z\nG29; mesh bed leveling ,comment this code to close it\nG0 X0 Y0 Z50 F6000\nM141 S{overall_chamber_temperature}\nM109 S[nozzle_temperature_initial_layer]\nM106 P3 S255\nM83\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 12} E{-10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 E{10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\n",
+	"machine_start_gcode": "PRINT_START\nG28\nM141 S0\nG0 Z50 F600\nM190 S[bed_temperature_initial_layer_single]\nG28 Z\nG29; mesh bed leveling ,comment this code to close it\nG0 X0 Y0 Z50 F6000\nM141 S{overall_chamber_temperature}\nM109 S[nozzle_temperature_initial_layer]\nM106 P3 S255\nM83\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 12} E{-10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 E{10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\n",
 	"machine_end_gcode": "M141 S0\nM104 S0\nM140 S0\nG1 E-3 F1800\nG0 Z{min(max_print_height, max_layer_z + 3)} F600\nG0 X0 Y0 F12000\n{if max_layer_z < max_print_height / 2}G1 Z{max_print_height / 2 + 10} F600{else}G1 Z{min(max_print_height, max_layer_z + 3)}{endif}",
 	"scan_first_layer": "0"
 }

resources/shaders/110/texture_displacement_shaded.fs

@@ -72,17 +72,21 @@ varying float weight;
 varying float island_active;
 varying vec2  vertex_uv;
 
-// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - including
-// the handedness, which comes out left-handed for an axis of +Z. Copied rather than "corrected", so
-// the preview wraps the texture the same way round as the bake.
+// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - right
+// handed, so the angle taken from it grows anticlockwise about the axis, which seen from outside the
+// cylinder is to the viewer's right rather than mirrored.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
+// sign(), which returns 0 there and would collapse the coordinate onto a line.
+float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
+
 // The raw, millimetre-valued projection of `p` (a position in the texture frame), before the layer's
 // tiling/rotation/aspect/offset - a term-for-term transcription of libslic3r's project_planar(),
 // project_cylindrical() and project_spherical(). `n` is read by the planar mode only.
@@ -94,7 +98,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
     }
     if (projection_mode == 2) {                 // Spherical: (longitude, latitude) * radius
         vec3  rel    = p - patch_center;
@@ -102,10 +106,18 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
-    vec3 an = abs(n);                           // Triplanar: drop the dominant normal axis
-    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
+    // Triplanar: drop the dominant normal axis. v is negated so the image's first pixel row (v = 0)
+    // sits at the top of the model instead of upside down, and u is flipped on the far side of each
+    // plane so the two faces sharing it are not mirror images. libslic3r's box_plane_yz() and its two
+    // siblings, term for term.
+    vec3 an = abs(n);
+    if (an.x >= an.y && an.x >= an.z)
+        return vec2(box_face_sign(n.x) * p.y, -p.z);
+    if (an.y >= an.x && an.y >= an.z)
+        return vec2(-box_face_sign(n.y) * p.x, -p.z);
+    return vec2(box_face_sign(n.z) * p.x, -p.y);
 }
 
 // The two surface directions projection_raw()'s u and v run along at `p`, plus how many raw units one
@@ -124,7 +136,7 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec2  xy  = vec2(dot(rel, right), dot(rel, fwd));
         float r   = length(xy);
         t = (r > 1e-6) ? (fwd * xy.x - right * xy.y) / r : right; // circumferential: u runs along it
-        b = up;                                                   // v is the distance along the axis
+        b = -up;                                                  // v is the distance *against* the axis
         return;
     }
     if (projection_mode == 2) {
@@ -133,20 +145,20 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec3  dir = (r > 1e-8) ? rel / r : vec3(0.0, 0.0, 1.0);
         float c   = length(dir.xy);                               // cos(latitude)
         t = (c > 1e-6) ? vec3(-dir.y, dir.x, 0.0) / c : vec3(1.0, 0.0, 0.0);
-        b = cross(dir, t);                                        // increasing latitude, unit length
+        b = -cross(dir, t);                                       // v grows away from the pole, unit length
         units_per_mm = vec2(1.0 / max(c, 1e-3), 1.0);
         return;
     }
-    vec3 an = abs(n);
-    if (an.x >= an.y && an.x >= an.z) {        // planar = p.yz
-        t = vec3(0.0, 1.0, 0.0);
-        b = vec3(0.0, 0.0, 1.0);
-    } else if (an.y >= an.x && an.y >= an.z) { // planar = p.xz
-        t = vec3(1.0, 0.0, 0.0);
-        b = vec3(0.0, 0.0, 1.0);
-    } else {                                   // planar = p.xy
-        t = vec3(1.0, 0.0, 0.0);
-        b = vec3(0.0, 1.0, 0.0);
+    vec3 an = abs(n);                          // the same signed basis projection_raw() uses
+    if (an.x >= an.y && an.x >= an.z) {        // planar = (+-y, -z)
+        t = vec3(0.0, box_face_sign(n.x), 0.0);
+        b = vec3(0.0, 0.0, -1.0);
+    } else if (an.y >= an.x && an.y >= an.z) { // planar = (+-x, -z)
+        t = vec3(-box_face_sign(n.y), 0.0, 0.0);
+        b = vec3(0.0, 0.0, -1.0);
+    } else {                                   // planar = (+-x, -y)
+        t = vec3(box_face_sign(n.z), 0.0, 0.0);
+        b = vec3(0.0, -1.0, 0.0);
     }
 }
 

resources/shaders/110/texture_displacement_uvcheck.fs

@@ -36,14 +36,20 @@ varying vec4  world_pos;
 varying float distortion;
 varying vec2  vertex_uv;
 
+// Right handed (up x right), like libslic3r's project_cylindrical(), so the angle taken from it grows
+// anticlockwise about the axis - to the viewer's right when seen from outside the cylinder.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
+// sign(), which returns 0 there and would collapse the coordinate onto a line.
+float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
+
 // Term for term libslic3r's project_planar() / project_cylindrical() / project_spherical(), in mm.
 vec2 projection_raw(vec3 p, vec3 n)
 {
@@ -53,7 +59,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
     }
     if (projection_mode == 2) {
         vec3  rel    = p - patch_center;
@@ -61,10 +67,16 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
+    // v negated so the image's first pixel row sits at the top of the model, u flipped on the far side
+    // of each plane so the two faces sharing it are not mirror images - see libslic3r's box_plane_yz().
     vec3 an = abs(n);
-    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
+    if (an.x >= an.y && an.x >= an.z)
+        return vec2(box_face_sign(n.x) * p.y, -p.z);
+    if (an.y >= an.x && an.y >= an.z)
+        return vec2(-box_face_sign(n.y) * p.x, -p.z);
+    return vec2(box_face_sign(n.z) * p.x, -p.y);
 }
 
 vec2 project_uv(vec3 p, vec3 n)

resources/shaders/140/texture_displacement_shaded.fs

@@ -138,17 +138,21 @@ in vec2  vertex_uv;
 
 out vec4 out_color;
 
-// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - including
-// the handedness, which comes out left-handed for an axis of +Z. Copied rather than "corrected", so
-// the preview wraps the texture the same way round as the bake.
+// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - right
+// handed, so the angle taken from it grows anticlockwise about the axis, which seen from outside the
+// cylinder is to the viewer's right rather than mirrored.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
+// sign(), which returns 0 there and would collapse the coordinate onto a line.
+float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
+
 // The raw, millimetre-valued projection of `p` (a position in the texture frame), before the layer's
 // tiling/rotation/aspect/offset - a term-for-term transcription of libslic3r's project_planar(),
 // project_cylindrical() and project_spherical(). `n` is read by the planar mode only.
@@ -160,7 +164,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
     }
     if (projection_mode == 2) {                 // Spherical: (longitude, latitude) * radius
         vec3  rel    = p - patch_center;
@@ -168,10 +172,18 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
-    vec3 an = abs(n);                           // Triplanar: drop the dominant normal axis
-    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
+    // Triplanar: drop the dominant normal axis. v is negated so the image's first pixel row (v = 0)
+    // sits at the top of the model instead of upside down, and u is flipped on the far side of each
+    // plane so the two faces sharing it are not mirror images. libslic3r's box_plane_yz() and its two
+    // siblings, term for term.
+    vec3 an = abs(n);
+    if (an.x >= an.y && an.x >= an.z)
+        return vec2(box_face_sign(n.x) * p.y, -p.z);
+    if (an.y >= an.x && an.y >= an.z)
+        return vec2(-box_face_sign(n.y) * p.x, -p.z);
+    return vec2(box_face_sign(n.z) * p.x, -p.y);
 }
 
 // The two surface directions projection_raw()'s u and v run along at `p`, plus how many raw units one
@@ -190,7 +202,7 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec2  xy  = vec2(dot(rel, right), dot(rel, fwd));
         float r   = length(xy);
         t = (r > 1e-6) ? (fwd * xy.x - right * xy.y) / r : right; // circumferential: u runs along it
-        b = up;                                                   // v is the distance along the axis
+        b = -up;                                                  // v is the distance *against* the axis
         return;
     }
     if (projection_mode == 2) {
@@ -199,20 +211,20 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec3  dir = (r > 1e-8) ? rel / r : vec3(0.0, 0.0, 1.0);
         float c   = length(dir.xy);                               // cos(latitude)
         t = (c > 1e-6) ? vec3(-dir.y, dir.x, 0.0) / c : vec3(1.0, 0.0, 0.0);
-        b = cross(dir, t);                                        // increasing latitude, unit length
+        b = -cross(dir, t);                                       // v grows away from the pole, unit length
         units_per_mm = vec2(1.0 / max(c, 1e-3), 1.0);
         return;
     }
-    vec3 an = abs(n);
-    if (an.x >= an.y && an.x >= an.z) {        // planar = p.yz
-        t = vec3(0.0, 1.0, 0.0);
-        b = vec3(0.0, 0.0, 1.0);
-    } else if (an.y >= an.x && an.y >= an.z) { // planar = p.xz
-        t = vec3(1.0, 0.0, 0.0);
-        b = vec3(0.0, 0.0, 1.0);
-    } else {                                   // planar = p.xy
-        t = vec3(1.0, 0.0, 0.0);
-        b = vec3(0.0, 1.0, 0.0);
+    vec3 an = abs(n);                          // the same signed basis projection_raw() uses
+    if (an.x >= an.y && an.x >= an.z) {        // planar = (+-y, -z)
+        t = vec3(0.0, box_face_sign(n.x), 0.0);
+        b = vec3(0.0, 0.0, -1.0);
+    } else if (an.y >= an.x && an.y >= an.z) { // planar = (+-x, -z)
+        t = vec3(-box_face_sign(n.y), 0.0, 0.0);
+        b = vec3(0.0, 0.0, -1.0);
+    } else {                                   // planar = (+-x, -y)
+        t = vec3(box_face_sign(n.z), 0.0, 0.0);
+        b = vec3(0.0, -1.0, 0.0);
     }
 }
 

resources/shaders/140/texture_displacement_uvcheck.fs

@@ -47,14 +47,20 @@ in vec2  vertex_uv;
 
 out vec4 out_color;
 
+// Right handed (up x right), like libslic3r's project_cylindrical(), so the angle taken from it grows
+// anticlockwise about the axis - to the viewer's right when seen from outside the cylinder.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
+// sign(), which returns 0 there and would collapse the coordinate onto a line.
+float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
+
 // Term for term libslic3r's project_planar() / project_cylindrical() / project_spherical(), in mm.
 vec2 projection_raw(vec3 p, vec3 n)
 {
@@ -64,7 +70,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
     }
     if (projection_mode == 2) {
         vec3  rel    = p - patch_center;
@@ -72,10 +78,16 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
+    // v negated so the image's first pixel row sits at the top of the model, u flipped on the far side
+    // of each plane so the two faces sharing it are not mirror images - see libslic3r's box_plane_yz().
     vec3 an = abs(n);
-    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
+    if (an.x >= an.y && an.x >= an.z)
+        return vec2(box_face_sign(n.x) * p.y, -p.z);
+    if (an.y >= an.x && an.y >= an.z)
+        return vec2(-box_face_sign(n.y) * p.x, -p.z);
+    return vec2(box_face_sign(n.z) * p.x, -p.y);
 }
 
 vec2 project_uv(vec3 p, vec3 n)

resources/web/dialog/PresetBundleDialog/index.html

@@ -61,7 +61,7 @@
 
   <!-- Context Menu -->
   <div id="ctxMenu" class="ctx" hidden>
-    <button class="ctx-item" data-action="open_folder" data-i18n="open_folder">Open folder in explorer</button>
+    <button class="ctx-item" data-action="open_folder" data-i18n="open_folder">Show in folder</button>
     <button id = "delete_btn" class="ctx-item-delete" data-action="delete_bundle" data-i18n="delete_bundle" hidden>Delete bundle</button>
     <button id = "unsubscribe_btn" class="ctx-item-subscribed" data-action="unsubscribe_bundle" data-i18n="unsubscribe_bundle" hidden>Unsubscribe bundle</button>
   </div>

resources/web/dialog/SpeedDial/speeddial.js

@@ -676,7 +676,7 @@ function labelParts(actions) {
 // Accessible label "Title from Pretty Source", disambiguated with the opaque action id when another
 // action shares the same title+source (case/separator-insensitive) - so two rows never read out identically.
 function actionLabel(action, actions) {
-    var label = action.title + " from " + prettySource(action.source || action.group || "");
+    var label = T("sd_action_from", "%s from %s", action.title, prettySource(action.source || action.group || ""));
     if (actions && actions.length) {
         var cache = labelParts(actions);
         var mine  = cache.sig[action.id];

resources/web/flush/WipingDialog.html

@@ -2,6 +2,7 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
+    <script type="text/javascript" src="../include/i18n.js"></script>
     <style>
       * {
         user-select: none;
@@ -525,7 +526,7 @@
         for (let j = 0; j < m_number_of_filaments; j++) {
           if (j == 0) {
             var tag = document.createElement("th")
-            tag.innerHTML = "<div style='font-size:12px'>from/to</div>"
+            tag.innerHTML = "<div style='font-size:12px'>" + T("from_to", "from/to") + "</div>"
             thead.appendChild(tag)
           }
           let th = document.createElement("th");

resources/web/guide/21/common.js

@@ -337,8 +337,10 @@ function UpdateSidebarVendors()
 {
 	let SidebarHTML = "";
 	$(`.OneVendorBlock`).each((i, el)=>{
-		UpdateVendorCheckbox(el.getAttribute("vendor"));
-		SidebarHTML +=`<div class="SidebarItem" onclick="scrollToVendor(this.textContent)">${el.getAttribute('vendor')}</div>`;
+		let vendor = el.getAttribute('vendor');
+		UpdateVendorCheckbox(vendor);
+		let label = vendor == "Custom" ? T("custom_vendor", "Custom") : vendor;
+		SidebarHTML +=`<div class="SidebarItem" vendor="${vendor}" onclick="scrollToVendor(this.getAttribute('vendor'))">${label}</div>`;
 	});
 	$('#SidebarVendors').html(SidebarHTML)
 }

resources/web/homepage/js/home.js

@@ -315,7 +315,7 @@ function ShowRecentFileList( pList )
 		//let index=sPath.lastIndexOf('\\')>0?sPath.lastIndexOf('\\'):sPath.lastIndexOf('\/');
 		//let sShortName=sPath.substring(index+1,sPath.length);
 		
-		let sBadge=sPublished? '<span class="FilePublishedBadge">PUB</span>':'';
+		let sBadge=sPublished? '<span class="FilePublishedBadge">'+T("published_badge", "PUB")+'</span>':'';
 		let sLogoBadge=sPublished? '<img class="FileLogoBadge" src="../../images/OrcaSlicer_gradient_circle.svg" alt="" />':'';
 
 		let TmpHtml='<div class="FileItem"  fpath="'+sPath+'"  >'+

resources/web/model/index.html

@@ -55,7 +55,7 @@
 		<div id="Model_Name_Area" class="Text_TitleBoard">
 		<div id="Model_Name_Line" class="Text_TitleArea">
 		   <div class="Text_Title" id="ModelNameBar" ><div data-i18n="model_name">Model name</div><div>:</div><div title="xxxxxxxxxx" id="ModelName" style="margin-left: 8px;">xxxxxxxxxx</div></div>
-		   <div><span id="ModelAuthorType">Created by</span><span>:</span><span id="ModelAuthorName" style="margin-left: 8px;" class="Text_Value">xxxxxxx</span></div>
+		   <div><span id="ModelAuthorType" data-i18n="created_by">Created by</span><span>:</span><span id="ModelAuthorName" style="margin-left: 8px;" class="Text_Value">xxxxxxx</span></div>
 		</div>
 	    <div id="ModelLicenceImg"><img src="img/by-nc-nd.png"></div>
 		</div>

scripts/DockerRun.sh

@@ -12,8 +12,11 @@ docker run \
   --net=host \
   `# Some X installs will not have permissions to talk to sockets for shared memory` \
   --ipc host \
-  `# Run as your workstations username to keep permissions the same` \
-  -u "$USER" \
+  `# Run as your workstations UID and GID to keep permissions the same.` \
+  `# Numeric IDs work even when the image has no user with your name` \
+  -u "$(id -u):$(id -g)" \
+  -e HOME="/home/$USER" \
+  -w "/home/$USER" \
   `# Bind mount your home directory into the container for loading/saving files` \
   -v "$HOME:/home/$USER" \
   `# Pass the X display number to the container` \

scripts/check_profile.ps1

@@ -5,11 +5,13 @@
 .DESCRIPTION
     The Windows counterpart of scripts/check_profile.sh, and kept deliberately close to it.
 
-    Runs the same five checks, in the same order, with the same validator flags, and with the
+    Runs the same six checks, in the same order, with the same validator flags, and with the
     same semantics: every check runs even after an earlier one fails (the workflow's
     continue-on-error), then the script exits non-zero once at the end.
 
         profile_tool                  scripts/orca_profile_tool.py check
+        legacy_compat                 scripts/orca_profile_tool.py legacy-compat --check against
+                                      the v2.4.2 profiles
         validate_system               validator -p <profiles> -l <level>
         validate_slice                validator -p <profiles> -s -l <level>
         validate_filament_subtypes    validator -p <profiles> -l <level> -f
@@ -20,8 +22,9 @@
     never sees a profile no <vendor>.json indexes, a preset name two files claim, or a file
     normalize and update-index would still rewrite.
 
-    Everything that has to be downloaded - the profile validator and the custom-preset fixture
-    archives - lands under a per-user cache directory (%LOCALAPPDATA%\orca-profile-check) and
+    Everything that has to be downloaded - the profile validator, the custom-preset fixture
+    archives and the v2.4.2 profile tree - lands under a per-user cache directory
+    (%LOCALAPPDATA%\orca-profile-check) and
     is reused on the next run. Being outside the checkout, that directory is shared by every
     worktree on the machine. It also holds one log per check plus a copy of the comment CI would
     post on the PR.
@@ -48,7 +51,8 @@
     check it cannot narrow is validate_slice for a vendor that ships no printers; the summary
     reports that one as skipped, and naming it explicitly still runs it. profile_tool keeps its
     two cross-vendor checks (setting_id and filament_id) tree-wide, so a scoped run can still
-    fail on another vendor's files.
+    fail on another vendor's files, and legacy_compat is tree-wide too: the map it checks covers
+    every vendor.
 
 .PARAMETER Validator
     OrcaSlicer_profile_validator.exe to use; also $env:ORCA_PROFILE_VALIDATOR. Default: the local
@@ -116,7 +120,7 @@ $HostArch = switch ($HostArch) {
     default { 'x86' }
 }
 
-$AllChecks = @('profile_tool', 'validate_system', 'validate_slice', 'validate_filament_subtypes', 'validate_custom')
+$AllChecks = @('profile_tool', 'legacy_compat', 'validate_system', 'validate_slice', 'validate_filament_subtypes', 'validate_custom')
 
 $script:LogWriter = $null
 $script:Python = ''
@@ -439,6 +443,43 @@ function Expand-VendorPresets([string] $Zip, [string] $Tree, [string] $Prefix) {
     return $kept
 }
 
+# The profile tree of the release resources\info\legacy_compatible_printers.json is generated
+# against. The tag is immutable, so the extracted tree is cached in the work dir and -Refresh
+# re-extracts it. A checkout without the tag (a shallow clone, a fork that never fetched tags)
+# gets it from upstream, as CI does. git archive writes a file rather than a pipe, which
+# PowerShell would re-encode, and tar.exe ships with Windows 10 and later.
+$LegacyBaseTag = 'v2.4.2'
+$LegacyBaseUrl = 'https://github.com/OrcaSlicer/OrcaSlicer.git'
+
+function Get-LegacyBaseProfiles {
+    $ErrorActionPreference = 'Continue'
+    $base = Join-Path (Join-Path $WorkDir 'legacy-base') $LegacyBaseTag
+    $profiles = Join-Path (Join-Path $base 'resources') 'profiles'
+    if ($Refresh -or -not (Test-Path -LiteralPath $profiles -PathType Container)) {
+        & git -C $RepoRoot rev-parse -q --verify "refs/tags/$LegacyBaseTag^{commit}" 2>$null | Out-Null
+        if ($LASTEXITCODE -ne 0) {
+            Write-Host "fetching tag $LegacyBaseTag from $LegacyBaseUrl ..."
+            & git -C $RepoRoot fetch --no-tags $LegacyBaseUrl "refs/tags/${LegacyBaseTag}:refs/tags/${LegacyBaseTag}"
+            if ($LASTEXITCODE -ne 0) { throw "cannot fetch tag $LegacyBaseTag" }
+        }
+        # Extracted beside its final place and moved there whole, so an interrupted extraction is
+        # never mistaken for the tree on the next run.
+        $partial = "$base.partial"
+        foreach ($dir in $base, $partial) {
+            if (Test-Path -LiteralPath $dir) { Remove-Item -LiteralPath $dir -Recurse -Force }
+        }
+        New-Item -ItemType Directory -Force -Path $partial | Out-Null
+        $archive = Join-Path $partial 'profiles.tar'
+        & git -C $RepoRoot archive -o $archive $LegacyBaseTag resources/profiles
+        if ($LASTEXITCODE -ne 0) { throw "cannot archive resources/profiles of $LegacyBaseTag" }
+        & tar -xf $archive -C $partial
+        if ($LASTEXITCODE -ne 0) { throw "cannot extract $archive" }
+        Remove-Item -LiteralPath $archive -Force
+        Move-Item -LiteralPath $partial -Destination $base
+    }
+    return $profiles
+}
+
 # ---------------------------------------------------------------------------- checks
 
 $CheckBodies = @{
@@ -447,6 +488,14 @@ $CheckBodies = @{
         Invoke-Tool -Exe (Resolve-Python) -Arguments (@((Join-Path $RepoRoot 'scripts\orca_profile_tool.py'), 'check', '--profiles', $ProfilesDir) + $VendorPyArgs)
     }
 
+    # The map says which printers a user filament preset made against 2.4.2 can be migrated
+    # back to, so a profile change that renames a filament preset or narrows its
+    # compatible_printers has to regenerate it (the CI comment gives the command).
+    legacy_compat = {
+        $base = Get-LegacyBaseProfiles
+        Invoke-Tool -Exe (Resolve-Python) -Arguments @((Join-Path $RepoRoot 'scripts\orca_profile_tool.py'), 'legacy-compat', '--profiles', $ProfilesDir, '--base', $base, '--check')
+    }
+
     validate_system = {
         Invoke-Tool -Exe $Validator -Arguments (@('-p', $ProfilesDir) + $VendorArgs + @('-l', "$LogLevel"))
     }
@@ -581,6 +630,7 @@ $CheckBodies = @{
 # Heading CI puts above this check's log in the PR comment.
 $CommentHeadings = @{
     profile_tool               = '### Profile Check Failed (orca_profile_tool.py)'
+    legacy_compat              = '### Legacy Compatible Printers Map Out of Date'
     validate_system            = '### System Profile Validation Failed'
     validate_slice             = '### Slice Validation Failed (custom g-code expansion)'
     validate_filament_subtypes = '### Filament Subtype Validation Failed'
@@ -627,7 +677,7 @@ try {
     [Console]::OutputEncoding = New-Object Text.UTF8Encoding($false)
     Push-UserPresets
 
-    if ($Checks | Where-Object { $_ -ne 'profile_tool' }) { $Validator = Resolve-Validator }
+    if ($Checks | Where-Object { $_ -ne 'profile_tool' -and $_ -ne 'legacy_compat' }) { $Validator = Resolve-Validator }
 
     # An empty printer set is a failure to the sweep, so validate_slice is recorded as skipped
     # rather than run for a vendor that ships no printers (the filament-only OrcaFilamentLibrary);

scripts/check_profile.sh

@@ -2,12 +2,13 @@
 #
 # Local twin of the "Check profiles" CI job (.github/workflows/check_profiles.yml).
 #
-# Runs the same five checks, in the same order, with the same validator flags, and with the
+# Runs the same six checks, in the same order, with the same validator flags, and with the
 # same semantics: every check runs even after an earlier one fails (the workflow's
 # continue-on-error), then the script exits non-zero once at the end.
 #
-# Everything that has to be downloaded - the profile validator and the custom-preset fixture
-# archives - lands under a per-user cache directory and is reused on the next run. Being outside
+# Everything that has to be downloaded - the profile validator, the custom-preset fixture
+# archives and the v2.4.2 profile tree - lands under a per-user cache directory and is reused on
+# the next run. Being outside
 # the checkout, that directory is shared by every worktree on the machine. It also holds one log
 # per check plus a copy of the comment CI would post on the PR.
 #
@@ -58,7 +59,7 @@ LOG_LEVEL=2
 PREFER_DOWNLOAD=0
 REFRESH=0
 
-ALL_CHECKS=(profile_tool validate_system validate_slice validate_filament_subtypes validate_custom)
+ALL_CHECKS=(profile_tool legacy_compat validate_system validate_slice validate_filament_subtypes validate_custom)
 CHECKS=()
 # "<check><TAB>pass|fail" per check that ran, plus "<check><TAB>skip<TAB>why" for one a vendor
 # scope left out; a string rather than an array because bash 3.2 (still the /bin/bash on macOS)
@@ -73,6 +74,8 @@ Usage: scripts/check_profile.sh [OPTION]... [CHECK]...
 
 Checks (default: all, in this order):
   profile_tool                  scripts/orca_profile_tool.py check
+  legacy_compat                 scripts/orca_profile_tool.py legacy-compat --check against the
+                                v2.4.2 profiles
   validate_system               validator -p <profiles> -l <level>
   validate_slice                validator -p <profiles> -s -l <level>
   validate_filament_subtypes    validator -p <profiles> -l <level> -f
@@ -100,7 +103,8 @@ Note: --vendor narrows validate_custom too, by keeping only that vendor's preset
 fixture tree. The one check it cannot narrow is validate_slice for a vendor that ships no
 printers; the summary reports that one as skipped, and naming it explicitly still runs it.
 profile_tool keeps its two cross-vendor checks (setting_id and filament_id) tree-wide, so a
-scoped run can still fail on another vendor's files.
+scoped run can still fail on another vendor's files, and legacy_compat is tree-wide too: the map
+it checks covers every vendor.
 EOF
 }
 
@@ -379,6 +383,44 @@ check_profile_tool() {
     python3 "${REPO_ROOT}/scripts/orca_profile_tool.py" check --profiles "${PROFILES_DIR}" --vendor "${VENDOR}"
 }
 
+# The profile tree of the release resources/info/legacy_compatible_printers.json is generated
+# against. The tag is immutable, so the extracted tree is cached in the work dir and --refresh
+# re-extracts it. A checkout without the tag (a shallow clone, a fork that never fetched tags)
+# gets it from upstream, as CI does.
+LEGACY_BASE_TAG="v2.4.2"
+LEGACY_BASE_URL="https://github.com/OrcaSlicer/OrcaSlicer.git"
+
+legacy_base_profiles() {
+    local base="${WORK_DIR}/legacy-base/${LEGACY_BASE_TAG}"
+    if [ "${REFRESH}" -eq 1 ] || [ ! -d "${base}/resources/profiles" ]; then
+        if ! git -C "${REPO_ROOT}" rev-parse -q --verify "refs/tags/${LEGACY_BASE_TAG}^{commit}" >/dev/null; then
+            msg "fetching tag ${LEGACY_BASE_TAG} from ${LEGACY_BASE_URL} ..."
+            git -C "${REPO_ROOT}" fetch --no-tags "${LEGACY_BASE_URL}" \
+                "refs/tags/${LEGACY_BASE_TAG}:refs/tags/${LEGACY_BASE_TAG}" || return 1
+        fi
+        # Extracted beside its final place and moved there whole, so an interrupted extraction is
+        # never mistaken for the tree on the next run.
+        local partial="${base}.partial"
+        rm -rf "${base}" "${partial}"
+        mkdir -p "${partial}" || return 1
+        if ! git -C "${REPO_ROOT}" archive "${LEGACY_BASE_TAG}" resources/profiles | tar -x -C "${partial}"; then
+            rm -rf "${partial}"
+            return 1
+        fi
+        mv "${partial}" "${base}" || return 1
+    fi
+    printf '%s\n' "${base}/resources/profiles"
+}
+
+# The map says which printers a user filament preset made against 2.4.2 can be migrated back
+# to, so a profile change that renames a filament preset or narrows its compatible_printers has
+# to regenerate it (the CI comment gives the command).
+check_legacy_compat() {
+    local base
+    base="$(legacy_base_profiles)" || return 1
+    python3 "${REPO_ROOT}/scripts/orca_profile_tool.py" legacy-compat --profiles "${PROFILES_DIR}" --base "${base}" --check
+}
+
 check_validate_system() {
     "${VALIDATOR}" -p "${PROFILES_DIR}" -v "${VENDOR}" -l "${LOG_LEVEL}"
 }
@@ -563,6 +605,7 @@ EOF
 comment_heading() {
     case "$1" in
         profile_tool) echo "### Profile Check Failed (orca_profile_tool.py)" ;;
+        legacy_compat) echo "### Legacy Compatible Printers Map Out of Date" ;;
         validate_system) echo "### System Profile Validation Failed" ;;
         validate_slice) echo "### Slice Validation Failed (custom g-code expansion)" ;;
         validate_filament_subtypes) echo "### Filament Subtype Validation Failed" ;;

scripts/ci_deps_cache.sh

@@ -1,21 +1,27 @@
 #!/usr/bin/env bash
-# Lets a pull request's macOS deps build wait for a push build of the base
-# branch that builds the same deps, from a Linux job. `check` runs after a cache
-# miss and names a queued or running base build with the same deps/ and .github/
-# to wait for, unless the pull request changes either. `wait` waits until that
-# build saves KEY. actions/cache then confirms the entry can be restored.
+# Lets a pull request's macOS deps build, or its clang-tidy job, wait for a
+# build that saves the deps cache it needs, from a Linux job. `check` runs after
+# a cache miss and names a queued or running push build of the base branch with
+# the same deps/ and .github/ to wait for, unless the pull request changes either.
+# `own` names the pull request's own build instead, for clang-tidy when the pull
+# request changes deps/. `wait` waits until that build saves KEY under CACHE_REF,
+# or its deps job fails. actions/cache then confirms the entry can be restored.
 #
-# Environment: GH_TOKEN, REPO, WORKFLOW_REF and BASE_REF, plus KEY_INPUTS,
-# WAIT_FOR, WAIT_SINCE, WAIT_MINUTES, KEY and ARCH for `wait`.
+# Environment: GH_TOKEN, REPO, WORKFLOW_REF (or WORKFLOW, the build workflow's
+# file name) and BASE_REF, plus HEAD_SHA for `own`, and KEY_INPUTS, WAIT_FOR,
+# WAIT_SINCE, WAIT_MINUTES, KEY, CACHE_REF (default the base branch) and ARCH
+# (or JOB, the matrix job's name) for `wait`.
 # Writes key-inputs, wait-for and wait-since to $GITHUB_OUTPUT.
 set -uo pipefail
 
-workflow=${WORKFLOW_REF%%@*}
-workflow=${workflow##*/}
+workflow=${WORKFLOW_REF:-}
+workflow=${workflow%%@*}
+workflow=${WORKFLOW:-${workflow##*/}}
 
 # Must match the job names in build_all.yml, build_check_cache.yml and build_deps.yml.
-check_job_name="build_macos_arch (${ARCH:-}) / Check Cache"
-deps_job_name="build_macos_arch (${ARCH:-}) / Build Deps / Build Deps"
+job=${JOB:-build_macos_arch (${ARCH:-})}
+check_job_name="$job / Check Cache"
+deps_job_name="$job / Build Deps / Build Deps"
 
 out() { echo "$1" >> "${GITHUB_OUTPUT:-/dev/stdout}"; }
 
@@ -63,8 +69,27 @@ check() {
   fi
 }
 
+own() {
+  out "key-inputs=$(local_key_inputs HEAD)"
+  local id
+  # The build can be created a moment after this job.
+  for _ in 1 2 3 4 5; do
+    id=$(gh api -X GET "repos/$REPO/actions/workflows/$workflow/runs" \
+      -f head_sha="$HEAD_SHA" -f event=pull_request -f per_page=1 --jq '.workflow_runs[0].id // empty' < /dev/null)
+    [ -n "$id" ] && break
+    sleep 30
+  done
+  if [ -n "$id" ]; then
+    echo "Waiting for the deps cache of build $id of this pull request."
+    out "wait-for=$id"
+    out "wait-since=$(date +%s)"
+  else
+    echo "No build of this pull request is building its deps."
+  fi
+}
+
 key_saved() {
-  gh cache list -R "$REPO" --ref "refs/heads/$BASE_REF" --key "$KEY" --json key < /dev/null \
+  gh cache list -R "$REPO" --ref "${CACHE_REF:-refs/heads/$BASE_REF}" --key "$KEY" --json key < /dev/null \
     | jq -e --arg key "$KEY" 'any(.[]; .key == $key)' > /dev/null
 }
 
@@ -87,11 +112,11 @@ wait_for() {
           key_saved && { echo "Found $KEY."; return; }
           sleep 20
         done
-        echo "Build $id of $BASE_REF finished its deps without saving $KEY."
+        echo "Build $id finished its deps without saving $KEY."
         return ;;
       "completed cancelled") ;;
       completed*)
-        echo "The deps job of build $id of $BASE_REF did not succeed."
+        echo "The deps job of build $id did not succeed."
         return ;;
       # The deps job exists only once the build's cache check has succeeded.
       "")
@@ -100,7 +125,7 @@ wait_for() {
           completed*)
             check=$(jq -r --arg name "$check_job_name" 'first(.jobs[] | select(.name == $name) | .conclusion) // ""' <<< "$jobs")
             if [ -z "$warned" ] && { [ -z "$check" ] || [ "$check" = success ]; }; then
-              echo "::warning title=Deps wait::Build $id of $BASE_REF has no job named \"$deps_job_name\". If the build jobs were renamed, update scripts/ci_deps_cache.sh. This does not affect this pull request."
+              echo "::warning title=Deps wait::Build $id has no job named \"$deps_job_name\". If the build jobs were renamed, update scripts/ci_deps_cache.sh. This does not affect this pull request."
               warned=1
             fi ;;
           *)
@@ -118,11 +143,12 @@ wait_for() {
     seen="$seen $id"
     echo "Following build $id of $BASE_REF."
   done
-  echo "No build of $BASE_REF saved $KEY."
+  echo "No build saved $KEY."
 }
 
 case "${1:-}" in
   check) check ;;
+  own) own ;;
   wait) wait_for ;;
-  *) echo "usage: $0 check|wait" >&2; exit 2 ;;
+  *) echo "usage: $0 check|own|wait" >&2; exit 2 ;;
 esac

scripts/orca_profile_tool.py

@@ -11,6 +11,7 @@ commands:
   normalize        rewrite profile files into their canonical shape
   trim             delete profile files no <vendor>.json list references
   update-index     regenerate the *_list sections of <vendor>.json
+  legacy-compat    write the printers user presets can be migrated back to
 
 options shared by several commands:
   --vendor VENDOR      act on one vendor bundle only; repeatable, empty means all
@@ -24,6 +25,9 @@ After adding, renaming or deleting profile files, run:
   normalize -> update-index -> generate-id -> check
 normalize supplies missing types; update-index registers presets before id
 generation.
+After renaming filament presets or narrowing their compatible_printers, also
+rerun legacy-compat --base <2.4.2 profiles> so user presets made against 2.4.2
+can be migrated back to their printers; CI runs it with --check.
 Use trim only for deliberate cleanup, previewed with --dry-run: it judges against
 the current index and can delete newly added, unindexed presets.
 
@@ -3072,6 +3076,139 @@ def fix_variant_arrays(profiles_dir=PROFILES_DIR, vendors=None, dry_run=False, s
     return len(changed), errors
 
 
+# ---------------------------------------------------------------------------
+# legacy-compat
+# ---------------------------------------------------------------------------
+
+LEGACY_COMPAT_PATH = os.path.normpath(
+    os.path.join(SCRIPTS_DIR, "..", "resources", "info", "legacy_compatible_printers.json"))
+
+
+def _renamed_from(data):
+    """A preset's renamed_from names. Profiles write one ';'-separated string, as the
+    loader's unescape_strings_cstyle reads it; none of them quote or escape a name."""
+    value = data.get("renamed_from") or []
+    return [n for v in _as_list(value) for n in v.split(";") if n]
+
+
+def _flatten_presets(profiles_dir):
+    """Every bundle's composed filament and printer presets, for legacy-compat.
+
+    Returns (filaments, printers): filaments maps (vendor, name) to a dict with the
+    resolved compatible_printers, filament_id, extruder variants, renamed_from and
+    whether it is instantiated; printers maps each instantiated printer name to a
+    dict with its renamed_from and extruder variants. instantiation is read from the
+    preset's own file, as the loader requires every file to state it.
+    """
+    def instantiated(data):
+        return str(data.get("instantiation", "")).lower() == "true"
+
+    ofl = load_vendor_configs(profiles_dir, OFL)["filament"]
+    filaments, printers = {}, {}
+    for vendor in list_vendor_names(profiles_dir):
+        configs = load_vendor_configs(profiles_dir, vendor)
+        cache = {}
+        for name, (_rel, data) in configs["filament"].items():
+            config = compose_config(name, configs["filament"], ofl, cache, vendor == OFL)
+            filaments[(vendor, name)] = {
+                "compatible_printers": set(_as_list(config.get("compatible_printers", ([],))[0])),
+                "filament_id": config.get("filament_id", (None,))[0],
+                "variants": set(_as_list(config.get("filament_extruder_variant", ([],))[0])),
+                "instantiation": instantiated(data),
+                "renamed_from": _renamed_from(data),
+            }
+        cache = {}
+        for name, (_rel, data) in configs["machine"].items():
+            if instantiated(data):
+                config = compose_config(name, configs["machine"], {}, cache)
+                printers[name] = {
+                    "renamed_from": _renamed_from(data),
+                    "variants": set(_as_list(config.get("printer_extruder_variant", ([],))[0])),
+                }
+    return filaments, printers
+
+
+def legacy_compatible_printers(base_dir, profiles_dir=PROFILES_DIR):
+    """Printers each filament preset of the base release covered but the current
+    preset it loads as no longer lists, kept only where a current preset with
+    the same filament_id still covers that printer.
+
+    User presets store only their diff, so they inherit their parent's
+    compatible_printers; when a profile change narrows that list, a user preset
+    made against the base release disappears from printers it was used on. The
+    app offers to write these printers into such user presets. Requiring a same-id
+    successor leaves out printers a filament was deliberately taken off, and
+    requiring a shared extruder variant keeps a printer from picking up another
+    variant's values.
+
+    Keyed by the base release's preset name, which is what such a user preset's
+    inherits still says. One current preset can stand in for several old ones
+    through renamed_from, each with its own old list, so the key tells them
+    apart. An old name resolves as the loader resolves an inherits: to the
+    current selectable preset of that name, else to one listing it in
+    renamed_from. A preset that is not instantiated never enters the loader's
+    collection, so it does not stop the renamed_from lookup. Printer names are
+    translated through the printers' renamed_from. Returns
+    {old preset name: sorted printer names}.
+    """
+    old_filaments, _ = _flatten_presets(base_dir)
+    new_filaments, new_printers = _flatten_presets(profiles_dir)
+    renamed_printer = {old: new for new, rec in new_printers.items() for old in rec["renamed_from"]}
+
+    by_name, by_old_name = {}, {}
+    for (vendor, name), rec in new_filaments.items():
+        if rec["instantiation"]:
+            by_name.setdefault(name, []).append((vendor, rec))
+            for old_name in rec["renamed_from"]:
+                by_old_name.setdefault(old_name, []).append((vendor, rec))
+
+    covering = {}  # filament_id -> printers some current instantiated preset covers
+    for rec in new_filaments.values():
+        if rec["instantiation"] and rec["filament_id"]:
+            covering.setdefault(rec["filament_id"], set()).update(rec["compatible_printers"])
+
+    def shares_variant(filament, printer):
+        variants = new_printers[printer]["variants"]
+        return not filament["variants"] or not variants or bool(filament["variants"] & variants)
+
+    result = {}
+    for (vendor, name), old in sorted(old_filaments.items()):
+        # Only a selectable preset can be a user preset's parent.
+        if not old["instantiation"]:
+            continue
+        candidates = by_name.get(name) or by_old_name.get(name, [])
+        same_vendor = [r for v, r in candidates if v == vendor]
+        rec = (same_vendor or [r for _, r in candidates] or [None])[0]
+        # An empty list means every printer, so nothing can have been lost.
+        if rec is None or not rec["compatible_printers"]:
+            continue
+        lost = {renamed_printer.get(p, p) for p in old["compatible_printers"]} - rec["compatible_printers"]
+        lost &= covering.get(rec["filament_id"], set()) & set(new_printers)
+        lost = {p for p in lost if shares_variant(rec, p)}
+        if lost:
+            result.setdefault(name, set()).update(lost)
+    return {name: sorted(printers) for name, printers in result.items()}
+
+
+def run_legacy_compat(base_dir, profiles_dir, output, check):
+    presets = legacy_compatible_printers(base_dir, profiles_dir)
+    if check:
+        try:
+            with open(output, encoding="utf-8") as f:
+                current = json.load(f).get("presets")
+        except (OSError, ValueError, AttributeError):
+            current = None
+        if current != presets:
+            print_error(f"{output} is out of date; rerun legacy-compat --base {base_dir}")
+            return 1
+        print_success(f"{output} is up to date")
+        return 0
+    with open(output, "w", encoding="utf-8", newline="\n") as f:
+        f.write(json.dumps({"presets": presets}, indent=4, sort_keys=True, ensure_ascii=False) + "\n")
+    print_info(f"wrote {len(presets)} presets / {sum(map(len, presets.values()))} printers to {output}")
+    return 0
+
+
 # ---------------------------------------------------------------------------
 # CLI
 # ---------------------------------------------------------------------------
@@ -3093,11 +3230,17 @@ examples:
       preview resizing the variant arrays check rejects in that bundle
   orca_profile_tool.py check --strict --vendor BBL
       also hold every preset's inherited variant arrays to its own width
+  orca_profile_tool.py legacy-compat --base /tmp/v2.4.2/resources/profiles
+      rewrite resources/info/legacy_compatible_printers.json against 2.4.2's
+      profiles (git archive v2.4.2 resources/profiles | tar -x -C /tmp/v2.4.2)
 
 after adding, renaming or deleting profile files, run in this order:
   normalize -> update-index -> generate-id -> check
 normalize supplies missing types; update-index registers presets before id
 generation.
+After renaming filament presets or narrowing their compatible_printers, also
+rerun legacy-compat --base <2.4.2 profiles> so user presets made against 2.4.2
+can be migrated back to their printers; CI runs it with --check.
 Use trim only for deliberate cleanup, previewed with --dry-run: it judges against
 the current index and can delete newly added, unindexed presets.
 """
@@ -3227,6 +3370,23 @@ def build_parser():
         "Use trim only for deliberate unindexed-file cleanup, previewed with\n"
         "--dry-run; it can also delete newly authored presets.")
 
+    legacy_cmd = add(
+        "legacy-compat", [profiles_opt],
+        "write the printers user presets can be migrated back to",
+        "Compare the tree with an older release's profiles and write, per filament\n"
+        "preset of that release, the printers it covered then that the preset it now\n"
+        "loads as no longer lists, where a preset with the same filament_id still\n"
+        "covers them. The app offers to write these into user presets that inherit\n"
+        "that preset by its old name and do not set compatible_printers, so a\n"
+        "narrowed list does not hide them on printers they were made for.")
+    legacy_cmd.add_argument("--base", required=True, metavar="DIR",
+                            help="the older release's resources/profiles directory")
+    legacy_cmd.add_argument("--output", default=LEGACY_COMPAT_PATH, metavar="FILE",
+                            help="map to write (default: resources/info/"
+                                 "legacy_compatible_printers.json)")
+    legacy_cmd.add_argument("--check", action="store_true",
+                            help="fail if the map differs from what --base implies; write nothing")
+
     return parser
 
 
@@ -3260,6 +3420,9 @@ def main(argv=None):
         return run_generate_id(profiles_dir, vendors, args.filament_id, args.setting_id,
                                args.dry_run)
 
+    if args.command == "legacy-compat":
+        return run_legacy_compat(args.base, profiles_dir, args.output, args.check)
+
     if args.command == "fix-variant":
         _changed, errors = fix_variant_arrays(profiles_dir, vendors, dry_run=args.dry_run,
                                                strict=args.strict)

scripts/tests/test_profile_tool.py

@@ -1258,6 +1258,118 @@ class TestVariantNames(TreeCase):
         self.assertIn('holds the legacy variant "Direct Drive Normal"', out)
 
 
+# ---------------------------------------------------------------------------
+# legacy-compat
+# ---------------------------------------------------------------------------
+
+class TestLegacyCompat(unittest.TestCase):
+    """A base release and the current tree, each with one vendor."""
+
+    def setUp(self):
+        self.base, self.cur = Tree(), Tree()
+        self.addCleanup(self.base.cleanup)
+        self.addCleanup(self.cur.cleanup)
+
+    @staticmethod
+    def printer(tree, name, **extra):
+        tree.write("V", f"machine/{name}.json",
+                   {"type": "machine", "name": name, "instantiation": "true", **extra})
+        tree.index("V", "machine", name, f"machine/{name}.json")
+
+    @staticmethod
+    def filament(tree, name, printers, filament_id="OFpetg01", **extra):
+        tree.write("V", f"filament/{name}.json",
+                   {"type": "filament", "name": name, "instantiation": "true",
+                    "filament_id": filament_id, "compatible_printers": printers, **extra})
+        tree.index("V", "filament", name, f"filament/{name}.json")
+
+    def generate(self):
+        return apt.legacy_compatible_printers(self.base.profiles, self.cur.profiles)
+
+    def test_renamed_and_narrowed_preset_keeps_printers_a_same_id_sibling_covers(self):
+        for tree in (self.base, self.cur):
+            for p in ("A 0.4", "A 0.6", "B 0.4"):
+                self.printer(tree, p)
+        self.filament(self.base, "PETG @A-all", ["A 0.4", "A 0.6", "B 0.4"])
+        self.filament(self.cur, "PETG @V A-all", ["A 0.6"], renamed_from="PETG @A-all;PETG A-all")
+        self.filament(self.cur, "PETG @A 0.4", ["A 0.4"])
+        self.assertEqual(self.generate(), {"PETG @A-all": ["A 0.4"]})
+
+    def test_each_old_name_gets_back_only_its_own_list(self):
+        # The current "PC @0.4" existed in the base and also replaces the split "PC".
+        for tree in (self.base, self.cur):
+            for p in ("A 0.4", "A 0.8"):
+                self.printer(tree, p)
+        self.filament(self.base, "PC", ["A 0.4", "A 0.8"])
+        self.filament(self.base, "PC @0.4", ["A 0.4"])
+        self.filament(self.cur, "PC @0.4", ["A 0.4"], renamed_from="PC")
+        self.filament(self.cur, "PC @0.8", ["A 0.8"])
+        self.assertEqual(self.generate(), {"PC": ["A 0.8"]})
+
+    def test_old_name_now_a_base_preset_resolves_through_renamed_from(self):
+        for tree in (self.base, self.cur):
+            for p in ("I 0.4", "Plus 0.4"):
+                self.printer(tree, p)
+        self.filament(self.base, "PLA @base", ["I 0.4", "Plus 0.4"])
+        self.filament(self.cur, "PLA @base", [], instantiation="false")
+        self.filament(self.cur, "PLA @I 0.4", ["I 0.4"], renamed_from="PLA @base")
+        self.filament(self.cur, "PLA @Plus 0.4", ["Plus 0.4"])
+        self.assertEqual(self.generate(), {"PLA @base": ["Plus 0.4"]})
+
+    def test_printer_without_a_successor_is_left_out(self):
+        for tree in (self.base, self.cur):
+            for p in ("A 0.4", "A 0.6"):
+                self.printer(tree, p)
+        self.filament(self.base, "PETG @A", ["A 0.4", "A 0.6"])
+        self.filament(self.cur, "PETG @A", ["A 0.6"])
+        self.filament(self.cur, "Other @A", ["A 0.4"], filament_id="OFother1")
+        self.assertEqual(self.generate(), {})
+
+    def test_printer_names_follow_printer_renames(self):
+        self.printer(self.base, "Old 0.4")
+        self.printer(self.base, "A 0.6")
+        self.printer(self.cur, "New 0.4", renamed_from="Old 0.4")
+        self.printer(self.cur, "A 0.6")
+        self.filament(self.base, "PETG @A", ["Old 0.4", "A 0.6"])
+        self.filament(self.cur, "PETG @A", ["A 0.6"])
+        self.filament(self.cur, "PETG @New", ["New 0.4"])
+        self.assertEqual(self.generate(), {"PETG @A": ["New 0.4"]})
+
+    def test_printer_without_a_shared_extruder_variant_is_left_out(self):
+        for tree in (self.base, self.cur):
+            self.printer(tree, "Direct 0.4", printer_extruder_variant=["Direct Drive Standard"])
+            self.printer(tree, "Bowden 0.4", printer_extruder_variant=["Bowden Standard"])
+        self.filament(self.base, "PETG @all", ["Direct 0.4", "Bowden 0.4"])
+        self.filament(self.cur, "PETG @all", ["Direct 0.4"],
+                      filament_extruder_variant=["Direct Drive Standard"])
+        self.filament(self.cur, "PETG @Bowden", ["Bowden 0.4"])
+        self.assertEqual(self.generate(), {})
+
+    def test_preset_now_listing_no_printer_is_skipped(self):
+        for tree in (self.base, self.cur):
+            self.printer(tree, "A 0.4")
+        self.filament(self.base, "PETG @A", ["A 0.4"])
+        self.filament(self.cur, "PETG @A", [])
+        self.assertEqual(self.generate(), {})
+
+    def test_check_passes_on_a_current_map_and_fails_on_a_stale_one(self):
+        for tree in (self.base, self.cur):
+            for p in ("A 0.4", "A 0.6"):
+                self.printer(tree, p)
+        self.filament(self.base, "PETG @A", ["A 0.4", "A 0.6"])
+        self.filament(self.cur, "PETG @A", ["A 0.6"])
+        self.filament(self.cur, "PETG @A 0.4", ["A 0.4"])
+        output = os.path.join(self.cur.dir, "map.json")
+        argv = ["legacy-compat", "--base", self.base.profiles, "--profiles", self.cur.profiles,
+                "--output", output]
+        with contextlib.redirect_stdout(io.StringIO()):
+            self.assertEqual(apt.main(argv), 0)
+            self.assertEqual(apt.main(argv + ["--check"]), 0)
+            with open(output, "w", encoding="utf-8") as f:
+                json.dump({"presets": {}}, f)
+            self.assertEqual(apt.main(argv + ["--check"]), 1)
+
+
 class TestDispatch(TreeCase):
     def test_each_command_reaches_its_own_writer(self):
         self.t.write("V", "filament/A.json", {"type": "filament", "name": "A"})

src/OrcaSlicer.cpp

@@ -99,6 +99,7 @@
 #include "libslic3r/Preset.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/GCode.hpp"
+#include "libslic3r/MeshRepair.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/ModelArrange.hpp"
 #include "libslic3r/Platform.hpp"
@@ -206,7 +207,7 @@ std::map<int, std::string> cli_errors = {
     {CLI_OBJECT_ORIENT_FAILED, "An error occurred when auto-orienting object(s)."},
     {CLI_MODIFIED_PARAMS_TO_PRINTER, "Found modified parameter in printer preset in the 3mf file, which should not be changed."},
         {CLI_FILE_VERSION_NOT_SUPPORTED, "Unsupported 3MF version. Please make sure the 3MF file was created with the official version of Bambu Studio, not a beta version."},
-    {CLI_NO_SUITABLE_OBJECTS, "One of the plate is empty or has no object fully inside it. Please check that the 3mf contains no empty plate in Orca Slicer before uploading."},
+    {CLI_NO_SUITABLE_OBJECTS, "The plate has nothing to slice: it is empty, or no object on it is both printable and fully inside the print volume."},
     {CLI_VALIDATE_ERROR, "There are some incorrect slicing parameters in the 3mf. Please verify the slicing of all plates in Orca Slicer before uploading."},
     {CLI_OBJECTS_PARTLY_INSIDE, "Some objects are located over the boundary of the heated bed."},
     {CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED, "Failed creating directory when exporting cache data."},
@@ -1463,7 +1464,7 @@ int CLI::run(int argc, char **argv)
     //int arrange_option;
     int plate_to_slice = 0, filament_count = 0, duplicate_count = 0, real_duplicate_count = 0, current_extruder_count = 1, new_extruder_count = 1, current_printer_variant_count = 1, current_print_variant_count = 1, new_printer_variant_count = 1;
     bool first_file = true, is_bbl_3mf = false, need_arrange = true, has_thumbnails = false, up_config_to_date = false, normative_check = true, duplicate_single_object = false, use_first_fila_as_default = false, minimum_save = false, enable_timelapse = false;
-    bool allow_rotations = true, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
+    bool allow_rotations = false, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
     Semver file_version;
     std::map<size_t, bool> orients_requirement;
     std::vector<Preset*> project_presets;
@@ -5130,9 +5131,19 @@ int CLI::run(int argc, char **argv)
                 }
             }
         } else if (opt_key == "repair") {
-            // Models are repaired by default.
-            //for (auto &model : m_models)
-            //    model.repair();
+            if (m_config.opt_bool(opt_key))
+                for (Model &model : m_models)
+                    for (ModelObject *object : model.objects) {
+                        for (ModelVolume *volume : object->volumes) {
+                            MeshRepairStats stats;
+                            std::string     error;
+                            if (!volume->repair(true, &stats, &error))
+                                BOOST_LOG_TRIVIAL(warning) << "repair of " << object->name << " / " << volume->name << " failed: " << error;
+                            else if (stats.modified)
+                                BOOST_LOG_TRIVIAL(info) << "repaired " << object->name << " / " << volume->name;
+                        }
+                        object->invalidate_bounding_box();
+                    }
         } else {
             boost::nowide::cerr << "error: option not implemented yet: " << opt_key << std::endl;
             record_exit_reson(outfile_dir, CLI_UNSUPPORTED_OPERATION, 0, cli_errors[CLI_UNSUPPORTED_OPERATION], sliced_info);
@@ -5142,6 +5153,7 @@ int CLI::run(int argc, char **argv)
 
     BOOST_LOG_TRIVIAL(info) << "finished model pre-process commands\n";
     bool oriented_or_arranged = false;
+    bool arranged_without_rotations = false;
     //BBS: add orient and arrange logic here
     for (auto& model : m_models)
     {
@@ -5409,6 +5421,7 @@ int CLI::run(int argc, char **argv)
                 BOOST_LOG_TRIVIAL(info) << boost::format("start plate %1%'s arranging...") % (i + 1);
                 arrangement::arrange(selected, unselected, beds, arrange_cfg);
                 //arrangement::arrange(unprintable, {}, beds, arrange_cfg);
+                arranged_without_rotations |= !arrange_cfg.allow_rotations;
                 BOOST_LOG_TRIVIAL(info) << boost::format("finished plate %1%'s arranging") % (i + 1);
 
                 //step-4: postprocess the bed index and result
@@ -5881,6 +5894,7 @@ int CLI::run(int argc, char **argv)
                 BOOST_LOG_TRIVIAL(info) << boost::format("start %1% th arranging...")%arrange_count;
                 arrangement::arrange(selected, unselected, beds, arrange_cfg);
                 arrangement::arrange(unprintable, {}, beds, arrange_cfg);
+                arranged_without_rotations |= !arrange_cfg.allow_rotations;
                 BOOST_LOG_TRIVIAL(info) << boost::format("finished %1% th arranging...")%arrange_count;
 
                 //Step-4:postprocess by partplate list&&apply the result
@@ -6425,7 +6439,15 @@ int CLI::run(int argc, char **argv)
 
                         if (count == 0) {
                             BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Nothing to be sliced, Either the print is empty or no object is fully inside the print volume before apply." << std::endl;
-                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, cli_errors[CLI_NO_SUITABLE_OBJECTS], sliced_info);
+                            std::string no_objects_reason = cli_errors[CLI_NO_SUITABLE_OBJECTS];
+                            if (arranged_without_rotations) {
+                                //ORCA: result.json is only written on Linux, so also print the reason to stderr.
+                                no_objects_reason = "No object is fully inside the print volume. Arrange ran without rotations."
+                                                    " If an object only fits the bed when rotated, pass --allow-rotations."
+                                                    " Otherwise the plate is empty or an object is larger than the printable area or height.";
+                                boost::nowide::cerr << "plate " << index+1 << ": " << no_objects_reason << std::endl;
+                            }
+                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, no_objects_reason, sliced_info);
                             flush_and_exit(CLI_NO_SUITABLE_OBJECTS);
                         }
                         else if ((plate_to_slice != 0) || pre_check) {

src/libslic3r/Arrange.cpp

@@ -300,12 +300,10 @@ template<class PConf>
 void fill_config(PConf& pcfg, const ArrangeParams &params) {
 
         if (params.is_belt) {
-            // Pack from the end of the belt that prints first, and keep the pile on the
-            // bed when it is larger than the room around that end.
+            // Pack from the end of the belt that prints first.
             pcfg.starting_point = !params.belt_reversed    ? PConf::Alignment::BOTTOM_LEFT :
                                   params.belt_axis == 1    ? PConf::Alignment::TOP_LEFT :
                                                              PConf::Alignment::BOTTOM_RIGHT;
-            pcfg.clamp_to_bin = true;
         }
         else if (params.is_seq_print) {
             // Start placing the items from the center of the print bed

src/libslic3r/BeltPurge.cpp

@@ -166,7 +166,7 @@ void Print::_plan_belt_purge()
     m_wipe_tower_data.tool_ordering.sort_and_build_data(*this, (unsigned int) -1, false);
 
     if (m_wipe_tower_data.tool_ordering.empty() || m_wipe_tower_data.tool_ordering.last_extruder() == unsigned(-1))
-        throw Slic3r::SlicingError("The print is empty. The model is not printable with current print settings.");
+        throw Slic3r::SlicingError(_u8L("The print is empty. The model is not printable with current print settings."));
 
     // Is there any filament change at all? Not ToolOrdering::has_wipe_tower(): that reads the
     // FIRST layer's flag, and on a belt the first layer may be a brim apron band, which carries

src/libslic3r/CAD/CadDocument.cpp

@@ -1807,7 +1807,8 @@ std::vector<std::pair<std::string, SketchPlane>> CadDocument::resolve_datum_plan
 
         }
 
-        out.emplace_back(base_missing ? f.name + " (base plane missing)" : f.name, result);
+        // TRN Datum plane entry in the reference plane list. %1% is the plane name.
+        out.emplace_back(base_missing ? format(_u8L("%1% (base plane missing)"), f.name) : f.name, result);
     }
     return out;
 }
@@ -2090,8 +2091,8 @@ static int pick_body(int ref, int nb)
 {
     if (ref == -1) return nb - 1;
     if (ref < 0 || ref >= nb)
-        throw std::runtime_error("a feature works on body " + std::to_string(ref + 1)
-                                 + ", which does not exist at that point in the history");
+        throw std::runtime_error(format(_u8L("a feature works on body %1%, which does not exist at that point in the history"),
+                                        ref + 1));
     return ref;
 }
 
@@ -2154,11 +2155,11 @@ static void settle_body_refs(CadFeature& f, const std::vector<CadBody>& v, bool
         CadFeature::BodyId& id = f.body_ref_ids[k++];
         if (kind != running) return;
         if (ref == kBodyGone)
-            throw std::runtime_error("\"" + f.name + "\" works on a body made by a feature that was deleted or hidden");
+            throw std::runtime_error(format(_u8L("\"%1%\" works on a body made by a feature that was deleted or hidden"), f.name));
         if (f.body_refs_pending && id.src >= 0) {
             const int i = find_body(v, id);
             if (i < 0)
-                throw std::runtime_error("\"" + f.name + "\" works on a body that does not exist at that point in the history");
+                throw std::runtime_error(format(_u8L("\"%1%\" works on a body that does not exist at that point in the history"), f.name));
             ref = i;
         }
         id = ref >= 0 ? body_id_of(v, ref) : CadFeature::BodyId{};
@@ -2384,7 +2385,8 @@ bool CadDocument::move_feature(int index, int delta)
         check(f.sketch_ref); check(f.sweep_path_ref); check(f.pattern_curve_sketch); check(f.rib_sketch_ref);
         for (int& r : f.loft_profile_refs) check(r);
         if (!bad.empty()) {
-            error = "\"" + f.name + "\" uses \"" + bad + "\", so it cannot come before it";
+            // TRN Feature reorder error. %1% is the moved feature, %2% the feature it depends on.
+            error = format(_u8L("\"%1%\" uses \"%2%\", so it cannot come before it"), f.name, bad);
             features.swap(snapshot);
             return false;
         }
@@ -2463,7 +2465,8 @@ static std::string open_loop_message(const CadFeature& sketch,
         for (size_t i = 0; i < shown; ++i)
             msg += "\n  " + format(_u8L("Open at (%.3f, %.3f)"), open[i].x(), open[i].y());
         if (open.size() > shown)
-            msg += "\n  " + format(_u8L("...and %1% more open end(s)"), open.size() - shown);
+            // TRN Follows a list of open sketch ends. %1% is how many more were not listed.
+            msg += "\n  " + format(_u8L("Open ends not shown: %1%"), open.size() - shown);
     }
     return msg;
 }
@@ -2475,11 +2478,11 @@ static gp_Ax1 revolve_axis_of(const CadFeature& f, const CadFeature& sk)
     if (f.revolve_axis_entity >= 0) {
         if (f.revolve_axis_entity >= int(sk.entities.size())
             || sk.entities[f.revolve_axis_entity].type != SketchEntity::Type::Line)
-            throw std::runtime_error("revolve: the axis line is no longer in the sketch — pick the axis again");
+            throw std::runtime_error(_u8L("revolve: the axis line is no longer in the sketch — pick the axis again"));
         const SketchEntity& e = sk.entities[f.revolve_axis_entity];
         const Vec3d a = sk.plane.to_world(e.p0), b = sk.plane.to_world(e.p1);
         if ((b - a).norm() < 1e-9)
-            throw std::runtime_error("revolve: the axis line has no length");
+            throw std::runtime_error(_u8L("revolve: the axis line has no length"));
         const Vec3d d = (b - a).normalized();
         return gp_Ax1(gp_Pnt(a.x(), a.y(), a.z()), gp_Dir(d.x(), d.y(), d.z()));
     }
@@ -3024,17 +3027,17 @@ void CadDocument::apply_feature(TopoDS_Shape& result, bool& have_body,
             // ISO external thread depth is ~0.61*P, so allow up to 0.7*P (0.49 wrongly rejected
             // every real thread -> nothing rendered). Still bound it well under a full pitch.
             // R >= 0.5 (not >): M1, the smallest size in the standards table, is exactly 0.5.
-            const char* why = R < 0.5                   ? "thread: the diameter must be at least 1 mm"
-                            : P <= 0.1                  ? "thread: the pitch must be more than 0.1 mm"
-                            : (D <= 1e-3 || D >= 0.7 * P) ? "thread: the depth must be between 0 and 0.7 x the pitch"
-                            : D >= 0.45 * R             ? "thread: the depth is too large for this diameter"
-                            : H <= 0.5 * P              ? "thread: the length must be more than half a pitch"
-                            : H / P >= 400.0            ? "thread: too many turns (length / pitch must stay under 400)"
+            const char* why = R < 0.5                   ? L("thread: the diameter must be at least 1 mm")
+                            : P <= 0.1                  ? L("thread: the pitch must be more than 0.1 mm")
+                            : (D <= 1e-3 || D >= 0.7 * P) ? L("thread: the depth must be between 0 and 0.7 x the pitch")
+                            : D >= 0.45 * R             ? L("thread: the depth is too large for this diameter")
+                            : H <= 0.5 * P              ? L("thread: the length must be more than half a pitch")
+                            : H / P >= 400.0            ? L("thread: too many turns (length / pitch must stay under 400)")
                                                         : nullptr;
             // Legacy recipes keep their old outcome (the body left as it was) so a project that
             // opened before still opens; every thread made now reports the reason instead.
             if (why != nullptr) {
-                if (f.thread_major_nominal) throw std::runtime_error(why);
+                if (f.thread_major_nominal) throw std::runtime_error(Slic3r::I18N::translate(why));
                 break;
             }
         }
@@ -3078,7 +3081,7 @@ void CadDocument::apply_feature(TopoDS_Shape& result, bool& have_body,
                 // Tapped hole: bore to the minor radius R - D, then cut the groove out to the
                 // major radius R. The bore sits 10 um inside the minor radius so that, threading
                 // an existing tap-drill hole, it does not coincide with that hole's wall.
-                if (!have_body) throw std::runtime_error("internal thread needs a body");
+                if (!have_body) throw std::runtime_error(_u8L("internal thread needs a body"));
                 const double bore_r = R - D - 0.01;
                 cut_from(result, BRepPrimAPI_MakeCylinder(ax2, bore_r, f.thread_height).Shape());
                 TopoDS_Shape groove;
@@ -3241,12 +3244,12 @@ void CadDocument::apply_boolean(std::vector<CadBody>& bodies, const CadFeature&
     const int tool = f.bool_tool_body == -1 ? -1 : pick_body(f.bool_tool_body, nb);
     // Same rule as Cut, Mirror and Transform: an operation that cannot run says why, rather
     // than leaving the bodies as they were and reporting success.
-    if (tgt < 0)     throw std::runtime_error("boolean: no target body");
-    if (tool < 0)    throw std::runtime_error("boolean: no tool body — pick a second body");
-    if (tgt == tool) throw std::runtime_error("boolean: the target and the tool are the same body");
+    if (tgt < 0)     throw std::runtime_error(_u8L("boolean: no target body"));
+    if (tool < 0)    throw std::runtime_error(_u8L("boolean: no tool body — pick a second body"));
+    if (tgt == tool) throw std::runtime_error(_u8L("boolean: the target and the tool are the same body"));
     const TopoDS_Shape A = bodies[tgt].shape;          // target survives
     const TopoDS_Shape B = bodies[tool].shape;         // tool, consumed unless kept
-    if (A.IsNull() || B.IsNull()) throw std::runtime_error("boolean: a body has no geometry");
+    if (A.IsNull() || B.IsNull()) throw std::runtime_error(_u8L("boolean: a body has no geometry"));
 
     NCollection_List<TopoDS_Shape> args, tools;
     args.Append(A);
@@ -3554,7 +3557,7 @@ void CadDocument::apply_thicken_surface(std::vector<CadBody>& bodies, const CadF
         if (props.Mass() < 0.0) solid.Reverse();
     }
 
-    bodies.push_back({solid, f.name.empty() ? std::string("ThickenSurface") : f.name});
+    bodies.push_back({solid, f.name.empty() ? _u8L("Thicken Surface") : f.name});
 }
 
 void CadDocument::apply_surface_offset(std::vector<CadBody>& bodies, const CadFeature& f) const
@@ -3573,7 +3576,7 @@ void CadDocument::apply_surface_offset(std::vector<CadBody>& bodies, const CadFe
     TopoDS_Shape off_shape = mos.Shape();
     if (off_shape.IsNull()) throw std::runtime_error(_u8L("surface-offset: produced no geometry"));
 
-    bodies.push_back({off_shape, f.name.empty() ? std::string("SurfaceOffset") : f.name});
+    bodies.push_back({off_shape, f.name.empty() ? _u8L("Surface Offset") : f.name});
 }
 
 // Project `edges` of a shape onto `plane`, appending the resulting 2D entities to `out`.

src/libslic3r/CAD/GeometryEngine.cpp

@@ -325,10 +325,10 @@ std::vector<TopoDS_Edge> GeometryEngine::collect_edges(const TopoDS_Shape& solid
 // handing the solid back unchanged, which recompute then reported as a success.
 TopoDS_Shape GeometryEngine::apply_fillet(const TopoDS_Shape& solid, double radius, FaceGroup faces)
 {
-    if (radius <= 0.001) throw std::runtime_error("the fillet radius must be greater than 0");
+    if (radius <= 0.001) throw std::runtime_error(_u8L("the fillet radius must be greater than 0"));
 
     std::vector<TopoDS_Edge> edges = collect_edges(solid, faces);
-    if (edges.empty()) throw std::runtime_error("no edges to fillet in that group");
+    if (edges.empty()) throw std::runtime_error(_u8L("no edges to fillet in that group"));
 
     BRepFilletAPI_MakeFillet fillet(solid);
     for (const auto& edge : edges)
@@ -344,10 +344,10 @@ TopoDS_Shape GeometryEngine::apply_fillet(const TopoDS_Shape& solid, double radi
 
 TopoDS_Shape GeometryEngine::apply_chamfer(const TopoDS_Shape& solid, double distance, FaceGroup faces)
 {
-    if (distance <= 0.001) throw std::runtime_error("the chamfer distance must be greater than 0");
+    if (distance <= 0.001) throw std::runtime_error(_u8L("the chamfer distance must be greater than 0"));
 
     std::vector<TopoDS_Edge> edges = collect_edges(solid, faces);
-    if (edges.empty()) throw std::runtime_error("no edges to chamfer in that group");
+    if (edges.empty()) throw std::runtime_error(_u8L("no edges to chamfer in that group"));
 
     BRepFilletAPI_MakeChamfer chamfer(solid);
     for (const auto& edge : edges)
@@ -370,7 +370,7 @@ TopoDS_Shape GeometryEngine::apply_chamfer(const TopoDS_Shape& solid, double dis
 
 TopoDS_Shape GeometryEngine::apply_fillet(const TopoDS_Shape& solid, double radius, const std::vector<int>& edge_ids)
 {
-    if (radius <= 0.001) throw std::runtime_error("the fillet radius must be greater than 0");
+    if (radius <= 0.001) throw std::runtime_error(_u8L("the fillet radius must be greater than 0"));
     if (edge_ids.empty()) throw std::runtime_error("apply_fillet: no edge picked");
 
     BRepFilletAPI_MakeFillet mk(solid);
@@ -387,7 +387,7 @@ TopoDS_Shape GeometryEngine::apply_fillet(const TopoDS_Shape& solid, double radi
 
 TopoDS_Shape GeometryEngine::apply_chamfer(const TopoDS_Shape& solid, double distance, const std::vector<int>& edge_ids)
 {
-    if (distance <= 0.001) throw std::runtime_error("the chamfer distance must be greater than 0");
+    if (distance <= 0.001) throw std::runtime_error(_u8L("the chamfer distance must be greater than 0"));
     if (edge_ids.empty()) throw std::runtime_error("apply_chamfer: no edge picked");
 
     BRepFilletAPI_MakeChamfer mk(solid);

src/libslic3r/CAD/SketchEngine.cpp

@@ -379,7 +379,7 @@ TopoDS_Shape SketchEngine::make_revolve(const TopoDS_Wire& wire, const gp_Ax1& a
             }
         }
         if (pos && neg)
-            throw std::runtime_error("the profile crosses the revolve axis — it must lie on one side of it");
+            throw std::runtime_error(_u8L("the profile crosses the revolve axis — it must lie on one side of it"));
     }
     gp_Ax1 axis = axis_in;
     double angle_rad = angle_deg * M_PI / 180.0;
@@ -390,7 +390,7 @@ TopoDS_Shape SketchEngine::make_revolve(const TopoDS_Wire& wire, const gp_Ax1& a
     if (!rev.IsDone())
         throw std::runtime_error(_u8L("Failed to revolve"));
     if (!BRepCheck_Analyzer(rev.Shape()).IsValid())
-        throw std::runtime_error("the profile crosses the revolve axis — it must lie on one side of it");
+        throw std::runtime_error(_u8L("the profile crosses the revolve axis — it must lie on one side of it"));
     return rev.Shape();
 }
 
@@ -923,7 +923,7 @@ static TopoDS_Face checked_profile_face(const TopoDS_Face& f)
 {
     BRepCheck_Analyzer an(f);
     if (!an.IsValid())
-        throw std::runtime_error("the profile crosses or folds back on itself, so it does not bound one region");
+        throw std::runtime_error(_u8L("the profile crosses or folds back on itself, so it does not bound one region"));
     return f;
 }
 

src/libslic3r/CMakeLists.txt

@@ -625,6 +625,7 @@ add_library(libslic3r_cgal STATIC
     CutSurface.hpp CutSurface.cpp
     IntersectionPoints.hpp IntersectionPoints.cpp
     MeshBoolean.hpp MeshBoolean.cpp
+    MeshRepair.hpp MeshRepair.cpp
     TryCatchSignal.hpp TryCatchSignal.cpp
     Triangulation.hpp Triangulation.cpp
 )
@@ -652,7 +653,9 @@ if (IS_CLANG_CL)
     target_compile_options(libslic3r_cgal PRIVATE -Wno-overriding-option)
 endif ()
 
-target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs)
+# Lets CGAL algorithms given CGAL::Parallel_if_available_tag run on TBB.
+target_compile_definitions(libslic3r_cgal PRIVATE CGAL_LINKED_WITH_TBB)
+target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs TBB::tbb)
 
 if (MSVC AND "${CMAKE_SIZEOF_VOID_P}" STREQUAL "4") # 32 bit MSVC workaround
     target_compile_definitions(libslic3r_cgal PRIVATE CGAL_DO_NOT_USE_MPZF)

src/libslic3r/Config.cpp

@@ -2,6 +2,7 @@
 #include "Exception.hpp"
 #include "Point.hpp"
 #include "format.hpp"
+#include "I18N.hpp"
 #include "Utils.hpp"
 #include "LocalesUtils.hpp"
 #include "Preset.hpp"
@@ -613,7 +614,7 @@ bool ConfigBase::set_deserialize_nothrow(const t_config_option_key &opt_key_src,
 void ConfigBase::set_deserialize(const t_config_option_key &opt_key_src, const std::string &value_src, ConfigSubstitutionContext& substitutions_ctxt, bool append)
 {
 	if (! this->set_deserialize_nothrow(opt_key_src, value_src, substitutions_ctxt, append))
-		throw BadOptionValueException(format("Invalid value provided for parameter %1%: %2%", opt_key_src,  value_src));
+		throw BadOptionValueException(format(_u8L("Invalid value provided for parameter %1%: %2%"), opt_key_src,  value_src));
 }
 
 void ConfigBase::set_deserialize(std::initializer_list<SetDeserializeItem> items, ConfigSubstitutionContext& substitutions_ctxt)
@@ -1173,7 +1174,7 @@ ConfigSubstitutions ConfigBase::load_from_ini(const std::string &file, ForwardCo
         boost::property_tree::read_ini(ifs, tree);
         return this->load(tree, compatibility_rule);
     } catch (const ConfigurationError &e) {
-        throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file, e.what()));
+        throw ConfigurationError(format(_u8L("Failed loading configuration file \"%1%\": %2%"), file, e.what()));
     }
 }
 
@@ -1430,9 +1431,8 @@ ConfigSubstitutions ConfigBase::load_from_gcode_file(const std::string &file, Fo
             }
         }
         if (!header_found) {
-            std::string error_message = "Not a gcode file generated by ";
-            error_message += SLIC3R_APP_FULL_NAME;
-            error_message += ".";
+            // TRN %1% is the application name.
+            std::string error_message = format(_u8L("Not a gcode file generated by %1%."), SLIC3R_APP_FULL_NAME);
             BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << error_message;
             throw Slic3r::RuntimeError(error_message.c_str());
         }
@@ -1458,7 +1458,8 @@ ConfigSubstitutions ConfigBase::load_from_gcode_file(const std::string &file, Fo
             }
         if (!begin_found) {
             //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Configuration block closing tag \"; CONFIG_BLOCK_START\" not found when reading %1%", file);
-            throw Slic3r::RuntimeError(format("Config tag \"; CONFIG_BLOCK_START\" not found"));
+            // TRN %1% is a tag in the G-code file that must not be translated.
+            throw Slic3r::RuntimeError(format(_u8L("Config tag \"%1%\" not found"), "; CONFIG_BLOCK_START"));
         }
         std::string key, value;
         while (std::getline(ifs, line)) {
@@ -1483,7 +1484,7 @@ ConfigSubstitutions ConfigBase::load_from_gcode_file(const std::string &file, Fo
         }
         if (!end_found) {
             //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Configuration block opening tag \"; CONFIG_BLOCK_END\" not found when reading %1%", file);
-            throw Slic3r::RuntimeError(format("Config tag \"; CONFIG_BLOCK_END\" not found"));
+            throw Slic3r::RuntimeError(format(_u8L("Config tag \"%1%\" not found"), "; CONFIG_BLOCK_END"));
         }
     }
     else
@@ -1503,7 +1504,7 @@ ConfigSubstitutions ConfigBase::load_from_gcode_file(const std::string &file, Fo
 
     if (key_value_pairs < 80) {
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Suspiciously low number of configuration values extracted from %1%: %2%", file, key_value_pairs);
-        throw Slic3r::RuntimeError(format("Suspiciously low number of configuration values extracted from %1%: %2%", file, key_value_pairs));
+        throw Slic3r::RuntimeError(format(_u8L("Suspiciously low number of configuration values extracted from %1%: %2%"), file, key_value_pairs));
     }
 
     // Do legacy conversion on a completely loaded dictionary.

src/libslic3r/Extruder.cpp

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cmath>
 #include "Config.hpp"
+#include "I18N.hpp"
 
 namespace Slic3r {
 
@@ -124,9 +125,9 @@ double Extruder::unretract()
 void Extruder::set_retracted(double retracted, double restart_extra)
 {
     if (retracted < - EPSILON)
-        throw Slic3r::RuntimeError("Custom G-code reports negative z_retracted.");
+        throw Slic3r::RuntimeError(_u8L("Custom G-code reports negative z_retracted."));
     if (restart_extra < - EPSILON)
-        throw Slic3r::RuntimeError("Custom G-code reports negative z_restart_extra.");
+        throw Slic3r::RuntimeError(_u8L("Custom G-code reports negative z_restart_extra."));
 
     if (retracted > EPSILON) {
         m_retracted     = retracted;

src/libslic3r/FilamentMixer.cpp

@@ -19,6 +19,8 @@
 
 #include "ColorDecomposeRecipe.hpp"
 #include "Config.hpp"
+#include "I18N.hpp"
+#include "format.hpp"
 #include "FilamentMixerModel.hpp"
 #include "LocalesUtils.hpp"
 
@@ -633,36 +635,36 @@ bool try_parse_mixed_components_strict(const std::string &str,
 {
     components.clear();
     if (str.empty()) {
-        err = "empty component list";
+        err = _u8L("empty component list");
         return false;
     }
     std::istringstream ss(str);
     std::string token;
     while (std::getline(ss, token, ',')) {
         if (token.empty()) {
-            err = "empty component index";
+            err = _u8L("empty component index");
             return false;
         }
         try {
             const long val = std::stol(token);
             if (val < 1) {
-                err = "component index must be >= 1 (got " + token + ")";
+                err = format(_u8L("component index must be >= 1 (got %1%)"), token);
                 return false;
             }
             components.push_back(static_cast<unsigned int>(val));
         } catch (...) {
-            err = "invalid component index \"" + token + "\"";
+            err = format(_u8L("invalid component index \"%1%\""), token);
             return false;
         }
     }
     if (components.size() < 2) {
-        err = "at least 2 components required (got " + std::to_string(components.size()) + ")";
+        err = format(_u8L("at least 2 components required (got %1%)"), components.size());
         return false;
     }
     std::set<unsigned int> seen;
     for (unsigned int c : components) {
         if (!seen.insert(c).second) {
-            err = "duplicate component index " + std::to_string(c);
+            err = format(_u8L("duplicate component index %1%"), c);
             return false;
         }
     }
@@ -682,24 +684,24 @@ bool try_parse_mixed_ratios_strict(const std::string &str,
     std::string token;
     while (std::getline(ss, token, ',')) {
         if (token.empty()) {
-            err = "empty ratio value";
+            err = _u8L("empty ratio value");
             return false;
         }
         try {
             const double val = std::stod(token);
             if (!(val > 0.0)) {
-                err = "ratio must be positive (got " + token + ")";
+                err = format(_u8L("ratio must be positive (got %1%)"), token);
                 return false;
             }
             ratios.push_back(val);
         } catch (...) {
-            err = "invalid ratio \"" + token + "\"";
+            err = format(_u8L("invalid ratio \"%1%\""), token);
             return false;
         }
     }
     if (ratios.size() != n_components) {
-        err = "expected " + std::to_string(n_components) + " ratio(s), got "
-            + std::to_string(ratios.size());
+        // TRN %1% is the expected number of ratios, %2% the number found.
+        err = format(_u8L("the ratio count must match the component count: expected %1%, got %2%"), n_components, ratios.size());
         return false;
     }
     return true;
@@ -713,11 +715,11 @@ bool validate_gradient_range_strict(const std::string &str, std::string &err)
     CNumericLocalesSetter c_locale_setter;
     float v0 = 0.f, v1 = 0.f;
     if (std::sscanf(str.c_str(), "%f,%f", &v0, &v1) != 2) {
-        err = "expected two comma-separated floats, e.g. \"0.10,0.90\"";
+        err = _u8L("expected two comma-separated floats, e.g. \"0.10,0.90\"");
         return false;
     }
     if (!(v0 > 0.f && v0 < 1.f && v1 > 0.f && v1 < 1.f)) {
-        err = "start and end ratios must be in (0, 1)";
+        err = _u8L("start and end ratios must be in (0, 1)");
         return false;
     }
     return true;
@@ -771,8 +773,7 @@ static void check_mixed_array_size_required(std::map<std::string, std::string> &
 {
     if (actual_size != expected_size) {
         append_error(errors, opt_key,
-            "array size " + std::to_string(actual_size)
-            + " does not match filament slot count " + std::to_string(expected_size));
+            format(_u8L("array size %1% does not match filament slot count %2%"), actual_size, expected_size));
     }
 }
 
@@ -789,7 +790,7 @@ std::map<std::string, std::string> validate_mixed_filament_params(
     if (has_mixed_sub_params_specified(comp_strs, ratio_strs, gradient_flags)
         && !has_any_mixed_filament(is_mixed)) {
         append_error(errors, "filament_is_mixed",
-            "must be set when mixed filament parameters are specified");
+            _u8L("must be set when mixed filament parameters are specified"));
         return errors;
     }
 
@@ -822,34 +823,33 @@ std::map<std::string, std::string> validate_mixed_filament_params(
         if (!is_mixed[i])
             continue;
 
-        const std::string slot = "slot " + std::to_string(i + 1);
+        const size_t      slot = i + 1;
         const std::string comp_str = i < comp_strs.size() ? comp_strs[i] : "";
 
         std::vector<unsigned int> components;
         std::string comp_err;
         if (!try_parse_mixed_components_strict(comp_str, components, comp_err)) {
-            append_error(errors, "filament_mixed_components", slot + ": " + comp_err);
+            // TRN Mixed filament validation error. %1% is the filament slot number, %2% the reason.
+            append_error(errors, "filament_mixed_components", format(_u8L("slot %1%: %2%"), slot, comp_err));
             continue;
         }
 
         for (unsigned int c : components) {
             if (c > num_physical) {
                 append_error(errors, "filament_mixed_components",
-                       slot + ": component " + std::to_string(c)
-                       + " out of range (max physical filament index is "
-                       + std::to_string(num_physical) + ")");
+                       format(_u8L("slot %1%: component %2% out of range (max physical filament index is %3%)"),
+                              slot, c, num_physical));
                 break;
             }
             if (c == i + 1) {
                 append_error(errors, "filament_mixed_components",
-                       slot + ": cannot reference itself as a component");
+                       format(_u8L("slot %1%: cannot reference itself as a component"), slot));
                 break;
             }
             const size_t idx0 = static_cast<size_t>(c - 1);
             if (idx0 < is_mixed.size() && is_mixed[idx0]) {
                 append_error(errors, "filament_mixed_components",
-                       slot + ": component " + std::to_string(c)
-                       + " references a mixed filament slot");
+                       format(_u8L("slot %1%: component %2% references a mixed filament slot"), slot, c));
                 break;
             }
         }
@@ -857,27 +857,27 @@ std::map<std::string, std::string> validate_mixed_filament_params(
         std::string ratio_err;
         const std::string ratio_str = i < ratio_strs.size() ? ratio_strs[i] : "";
         if (!try_parse_mixed_ratios_strict(ratio_str, components.size(), ratio_err))
-            append_error(errors, "filament_mixed_sublayer_ratios", slot + ": " + ratio_err);
+            append_error(errors, "filament_mixed_sublayer_ratios", format(_u8L("slot %1%: %2%"), slot, ratio_err));
 
         const bool gradient_on = i < gradient_flags.size() && gradient_flags[i];
         if (gradient_on) {
             if (components.size() != 2) {
                 append_error(errors, "filament_mixed_gradient",
-                       slot + ": gradient requires exactly 2 components");
+                       format(_u8L("slot %1%: gradient requires exactly 2 components"), slot));
             }
 
             if (gradient_specified) {
                 std::string range_err;
                 const std::string range_str = i < gradient_range_strs.size() ? gradient_range_strs[i] : "";
                 if (!validate_gradient_range_strict(range_str, range_err))
-                    append_error(errors, "filament_mixed_gradient_range", slot + ": " + range_err);
+                    append_error(errors, "filament_mixed_gradient_range", format(_u8L("slot %1%: %2%"), slot, range_err));
             }
 
             if (curve_specified) {
                 const std::string curve_str = i < gradient_curve_strs.size() ? gradient_curve_strs[i] : "";
                 if (!curve_str.empty() && parse_gradient_curve(curve_str).empty())
                     append_error(errors, "filament_mixed_gradient_curve",
-                           slot + ": invalid curve (need at least 2 valid control points)");
+                           format(_u8L("slot %1%: invalid curve (need at least 2 valid control points)"), slot));
             }
         }
     }

src/libslic3r/Flow.cpp

@@ -10,6 +10,7 @@
 #include <string>
 #include <math.h>
 #include "PrintConfig.hpp"
+#include "I18N.hpp"
 
 // Mark string for localization and translate.
 #define L(s) Slic3r::I18N::translate(s)
@@ -17,10 +18,10 @@
 namespace Slic3r {
 
 FlowErrorNegativeSpacing::FlowErrorNegativeSpacing() : 
-	FlowError("Flow::spacing() produced negative spacing. Did you set some extrusion width too small?") {}
+	FlowError(L("Flow::spacing() produced negative spacing. Did you set some extrusion width too small?")) {}
 
 FlowErrorNegativeFlow::FlowErrorNegativeFlow() :
-    FlowError("Flow::mm3_per_mm() produced negative flow. Did you set some extrusion width too small?") {}
+    FlowError(L("Flow::mm3_per_mm() produced negative flow. Did you set some extrusion width too small?")) {}
 
 // This static method returns a sane extrusion width default.
 float Flow::auto_extrusion_width(FlowRole role, float nozzle_diameter)
@@ -66,7 +67,8 @@ static inline FlowRole opt_key_to_flow_role(const std::string &opt_key)
 
 static inline void throw_on_missing_variable(const std::string &opt_key, const char *dependent_opt_key) 
 {
-	throw FlowErrorMissingVariable((boost::format("Failed to calculate line width of %1%. Cannot get value of \u201c%2%\u201d.") % opt_key % dependent_opt_key).str());
+	// TRN %1% and %2% are names of settings.
+	throw FlowErrorMissingVariable((boost::format(L("Failed to calculate line width of %1%. Cannot get value of \"%2%\".")) % opt_key % dependent_opt_key).str());
 }
 
 // Used to provide hints to the user on default extrusion width values, and to provide reasonable values to the PlaceholderParser.
@@ -162,7 +164,7 @@ Flow Flow::with_spacing(float new_spacing) const
         assert(m_width >= m_height);
         out.m_width += new_spacing - m_spacing;
         if (out.m_width < out.m_height)
-            throw Slic3r::InvalidArgument("Invalid spacing supplied to Flow::with_spacing(), check your layer height and extrusion width.");
+            throw Slic3r::InvalidArgument(L("Invalid spacing supplied to Flow::with_spacing(), check your layer height and extrusion width."));
     }
     out.m_spacing = new_spacing;
     return out;

src/libslic3r/Format/STEP.cpp

@@ -4,6 +4,7 @@
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Thread.hpp"
+#include "libslic3r/I18N.hpp"
 
 #include "STEP.hpp"
 
@@ -68,7 +69,7 @@ bool StepPreProcessor::preprocess(const char* path, std::string &output_path)
 {
     boost::nowide::ifstream infile(path);
     if (!infile.good()) {
-        throw Slic3r::RuntimeError(std::string("Load step file failed.\nCannot open file for reading.\n"));
+        throw Slic3r::RuntimeError(_u8L("Load step file failed.\nCannot open file for reading.\n"));
         return false;
     }
 
@@ -116,7 +117,7 @@ bool StepPreProcessor::isUtf8File(const char* path)
 {
     boost::nowide::ifstream infile(path);
     if (!infile.good()) {
-        throw Slic3r::RuntimeError(std::string("Load step file failed.\nCannot open file for reading.\n"));
+        throw Slic3r::RuntimeError(_u8L("Load step file failed.\nCannot open file for reading.\n"));
         return false;
     }
 
@@ -236,19 +237,29 @@ static void getNamedSolids(const TopLoc_Location& location,
         int                      i = 0;
         switch (shape_type) {
         case TopAbs_COMPOUND:
-            if (!isSplitCompound) {
-                namedSolids.emplace_back(TopoDS::Compound(transform.Shape()), fullName);
-                break;
-            }
         case TopAbs_COMPSOLID:
             if (!isSplitCompound) {
-                namedSolids.emplace_back(TopoDS::CompSolid(transform.Shape()), fullName);
+                namedSolids.emplace_back(transform.Shape(), fullName);
             } else {
                 for (explorer.Init(transform.Shape(), TopAbs_SOLID); explorer.More(); explorer.Next()) {
                     i++;
                     const TopoDS_Shape& currentShape = explorer.Current();
                     namedSolids.emplace_back(TopoDS::Solid(currentShape), fullName + "-SOLID-" + std::to_string(i));
                 }
+                // Surface models have no solids: each shell outside a solid is a part, and loose faces stay together.
+                i = 0;
+                for (explorer.Init(transform.Shape(), TopAbs_SHELL, TopAbs_SOLID); explorer.More(); explorer.Next())
+                    namedSolids.emplace_back(explorer.Current(), fullName + "-SHELL-" + std::to_string(++i));
+                TopoDS_Compound loose_faces;
+                TopoDS_Builder  builder;
+                builder.MakeCompound(loose_faces);
+                bool has_loose_faces = false;
+                for (explorer.Init(transform.Shape(), TopAbs_FACE, TopAbs_SHELL); explorer.More(); explorer.Next()) {
+                    builder.Add(loose_faces, explorer.Current());
+                    has_loose_faces = true;
+                }
+                if (has_loose_faces)
+                    namedSolids.emplace_back(loose_faces, fullName);
             }
             break;
         case TopAbs_SOLID:

src/libslic3r/Format/bbs_3mf.cpp

@@ -22,6 +22,7 @@
 #include "libslic3r/BrimEarsPoint.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
 #include "libslic3r_version.h"
 
 #include "bbs_3mf.hpp"
@@ -354,6 +355,13 @@ static constexpr const char* CUSTOM_SUPPORTS_ATTR = "paint_supports";
 static constexpr const char* CUSTOM_FUZZY_SKIN_ATTR  = "paint_fuzzy_skin";
 static constexpr const char* CUSTOM_SEAM_ATTR = "paint_seam";
 static constexpr const char* MMU_SEGMENTATION_ATTR = "paint_color";
+// Texture displacement. One paint mask per layer slot, mirroring paint_color; the layer stack itself is
+// a JSON file in the archive, named by the volume metadata key below (see add_texture_displacement()).
+static constexpr const char* TEXTURE_DISPLACEMENT_ATTRS[Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS] = {
+    "paint_texture_0", "paint_texture_1", "paint_texture_2", "paint_texture_3",
+    "paint_texture_4", "paint_texture_5", "paint_texture_6", "paint_texture_7" };
+static constexpr const char* TEXTURE_DISPLACEMENT_KEY = "texture_displacement";
+static constexpr const char* TEXTURE_DISPLACEMENT_DIR = "Metadata/texture_displacement/";
 // BBS
 static constexpr const char* FACE_PROPERTY_ATTR = "face_property";
 
@@ -847,6 +855,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             std::vector<std::string> custom_seam;
             std::vector<std::string> mmu_segmentation;
             std::vector<std::string> fuzzy_skin;
+            // One per texture displacement layer slot, indexed like `triangles` but stored only as far as the
+            // slot's last painted triangle: empty when the slot has no paint, which is nearly every file.
+            std::vector<std::string> texture_displacement[TEXTURE_DISPLACEMENT_MAX_LAYERS];
             // BBS
             std::vector<std::string> face_properties;
 
@@ -867,6 +878,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 custom_seam.clear();
                 mmu_segmentation.clear();
                 fuzzy_skin.clear();
+                for (std::vector<std::string> &slot : texture_displacement)
+                    slot.clear();
             }
         };
 
@@ -974,6 +987,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
 
             MetadataList metadata;
             VolumeMetadataList volumes;
+            bool auto_drop { true };
         };
 
         struct CutObjectInfo
@@ -1200,6 +1214,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         /*IdToSlaSupportPointsMap m_sla_support_points;
         IdToSlaDrainHolesMap    m_sla_drain_holes;*/
         PathToEmbossShapeFileMap m_path_to_emboss_shape_files;
+        // Texture displacement: every file under Metadata/texture_displacement/, by archive path. Volumes
+        // are built only after the whole archive has been walked, so by the time a volume names its JSON
+        // every file it could refer to is already in here, whatever order the archive happened to be in.
+        std::map<std::string, std::string> m_texture_displacement_files;
+        void _apply_texture_displacement(ModelVolume &volume, const std::string &json_path);
         std::string m_curr_metadata_name;
         std::string m_curr_characters;
         std::string m_name;
@@ -1349,7 +1368,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         bool _handle_start_text_configuration(const char** attributes, unsigned int num_attributes);
         bool _handle_start_shape_configuration(const char **attributes, unsigned int num_attributes);
 
-        bool _create_object_instance(std::string const & path, int object_id, const Transform3d& transform, const bool printable, const bool auto_drop, unsigned int recur_counter);
+        bool _create_object_instance(std::string const & path, int object_id, const Transform3d& transform, const bool printable, unsigned int recur_counter);
 
         void _apply_transform(ModelInstance& instance, const Transform3d& transform);
 
@@ -2073,6 +2092,13 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 else if (_is_svg_shape_file(name)) {
                     _extract_embossed_svg_shape_file(name, archive, stat);
                 }
+                else if (boost::algorithm::istarts_with(name, TEXTURE_DISPLACEMENT_DIR)) {
+                    std::string contents(stat.m_uncomp_size, '\0');
+                    if (mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, contents.data(), stat.m_uncomp_size, 0))
+                        m_texture_displacement_files.emplace(name, std::move(contents));
+                    else
+                        add_error("Error while reading texture displacement data");
+                }
                 else if (!dont_load_config && boost::algorithm::iequals(name, SLICE_INFO_CONFIG_FILE)) {
                     m_parsing_slice_info = true;
                     //extract slice info from archive
@@ -2234,6 +2260,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             if (obj_metadata != m_objects_metadata.end()) {
                 // config data has been found, this model was saved using slic3r pe
 
+                model_object->auto_drop = obj_metadata->second.auto_drop;
+
                 // apply object's name and config data
                 for (const Metadata& metadata : obj_metadata->second.metadata) {
                     if (metadata.key == "name")
@@ -3310,6 +3338,45 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         }
     }*/
 
+    // Restores one volume's texture displacement stack from the JSON it named. Called while the volume is
+    // being built, which is after the whole archive has been walked - so every file it can refer to is
+    // already extracted, and no deferral is needed.
+    //
+    // A missing or malformed JSON leaves the volume with no layers but keeps the paint mask it already
+    // loaded, which is the same state as a project saved by a build without the feature: recoverable by
+    // picking the texture again rather than a hard failure.
+    void _BBS_3MF_Importer::_apply_texture_displacement(ModelVolume &volume, const std::string &json_path)
+    {
+        const auto json = m_texture_displacement_files.find(json_path);
+        if (json == m_texture_displacement_files.end()) {
+            add_error("Missing texture displacement data: " + json_path);
+            return;
+        }
+        std::vector<TextureDisplacementLayer> layers;
+        TextureDisplacementOptions            options;
+        if (!texture_displacement_layers_from_json(json->second, layers, options)) {
+            add_error("Malformed texture displacement data: " + json_path);
+            return;
+        }
+        // The archive is the only source of a layer's pixels. `path` comes from the project file, so loading
+        // the project must never read the file it names: that would let whoever made the project pick any
+        // local (or, on Windows, network) file to read, and the next save would embed it in the archive.
+        // `path` stays a label of where the texture came from; a layer the archive carries no image for
+        // loads without one, its settings intact, until the user picks a texture again.
+        for (TextureDisplacementLayer &layer : layers) {
+            if (layer.path_in_3mf.empty())
+                continue;
+            const auto image = m_texture_displacement_files.find(layer.path_in_3mf);
+            if (image == m_texture_displacement_files.end()) {
+                add_error("Missing texture displacement image: " + layer.path_in_3mf);
+                continue;
+            }
+            layer.image_data = std::make_shared<std::vector<unsigned char>>(image->second.begin(), image->second.end());
+        }
+        volume.texture_displacement_layers  = std::move(layers);
+        volume.texture_displacement_options = options;
+    }
+
     void _BBS_3MF_Importer::_extract_embossed_svg_shape_file(const std::string &filename, mz_zip_archive &archive, const mz_zip_archive_file_stat &stat){
         assert(m_path_to_emboss_shape_files.find(filename) == m_path_to_emboss_shape_files.end());
         auto file = std::make_unique<std::string>(stat.m_uncomp_size, '\0');
@@ -3966,6 +4033,12 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             m_curr_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
             m_curr_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
             m_curr_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
+                if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
+                    std::vector<std::string> &mask = m_curr_object->geometry.texture_displacement[slot];
+                    mask.resize(m_curr_object->geometry.triangles.size());
+                    mask.back() = paint;
+                }
             // BBS
             m_curr_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
         }
@@ -4047,9 +4120,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         std::string path = bbs_get_attribute_value_string(attributes, num_attributes, PPATH_ATTR);
         Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
         int printable = bbs_get_attribute_value_bool(attributes, num_attributes, PRINTABLE_ATTR);
-        int auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
-
-        return !m_load_model || _create_object_instance(path, object_id, transform, printable, auto_drop, 1);
+        return !m_load_model || _create_object_instance(path, object_id, transform, printable, 1);
     }
 
     bool _BBS_3MF_Importer::_handle_end_item()
@@ -4277,7 +4348,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         return true;
     }
 
-    bool _BBS_3MF_Importer::_create_object_instance(std::string const & path, int object_id, const Transform3d& transform, const bool printable, const bool auto_drop, unsigned int recur_counter)
+    bool _BBS_3MF_Importer::_create_object_instance(std::string const & path, int object_id, const Transform3d& transform, const bool printable, unsigned int recur_counter)
     {
         static const unsigned int MAX_RECURSIONS = 10;
 
@@ -4314,7 +4385,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 return false;
             }
             instance->printable = printable;
-            instance->auto_drop = auto_drop;    
 
             m_instances.emplace_back(instance, transform);
 
@@ -4347,7 +4417,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 return false;
             }
             instance->printable = printable;
-            instance->auto_drop = auto_drop;    
 
             m_instances.emplace_back(instance, transform);
         }
@@ -4418,7 +4487,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         // Added because of github #3435, currently not used by PrusaSlicer
         // int instances_count_id = bbs_get_attribute_value_int(attributes, num_attributes, INSTANCESCOUNT_ATTR);
 
-        m_objects_metadata.insert({ object_id, ObjectMetadata() });
+        ObjectMetadata metadata;
+        metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
+        m_objects_metadata.insert({ object_id, std::move(metadata) });
         m_curr_config.object_id = object_id;
         return true;
     }
@@ -5317,6 +5388,18 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 volume->mmu_segmentation_facets.touch();
                 volume->fuzzy_skin_facets.shrink_to_fit();
                 volume->fuzzy_skin_facets.touch();
+                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                    const std::vector<std::string> &mask = sub_object->geometry.texture_displacement[slot];
+                    if (mask.empty())
+                        continue; // no triangle painted on this slot
+                    FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
+                    facets.reserve(triangles_count);
+                    for (size_t i = 0; i < triangles_count && i < mask.size(); ++i)
+                        if (!mask[i].empty())
+                            facets.set_triangle_from_string(i, mask[i]);
+                    facets.shrink_to_fit();
+                    facets.touch();
+                }
             }
 
             volume->set_type(volume_data->part_type);
@@ -5332,6 +5415,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             for (const Metadata& metadata : volume_data->metadata) {
                 if (metadata.key == NAME_KEY)
                     volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                 //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5496,12 +5581,28 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             volume->seam_facets.shrink_to_fit();
             volume->mmu_segmentation_facets.shrink_to_fit();
 
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                const std::vector<std::string> &mask = geometry.texture_displacement[slot];
+                if (mask.empty())
+                    continue; // written by a build without the feature
+                FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
+                facets.reserve(triangles_count);
+                for (size_t i = 0; i < triangles_count; ++i) {
+                    const size_t index = volume_data.first_triangle_id + i;
+                    if (index < mask.size() && !mask[index].empty())
+                        facets.set_triangle_from_string(i, mask[index]);
+                }
+                facets.shrink_to_fit();
+                facets.touch();
+            }
             volume->set_type(volume_data.part_type);
 
             // apply the remaining volume's metadata
             for (const Metadata& metadata : volume_data.metadata) {
                 if (metadata.key == NAME_KEY)
                     volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                 //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5805,6 +5906,12 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             current_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
             current_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
             current_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
+                if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
+                    std::vector<std::string> &mask = current_object->geometry.texture_displacement[slot];
+                    mask.resize(current_object->geometry.triangles.size());
+                    mask.back() = paint;
+                }
             // BBS
             current_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
         }
@@ -6058,14 +6165,12 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             unsigned int id;
             Transform3d transform;
             bool printable;
-            bool auto_drop;
 
-            BuildItem(std::string const & path, unsigned int id, const Transform3d& transform, const bool printable, const bool auto_drop)
+            BuildItem(std::string const & path, unsigned int id, const Transform3d& transform, const bool printable)
                 : path(path)
                 , id(id)
                 , transform(transform)
                 , printable(printable)
-                , auto_drop(auto_drop)
             {
             }
         };
@@ -6156,7 +6261,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                                                 std::vector<std::string> const &targets = {},
                                                 std::vector<std::string> const &types   = {},
                                                 PackingTemporaryData            data    = PackingTemporaryData(),
-                                                int export_plate_idx = -1) const;
+                                                int                             export_plate_idx = -1,
+                                                bool                            plate_thumbnail_written = false,
+                                                bool                            plate_small_thumbnail_written = false) const;
         bool _add_model_file_to_archive(const std::string& filename, mz_zip_archive& archive, const Model& model, ObjectToObjectDataMap& objects_data, Export3mfProgressFn proFn = nullptr, BBLProject* project = nullptr) const;
         bool _add_object_to_model_stream(mz_zip_writer_staged_context &context, ObjectData const &object_data) const;
         void _add_object_components_to_stream(std::stringstream &stream, ObjectData const &object_data) const;
@@ -6366,6 +6473,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",top&&pick thumbnails, count %1%")%top_thumbnail_data.size();
 
         //BBS: add thumbnail for each plate
+        //ORCA: the relationships file points at plate 1's thumbnail for a whole-project export,
+        //      otherwise at the exported plate's. Track whether that thumbnail was written.
+        const size_t rels_plate_idx = (export_plate_idx < 0) ? 0 : static_cast<size_t>(export_plate_idx);
+        bool rels_thumbnail_written = false;
+        bool rels_small_thumbnail_written = false;
         if (!m_skip_static) {
             std::vector<bool> thumbnail_status(plate_data_list.size(), false);
             std::vector<bool> no_light_thumbnail_status(plate_data_list.size(), false);
@@ -6414,6 +6526,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
 
                     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",add thumbnail %1%'s data into 3mf")%(index+1);
                     thumbnail_status[index] = true;
+                    if (static_cast<size_t>(index) == rels_plate_idx) {
+                        //ORCA: this call also writes the _small companion
+                        rels_thumbnail_written       = true;
+                        rels_small_thumbnail_written = true;
+                    }
                 }
             }
 
@@ -6460,6 +6577,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", add thumbnail %1% from file %2% failed\n") % (i+1) %plate_data->thumbnail_file;
                         return false;
                     }
+                    //ORCA: copied from file, so there is no _small companion for this plate
+                    if (static_cast<size_t>(i) == rels_plate_idx)
+                        rels_thumbnail_written = true;
                 }
 
                 if (!no_light_thumbnail_status[i] && !plate_data->no_light_thumbnail_file.empty() && (boost::filesystem::exists(plate_data->no_light_thumbnail_file))){
@@ -6754,7 +6874,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         // Adds relationships file ("_rels/.rels").
         // The content of this file is the same for each OrcaSlicer 3mf.
         // The relationshis file contains a reference to the geometry file "3D/3dmodel.model", the name was chosen to be compatible with CURA.
-        if (!_add_relationships_file_to_archive(archive, {}, {}, {}, temp_data, export_plate_idx)) {
+        if (!_add_relationships_file_to_archive(archive, {}, {}, {}, temp_data, export_plate_idx, rels_thumbnail_written, rels_small_thumbnail_written)) {
             BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", _add_relationships_file_to_archive failed\n");
             return false;
         }
@@ -6808,6 +6928,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         stream << " <Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\n";
         stream << " <Default Extension=\"model\" ContentType=\"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\"/>\n";
         stream << " <Default Extension=\"png\" ContentType=\"image/png\"/>\n";
+        stream << " <Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"jpeg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"json\" ContentType=\"application/json\"/>\n";
         stream << " <Default Extension=\"gcode\" ContentType=\"text/x.gcode\"/>\n";
         stream << "</Types>";
 
@@ -6926,7 +7049,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
     }
 
     bool _BBS_3MF_Exporter::_add_relationships_file_to_archive(
-        mz_zip_archive &archive, std::string const &from, std::vector<std::string> const &targets, std::vector<std::string> const &types, PackingTemporaryData data, int export_plate_idx) const
+        mz_zip_archive &archive, std::string const &from, std::vector<std::string> const &targets, std::vector<std::string> const &types, PackingTemporaryData data, int export_plate_idx,
+        bool plate_thumbnail_written, bool plate_small_thumbnail_written) const
     {
         std::stringstream stream;
         stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
@@ -6937,7 +7061,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             if (export_plate_idx < 0) {
                 //use cover image if have
                 if (data._3mf_thumbnail.empty()) {
-                    stream << " <Relationship Target=\"/Metadata/plate_1.png"
+                    // ORCA: only reference the plate thumbnail if it was written
+                    if (plate_thumbnail_written)
+                        stream << " <Relationship Target=\"/Metadata/plate_1.png"
                                << "\" Id=\"rel-2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail\"/>\n";
                 } else {
                     stream << " <Relationship Target=\"/" << xml_escape(data._3mf_thumbnail)
@@ -6945,22 +7071,24 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 }
 
                 if (data._3mf_printer_thumbnail_middle.empty()) {
-                    stream << " <Relationship Target=\"/Metadata/plate_1.png"
-                           << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
+                    if (plate_thumbnail_written)
+                        stream << " <Relationship Target=\"/Metadata/plate_1.png"
+                               << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
                 } else {
                     stream << " <Relationship Target=\"/" << xml_escape(data._3mf_printer_thumbnail_middle)
                            << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
                 }
 
                 if (data._3mf_printer_thumbnail_small.empty()) {
-                    stream << "<Relationship Target=\"/Metadata/plate_1_small.png"
-                           << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
+                    if (plate_small_thumbnail_written)
+                        stream << "<Relationship Target=\"/Metadata/plate_1_small.png"
+                               << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
                 } else {
                     stream << " <Relationship Target=\"/" << xml_escape(data._3mf_printer_thumbnail_small)
                            << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
                 }
             }
-            else {
+            else if (plate_thumbnail_written) {
                 //always use plate thumbnails
                 std::string thumbnail_file_str = (boost::format("Metadata/plate_%1%.png") % (export_plate_idx + 1)).str();
                 stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
@@ -6970,9 +7098,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
                    << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
 
-                thumbnail_file_str = (boost::format("Metadata/plate_%1%_small.png") % (export_plate_idx + 1)).str();
-                stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
-                   << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
+                if (plate_small_thumbnail_written) {
+                    thumbnail_file_str = (boost::format("Metadata/plate_%1%_small.png") % (export_plate_idx + 1)).str();
+                    stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
+                       << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
+                }
             }
         }
         else if (targets.empty()) {
@@ -7232,10 +7362,14 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                             if (iter != m_shared_meshes.end())
                             {
                                 const ModelVolume* shared_volume = iter->second.second;
+                                bool same_texture_paint = true;
+                                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS) && same_texture_paint; ++slot)
+                                    same_texture_paint = shared_volume->texture_displacement_facet(slot).equals(volume->texture_displacement_facet(slot));
                                 if ((shared_volume->supported_facets.equals(volume->supported_facets))
                                     && (shared_volume->seam_facets.equals(volume->seam_facets))
                                     && (shared_volume->mmu_segmentation_facets.equals(volume->mmu_segmentation_facets))
-                                    && (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets)))
+                                    && (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets))
+                                    && same_texture_paint)
                                 {
                                     auto data = iter->second.first;
                                     const_cast<_BBS_3MF_Exporter *>(this)->m_volume_paths.insert({volume, {data->sub_path, data->volumes_objectID.find(iter->second.second)->second}});
@@ -7277,7 +7411,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                     // instance_id is just a 1 indexed index in build_items.
                     //assert(m_skip_static || curr_id == build_items.size() + 1);
 
-                    build_items.emplace_back("", object_it->second.object_id, t, instance->printable, instance->auto_drop);
+                    build_items.emplace_back("", object_it->second.object_id, t, instance->printable);
                     count++;
                 }
 
@@ -7651,6 +7785,20 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                     output_buffer += "\"";
                 }
 
+                // One attribute per texture displacement layer slot. Older readers ignore attributes they do
+                // not know, so a project written here still opens in a build without the feature - it just
+                // loses the paint, which is also all it could have done with it.
+                for (int slot = 0; slot < TEXTURE_DISPLACEMENT_MAX_LAYERS; ++slot) {
+                    const std::string texture_paint = volume->texture_displacement_facet(slot).get_triangle_as_string(i);
+                    if (texture_paint.empty())
+                        continue;
+                    output_buffer += " ";
+                    output_buffer += TEXTURE_DISPLACEMENT_ATTRS[slot];
+                    output_buffer += "=\"";
+                    output_buffer += texture_paint;
+                    output_buffer += "\"";
+                }
+
                 // BBS
                 if (i < its.properties.size()) {
                     std::string prop_str = its.properties[i].to_string();
@@ -7713,8 +7861,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 stream << "\" " << PPATH_ATTR << "=\"" << xml_escape(item.path);
             stream << "\" " << TRANSFORM_ATTR << "=\"";
             add_transformation(stream, item.transform);
-            stream << "\" " << PRINTABLE_ATTR << "=\"" << item.printable;
-            stream << "\" " << AUTO_DROP_ATTR << "=\"" << item.auto_drop << "\"/>\n";
+            stream << "\" " << PRINTABLE_ATTR << "=\"" << item.printable << "\"/>\n";
         }
 
         stream << " </" << BUILD_TAG << ">\n";
@@ -8100,7 +8247,42 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         return file_path;
     }
 
-    bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
+    // Writes a volume's texture displacement stack into the archive and points the volume's metadata at it.
+// The layer settings go in as JSON and each layer's texture as the image file it was loaded from, both
+// referenced by path - the same split EmbossShape makes for its SVG. The image deliberately stays out of
+// the XML: it is binary and routinely megabytes, and base64 in an attribute would bloat the one file
+// every reader has to parse just to list the objects.
+static void add_texture_displacement(std::stringstream &stream, const ModelVolume &volume, mz_zip_archive &archive,
+                                     const std::string &id)
+{
+    if (volume.texture_displacement_layers.empty())
+        return;
+
+    // A copy, because path_in_3mf is only meaningful inside the archive being written and the volume
+    // being exported is const (and may be saved again, elsewhere, with different paths).
+    std::vector<TextureDisplacementLayer> layers = volume.texture_displacement_layers;
+    for (TextureDisplacementLayer &layer : layers) {
+        layer.path_in_3mf.clear();
+        if (!layer.image_data || layer.image_data->empty())
+            continue;
+        // Always .png: the importer converts whatever the user picked (jpg, bmp, ...) to an 8-bit
+        // greyscale PNG, so image_data is PNG whatever layer.path happens to be named.
+        const std::string path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + "_" + std::to_string(layer.slot) + ".png";
+        // No deflate: a PNG is already compressed, so a second pass only costs time.
+        if (mz_zip_writer_add_mem(&archive, path.c_str(), layer.image_data->data(), layer.image_data->size(),
+                                  MZ_NO_COMPRESSION))
+            layer.path_in_3mf = path;
+    }
+
+    const std::string json      = texture_displacement_layers_to_json(layers, volume.texture_displacement_options);
+    const std::string json_path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + ".json";
+    if (!mz_zip_writer_add_mem(&archive, json_path.c_str(), json.data(), json.size(), MZ_DEFAULT_COMPRESSION))
+        return;
+    stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << TEXTURE_DISPLACEMENT_KEY << "\" "
+           << VALUE_ATTR << "=\"" << xml_escape(json_path) << "\"/>\n";
+}
+
+bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
     {
         std::stringstream stream;
         // Store mesh transformation in full precision, as the volumes are stored transformed and they need to be transformed back
@@ -8116,7 +8298,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             if (obj != nullptr) {
                 // Output of instances count added because of github #3435, currently not used by PrusaSlicer
                 //stream << "  <"  << OBJECT_TAG << " " << ID_ATTR << "=\"" << obj_metadata.first << "\" " << INSTANCESCOUNT_ATTR << "=\"" << obj->instances.size() << "\">\n";
-                stream << "  <" << OBJECT_TAG << " " << ID_ATTR << "=\"" << object_data.object_id << "\">\n";
+                stream << "  <" << OBJECT_TAG << " " << ID_ATTR << "=\"" << object_data.object_id
+                       << "\" " << AUTO_DROP_ATTR << "=\"" << obj->auto_drop << "\">\n";
 
                 // stores object's name
                 if (!obj->name.empty())
@@ -8211,6 +8394,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                             if (const std::optional<EmbossShape> &es = volume->emboss_shape; es.has_value()) {
                                 to_xml(stream, *es, *volume, archive, m_fullpath_sources);
                             }
+
+                            add_texture_displacement(stream, *volume, archive, std::to_string(volume->id().id));
                     
                             if (const std::optional<TextConfiguration> &tc = volume->text_configuration;
                                 tc.has_value())

src/libslic3r/Format/svg.cpp

@@ -4,6 +4,7 @@
 #include "../libslic3r.h"
 #include "../Model.hpp"
 #include "../TriangleMesh.hpp"
+#include "../I18N.hpp"
 
 #include "svg.hpp"
 #include "nanosvg/nanosvg.h"
@@ -143,11 +144,11 @@ bool get_svg_profile(const char *path, std::vector<Element_Info> &element_infos,
     NSVGimage *svg_data = nullptr;
     svg_data            = nsvgParseFromFile(path, "mm", 96.0f);
     if (svg_data == nullptr) {
-        message = "import svg failed: could not open svg.";
+        message = _u8L("import svg failed: could not open svg.");
         return false;
     }
     if (svg_data->shapes == nullptr) {
-        message = "import svg failed: could not parse imported svg data.";
+        message = _u8L("import svg failed: could not parse imported svg data.");
         return false;
     }
 

src/libslic3r/GCode.cpp

@@ -1033,6 +1033,15 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
         return buf;
     }
 
+    // FanMover consumes these markers (and drops them) to avoid splitting a G1 inside custom gcode.
+    // Only written when FanMover runs, the same gate as its construction in GCode::process_layers.
+    static std::string wrap_custom_gcode_for_fan_mover(const FullPrintConfig &config, const std::string &gcode)
+    {
+        if (config.fan_speedup_time.value == 0 && config.fan_kickstart.value <= 0)
+            return gcode;
+        return ";_FAN_MOVER_SKIP_START\n" + gcode + ";_FAN_MOVER_SKIP_END\n";
+    }
+
     std::string WipeTowerIntegration::append_tcr(GCode& gcodegen, const WipeTower::ToolChangeResult& tcr, int new_filament_id, double z) const
     {
         if (new_filament_id != -1 && new_filament_id != tcr.new_tool)
@@ -1384,6 +1393,9 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
             toolchange_gcode_str = gcodegen.placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &config);
 
             check_add_eol(toolchange_gcode_str);
+            // Type1 wipe tower path (every BBL printer): bracket the same way set_extruder() does,
+            // so FanMover doesn't split a G1 inside this custom gcode either.
+            toolchange_gcode_str = wrap_custom_gcode_for_fan_mover(gcodegen.config(), toolchange_gcode_str);
 
             //BBS
             {
@@ -1967,7 +1979,7 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
             if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
                 if (m_layer_idx < (int) m_tool_changes.size()) {
                     if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
-                        throw Slic3r::RuntimeError("Wipe tower generation failed, possibly due to empty first layer.");
+                        throw Slic3r::RuntimeError(_(L("Wipe tower generation failed, possibly due to empty first layer.")));
 
                     // Calculate where the wipe tower layer will be printed. -1 means that print z will not change,
                     // resulting in a wipe tower with sparse layers.
@@ -2006,7 +2018,7 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
 
             if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
                 if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
-                    throw Slic3r::RuntimeError("Wipe tower generation failed, possibly due to empty first layer.");
+                    throw Slic3r::RuntimeError(_(L("Wipe tower generation failed, possibly due to empty first layer.")));
 
                 if (!ignore_sparse)
                     gcode += append_tcr(gcodegen, m_tool_changes[m_layer_idx][m_tool_change_idx++], extruder_id, wipe_tower_z);
@@ -2032,7 +2044,7 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
 
         if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
             if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
-                throw Slic3r::RuntimeError("Wipe tower generation failed, possibly due to empty first layer.");
+                throw Slic3r::RuntimeError(_(L("Wipe tower generation failed, possibly due to empty first layer.")));
 
             if (!ignore_sparse) {
                 return false;
@@ -2780,11 +2792,13 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
     m_processor.set_print(print);
     GCodeOutputStream file(boost::nowide::fopen(path_tmp.c_str(), "wb"), m_processor);
     if (! file.is_open()) {
-        std::string err_msg = std::string("G-code export to ") + path + " failed.\nCannot open the file for writing.\n";
+        // TRN %1% is a file path.
+        std::string err_msg = Slic3r::format(_(L("G-code export to %1% failed.\nCannot open the file for writing.")), path) + "\n";
         BOOST_LOG_TRIVIAL(error) << err_msg << std::endl;
         if (!fs::exists(folder)) {
             //fs::create_directory(folder);
-            std::string add_err_msg = "the parent path " + folder.string() +" is not there!!!";
+            // TRN %1% is a folder path.
+            std::string add_err_msg = Slic3r::format(_(L("The folder %1% does not exist.")), folder.string());
             BOOST_LOG_TRIVIAL(error) << add_err_msg << std::endl;
             err_msg += add_err_msg;
         }
@@ -2806,7 +2820,8 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
         if (file.is_error()) {
             file.close();
             boost::nowide::remove(path_tmp.c_str());
-            throw Slic3r::RuntimeError(std::string("G-code export to ") + path + " failed\nIs the disk full?\n");
+            // TRN %1% is a file path.
+            throw Slic3r::RuntimeError(Slic3r::format(_(L("G-code export to %1% failed.\nIs the disk full?")), path) + "\n");
         }
     } catch (std::exception &ex) {
         // Rethrow on any exception. std::runtime_exception and CanceledException are expected to be thrown.
@@ -2937,8 +2952,9 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
             fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
         }
         throw Slic3r::RuntimeError(
-            std::string("Failed to rename the output G-code file from ") + path_tmp + " to " + path + '\n' + "error code " + ret.message() + '\n' +
-            "Is " + path_tmp + " locked?" + '\n');
+            // TRN %1% is the temporary file path, %2% the output file path, %3% the system error message.
+            Slic3r::format(_(L("Failed to rename the output G-code file from %1% to %2%.\nError: %3%\nIs %1% locked?")),
+                           path_tmp, path, ret.message()) + '\n');
     }
     else {
         BOOST_LOG_TRIVIAL(info) << boost::format("rename_file from %1% to %2% successfully")% path_tmp % path;
@@ -4149,7 +4165,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
             auto [thumbnails, errors] = GCodeThumbnails::make_and_check_thumbnail_list(print.full_print_config());
 
             if (errors != enum_bitmask<ThumbnailError>()) {
-                std::string error_str = format("Invalid thumbnails value:");
+                std::string error_str = _(L("Invalid thumbnails value:"));
                 error_str += GCodeThumbnails::get_error_string(errors);
                 throw Slic3r::ExportError(error_str);
             }
@@ -4250,7 +4266,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
             config.set_key_value("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
             config.set_key_value("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
             config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
-            std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.values.at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
+            std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.get_at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
             file.writeln(filament_start_gcode);
             // Mark the first filament used in print. Multi-nozzle printers (H2C) get ";VT%d H%d" where
             // H = dynamic ? nozzle_id : -1; existing single-nozzle printers keep the bare ";VT%d" so their
@@ -10895,7 +10911,8 @@ std::string GCode::set_extruder(unsigned int new_filament_id, double print_z, bo
 
         toolchange_gcode_parsed = placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &dyn_config);
         check_add_eol(toolchange_gcode_parsed);
-        gcode += toolchange_gcode_parsed;
+        // toolchange_gcode_parsed is still read below (get_last_z_from_gcode, custom_gcode_changes_tool).
+        gcode += wrap_custom_gcode_for_fan_mover(m_config, toolchange_gcode_parsed);
 
         //BBS
         {

src/libslic3r/GCode/AdaptivePAProcessor.cpp

@@ -22,6 +22,8 @@
 #include "libslic3r/Config.hpp"
 #include "libslic3r/GCodeWriter.hpp"
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/I18N.hpp"
+#include "libslic3r/format.hpp"
 
 namespace Slic3r {
 
@@ -321,8 +323,7 @@ std::string AdaptivePAProcessor::validate_adaptive_pa_model(const std::string& m
         // Only numbers, commas and dots are allowed (no letters or other characters)
         for (char c : line) {
             if (!std::isdigit(static_cast<unsigned char>(c)) && c != ',' && c != '.') {
-                return "Line " + std::to_string(line_number) +
-                       ": only numbers, commas and dots are allowed";
+                return Slic3r::format(_u8L("Line %1%: only numbers, commas and dots are allowed"), line_number);
             }
         }
 
@@ -333,8 +334,7 @@ std::string AdaptivePAProcessor::validate_adaptive_pa_model(const std::string& m
         }
         
         if (comma_count != 2) {
-            return "Line " + std::to_string(line_number) + 
-                   ": must contain exactly 3 comma-separated values (PA, flow, acceleration)";
+            return Slic3r::format(_u8L("Line %1%: must contain exactly 3 comma-separated values (PA, flow, acceleration)"), line_number);
         }
         
         // Parse and validate the values
@@ -344,31 +344,31 @@ std::string AdaptivePAProcessor::validate_adaptive_pa_model(const std::string& m
             
             // Parse PA
             if (!std::getline(line_stream, value, ','))
-                return "Line " + std::to_string(line_number) + ": missing PA value";
+                return Slic3r::format(_u8L("Line %1%: missing PA value"), line_number);
             double pa = std::stod(value);
             
             // Parse flow
             if (!std::getline(line_stream, value, ','))
-                return "Line " + std::to_string(line_number) + ": missing flow value";
+                return Slic3r::format(_u8L("Line %1%: missing flow value"), line_number);
             double flow = std::stod(value);
             
             // Parse acceleration
             if (!std::getline(line_stream, value, ','))
-                return "Line " + std::to_string(line_number) + ": missing acceleration value";
+                return Slic3r::format(_u8L("Line %1%: missing acceleration value"), line_number);
             double accel = std::stod(value);
             
             // Validate constraints
             if (pa >= 2.0) {
-                return "Line " + std::to_string(line_number) + ": PA value must be less than 2";
+                return Slic3r::format(_u8L("Line %1%: PA value must be less than 2"), line_number);
             }
             if (flow <= pa) {
-                return "Line " + std::to_string(line_number) + ": flow value must be greater than PA value";
+                return Slic3r::format(_u8L("Line %1%: flow value must be greater than PA value"), line_number);
             }
             if (accel <= flow) {
-                return "Line " + std::to_string(line_number) + ": acceleration value must be greater than flow value";
+                return Slic3r::format(_u8L("Line %1%: acceleration value must be greater than flow value"), line_number);
             }
         } catch (const std::exception&) {
-            return "Line " + std::to_string(line_number) + ": invalid numeric value";
+            return Slic3r::format(_u8L("Line %1%: invalid numeric value"), line_number);
         }
     }
     

src/libslic3r/GCode/FanMover.cpp

@@ -445,6 +445,11 @@ void FanMover::_process_gcode_line(GCodeReader& reader, const GCodeReader::GCode
                 std::string extrusion_string = line.raw().substr(6, line.raw().size() - 6);
                 current_role = ExtrusionEntity::string_to_role(extrusion_string);
             }
+            if (line.raw().rfind(";_FAN_MOVER_SKIP_", 0) == 0) {
+                // Internal markers: read here, then dropped from the output.
+                m_is_custom_gcode = line.raw().rfind(";_FAN_MOVER_SKIP_START", 0) == 0;
+                time = -1;
+            }
             if (line.raw().size() > 16) {
                 if (line.raw().rfind("; custom gcode", 0) != std::string::npos) {
                     if (line.raw().rfind("; custom gcode end", 0) != std::string::npos)

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -18,6 +18,7 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/LocalesUtils.hpp"
 #include "libslic3r/format.hpp"
+#include "libslic3r/I18N.hpp"
 #include "libslic3r_version.h"
 #include "GCodeProcessor.hpp"
 
@@ -1066,13 +1067,13 @@ void GCodeProcessor::run_post_process()
 {
     FilePtr in{ boost::nowide::fopen(m_result.filename.c_str(), "rb") };
     if (in.f == nullptr)
-        throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nCannot open file for reading.\n"));
+        throw Slic3r::RuntimeError(_u8L("G-code processor post-process export failed.\nCannot open file for reading.\n"));
 
     // temporary file to contain modified gcode
     std::string out_path = m_result.filename + ".postprocess";
     FilePtr out{ boost::nowide::fopen(out_path.c_str(), "wb") };
     if (out.f == nullptr)
-        throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nCannot open file for writing.\n"));
+        throw Slic3r::RuntimeError(_u8L("G-code processor post-process export failed.\nCannot open file for writing.\n"));
 
     std::vector<double> filament_mm(m_result.filaments_count, 0.0);
     std::vector<double> filament_cm3(m_result.filaments_count, 0.0);
@@ -1467,10 +1468,10 @@ void GCodeProcessor::run_post_process()
                     // found an invalid value, clamp it to a valid one
                     tool_number = std::clamp<int>(0, m_filament_nozzle_temp.size() - 1, tool_number);
                     // emit warning
-                    std::string warning = "GCode Post-Processor encountered an invalid toolchange, maybe from a custom gcode:";
+                    std::string warning = _u8L("The G-code post-processor encountered an invalid tool change, maybe from custom G-code:");
                     warning += "\n> ";
                     warning += gcode_line;
-                    warning += "Generated M104 lines may be incorrect.";
+                    warning += _u8L("Generated M104 lines may be incorrect.");
                     BOOST_LOG_TRIVIAL(error) << warning;
                     // Orca todo
                     if (m_print != nullptr)
@@ -1712,7 +1713,7 @@ void GCodeProcessor::run_post_process()
         for (;;) {
             size_t cnt_read = ::fread(buffer.data(), 1, buffer.size(), in.f);
             if (::ferror(in.f))
-                throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nError while reading from file.\n"));
+                throw Slic3r::RuntimeError(_u8L("G-code processor post-process export failed.\nError while reading from file.\n"));
             bool eof       = cnt_read == 0;
             auto it        = buffer.begin();
             auto it_bufend = buffer.begin() + cnt_read;
@@ -1877,8 +1878,9 @@ void GCodeProcessor::run_post_process()
     }
 
     if (rename_file(out_path, result_filename))
-        throw Slic3r::RuntimeError(std::string("Failed to rename the output G-code file from ") + out_path + " to " + result_filename + '\n' +
-            "Is " + out_path + " locked?" + '\n');
+        // TRN %1% is the temporary file path, %2% the output file path.
+        throw Slic3r::RuntimeError(Slic3r::format(_u8L("Failed to rename the output G-code file from %1% to %2%.\nIs %1% locked?"),
+                                                  out_path, result_filename) + '\n');
 }
 
 // Additive second file-rewrite pass for the pre-heat/pre-cool injector. The single-pass
@@ -1979,12 +1981,12 @@ void GCodeProcessor::run_second_pass_injection()
 
     FilePtr in{ boost::nowide::fopen(m_result.filename.c_str(), "rb") };
     if (in.f == nullptr)
-        throw Slic3r::RuntimeError(std::string("GCode processor pre-heat injection pass failed.\nCannot open file for reading.\n"));
+        throw Slic3r::RuntimeError(_u8L("G-code processor pre-heat injection pass failed.\nCannot open file for reading.\n"));
 
     const std::string out_path = m_result.filename + ".preheat";
     FilePtr out{ boost::nowide::fopen(out_path.c_str(), "wb") };
     if (out.f == nullptr)
-        throw Slic3r::RuntimeError(std::string("GCode processor pre-heat injection pass failed.\nCannot open file for writing.\n"));
+        throw Slic3r::RuntimeError(_u8L("G-code processor pre-heat injection pass failed.\nCannot open file for writing.\n"));
 
     // The rewrite may shift byte positions (once the injector inserts lines), so rebuild lines_ends from scratch.
     // With an empty map the scanned '\n' offsets reproduce the current lines_ends exactly.
@@ -2002,7 +2004,7 @@ void GCodeProcessor::run_second_pass_injection()
     for (;;) {
         size_t cnt_read = ::fread(buffer.data(), 1, buffer.size(), in.f);
         if (::ferror(in.f))
-            throw Slic3r::RuntimeError(std::string("GCode processor pre-heat injection pass failed.\nError while reading from file.\n"));
+            throw Slic3r::RuntimeError(_u8L("G-code processor pre-heat injection pass failed.\nError while reading from file.\n"));
         bool eof       = cnt_read == 0;
         auto it        = buffer.begin();
         auto it_bufend = buffer.begin() + cnt_read;
@@ -2053,8 +2055,9 @@ void GCodeProcessor::run_second_pass_injection()
     handle_offsets_of_second_process(inserted_operation_lines);
 
     if (rename_file(out_path, m_result.filename))
-        throw Slic3r::RuntimeError(std::string("Failed to rename the output G-code file from ") + out_path + " to " + m_result.filename + '\n' +
-            "Is " + out_path + " locked?" + '\n');
+        // TRN %1% is the temporary file path, %2% the output file path.
+        throw Slic3r::RuntimeError(Slic3r::format(_u8L("Failed to rename the output G-code file from %1% to %2%.\nIs %1% locked?"),
+                                                  out_path, m_result.filename) + '\n');
 }
 
 // Every move whose gcode_id sits at or after an inserted line is pushed down by the running count of
@@ -2602,12 +2605,13 @@ void GCodeProcessorResult::reset() {
     //BBS: add mutex for protection of gcode result
     lock();
 
-    moves.clear();
+    // moves and lines_ends grow with the print: free them, as no reset result reuses the capacity.
+    clear_and_shrink(moves);
     plate_mass = {};
     object_masses.clear();
     body_masses.clear();
     support_masses.clear();
-    lines_ends.clear();
+    clear_and_shrink(lines_ends);
     printable_area = Pointfs();
     //BBS: add bed exclude area
     bed_exclude_area = Pointfs();
@@ -3598,6 +3602,10 @@ void GCodeProcessor::apply_config(const DynamicPrintConfig& config)
     if (has_scarf_joint_seam != nullptr)
         m_detect_layer_based_on_tag = m_detect_layer_based_on_tag || has_scarf_joint_seam->value;
 
+    const ConfigOptionBool* manual_filament_change = config.option<ConfigOptionBool>("manual_filament_change");
+    if (manual_filament_change != nullptr)
+        m_manual_filament_change = manual_filament_change->value;
+
     const ConfigOptionEnumGeneric *bed_type = config.option<ConfigOptionEnumGeneric>("curr_bed_type");
     if (bed_type != nullptr)
         m_result.bed_type = (BedType)bed_type->value;
@@ -3722,6 +3730,7 @@ void GCodeProcessor::reset()
     m_detect_layer_based_on_tag = false;
 
     m_seams_count = 0;
+    m_g29_time_added = false;
     m_preheat_time = 0.f;
     m_preheat_steps = 1;
 }
@@ -3743,7 +3752,8 @@ DynamicConfig GCodeProcessor::export_config_for_render() const
     config.set_key_value("filament_is_support", new ConfigOptionBools(m_parser.get_config().filament_is_support.values));
     config.set_key_value("filament_type", new ConfigOptionStrings(m_parser.get_config().filament_type.values));
     config.set_key_value("filament_map", new ConfigOptionInts(m_parser.get_config().filament_map.values));
-    config.apply(m_belt_render_config);
+    // += clones the options; apply() would need a definition this config does not have.
+    config += m_belt_render_config;
     return config;
 }
 
@@ -3936,7 +3946,7 @@ ConfigSubstitutions load_from_superslicer_gcode_file(const std::string& filename
     key_value_pairs = ConfigBase::load_from_gcode_string_legacy(config, data.data(), substitutions_ctxt);
 
     if (key_value_pairs < 80)
-        throw Slic3r::RuntimeError(format("Suspiciously low number of configuration values extracted from %1%: %2%", filename, key_value_pairs));
+        throw Slic3r::RuntimeError(format(_u8L("Suspiciously low number of configuration values extracted from %1%: %2%"), filename, key_value_pairs));
 
     return std::move(substitutions_ctxt.substitutions);
 }
@@ -6123,15 +6133,12 @@ void GCodeProcessor::process_G4(const GCodeReader::GCodeLine& line)
 //BBS
 void GCodeProcessor::process_G29(const GCodeReader::GCodeLine& line)
 {
-    //BBS: hardcode 260 seconds for G29
-    //Todo: use a machine related setting when we have second kind of BBL printer
-    const float value_s = 260.0;
-    if (s_IsBBLPrinter){
-        if(m_measure_g29_time)
-            simulate_st_synchronize(value_s);
-    }
-    else{
-        simulate_st_synchronize(value_s);
+    // Firmware may split one bed-leveling sequence across multiple G29 subcommands.
+    constexpr float g29_time = 260.0f;
+    const bool should_add_time = !s_IsBBLPrinter || m_measure_g29_time;
+    if (should_add_time && !m_g29_time_added) {
+        simulate_st_synchronize(g29_time);
+        m_g29_time_added = true;
     }
 }
 

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -1228,7 +1228,7 @@ inline constexpr float DEFAULT_FILAMENT_DENSITY = 1.245f;
         // m_result.nozzle_group_result, which is handed over only after the stream for the
         // pre-heat injector's second pass and gates the richer change-time model.
         std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> m_nozzle_group_result;
-        bool m_manual_filament_change;
+        bool m_manual_filament_change{ false };
 
         //BBS: x, y offset for gcode generated
         double          m_x_offset{ 0 };
@@ -1280,6 +1280,7 @@ inline constexpr float DEFAULT_FILAMENT_DENSITY = 1.245f;
         bool m_detect_layer_based_on_tag {false};
         int m_seams_count;
         bool m_measure_g29_time {false};
+        bool m_g29_time_added {false};
         bool m_single_extruder_multi_material;
         float m_preheat_time;
         int m_preheat_steps;

src/libslic3r/GCode/SmallAreaInfillFlowCompensator.cpp

@@ -20,6 +20,8 @@
 #include "libslic3r/Exception.hpp"
 #include "libslic3r/GCode/PchipInterpolatorHelper.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/I18N.hpp"
+#include "libslic3r/format.hpp"
 
 #include "SmallAreaInfillFlowCompensator.hpp"
 #include <boost/log/trivial.hpp>
@@ -55,10 +57,8 @@ SmallAreaInfillFlowCompensator::SmallAreaInfillFlowCompensator(const Slic3r::GCo
                         flowComps.push_back(std::stod(value_str));
                     }
                 } catch (...) {
-                    std::stringstream ss;
-                    ss << "Small Area Flow Compensation: Error parsing data point in small area infill compensation model:" << line << std::endl;
-
-                    throw Slic3r::InvalidArgument(ss.str());
+                    // TRN %1% is the line of the model that could not be parsed.
+                    throw Slic3r::InvalidArgument(Slic3r::format(_u8L("Small Area Flow Compensation: Error parsing data point in small area infill compensation model: %1%"), line) + "\n");
                 }
             }
         }
@@ -66,26 +66,26 @@ SmallAreaInfillFlowCompensator::SmallAreaInfillFlowCompensator(const Slic3r::GCo
         for (size_t i = 0; i < eLengths.size(); i++) {
             if (i == 0) {
                 if (!nearly_equal(eLengths[i], 0.0)) {
-                    throw Slic3r::InvalidArgument("Small Area Flow Compensation: First extrusion length for small area infill compensation model must be 0");
+                    throw Slic3r::InvalidArgument(_u8L("Small Area Flow Compensation: First extrusion length for small area infill compensation model must be 0"));
                 }
             } else {
                 if (nearly_equal(eLengths[i], 0.0)) {
-                    throw Slic3r::InvalidArgument("Small Area Flow Compensation: Only the first extrusion length for small area infill compensation model can be 0");
+                    throw Slic3r::InvalidArgument(_u8L("Small Area Flow Compensation: Only the first extrusion length for small area infill compensation model can be 0"));
                 }
                 if (eLengths[i] <= eLengths[i - 1]) {
-                    throw Slic3r::InvalidArgument("Small Area Flow Compensation: Extrusion lengths for subsequent points must be increasing");
+                    throw Slic3r::InvalidArgument(_u8L("Small Area Flow Compensation: Extrusion lengths for subsequent points must be increasing"));
                 }
             }
         }
 
         for (size_t i = 1; i < flowComps.size(); ++i) {
             if (flowComps[i] <= flowComps[i - 1]) {
-                throw Slic3r::InvalidArgument("Small Area Flow Compensation: Flow compensation factors must strictly increase with extrusion length");
+                throw Slic3r::InvalidArgument(_u8L("Small Area Flow Compensation: Flow compensation factors must strictly increase with extrusion length"));
             }
         }
 
         if (!flowComps.empty() && !nearly_equal(flowComps.back(), 1.0)) {
-            throw Slic3r::InvalidArgument("Small Area Flow Compensation: Final compensation factor for small area infill flow compensation model must be 1.0");
+            throw Slic3r::InvalidArgument(_u8L("Small Area Flow Compensation: Final compensation factor for small area infill flow compensation model must be 1.0"));
         }
 
         flowModel = std::make_unique<PchipInterpolatorHelper>(eLengths, flowComps);

src/libslic3r/GCode/Thumbnails.cpp

@@ -5,6 +5,7 @@
 #include "libslic3r/Config.hpp"
 #include "libslic3r/enum_bitmask.hpp"
 #include "format.hpp"
+#include "libslic3r/I18N.hpp"
 
 #include <boost/algorithm/string/case_conv.hpp>
 #include <qoi/qoi.h>
@@ -610,11 +611,11 @@ std::string get_error_string(const ThumbnailErrors& errors)
     std::string error_str;
 
     if (errors.has(ThumbnailError::InvalidVal))
-        error_str += "\n - " + Slic3r::format("Invalid input format. Expected vector of dimensions in the following format: \"%1%\"", "XxY/EXT, XxY/EXT, ...");
+        error_str += "\n - " + Slic3r::format(_u8L("Invalid input format. Expected vector of dimensions in the following format: \"%1%\""), "XxY/EXT, XxY/EXT, ...");
     if (errors.has(ThumbnailError::OutOfRange))
-        error_str += "\n - Input value is out of range";
+        error_str += "\n - " + _u8L("Input value is out of range");
     if (errors.has(ThumbnailError::InvalidExt))
-        error_str += "\n - Some extension in the input is invalid";
+        error_str += "\n - " + _u8L("Some extension in the input is invalid");
 
     return error_str;
 }

src/libslic3r/GCode/ToolOrdering.cpp

@@ -1646,7 +1646,7 @@ static FilamentGroupContext build_filament_group_context(
     context.nozzle_info.extruder_nozzle_list = build_extruder_nozzle_list(context.nozzle_info.nozzle_list);
 
     if (context.nozzle_info.nozzle_list.empty())
-        throw Slic3r::RuntimeError("No valid nozzle found. Please check nozzle count.");
+        throw Slic3r::RuntimeError(_L("No valid nozzle found. Please check nozzle count."));
 
     if (!nozzle_status.empty())
         context.nozzle_info.nozzle_status = nozzle_status;

src/libslic3r/GCode/WipeTowerEstimate.cpp

@@ -4,6 +4,7 @@
 #include "WipeTower.hpp"
 #include "WipeTower2.hpp"
 #include "../Config.hpp"
+#include "../FilamentMixer.hpp"
 #include "../PrintConfig.hpp"
 #include "../libslic3r.h"
 
@@ -74,10 +75,19 @@ Polygon estimate_wipe_tower_first_layer_outline(const ConfigBase &config, WipeTo
     return WipeTower2::cone_base_polygon(width, depth, height, cone ? cone_angle->getFloat() : 0.);
 }
 
-WipeTowerFootprint estimate_wipe_tower_footprint(const ConfigBase &config, WipeTowerType tower_type, const std::vector<unsigned int> &filament_ids, double layer_height, double max_object_height)
+WipeTowerFootprint estimate_wipe_tower_footprint(const ConfigBase &config, WipeTowerType tower_type, const std::vector<unsigned int> &filament_slots, double layer_height, double max_object_height)
 {
     WipeTowerFootprint footprint;
     footprint.height = max_object_height;
+    // A mixed slot is virtual: the tool ordering resolves it to one of its physical components
+    // on every layer, with or without colour sublayers, so the tower only ever purges those.
+    // Validation passes the slots as Print::extruders() lists them; the GUI and CLI placement
+    // expand them beforehand, which repeating here leaves unchanged.
+    std::vector<unsigned int> filament_ids = filament_slots;
+    const auto *is_mixed_opt   = dynamic_cast<const ConfigOptionBools *>(option_of(config, "filament_is_mixed"));
+    const auto *components_opt = dynamic_cast<const ConfigOptionStrings *>(option_of(config, "filament_mixed_components"));
+    if (is_mixed_opt != nullptr && components_opt != nullptr && has_any_mixed_filament(is_mixed_opt->values))
+        filament_ids = expand_mixed_filaments(filament_slots, is_mixed_opt->values, components_opt->values);
     const size_t filaments_cnt = filament_ids.size();
     if (filaments_cnt == 0 || layer_height < EPSILON)
         return footprint;

src/libslic3r/GCode/WipeTowerEstimate.hpp

@@ -34,6 +34,8 @@ Polygon estimate_wipe_tower_first_layer_outline(const ConfigBase &config, WipeTo
 // filament_ids:  0-based filaments purged on the plate. The config cannot see custom G-code tool
 //                changes, so ids derived from the model must include them
 //                (Print::extruders(true)) or a real tower is sized as if it were never built.
+//                A mixed slot may be passed as itself or already expanded: it is sized as its
+//                physical components either way, since those are all the tower ever purges.
 // layer_height:  thinnest layer the objects are sliced at. The first layer is folded in here.
 //
 // A raft is deliberately not a reason: normalize_fdm_2 clears enable_prime_tower for a plate

src/libslic3r/IMEXHelpers.cpp

@@ -198,10 +198,12 @@ std::string imex_multicolor_block_reason(const std::string& parallel_mode,
         // Filaments are numbered from 1 as the sidebar shows them, heads by their T index; the map
         // decides which head a filament is on, so with MMU lanes the two numbers differ.
         if (phys < 0)
-            return (boost::format(L("In this Span mode only %1% print colors, but filament %2% isn't routed to any "
+            // TRN %1% is a list of tools such as "T0/T1", %2% a filament number.
+            return (boost::format(L("In this Span mode, colors are printed only by %1%, but filament %2% isn't routed to any "
                                     "tool. Use filaments routed to %1%, or switch this plate to Primary mode.")) %
                     tools % (filament + 1)).str();
-        return (boost::format(L("In this Span mode only %1% print colors, but filament %2% is routed to T%3%. Use "
+        // TRN %1% is a list of tools such as "T0/T1", %2% a filament number, %3% a tool number.
+        return (boost::format(L("In this Span mode, colors are printed only by %1%, but filament %2% is routed to T%3%. Use "
                                 "filaments routed to %1%, or switch this plate to Primary mode.")) %
                 tools % (filament + 1) % phys).str();
     }

src/libslic3r/JumpPointSearch.cpp

@@ -1,349 +0,0 @@
-#include "JumpPointSearch.hpp"
-#include "BoundingBox.hpp"
-#include "ExPolygon.hpp"
-#include "Point.hpp"
-#include "libslic3r/AStar.hpp"
-#include "libslic3r/KDTreeIndirect.hpp"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/libslic3r.h"
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <iterator>
-#include <limits>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include <oneapi/tbb/scalable_allocator.h>
-
-//#define DEBUG_FILES
-#ifdef DEBUG_FILES
-#include "libslic3r/SVG.hpp"
-#endif
-
-namespace Slic3r {
-
-// execute fn for each pixel on the line. If fn returns false, terminate the iteration
-template<typename PointFn> void dda(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const PointFn &fn)
-{
-    coord_t dx    = abs(x1 - x0);
-    coord_t dy    = abs(y1 - y0);
-    coord_t x     = x0;
-    coord_t y     = y0;
-    coord_t n     = 1 + dx + dy;
-    coord_t x_inc = (x1 > x0) ? 1 : -1;
-    coord_t y_inc = (y1 > y0) ? 1 : -1;
-    coord_t error = dx - dy;
-    dx *= 2;
-    dy *= 2;
-
-    for (; n > 0; --n) {
-        if (!fn(x, y)) return;
-
-        if (error > 0) {
-            x += x_inc;
-            error -= dy;
-        } else {
-            y += y_inc;
-            error += dx;
-        }
-    }
-}
-
-// will draw the line twice, second time with and offset of 1 in the direction of normal
-// may call the fn on the same coordiantes multiple times!
-template<typename PointFn> void double_dda_with_offset(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const PointFn &fn)
-{
-    Vec2d normal       = Point{y1 - y0, x1 - x0}.cast<double>().normalized();
-    normal.x()         = ceil(normal.x());
-    normal.y()         = ceil(normal.y());
-    Point start_offset = Point(x0, y0) + (normal).cast<coord_t>();
-    Point end_offset   = Point(x1, y1) + (normal).cast<coord_t>();
-
-    dda(x0, y0, x1, y1, fn);
-    dda(start_offset.x(), start_offset.y(), end_offset.x(), end_offset.y(), fn);
-}
-
-template<typename CellPositionType, typename CellQueryFn> class JPSTracer
-{
-public:
-    // Use incoming_dir [0,0] for starting points, so that all directions are checked from that point
-    struct Node
-    {
-        CellPositionType position;
-        CellPositionType incoming_dir;
-    };
-
-    JPSTracer(CellPositionType target, CellQueryFn is_passable) : target(target), is_passable(is_passable) {}
-
-private:
-    CellPositionType target;
-    CellQueryFn      is_passable; // should return boolean whether the cell is passable or not
-
-    CellPositionType find_jump_point(CellPositionType start, CellPositionType forward_dir) const
-    {
-        CellPositionType next = start + forward_dir;
-        while (next != target && is_passable(next) && !(is_jump_point(next, forward_dir))) { next = next + forward_dir; }
-
-        if (is_passable(next)) {
-            return next;
-        } else {
-            return start;
-        }
-    }
-
-    bool is_jump_point(CellPositionType pos, CellPositionType forward_dir) const
-    {
-        if (abs(forward_dir.x()) + abs(forward_dir.y()) == 2) {
-            // diagonal
-            CellPositionType horizontal_check_dir = CellPositionType{forward_dir.x(), 0};
-            CellPositionType vertical_check_dir   = CellPositionType{0, forward_dir.y()};
-
-            if (!is_passable(pos - horizontal_check_dir) && is_passable(pos + forward_dir - 2 * horizontal_check_dir)) { return true; }
-
-            if (!is_passable(pos - vertical_check_dir) && is_passable(pos + forward_dir - 2 * vertical_check_dir)) { return true; }
-
-            if (find_jump_point(pos, horizontal_check_dir) != pos) { return true; }
-
-            if (find_jump_point(pos, vertical_check_dir) != pos) { return true; }
-
-            return false;
-        } else { // horizontal or vertical
-            CellPositionType side_dir = CellPositionType(forward_dir.y(), forward_dir.x());
-
-            if (!is_passable(pos + side_dir) && is_passable(pos + forward_dir + side_dir)) { return true; }
-
-            if (!is_passable(pos - side_dir) && is_passable(pos + forward_dir - side_dir)) { return true; }
-
-            return false;
-        }
-    }
-
-public:
-    template<class Fn> void foreach_reachable(const Node &from, Fn &&fn) const
-    {
-        const CellPositionType &      pos         = from.position;
-        const CellPositionType &      forward_dir = from.incoming_dir;
-        std::vector<CellPositionType> dirs_to_check{};
-
-        if (abs(forward_dir.x()) + abs(forward_dir.y()) == 0) { // special case for starting point
-            dirs_to_check = all_directions;
-        } else if (abs(forward_dir.x()) + abs(forward_dir.y()) == 2) {
-            // diagonal
-            CellPositionType horizontal_check_dir = CellPositionType{forward_dir.x(), 0};
-            CellPositionType vertical_check_dir   = CellPositionType{0, forward_dir.y()};
-
-            if (!is_passable(pos - horizontal_check_dir) && is_passable(pos + forward_dir - 2 * horizontal_check_dir)) {
-                dirs_to_check.push_back(forward_dir - 2 * horizontal_check_dir);
-            }
-
-            if (!is_passable(pos - vertical_check_dir) && is_passable(pos + forward_dir - 2 * vertical_check_dir)) {
-                dirs_to_check.push_back(forward_dir - 2 * vertical_check_dir);
-            }
-
-            dirs_to_check.push_back(horizontal_check_dir);
-            dirs_to_check.push_back(vertical_check_dir);
-            dirs_to_check.push_back(forward_dir);
-
-        } else { // horizontal or vertical
-            CellPositionType side_dir = CellPositionType(forward_dir.y(), forward_dir.x());
-
-            if (!is_passable(pos + side_dir) && is_passable(pos + forward_dir + side_dir)) { dirs_to_check.push_back(forward_dir + side_dir); }
-
-            if (!is_passable(pos - side_dir) && is_passable(pos + forward_dir - side_dir)) { dirs_to_check.push_back(forward_dir - side_dir); }
-            dirs_to_check.push_back(forward_dir);
-        }
-
-        for (const CellPositionType &dir : dirs_to_check) {
-            CellPositionType jp = find_jump_point(pos, dir);
-            if (jp != pos) fn(Node{jp, dir});
-        }
-    }
-
-    float distance(Node a, Node b) const { return (a.position - b.position).template cast<double>().norm(); }
-
-    float goal_heuristic(Node n) const { return n.position == target ? -1.f : (target - n.position).template cast<double>().norm(); }
-
-    size_t unique_id(Node n) const { return (static_cast<size_t>(uint16_t(n.position.x())) << 16) + static_cast<size_t>(uint16_t(n.position.y())); }
-
-    const std::vector<CellPositionType> all_directions{{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
-};
-
-void JPSPathFinder::clear()
-{
-    inpassable.clear();
-    max_search_box.max = Pixel(std::numeric_limits<coord_t>::min(), std::numeric_limits<coord_t>::min());
-    max_search_box.min = Pixel(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max());
-    add_obstacles(bed_shape);
-}
-
-void JPSPathFinder::add_obstacles(const Lines &obstacles)
-{
-    auto store_obstacle = [&](coord_t x, coord_t y) {
-        max_search_box.max.x() = std::max(max_search_box.max.x(), x);
-        max_search_box.max.y() = std::max(max_search_box.max.y(), y);
-        max_search_box.min.x() = std::min(max_search_box.min.x(), x);
-        max_search_box.min.y() = std::min(max_search_box.min.y(), y);
-        inpassable.insert(Pixel{x, y});
-        return true;
-    };
-
-    for (const Line &l : obstacles) {
-        Pixel start = pixelize(l.a);
-        Pixel end   = pixelize(l.b);
-        double_dda_with_offset(start.x(), start.y(), end.x(), end.y(), store_obstacle);
-    }
-}
-
-Polyline JPSPathFinder::find_path(const Point &p0, const Point &p1)
-{
-    Pixel start = pixelize(p0);
-    Pixel end   = pixelize(p1);
-    if (inpassable.empty() || (start - end).cast<float>().norm() < 3.0) { return Polyline{p0, p1}; }
-
-    if (inpassable.find(start) != inpassable.end()) {
-        dda(start.x(), start.y(), end.x(), end.y(), [&](coord_t x, coord_t y) {
-            if (inpassable.find(Pixel(x, y)) == inpassable.end() || start == end) { // new start not found yet, and xy passable
-                start = Pixel(x, y);
-                return false;
-            }
-            return true;
-        });
-    }
-
-    if (inpassable.find(end) != inpassable.end()) {
-        dda(end.x(), end.y(), start.x(), start.y(), [&](coord_t x, coord_t y) {
-            if (inpassable.find(Pixel(x, y)) == inpassable.end() || start == end) { // new start not found yet, and xy passable
-                end = Pixel(x, y);
-                return false;
-            }
-            return true;
-        });
-    }
-
-    BoundingBox search_box = max_search_box;
-    search_box.max -= Pixel(1, 1);
-    search_box.min += Pixel(1, 1);
-
-    BoundingBox bounding_square(Points{start, end});
-    bounding_square.max += Pixel(5, 5);
-    bounding_square.min -= Pixel(5, 5);
-    coord_t bounding_square_size = 2 * std::max(bounding_square.size().x(), bounding_square.size().y());
-    bounding_square.max.x() += (bounding_square_size - bounding_square.size().x()) / 2;
-    bounding_square.min.x() -= (bounding_square_size - bounding_square.size().x()) / 2;
-    bounding_square.max.y() += (bounding_square_size - bounding_square.size().y()) / 2;
-    bounding_square.min.y() -= (bounding_square_size - bounding_square.size().y()) / 2;
-
-    // Intersection - limit the search box to a square area around the start and end, to fasten the path searching
-    search_box.max = search_box.max.cwiseMin(bounding_square.max);
-    search_box.min = search_box.min.cwiseMax(bounding_square.min);
-
-    auto cell_query = [&](Pixel pixel) { return search_box.contains(pixel) && (pixel == start || pixel == end || inpassable.find(pixel) == inpassable.end()); };
-
-    JPSTracer<Pixel, decltype(cell_query)> tracer(end, cell_query);
-    using QNode = astar::QNode<JPSTracer<Pixel, decltype(cell_query)>>;
-
-    std::unordered_map<size_t, QNode>          astar_cache{};
-    std::vector<Pixel, PointsAllocator<Pixel>> out_path;
-    std::vector<decltype(tracer)::Node>        out_nodes;
-
-    if (!astar::search_route(tracer, {start, {0, 0}}, std::back_inserter(out_nodes), astar_cache)) {
-        // path not found - just reconstruct the best path from astar cache.
-        // Note that astar_cache is NOT empty - at least the starting point should always be there
-        auto                coordiante_func = [&astar_cache](size_t idx, size_t dim) { return float(astar_cache[idx].node.position[dim]); };
-        std::vector<size_t> keys;
-        keys.reserve(astar_cache.size());
-        for (const auto &pair : astar_cache) { keys.push_back(pair.first); }
-        KDTreeIndirect<2, float, decltype(coordiante_func)> kd_tree(coordiante_func, keys);
-        size_t                                              closest_qnode = find_closest_point(kd_tree, end.cast<float>());
-
-        out_path.push_back(end);
-        while (closest_qnode != astar::Unassigned) {
-            out_path.push_back(astar_cache[closest_qnode].node.position);
-            closest_qnode = astar_cache[closest_qnode].parent;
-        }
-    } else {
-        for (const auto &node : out_nodes) { out_path.push_back(node.position); }
-        out_path.push_back(start);
-    }
-
-#ifdef DEBUG_FILES
-    auto scaled_points = [](const Points &ps) {
-        Points r;
-        for (const Point &p : ps) { r.push_back(Point::new_scale(p.x(), p.y())); }
-        return r;
-    };
-    auto          scaled_point = [](const Point &p) { return Point::new_scale(p.x(), p.y()); };
-    ::Slic3r::SVG svg(debug_out_path(("path_jps" + std::to_string(print_z) + "_" + std::to_string(rand() % 1000)).c_str()).c_str(),
-                      BoundingBox(scaled_point(search_box.min), scaled_point(search_box.max)));
-    for (const auto &p : inpassable) { svg.draw(scaled_point(p), "black", scale_(0.4)); }
-    for (const auto &qn : astar_cache) { svg.draw(scaled_point(qn.second.node.position), "blue", scale_(0.3)); }
-    svg.draw(Polyline(scaled_points(out_path)), "yellow", scale_(0.25));
-    svg.draw(scaled_point(end), "purple", scale_(0.4));
-    svg.draw(scaled_point(start), "green", scale_(0.4));
-#endif
-
-    std::vector<Pixel, PointsAllocator<Pixel>> tmp_path;
-    tmp_path.reserve(out_path.size());
-    // Some path found, reverse and remove points that do not change direction
-    std::reverse(out_path.begin(), out_path.end());
-    {
-        tmp_path.push_back(out_path.front()); // first point
-        for (size_t i = 1; i < out_path.size() - 1; i++) {
-            if ((out_path[i] - out_path[i - 1]).cast<float>().normalized() != (out_path[i + 1] - out_path[i]).cast<float>().normalized()) { tmp_path.push_back(out_path[i]); }
-        }
-        tmp_path.push_back(out_path.back()); // last_point
-        out_path = tmp_path;
-    }
-
-#ifdef DEBUG_FILES
-    svg.draw(Polyline(scaled_points(out_path)), "orange", scale_(0.20));
-#endif
-
-    tmp_path.clear();
-    // remove redundant jump points - there are points that change direction but are not needed - this inefficiency arises from the
-    // usage of grid search The removal alg tries to find the longest Px Px+k path without obstacles. If Px Px+k+1 is blocked, it will
-    // insert the Px+k point to result and continue search from Px+k
-    {
-        tmp_path.push_back(out_path.front()); // first point
-        size_t index_of_last_stored_point = 0;
-        for (size_t i = 1; i < out_path.size(); i++) {
-            if (i - index_of_last_stored_point < 2) continue;
-            bool passable       = true;
-            auto store_obstacle = [&](coord_t x, coord_t y) {
-                if (Pixel(x, y) != start && Pixel(x, y) != end && inpassable.find(Pixel(x, y)) != inpassable.end()) {
-                    passable = false;
-                    return false;
-                }
-                return true;
-            };
-            dda(tmp_path.back().x(), tmp_path.back().y(), out_path[i].x(), out_path[i].y(), store_obstacle);
-            if (!passable) {
-                tmp_path.push_back(out_path[i - 1]);
-                index_of_last_stored_point = i - 1;
-            }
-        }
-        tmp_path.push_back(out_path.back()); // last_point
-        out_path = tmp_path;
-    }
-
-#ifdef DEBUG_FILES
-    svg.draw(Polyline(scaled_points(out_path)), "red", scale_(0.15));
-    svg.Close();
-#endif
-
-    // before returing the path, transform it from pixels back to points.
-    // Also replace the first and last pixel by input points so that result path patches input params exactly.
-    for (Pixel &p : out_path) { p = unpixelize(p); }
-    out_path.front() = p0;
-    out_path.back()  = p1;
-
-    return Polyline(out_path);
-}
-
-} // namespace Slic3r

src/libslic3r/JumpPointSearch.hpp

@@ -1,39 +0,0 @@
-#pragma once
-#include "Line.hpp"
-#ifndef SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
-#define SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
-
-#include "BoundingBox.hpp"
-#include "Polygon.hpp"
-#include "libslic3r/Layer.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/libslic3r.h"
-#include <unordered_map>
-#include <unordered_set>
-
-namespace Slic3r {
-
-class JPSPathFinder
-{
-    using Pixel = Point;
-    std::unordered_set<Pixel, PointHash> inpassable;
-    coordf_t                             print_z;
-    BoundingBox                          max_search_box;
-    Lines                                bed_shape;
-
-    const coord_t resolution = scaled(1.5);
-    Pixel         pixelize(const Point &p) { return p / resolution; }
-    Point         unpixelize(const Pixel &p) { return p * resolution; }
-
-public:
-    JPSPathFinder() = default;
-    void     init_bed_shape(const Points &bed_shape) { this->bed_shape = (to_lines(Polygon{bed_shape})); };
-    void     clear();
-    void     add_obstacles(const Lines &obstacles);
-    Polyline find_path(const Point &start, const Point &end);
-};
-
-} // namespace Slic3r
-
-#endif /* SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_ */

src/libslic3r/MeshBoolean.cpp

@@ -29,8 +29,6 @@
 #include <CGAL/Polygon_mesh_processing/triangulate_hole.h>
 #include <CGAL/Polygon_mesh_processing/stitch_borders.h>
 #include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
-#include <CGAL/Polygon_mesh_processing/repair_degeneracies.h>
-#include <CGAL/Polygon_mesh_processing/manifoldness.h>
 #include <cstdint>
 #include <map>
 #include <algorithm>
@@ -50,7 +48,6 @@
 #include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
 #include <CGAL/Polygon_mesh_processing/repair.h>
 #include <CGAL/Polygon_mesh_processing/remesh.h>
-#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
 #include <CGAL/Polygon_mesh_processing/orientation.h>
 // BBS: for segment
 #include <CGAL/mesh_segmentation.h>
@@ -658,91 +655,6 @@ bool empty(const CGALMesh &mesh)
     return mesh.m.is_empty();
 }
 
-bool repair(TriangleMesh& mesh, RepairedMeshErrors* repaired_errors, std::string* error)
-{
-    namespace PMP = CGAL::Polygon_mesh_processing;
-
-    if (mesh.empty())
-        return true;
-
-    try {
-        // 1) Convert to polygon soup
-        std::vector<_EpicMesh::Point>         points;
-        std::vector<std::vector<std::size_t>> polygons;
-
-        points.reserve(mesh.its.vertices.size());
-        polygons.reserve(mesh.its.indices.size());
-
-        for (const auto& v : mesh.its.vertices)
-            points.emplace_back(v.x(), v.y(), v.z());
-
-        for (const auto& f : mesh.its.indices)
-            polygons.push_back({size_t(f[0]), size_t(f[1]), size_t(f[2])});
-
-        // 2) Aggressive soup cleanup
-        PMP::repair_polygon_soup(points, polygons);
-
-        // 3) Convert soup → mesh
-        _EpicMesh cgal_mesh;
-        PMP::polygon_soup_to_polygon_mesh(points, polygons, cgal_mesh);
-
-        // 4) Remove degenerate geometry
-        PMP::remove_degenerate_faces(cgal_mesh);
-        PMP::remove_isolated_vertices(cgal_mesh);
-
-        // 5) Fix remaining non-manifold vertices
-        PMP::duplicate_non_manifold_vertices(cgal_mesh);
-
-        // 6) Boolean union (keeps only outer shell)
-        _EpicMesh tmp;
-        if (PMP::corefine_and_compute_union(cgal_mesh, cgal_mesh, tmp)) {
-            cgal_mesh = std::move(tmp);
-        }
-        // If it fails, continue anyway with previous mesh
-
-        // 7) Fill holes
-        if (!CGAL::is_closed(cgal_mesh)) {
-            using halfedge_descriptor = boost::graph_traits<_EpicMesh>::halfedge_descriptor;
-
-            std::vector<halfedge_descriptor> borders;
-            CGAL::extract_boundary_cycles(cgal_mesh, std::back_inserter(borders));
-
-            for (halfedge_descriptor h : borders) {
-                PMP::triangulate_and_refine_hole(cgal_mesh, h);
-            }
-        }
-
-        // 8) Final validity check
-        if (!CGAL::is_closed(cgal_mesh)) {
-            if (error)
-                *error = "Repair failed: mesh still open after hole filling.";
-            return false;
-        }
-
-        // 9) Ensure outward orientation
-        if (!PMP::does_bound_a_volume(cgal_mesh))
-            PMP::orient_to_bound_a_volume(cgal_mesh);
-
-        // 10) Convert back
-        indexed_triangle_set its = cgal_to_indexed_triangle_set(cgal_mesh);
-
-        RepairedMeshErrors errs{};
-        errs.facets_removed = 0;
-        errs.edges_fixed    = 0;
-
-        mesh = TriangleMesh(std::move(its), errs);
-
-        if (repaired_errors)
-            *repaired_errors = errs;
-
-        return true;
-    } catch (const std::exception& e) {
-        if (error)
-            *error = e.what();
-        return false;
-    }
-}
-
 CGALMeshPtr clone(const CGALMesh &m)
 {
     return CGALMeshPtr{new CGALMesh{m}};

src/libslic3r/MeshBoolean.hpp

@@ -77,9 +77,6 @@ TriangleMesh merge(std::vector<TriangleMesh> meshes);
 bool does_bound_a_volume(const CGALMesh &mesh);
 bool empty(const CGALMesh &mesh);
 
-// Repair a mesh using CGAL. Returns true on success. Optionally returns a summary of repairs and an error string.
-bool repair(TriangleMesh &mesh, RepairedMeshErrors *repaired_errors = nullptr, std::string *error = nullptr);
-
 // Real UV unwrap of an open mesh patch via CGAL's LSCM (Least Squares Conformal Maps) surface
 // parameterization. Returns one UV coordinate per input vertex (same indexing as `mesh.vertices`),
 // or nullopt if `mesh` isn't a single topological disk -- LSCM needs exactly one connected

src/libslic3r/MeshRepair.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <string>
+
+namespace Slic3r {
+
+class TriangleMesh;
+
+struct MeshRepairStats
+{
+    std::size_t welded_vertices    = 0;
+    std::size_t removed_triangles  = 0;
+    std::size_t reversed_shells    = 0;
+    std::size_t filled_holes       = 0;
+    std::size_t removed_shells     = 0;
+    std::size_t self_intersections = 0;
+    // False when the input already was closed, consistently oriented and free of self-intersections.
+    bool        modified           = false;
+};
+
+// Returns false, leaving the mesh untouched, if no solid can be built. progress gets the percentage done and may
+// throw to cancel. See docs/HLSD/mesh-repair.md.
+bool repair_mesh(TriangleMesh &mesh, MeshRepairStats *stats = nullptr, std::string *error = nullptr,
+                 const std::function<void(int)> &progress = {});
+
+} // namespace Slic3r

src/libslic3r/Model.cpp

@@ -29,6 +29,7 @@
 #include "TriangleMeshSlicer.hpp"
 #include "TriangleSelector.hpp"
 #include "MaterialType.hpp"
+#include "MeshRepair.hpp"
 
 #include "Format/AMF.hpp"
 #include "Format/svg.hpp"
@@ -353,6 +354,24 @@ Model Model::read_from_file(const std::string&
         ObjInfo                 obj_info;
         ObjParser::MtlData      mtl_data;
         result = load_obj(input_file.c_str(), &model, obj_info, message, nullptr, &mtl_data);
+        // Keep the model's own UV channel on the volume, whatever the colour import then does with
+        // the mesh: it is what TextureProjectionMethod::ModelUV maps a texture-displacement layer
+        // through, so a model that arrives with a UV layout is textured on that layout instead of on
+        // a fresh unwrap. load_obj() fills obj_info.uvs per face of the mesh it built, in the same
+        // order (and only when every face named a known material, hence the size check). V is flipped
+        // on the way in, to the convention DecodedHeightTexture samples in - the same flip
+        // obj_to_textured_mesh() does for the colour importer.
+        if (result && !obj_info.uvs.empty() && !model.objects.empty() && !model.objects.back()->volumes.empty()) {
+            ModelVolume                &volume = *model.objects.back()->volumes[0];
+            const indexed_triangle_set &its    = volume.mesh().its;
+            if (obj_info.uvs.size() == its.indices.size()) {
+                volume.texture_uv.resize(its.indices.size() * 3);
+                for (size_t fi = 0; fi < obj_info.uvs.size(); ++fi)
+                    for (int k = 0; k < 3; ++k)
+                        volume.texture_uv[fi * 3 + size_t(k)] =
+                            Vec2f(obj_info.uvs[fi][size_t(k)].x(), 1.f - obj_info.uvs[fi][size_t(k)].y());
+            }
+        }
         if (result && obj_info.has_uv_png && !obj_info.uvs.empty() && !model.objects.empty()) {
             // Textured OBJ: hand the mesh + materials to the texture-to-color importer
             // instead of the flat per-face colour dialog.
@@ -453,7 +472,7 @@ Model Model::read_from_file(const std::string&
              boost::algorithm::iends_with(input_file, ".abc") || boost::algorithm::iends_with(input_file, ".ply")) {
         std::string temp_stl = make_temp_stl_with_modelio(input_file);
         if (temp_stl.empty()) {
-            throw Slic3r::RuntimeError("Failed to convert asset to STL via ModelIO.");
+            throw Slic3r::RuntimeError(_L("Failed to convert asset to STL via ModelIO."));
         }
         result = load_stl(temp_stl.c_str(), &model);
         delete_temp_file(temp_stl);
@@ -1261,6 +1280,7 @@ ModelObject& ModelObject::assign_copy(const ModelObject &rhs)
     this->layer_config_ranges         = rhs.layer_config_ranges;
     this->layer_height_profile        = rhs.layer_height_profile;
     this->printable                   = rhs.printable;
+    this->auto_drop                   = rhs.auto_drop;
     this->origin_translation          = rhs.origin_translation;
     this->cut_id.copy(rhs.cut_id);
     this->copy_transformation_caches(rhs);
@@ -1301,6 +1321,7 @@ ModelObject& ModelObject::assign_copy(ModelObject &&rhs)
     this->layer_config_ranges         = std::move(rhs.layer_config_ranges);
     this->layer_height_profile        = std::move(rhs.layer_height_profile);
     this->printable                   = std::move(rhs.printable);
+    this->auto_drop                   = rhs.auto_drop;
     this->origin_translation          = std::move(rhs.origin_translation);
     this->copy_transformation_caches(rhs);
 
@@ -1870,6 +1891,9 @@ void ModelObject::center_around_origin(bool include_modifiers)
 
 void ModelObject::ensure_on_bed(bool allow_negative_z)
 {
+    if (!auto_drop)
+        return;
+
     double z_offset = 0.0;
 
     if (allow_negative_z) {
@@ -1888,14 +1912,8 @@ void ModelObject::ensure_on_bed(bool allow_negative_z)
     else
         z_offset = -this->min_z();
 
-    if (z_offset != 0.0) {
-        for (size_t i = 0; i < instances.size(); ++i) {
-            if (!instances[i]->auto_drop)
-                continue;
-
-            translate_instance(i, z_offset * Vec3d::UnitZ());
-        }
-    }
+    if (z_offset != 0.0)
+        translate_instances(z_offset * Vec3d::UnitZ());
 }
 
 void ModelObject::translate_instances(const Vec3d& vector)
@@ -2133,6 +2151,10 @@ void ModelVolume::reset_extra_facets()
     // than left referring to a mesh that no longer matches it.
     for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
         this->texture_displacement_facet(i).reset();
+    // Same reasoning for the model's own UV channel: it is indexed by triangle, so against a mesh
+    // this no longer matches it would map the texture by another mesh's triangle numbering. A caller
+    // that can carry it across - see transfer_uv_channel() - puts it back after this.
+    this->reset_texture_uv();
 }
 
 std::optional<TriangleSelector::SavedPainting> ModelVolume::save_painting() const
@@ -2946,6 +2968,18 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
     if (text_configuration.has_value())
         text_configuration.reset();
 
+    // Parts without a convex hull enclose no volume; drop them here, as deleting volumes later could delete this one.
+    std::vector<std::unique_ptr<ModelVolume>> parts;
+    for (TriangleMesh &mesh : meshes)
+        if (!mesh.empty()) {
+            std::unique_ptr<ModelVolume> part(new ModelVolume(object, *this, std::move(mesh)));
+            if (const std::shared_ptr<const TriangleMesh> &hull = part->get_convex_hull_shared_ptr();
+                hull != nullptr && !hull->its.vertices.empty() && !hull->its.indices.empty())
+                parts.emplace_back(std::move(part));
+        }
+    if (parts.empty())
+        return 1;
+
     std::optional<TriangleSelector::SavedPainting> saved_painting = remap_paint ? save_painting() :
                                                                                   std::optional<TriangleSelector::SavedPainting>{};
 
@@ -2956,26 +2990,22 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
     unsigned int extruder_counter = 0;
     const Vec3d offset = this->get_offset();
 
-    for (TriangleMesh &mesh : meshes) {
-        if (mesh.empty())
-            // Repair may have removed unconnected triangles, thus emptying the mesh.
-            continue;
-
+    for (std::unique_ptr<ModelVolume> &part : parts) {
         if (idx == 0) {
-            this->set_mesh(std::move(mesh));
-            this->calculate_convex_hull();
+            this->set_mesh(part->m_mesh);
+            m_convex_hull = part->m_convex_hull;
             this->invalidate_convex_hull_2d();
             // Assign a new unique ID, so that a new GLVolume will be generated.
             this->set_new_unique_id();
-            // reset the source to disable reload from disk
-            this->source = ModelVolume::Source();
 
             // BBS: reset facet annotations
             this->reset_extra_facets();
         }
         else
-            this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), new ModelVolume(object, *this, std::move(mesh)));
+            this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), part.release());
 
+        // reset the source to disable reload from disk
+        this->object->volumes[ivolume]->source = ModelVolume::Source();
         this->object->volumes[ivolume]->set_offset(Vec3d::Zero());
         this->object->volumes[ivolume]->center_geometry_after_creation();
         this->object->volumes[ivolume]->translate(offset);
@@ -2989,21 +3019,29 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
         ++ idx;
     }
 
-    // discard volumes for which the convex hull was not generated or is degenerate
-    size_t i = 0;
-    while (i < this->object->volumes.size()) {
-        const std::shared_ptr<const TriangleMesh> &hull = this->object->volumes[i]->get_convex_hull_shared_ptr();
-        if (hull == nullptr || hull->its.vertices.empty() || hull->its.indices.empty()) {
-            this->object->delete_volume(i);
-            --idx;
-            --i;
-        }
-        ++i;
-    }
-
     return idx;
 }
 
+bool ModelVolume::repair(bool keep_painting, MeshRepairStats *stats_out, std::string *error, const std::function<void(int)> &progress)
+{
+    TriangleMesh    mesh = this->mesh();
+    MeshRepairStats stats;
+    const bool      ok = repair_mesh(mesh, &stats, error, progress);
+    if (stats_out)
+        *stats_out = stats;
+    if (!ok || !stats.modified)
+        return ok;
+
+    const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ? save_painting() : std::nullopt;
+    this->set_mesh(std::move(mesh));
+    this->calculate_convex_hull();
+    this->invalidate_convex_hull_2d();
+    // Assign a new unique ID, so that a new GLVolume will be generated.
+    this->set_new_unique_id();
+    this->restore_painting(saved_painting);
+    return true;
+}
+
 void ModelVolume::translate(const Vec3d& displacement)
 {
     set_offset(get_offset() + displacement);

src/libslic3r/Model.hpp

@@ -77,6 +77,7 @@ class Preset;
 class BBLProject;
 
 class KeyStore;
+struct MeshRepairStats;
 
 namespace UndoRedo {
 	class StackImpl;
@@ -399,6 +400,9 @@ public:
     LayerHeightProfile      layer_height_profile;
     // Whether or not this object is printable
     bool                    printable { true };
+    // Whether this object is snapped to the build plate after transformations.
+    // Instance Z offsets are shared by all instances of an object.
+    bool                    auto_drop { true };
 
     // This vector holds position of selected support points for SLA. The data are
     // saved in mesh coordinates to allow using them for several instances.
@@ -705,7 +709,7 @@ private:
         Internal::StaticSerializationWrapper<ModelConfigObject const> config_wrapper(config);
         Internal::StaticSerializationWrapper<LayerHeightProfile const> layer_heigth_profile_wrapper(layer_height_profile);
         ar(name, module_name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper,
-            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation, brim_points,
+            sla_support_points, sla_points_status, sla_drain_holes, printable, auto_drop, origin_translation, brim_points,
             m_bounding_box_approx, m_bounding_box_approx_valid, 
             m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid,
             m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid,
@@ -718,7 +722,7 @@ private:
         // BBS: add backup, check modify
         SaveObjectGaurd gaurd(*this);
         ar(name, module_name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper,
-            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation, brim_points,
+            sla_support_points, sla_points_status, sla_drain_holes, printable, auto_drop, origin_translation, brim_points,
             m_bounding_box_approx, m_bounding_box_approx_valid, 
             m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid,
             m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid,
@@ -887,13 +891,13 @@ public:
     // The triangular model.
     const TriangleMesh& mesh() const { return *m_mesh.get(); }
     std::shared_ptr<const TriangleMesh> mesh_ptr() const { return m_mesh; }
-    void                set_mesh(const TriangleMesh &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); }
-    void                set_mesh(TriangleMesh &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); }
-    void                set_mesh(const indexed_triangle_set &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); }
-    void                set_mesh(indexed_triangle_set &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); }
-    void                set_mesh(std::shared_ptr<const TriangleMesh> &mesh) { m_mesh = mesh; }
-    void                set_mesh(std::unique_ptr<const TriangleMesh> &&mesh) { m_mesh = std::move(mesh); }
-	void				reset_mesh() { m_mesh = std::make_shared<const TriangleMesh>(); }
+    void                set_mesh(const TriangleMesh &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); m_is_splittable = -1; }
+    void                set_mesh(TriangleMesh &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); m_is_splittable = -1; }
+    void                set_mesh(const indexed_triangle_set &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); m_is_splittable = -1; }
+    void                set_mesh(indexed_triangle_set &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); m_is_splittable = -1; }
+    void                set_mesh(std::shared_ptr<const TriangleMesh> &mesh) { m_mesh = mesh; m_is_splittable = -1; }
+    void                set_mesh(std::unique_ptr<const TriangleMesh> &&mesh) { m_mesh = std::move(mesh); m_is_splittable = -1; }
+	void				reset_mesh() { m_mesh = std::make_shared<const TriangleMesh>(); m_is_splittable = -1; }
     const std::shared_ptr<const TriangleMesh>& get_mesh_shared_ptr() const { return m_mesh; }
     // Configuration parameters specific to an object model geometry or a modifier volume, 
     // overriding the global Slic3r settings and the ModelObject settings.
@@ -974,6 +978,26 @@ public:
     // they are not a property of any single layer.
     TextureDisplacementOptions texture_displacement_options;
 
+    // The model's own texture coordinates, as the file it was imported from carried them: three per
+    // triangle of mesh().its, in its triangle order (corner k of triangle i at 3i+k), V already
+    // flipped to the sampling convention (V = 0 is the image's top row). Empty when the source had
+    // none, which is every STL and every 3mf - only a textured OBJ brings one in today.
+    //
+    // Per corner rather than per vertex because that is what a UV layout is: the two sides of a seam
+    // are the same vertex with two different coordinates, and collapsing them would smear the texture
+    // across every island boundary. TextureProjectionMethod::ModelUV maps through it, which is what
+    // lets a model that already carries a UV channel be textured on the artist's own layout instead
+    // of on a fresh unwrap.
+    //
+    // Indexed by triangle, so anything that *replaces* the mesh has to bring it across (or drop it):
+    // see transfer_uv_channel(), and reset_texture_uv() for the cases that cannot.
+    std::vector<Vec2f> texture_uv;
+
+    bool has_texture_uv() const { return !texture_uv.empty() && texture_uv.size() == mesh().its.indices.size() * 3; }
+    // Forgets the channel. For a mesh change that nothing can carry it across - a split, a boolean -
+    // where leaving it would map the texture by another mesh's triangle numbering.
+    void reset_texture_uv() { texture_uv.clear(); }
+
     // Save painting data before reset_extra_facets() discards it.
     // Used for replacing mesh without losing painting data.
     // Only for model parts (not modifiers/connectors).
@@ -1043,6 +1067,9 @@ public:
     // Return the number of volumes created from this one.
     // This is useful to assign different materials to different volumes of an object.
     size_t              split(unsigned int max_extruders, bool remap_paint);
+    // Replaces the mesh by its repair_mesh() result if that changed it. False if no solid can be built.
+    bool                repair(bool keep_painting, MeshRepairStats *stats = nullptr, std::string *error = nullptr,
+                               const std::function<void(int)> &progress = {});
     void                translate(double x, double y, double z) { translate(Vec3d(x, y, z)); }
     void                translate(const Vec3d& displacement);
     void                scale(const Vec3d& scaling_factors);
@@ -1236,6 +1263,7 @@ private:
         texture_displacement_facets_6(other.texture_displacement_facets_6), texture_displacement_facets_7(other.texture_displacement_facets_7),
         texture_displacement_layers(other.texture_displacement_layers),
         texture_displacement_options(other.texture_displacement_options),
+        texture_uv(other.texture_uv),
         cut_info(other.cut_info), text_configuration(other.text_configuration), emboss_shape(other.emboss_shape)
     {
 		assert(this->id().valid());
@@ -1334,7 +1362,7 @@ private:
             cereal::load_by_value(ar, f);
             mesh_changed |= tf != f.timestamp();
         }
-        ar(texture_displacement_layers, texture_displacement_options);
+        ar(texture_displacement_layers, texture_displacement_options, texture_uv);
         cereal::load_by_value(ar, config);
         cereal::load(ar, text_configuration);
         cereal::load(ar, emboss_shape);
@@ -1358,7 +1386,7 @@ private:
         cereal::save_by_value(ar, fuzzy_skin_facets);
         for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
             cereal::save_by_value(ar, texture_displacement_facet(i));
-        ar(texture_displacement_layers, texture_displacement_options);
+        ar(texture_displacement_layers, texture_displacement_options, texture_uv);
         cereal::save_by_value(ar, config);
         cereal::save(ar, text_configuration);
         cereal::save(ar, emboss_shape);
@@ -1402,7 +1430,6 @@ public:
     ModelInstanceEPrintVolumeState print_volume_state;
     // Whether or not this instance is printable
     bool printable;
-    bool auto_drop;
     bool use_loaded_id_for_label {false};
     int arrange_order = 0; // BBS
     size_t loaded_id = 0; // BBS
@@ -1532,7 +1559,7 @@ private:
 
     // Constructor, which assigns a new unique ID.
     explicit ModelInstance(ModelObject* object)
-        : print_volume_state(ModelInstancePVS_Inside), printable(true), auto_drop(true), object(object), m_assemble_initialized(false)
+        : print_volume_state(ModelInstancePVS_Inside), printable(true), object(object), m_assemble_initialized(false)
     {
         assert(this->id().valid());
     }
@@ -1543,7 +1570,6 @@ private:
         , m_offset_to_assembly(other.m_offset_to_assembly)
         , print_volume_state(ModelInstancePVS_Inside)
         , printable(other.printable)
-        , auto_drop(other.auto_drop)
         , object(object)
         , m_assemble_initialized(false) { assert(this->id().valid() && this->id() != other.id()); }
 
@@ -1557,7 +1583,7 @@ private:
 	ModelInstance() : ObjectBase(-1), object(nullptr) { assert(this->id().invalid()); }
     // BBS. Add added members to archive.
     template<class Archive> void serialize(Archive& ar) {
-        ar(m_transformation, print_volume_state, printable, auto_drop, m_assemble_transformation, m_offset_to_assembly, m_assemble_initialized);
+        ar(m_transformation, print_volume_state, printable, m_assemble_transformation, m_offset_to_assembly, m_assemble_initialized);
     }
 };
 

src/libslic3r/PlaceholderParser.cpp

@@ -5,6 +5,8 @@
 #include "PrintConfig.hpp"
 #include "Point.hpp"
 #include "Utils.hpp"
+#include "I18N.hpp"
+#include "format.hpp"
 #include "libslic3r_version.h"
 #include <cassert>
 #include <boost/range/iterator_range_core.hpp>
@@ -383,7 +385,7 @@ namespace client
             case TYPE_DOUBLE:
                 return expr(- this->d(), start_pos, this->it_range.end()); 
             default:
-                this->throw_exception("Cannot apply unary minus operator.");
+                this->throw_exception(L("Cannot apply unary minus operator."));
             }
             assert(false);
             // Suppress compiler warnings.
@@ -401,7 +403,7 @@ namespace client
             case TYPE_DOUBLE:
                 return expr(static_cast<int>(this->d()), start_pos, this->it_range.end()); 
             default:
-                this->throw_exception("Cannot convert to integer.");
+                this->throw_exception(L("Cannot convert to integer."));
             }
             assert(false);
             // Suppress compiler warnings.
@@ -419,7 +421,7 @@ namespace client
             case TYPE_DOUBLE:
                 return expr(static_cast<int>(std::round(this->d())), start_pos, this->it_range.end());
             default:
-                this->throw_exception("Cannot round a non-numeric value.");
+                this->throw_exception(L("Cannot round a non-numeric value."));
             }
             assert(false);
             // Suppress compiler warnings.
@@ -434,7 +436,7 @@ namespace client
             case TYPE_DOUBLE:
                 return expr(static_cast<int>(std::floor(this->d())), start_pos, this->it_range.end());
             default:
-                this->throw_exception("Cannot floor a non-numeric value.");
+                this->throw_exception(L("Cannot floor a non-numeric value."));
             }
             assert(false);
             // Suppress compiler warnings.
@@ -449,7 +451,7 @@ namespace client
             case TYPE_DOUBLE:
                 return expr(static_cast<int>(std::ceil(this->d())), start_pos, this->it_range.end());
             default:
-                this->throw_exception("Cannot ceil a non-numeric value.");
+                this->throw_exception(L("Cannot ceil a non-numeric value."));
             }
             assert(false);
             // Suppress compiler warnings.
@@ -465,7 +467,7 @@ namespace client
             case TYPE_BOOL:
                 return expr(! this->b(), start_pos, this->it_range.end());
             default:
-                this->throw_exception("Cannot apply a not operator.");
+                this->throw_exception(L("Cannot apply a not operator."));
             }
             assert(false);
             // Suppress compiler warnings.
@@ -483,7 +485,7 @@ namespace client
                 // Conver the left hand side to string, append rhs.
                 this->set_s(this->to_string() + rhs.s());
             } else {
-                const char *err_msg = "Cannot add non-numeric types.";
+                const char *err_msg = L("Cannot add non-numeric types.");
                 this->throw_if_not_numeric(err_msg);
                 rhs.throw_if_not_numeric(err_msg);
                 if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
@@ -501,7 +503,7 @@ namespace client
                 // Inside an if / else block to be skipped.
                 this->reset();
             } else {
-                const char *err_msg = "Cannot subtract non-numeric types.";
+                const char *err_msg = L("Cannot subtract non-numeric types.");
                 this->throw_if_not_numeric(err_msg);
                 rhs.throw_if_not_numeric(err_msg);
                 if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
@@ -519,7 +521,7 @@ namespace client
                 // Inside an if / else block to be skipped.
                 this->reset();
             } else {
-                const char *err_msg = "Cannot multiply with non-numeric type.";
+                const char *err_msg = L("Cannot multiply with non-numeric type.");
                 this->throw_if_not_numeric(err_msg);
                 rhs.throw_if_not_numeric(err_msg);
                 if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
@@ -537,10 +539,10 @@ namespace client
                 // Inside an if / else block to be skipped.
                 this->reset();
             } else {
-                this->throw_if_not_numeric("Cannot divide a non-numeric type.");
-                rhs.throw_if_not_numeric("Cannot divide with a non-numeric type.");
+                this->throw_if_not_numeric(L("Cannot divide a non-numeric type."));
+                rhs.throw_if_not_numeric(L("Cannot divide with a non-numeric type."));
                 if (rhs.type() == TYPE_INT ? (rhs.i() == 0) : (rhs.d() == 0.))
-                    rhs.throw_exception("Division by zero");
+                    rhs.throw_exception(L("Division by zero"));
                 if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                     this->set_d_lite(this->as_d() / rhs.as_d());
                 else
@@ -556,10 +558,10 @@ namespace client
                 // Inside an if / else block to be skipped.
                 this->reset();
             } else {
-                this->throw_if_not_numeric("Cannot divide a non-numeric type.");
-                rhs.throw_if_not_numeric("Cannot divide with a non-numeric type.");
+                this->throw_if_not_numeric(L("Cannot divide a non-numeric type."));
+                rhs.throw_if_not_numeric(L("Cannot divide with a non-numeric type."));
                 if (rhs.type() == TYPE_INT ? (rhs.i() == 0) : (rhs.d() == 0.))
-                    rhs.throw_exception("Division by zero");
+                    rhs.throw_exception(L("Division by zero"));
                 if (this->type() == TYPE_DOUBLE || rhs.type() == TYPE_DOUBLE)
                     this->set_d_lite(std::fmod(this->as_d(), rhs.as_d()));
                 else
@@ -581,7 +583,7 @@ namespace client
             if (self.type() != TYPE_EMPTY) {
                 // Not inside an if / else block to be skipped
                 if (self.type() != TYPE_BOOL)
-                    self.throw_exception("Not a boolean expression");
+                    self.throw_exception(L("Not a boolean expression"));
                 out = self.b();
             }
         }
@@ -590,7 +592,7 @@ namespace client
         {
             assert(self.type() != TYPE_EMPTY);
             if (self.type() != TYPE_BOOL)
-                self.throw_exception("Not a boolean expression");
+                self.throw_exception(L("Not a boolean expression"));
             out = self.b() ? "true" : "false";
         }
 
@@ -622,7 +624,7 @@ namespace client
                 // Both type are bool.
                 if (op != '=')
                     boost::throw_exception(qi::expectation_failure<Iterator>(
-                        lhs.it_range.begin(), rhs.it_range.end(), spirit::info("*Cannot compare the types.")));
+                        lhs.it_range.begin(), rhs.it_range.end(), spirit::info(std::string("*") + L("Cannot compare the types."))));
                 value = lhs.b() == rhs.b();
             } else if (lhs.type() == TYPE_STRING || rhs.type() == TYPE_STRING) {
                 // One type is string, the other could be converted to string.
@@ -630,7 +632,7 @@ namespace client
                         (op == '<') ? (lhs.to_string() < rhs.to_string()) : (lhs.to_string() > rhs.to_string());
             } else {
                 boost::throw_exception(qi::expectation_failure<Iterator>(
-                    lhs.it_range.begin(), rhs.it_range.end(), spirit::info("*Cannot compare the types.")));
+                    lhs.it_range.begin(), rhs.it_range.end(), spirit::info(std::string("*") + L("Cannot compare the types."))));
             }
             lhs.reset();
             lhs.set_b_lite(invert ? ! value : value);
@@ -645,7 +647,7 @@ namespace client
 
         static void throw_if_not_numeric(const expr &param)
         {
-            const char *err_msg = "Not a numeric type.";
+            const char *err_msg = L("Not a numeric type.");
             param.throw_if_not_numeric(err_msg);
         }
 
@@ -707,10 +709,10 @@ namespace client
                 return;
             throw_if_not_numeric(param1);
             if (param2.type() != TYPE_INT)
-                param2.throw_exception("digits: second parameter must be integer");
+                param2.throw_exception(L("digits: second parameter must be integer"));
             bool has_decimals = param3.type() != TYPE_EMPTY;
             if (has_decimals && param3.type() != TYPE_INT)
-                param3.throw_exception("digits: third parameter must be integer");
+                param3.throw_exception(L("digits: third parameter must be integer"));
 
             char buf[256];
             int  ndigits = std::clamp(param2.as_i(), 0, 64);
@@ -734,7 +736,7 @@ namespace client
                 // One type is string, the other could be converted to string.
                 subject = &lhs.s();
             } else {
-                lhs.throw_exception("Left hand side of a regex match must be a string.");
+                lhs.throw_exception(L("Left hand side of a regex match must be a string."));
             }
             try {
                 std::string pattern(++ rhs.begin(), -- rhs.end());
@@ -745,7 +747,7 @@ namespace client
             } catch (SLIC3R_REGEX_NAMESPACE::regex_error &ex) {
                 // Syntax error in the regular expression
                 boost::throw_exception(qi::expectation_failure<Iterator>(
-                    rhs.begin(), rhs.end(), spirit::info(std::string("*Regular expression compilation failed: ") + ex.what())));
+                    rhs.begin(), rhs.end(), spirit::info("*" + Slic3r::format(_u8L("Regular expression compilation failed: %1%"), ex.what()))));
             }
         }
 
@@ -760,7 +762,7 @@ namespace client
                 // Inside an if / else block to be skipped
                 return;
             if (subject.type() != TYPE_STRING)
-                subject.throw_exception("regex_replace() first parameter must be a string.");
+                subject.throw_exception(L("regex_replace() first parameter must be a string."));
             try {
                 std::string re(++ pattern.begin(), -- pattern.end());
                 std::string result = SLIC3R_REGEX_NAMESPACE::regex_replace(subject.s(), SLIC3R_REGEX_NAMESPACE::regex(re), replacement.to_string());
@@ -768,7 +770,7 @@ namespace client
             } catch (SLIC3R_REGEX_NAMESPACE::regex_error &ex) {
                 // Syntax error in the regular expression
                 boost::throw_exception(qi::expectation_failure<Iterator>(
-                    pattern.begin(), pattern.end(), spirit::info(std::string("*Regular expression compilation failed: ") + ex.what())));
+                    pattern.begin(), pattern.end(), spirit::info("*" + Slic3r::format(_u8L("Regular expression compilation failed: %1%"), ex.what()))));
             }
         }
 
@@ -784,15 +786,15 @@ namespace client
             }
             if (! out.b()) {
                 if (match.type() != TYPE_STRING)
-                    match.throw_exception("one_of(): First parameter (the string to match against) has to be a string value");
+                    match.throw_exception(L("one_of(): First parameter (the string to match against) has to be a string value"));
                 if (pattern.type() != TYPE_STRING)
-                    match.throw_exception("one_of(): Pattern has to be a string value");
+                    match.throw_exception(L("one_of(): Pattern has to be a string value"));
                 if (RegEx) {
                     try {
                         out.set_b(SLIC3R_REGEX_NAMESPACE::regex_match(match.s(), SLIC3R_REGEX_NAMESPACE::regex(pattern.s())));
                     } catch (SLIC3R_REGEX_NAMESPACE::regex_error &) {
                         // Syntax error in the regular expression
-                        pattern.throw_exception("Regular expression compilation failed");
+                        pattern.throw_exception(L("Regular expression compilation failed"));
                     }
                 } else
                     out.set_b(match.s() == pattern.s());
@@ -806,7 +808,7 @@ namespace client
             }
             if (! out.b()) {
                 if (match.type() != TYPE_STRING)
-                    match.throw_exception("one_of(): First parameter (the string to match against) has to be a string value");
+                    match.throw_exception(L("one_of(): First parameter (the string to match against) has to be a string value"));
                 regex_op(match, pattern, '=', out);
             }
         }
@@ -821,7 +823,7 @@ namespace client
                 value = (op == '|') ? (lhs.b() || rhs.b()) : (lhs.b() && rhs.b());
             } else {
                 boost::throw_exception(qi::expectation_failure<Iterator>(
-                    lhs.it_range.begin(), rhs.it_range.end(), spirit::info("*Cannot apply logical operation to non-boolean operators.")));
+                    lhs.it_range.begin(), rhs.it_range.end(), spirit::info(std::string("*") + L("Cannot apply logical operation to non-boolean operands."))));
             }
             lhs.set_b_lite(value);
         }
@@ -984,30 +986,30 @@ namespace client
                     opt = ctx->resolve_symbol(opt_key_str.substr(0, idx));
                     if (opt != nullptr) {
                         if (! opt->is_vector())
-                            ctx->throw_exception("Trying to index a scalar variable", opt_key);
+                            ctx->throw_exception(L("Trying to index a scalar variable"), opt_key);
                         char *endptr = nullptr;
                         idx = strtol(opt_key_str.c_str() + idx + 1, &endptr, 10);
                         if (endptr == nullptr || *endptr != 0)
-                            ctx->throw_exception("Invalid vector index", IteratorRange(opt_key.begin() + idx + 1, opt_key.end()));
+                            ctx->throw_exception(L("Invalid vector index"), IteratorRange(opt_key.begin() + idx + 1, opt_key.end()));
                     }
                 }
             }
             if (opt == nullptr)
-                ctx->throw_exception(ctx->skipping() ? "Variable does not exist (in an inactive branch)" : "Variable does not exist", opt_key);
+                ctx->throw_exception(ctx->skipping() ? L("Variable does not exist (in an inactive branch)") : L("Variable does not exist"), opt_key);
             if (ctx->skipping())
                 return;
             if (opt->is_scalar()) {
                 if (opt->is_nil())
-                    ctx->throw_exception("Trying to reference an undefined (nil) optional variable", opt_key);
+                    ctx->throw_exception(L("Trying to reference an undefined (nil) optional variable"), opt_key);
                 output = opt->serialize();
             } else {
                 const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt);
                 if (vec->empty())
-                    ctx->throw_exception("Indexing an empty vector variable", opt_key);
+                    ctx->throw_exception(L("Indexing an empty vector variable"), opt_key);
                 if (idx >= vec->size())
                     idx = 0;
                 if (vec->is_nil(idx))
-                    ctx->throw_exception("Trying to reference an undefined (nil) element of vector of optional values", opt_key);
+                    ctx->throw_exception(L("Trying to reference an undefined (nil) element of vector of optional values"), opt_key);
                 output = vec->vserialize()[idx];
             }
         }
@@ -1021,7 +1023,7 @@ namespace client
             if (ctx->skipping() && ! ctx->check_inactive_names())
                 return;
 
-            const char         *not_found = ctx->skipping() ? "Variable does not exist (in an inactive branch)" : "Variable does not exist";
+            const char         *not_found = ctx->skipping() ? L("Variable does not exist (in an inactive branch)") : L("Variable does not exist");
             std::string         opt_key_str(opt_key.begin(), opt_key.end());
             const ConfigOption *opt = ctx->resolve_symbol(opt_key_str);
             if (opt == nullptr) {
@@ -1034,24 +1036,24 @@ namespace client
                     ctx->throw_exception(not_found, opt_key);
             }
             if (! opt->is_vector())
-                ctx->throw_exception("Trying to index a scalar variable", opt_key);
+                ctx->throw_exception(L("Trying to index a scalar variable"), opt_key);
             const ConfigOption *opt_index = ctx->resolve_symbol(std::string(opt_vector_index.begin(), opt_vector_index.end()));
             if (opt_index == nullptr)
                 ctx->throw_exception(not_found, opt_key);
             if (opt_index->type() != coInt)
-                ctx->throw_exception("Indexing variable has to be integer", opt_key);
+                ctx->throw_exception(L("Indexing variable has to be integer"), opt_key);
             if (ctx->skipping())
                 return;
             const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt);
             if (vec->empty())
-                ctx->throw_exception("Indexing an empty vector variable", opt_key);
+                ctx->throw_exception(L("Indexing an empty vector variable"), opt_key);
 			int idx = opt_index->getInt();
 			if (idx < 0)
-                ctx->throw_exception("Negative vector index", opt_key);
+                ctx->throw_exception(L("Negative vector index"), opt_key);
             if (idx >= (int)vec->size())
                 idx = 0;
             if (vec->is_nil(idx))
-                ctx->throw_exception("Trying to reference an undefined (nil) element of vector of optional values", opt_key);
+                ctx->throw_exception(L("Trying to reference an undefined (nil) element of vector of optional values"), opt_key);
 			output = vec->vserialize()[idx];
         }
 
@@ -1066,7 +1068,7 @@ namespace client
                 if (opt == nullptr) {
                     opt = ctx->resolve_output_symbol(key);
                     if (opt == nullptr)
-                        ctx->throw_exception("Not a variable name", opt_key);
+                        ctx->throw_exception(L("Not a variable name"), opt_key);
                     output.writable = true;
                 }
                 output.opt = opt;
@@ -1076,7 +1078,7 @@ namespace client
                 if (ctx->resolve_symbol(key) == nullptr && ctx->resolve_output_symbol(key) == nullptr &&
                     ctx->inactive_local_variables.count(key) == 0 &&
                     (ctx->context_data == nullptr || ctx->context_data->inactive_global_variables.count(key) == 0))
-                    ctx->throw_exception("Not a variable name (in an inactive branch)", opt_key);
+                    ctx->throw_exception(L("Not a variable name (in an inactive branch)"), opt_key);
             }
             output.it_range = opt_key;
         }
@@ -1110,7 +1112,7 @@ namespace client
             assert(opt.opt->is_scalar());
 
             if (opt.opt->is_nil())
-                ctx->throw_exception("Trying to reference an undefined (nil) optional variable", opt.it_range);
+                ctx->throw_exception(L("Trying to reference an undefined (nil) optional variable"), opt.it_range);
 
             switch (opt.opt->type()) {
             case coFloat:   output.set_d(opt.opt->getFloat());   break;
@@ -1137,7 +1139,7 @@ namespace client
     			    for (;;) {
     			        const ConfigOption *opt_parent = opt_def->ratio_over.empty() ? nullptr : ctx->resolve_symbol(opt_def->ratio_over);
     			        if (opt_parent == nullptr)
-    			            ctx->throw_exception("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies", opt.it_range);
+    			            ctx->throw_exception(L("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies"), opt.it_range);
     			        if (boost::ends_with(opt_def->ratio_over, "line_width")) {
                     		// Line width supports defaults and a complex graph of dependencies.
                             assert(opt_parent->type() == coFloatOrPercent);
@@ -1159,7 +1161,7 @@ namespace client
     		    break;
     		}
             default:
-                ctx->throw_exception("Unsupported scalar variable type", opt.it_range);
+                ctx->throw_exception(L("Unsupported scalar variable type"), opt.it_range);
             }
         }
 
@@ -1173,7 +1175,7 @@ namespace client
             assert(opt.opt->is_vector());
             const ConfigOptionVectorBase* vec = static_cast<const ConfigOptionVectorBase*>(opt.opt);
             if (vec->empty())
-                ctx->throw_exception("Indexing an empty vector variable", opt.it_range);
+                ctx->throw_exception(L("Indexing an empty vector variable"), opt.it_range);
 
             // Helper to resolve a FloatOrPercent value (handles ratio_over chain for percent values).
             // elem_index: the element index used to access this vector element, so that
@@ -1194,7 +1196,7 @@ namespace client
                     for (;;) {
                         const ConfigOption *opt_parent = opt_def->ratio_over.empty() ? nullptr : ctx->resolve_symbol(opt_def->ratio_over);
                         if (opt_parent == nullptr)
-                            ctx->throw_exception("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies", opt.it_range);
+                            ctx->throw_exception(L("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies"), opt.it_range);
                         if (boost::ends_with(opt_def->ratio_over, "line_width")) {
                             // Line width supports defaults and a complex graph of dependencies.
                             assert(opt_parent->type() == coFloatOrPercent);
@@ -1277,12 +1279,12 @@ namespace client
                     }
                     break;
                 }
-                default: ctx->throw_exception("Referencing a vector variable when scalar is expected", opt.it_range);
+                default: ctx->throw_exception(L("Referencing a vector variable when scalar is expected"), opt.it_range);
                 }
             } else {
                 size_t idx = (opt.index < 0) ? 0 : (opt.index >= int(vec->size())) ? 0 : size_t(opt.index);
                 if (vec->is_nil(idx))
-                    ctx->throw_exception("Trying to reference an undefined (nil) element of vector of optional values", opt.it_range);
+                    ctx->throw_exception(L("Trying to reference an undefined (nil) element of vector of optional values"), opt.it_range);
                 switch (opt.opt->type()) {
                 case coFloats:   output.set_d(static_cast<const ConfigOptionFloats*>(opt.opt)->values[idx]); break;
                 case coInts:     output.set_i(static_cast<const ConfigOptionInts*>(opt.opt)->values[idx]); break;
@@ -1301,27 +1303,27 @@ namespace client
                     break;
                 }
                 default:
-                    ctx->throw_exception("Unsupported vector variable type", opt.it_range);
+                    ctx->throw_exception(L("Unsupported vector variable type"), opt.it_range);
                 }
             }
         }
 
         static void check_writable(const MyContext *ctx, OptWithPos &opt) {
             if (! opt.writable)
-                ctx->throw_exception("Cannot modify a read-only variable", opt.it_range);
+                ctx->throw_exception(L("Cannot modify a read-only variable"), opt.it_range);
         }
 
         static void check_numeric(const expr &param) {
             if (! param.numeric_type())
-                param.throw_exception("Right side is not a numeric expression");
+                param.throw_exception(L("Right side is not a numeric expression"));
         };
 
         static size_t evaluate_count(const expr &expr_count) {
             if (expr_count.type() != expr::TYPE_INT)
-                expr_count.throw_exception("Expected number of elements to fill a vector with.");
+                expr_count.throw_exception(L("Expected number of elements to fill a vector with."));
             int count = expr_count.i();
             if (count < 0)
-                expr_count.throw_exception("Negative number of elements specified.");
+                expr_count.throw_exception(L("Negative number of elements specified."));
             return size_t(count);
         };
 
@@ -1349,11 +1351,11 @@ namespace client
                 break;
             case coBool:
                 if (rhs.type() != expr::TYPE_BOOL)
-                    ctx->throw_exception("Right side is not a boolean expression", rhs.it_range);
+                    ctx->throw_exception(L("Right side is not a boolean expression"), rhs.it_range);
                 static_cast<ConfigOptionBool*>(wropt)->value = rhs.b();
                 break;
             default:
-                ctx->throw_exception("Unsupported output scalar variable type", lhs.it_range);
+                ctx->throw_exception(L("Unsupported output scalar variable type"), lhs.it_range);
             }
         }
 
@@ -1363,12 +1365,12 @@ namespace client
             assert(lhs.opt->is_vector());
             check_writable(ctx, lhs);
             if (! lhs.has_index())
-                ctx->throw_exception("Referencing an output vector variable when scalar is expected", lhs.it_range);
+                ctx->throw_exception(L("Referencing an output vector variable when scalar is expected"), lhs.it_range);
             ConfigOptionVectorBase *vec = const_cast<ConfigOptionVectorBase*>(static_cast<const ConfigOptionVectorBase*>(lhs.opt));
             if (vec->empty())
-                ctx->throw_exception("Indexing an empty vector variable", lhs.it_range);
+                ctx->throw_exception(L("Indexing an empty vector variable"), lhs.it_range);
             if (lhs.index >= int(vec->size()))
-                ctx->throw_exception("Index out of range", lhs.it_range);
+                ctx->throw_exception(L("Index out of range"), lhs.it_range);
             switch (lhs.opt->type()) {
             case coFloats:
                 check_numeric(rhs);
@@ -1387,11 +1389,11 @@ namespace client
                 break;
             case coBools:
                 if (rhs.type() != expr::TYPE_BOOL)
-                    ctx->throw_exception("Right side is not a boolean expression", rhs.it_range);
+                    ctx->throw_exception(L("Right side is not a boolean expression"), rhs.it_range);
                 static_cast<ConfigOptionBools*>(vec)->values[lhs.index] = rhs.b();
                 break;
             default:
-                ctx->throw_exception("Unsupported output vector variable type", lhs.it_range);
+                ctx->throw_exception(L("Unsupported output vector variable type"), lhs.it_range);
             }
         }
 
@@ -1414,7 +1416,7 @@ namespace client
                 break;
             case coBools:
                 if (rhs_value.type() != expr::TYPE_BOOL)
-                    rhs_value.throw_exception("Right side is not a boolean expression");
+                    rhs_value.throw_exception(L("Right side is not a boolean expression"));
                 static_cast<ConfigOptionBools*>(opt)->values.assign(count, rhs_value.b());
                 break;
             default: assert(false);
@@ -1439,10 +1441,10 @@ namespace client
             if (ctx->skipping()) {
             } else if (opt.opt->is_vector()) {
                 if (! opt.has_index())
-                    ctx->throw_exception("Referencing a vector variable when scalar is expected", opt.it_range);
+                    ctx->throw_exception(L("Referencing a vector variable when scalar is expected"), opt.it_range);
                 const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt.opt);
                 if (vec->empty())
-                    ctx->throw_exception("Indexing an empty vector variable", opt.it_range);
+                    ctx->throw_exception(L("Indexing an empty vector variable"), opt.it_range);
                 output.set_b(static_cast<const ConfigOptionVectorBase*>(opt.opt)->is_nil(opt.index >= int(vec->size()) ? 0 : size_t(opt.index)));
             } else {
                 assert(opt.opt->is_scalar());
@@ -1466,19 +1468,19 @@ namespace client
             if (! ctx->skipping()) {
                 t_config_option_key key(std::string(it_range.begin(), it_range.end()));
                 if (const ConfigOption* opt = ctx->resolve_symbol(key); opt)
-                    ctx->throw_exception("Symbol is already defined in read-only system dictionary", it_range);
+                    ctx->throw_exception(L("Symbol is already defined in read-only system dictionary"), it_range);
                 if (ctx->config_outputs && ctx->config_outputs->optptr(key))
-                    ctx->throw_exception("Symbol is already defined as system output variable", it_range);
+                    ctx->throw_exception(L("Symbol is already defined as system output variable"), it_range);
                 bool has_global_dictionary = ctx->context_data != nullptr && ctx->context_data->global_config;
                 if (global_variable) {
                     if (! has_global_dictionary)
-                        ctx->throw_exception("Global variables are not available in this context", it_range);
+                        ctx->throw_exception(L("Global variables are not available in this context"), it_range);
                     if (ctx->config_local.optptr(key))
-                        ctx->throw_exception("Variable name already defined in local scope", it_range);
+                        ctx->throw_exception(L("Variable name already defined in local scope"), it_range);
                     out.opt = ctx->context_data->global_config->optptr(key);
                 } else {
                     if (has_global_dictionary && ctx->context_data->global_config->optptr(key))
-                        ctx->throw_exception("Variable name already defined in global scope", it_range);
+                        ctx->throw_exception(L("Variable name already defined in global scope"), it_range);
                     out.opt = ctx->config_local.optptr(key);
                 }
                 out.name     = std::move(key);
@@ -1514,7 +1516,7 @@ namespace client
             if (ctx->skipping()) {
             } else if (lhs.opt) {
                 if (lhs.opt->is_vector())
-                    rhs.throw_exception("Cannot assign a scalar value to a vector variable.");
+                    rhs.throw_exception(L("Cannot assign a scalar value to a vector variable."));
                 OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                 scalar_variable_assign_scalar(ctx, lhs_opt, rhs);
             } else {
@@ -1540,7 +1542,7 @@ namespace client
             if (ctx->skipping()) {
             } else if (lhs.opt) {
                 if (lhs.opt->is_scalar())
-                    rhs_value.throw_exception("Cannot assign a vector value to a scalar variable.");
+                    rhs_value.throw_exception(L("Cannot assign a vector value to a scalar variable."));
                 OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                 vector_variable_assign_expr_with_count(ctx, lhs_opt, rhs_count, rhs_value);
             } else {
@@ -1566,7 +1568,7 @@ namespace client
             if (! ctx->skipping()) {
                 check_writable(ctx, lhs);
                 if (lhs.opt->is_scalar())
-                    rhs_value.throw_exception("Cannot assign a vector value to a scalar variable.");
+                    rhs_value.throw_exception(L("Cannot assign a vector value to a scalar variable."));
                 vector_variable_assign_expr_with_count(ctx, lhs, rhs_count, rhs_value);
             }
         }
@@ -1595,13 +1597,13 @@ namespace client
                     // scalar_var = () 
                     // or
                     // scalar_var = ( scalar, scalar, ... )
-                    ctx->throw_exception("Cannot assign a vector value to a scalar variable.", lhs.it_range);
+                    ctx->throw_exception(L("Cannot assign a vector value to a scalar variable."), lhs.it_range);
             }
 
             auto check_numeric_vector = [](const std::vector<expr> &il) {
                 for (auto &i : il)
                     if (! i.numeric_type())
-                        i.throw_exception("Right side is not a numeric expression");
+                        i.throw_exception(L("Right side is not a numeric expression"));
             };
 
             ConfigOption *opt = const_cast<ConfigOption*>(lhs.opt);
@@ -1620,7 +1622,7 @@ namespace client
             case coBools:
                 for (auto &i : il)
                     if (i.type() != expr::TYPE_BOOL)
-                        i.throw_exception("Right side is not a boolean expression");
+                        i.throw_exception(L("Right side is not a boolean expression"));
                 fill_vector_from_initializer_list<ConfigOptionBools>(opt, il, [](auto &v){ return v.b(); });
                 break;
             default: assert(false);
@@ -1642,7 +1644,7 @@ namespace client
                 vector_variable_assign_initializer_list(ctx, lhs_opt, il);
             } else {
                 if (il.empty())
-                    ctx->throw_exception("Cannot create vector variable from an empty initializer list, because its type cannot be deduced.", lhs.it_range);
+                    ctx->throw_exception(L("Cannot create vector variable from an empty initializer list, because its type cannot be deduced."), lhs.it_range);
                 // Allocate a new vector variable.
                 // First guesstimate type of the output vector.
                 size_t num_bool = 0;
@@ -1663,7 +1665,7 @@ namespace client
                     opt_new = std::make_unique<ConfigOptionStrings>();
                 else if (num_bool > 0) {
                     if (num_double + num_int > 0)
-                        ctx->throw_exception("Right side is not valid: Mixing numeric and boolean types.", IteratorRange{ il.front().it_range.begin(), il.back().it_range.end() });
+                        ctx->throw_exception(L("Right side is not valid: Mixing numeric and boolean types."), IteratorRange{ il.front().it_range.begin(), il.back().it_range.end() });
                     opt_new = std::make_unique<ConfigOptionBools>();
                 } else {
                     // Output is numeric.
@@ -1695,22 +1697,22 @@ namespace client
             check_writable(ctx, lhs);
             assert(lhs.opt->is_vector());
             if (rhs.has_index() || ! rhs.opt->is_vector())
-                ctx->throw_exception("Cannot assign scalar to a vector", lhs.it_range);
+                ctx->throw_exception(L("Cannot assign scalar to a vector"), lhs.it_range);
             if (rhs.opt->is_nil())
-                ctx->throw_exception("Some elements of the right hand side vector variable of optional values are undefined (nil)", rhs.it_range);
+                ctx->throw_exception(L("Some elements of the right hand side vector variable of optional values are undefined (nil)"), rhs.it_range);
             if (lhs.opt->type() != rhs.opt->type()) {
                 // Vector types are not compatible.
                 switch (lhs.opt->type()) {
                 case coFloats:
-                    ctx->throw_exception("Left hand side is a float vector, while the right hand side is not.", lhs.it_range);
+                    ctx->throw_exception(L("Left hand side is a float vector, while the right hand side is not."), lhs.it_range);
                 case coInts:
-                    ctx->throw_exception("Left hand side is an int vector, while the right hand side is not.", lhs.it_range);
+                    ctx->throw_exception(L("Left hand side is an int vector, while the right hand side is not."), lhs.it_range);
                 case coStrings:
-                    ctx->throw_exception("Left hand side is a string vector, while the right hand side is not.", lhs.it_range);
+                    ctx->throw_exception(L("Left hand side is a string vector, while the right hand side is not."), lhs.it_range);
                 case coBools:
-                    ctx->throw_exception("Left hand side is a bool vector, while the right hand side is not.", lhs.it_range);
+                    ctx->throw_exception(L("Left hand side is a bool vector, while the right hand side is not."), lhs.it_range);
                 default:
-                    ctx->throw_exception("Left hand side / right hand side vectors are not compatible.", lhs.it_range);
+                    ctx->throw_exception(L("Left hand side / right hand side vectors are not compatible."), lhs.it_range);
                 }
             }
             const_cast<ConfigOption*>(lhs.opt)->set(rhs.opt);
@@ -1735,7 +1737,7 @@ namespace client
                     // Stop parsing, let the other rules resolve this case.
                     return false;
                 if (rhs.opt->is_nil())
-                    ctx->throw_exception("Some elements of the right hand side vector variable of optional values are undefined (nil)", rhs.it_range);
+                    ctx->throw_exception(L("Some elements of the right hand side vector variable of optional values are undefined (nil)"), rhs.it_range);
                 // Clone the vector variable.
                 std::unique_ptr<ConfigOption> opt_new;
                 if (one_of(rhs.opt->type(), { coFloats, coInts, coStrings, coBools }))
@@ -1743,7 +1745,7 @@ namespace client
                 else if (rhs.opt->type() == coPercents)
                     opt_new = std::make_unique<ConfigOptionFloats>(static_cast<const ConfigOptionPercents*>(rhs.opt)->values);
                 else
-                    ctx->throw_exception("Duplicating this type of vector variable is not supported", rhs.it_range);
+                    ctx->throw_exception(L("Duplicating this type of vector variable is not supported"), rhs.it_range);
                 const_cast<MyContext*>(ctx)->store_new_variable(lhs.name, std::move(opt_new), global_variable);
             }
             // Continue parsing.
@@ -1761,7 +1763,7 @@ namespace client
         {
             if (! ctx->skipping()) {
                 if (opt.has_index() || ! opt.opt->is_vector())
-                    ctx->throw_exception("parameter of empty() is not a vector variable", opt.it_range);
+                    ctx->throw_exception(L("parameter of empty() is not a vector variable"), opt.it_range);
                 out.set_b(static_cast<const ConfigOptionVectorBase*>(opt.opt)->size() == 0);
             }
             out.it_range = opt.it_range;
@@ -1771,7 +1773,7 @@ namespace client
         {
             if (! ctx->skipping()) {
                 if (opt.has_index() || ! opt.opt->is_vector())
-                    ctx->throw_exception("parameter of size() is not a vector variable", opt.it_range);
+                    ctx->throw_exception(L("parameter of size() is not a vector variable"), opt.it_range);
                 out.set_i(int(static_cast<const ConfigOptionVectorBase*>(opt.opt)->size()));
             }
             out.it_range = opt.it_range;
@@ -1783,7 +1785,7 @@ namespace client
         {
             if (expr_index.type() != expr::TYPE_EMPTY) {
                 if (expr_index.type() != expr::TYPE_INT)
-                    expr_index.throw_exception("Non-integer index is not allowed to address a vector variable.");
+                    expr_index.throw_exception(L("Non-integer index is not allowed to address a vector variable."));
                 output = expr_index.i();
             }
         }
@@ -1794,7 +1796,7 @@ namespace client
                 return;
 
             if (ctx->context_data == nullptr)
-                ctx->throw_exception("Random number generator not available in this context.",
+                ctx->throw_exception(L("Random number generator not available in this context."),
                     IteratorRange(param1.it_range.begin(), param2.it_range.end()));
             expr::random(param1, param2, ctx->context_data->rng);
         }
@@ -1832,21 +1834,20 @@ namespace client
             auto error_line = std::string(first, first_pos) + std::string(last, 0, last_pos);
             // Position of the it_error from the start of its line.
             auto error_pos  = (it_error - it_begin) - first_pos;
-            msg += "Parsing error at line " + std::to_string(line_nr);
             if (! info.tag.empty() && info.tag.front() == '*') {
                 // The gat contains an explanatory string.
-                msg += ": ";
-                msg += info.tag.substr(1);
+                // TRN Custom G-code error. %1% is the line number, %2% the reason.
+                msg += Slic3r::format(_u8L("Parsing error at line %1%: %2%"), line_nr, Slic3r::I18N::translate(info.tag.substr(1)));
             } else {
                 auto it = tag_to_error_message.find(info.tag);
                 if (it == tag_to_error_message.end()) {
                     // A generic error report based on the nonterminal or terminal symbol name.
-                    msg += ". Expecting tag ";
-                    msg += info.tag;
+                    // TRN Custom G-code error. %1% is the line number, %2% the name of a grammar rule.
+                    msg += Slic3r::format(_u8L("Parsing error at line %1%. Expecting tag %2%"), line_nr, info.tag);
                 } else {
                     // Use the human readable error message.
-                    msg += ". ";
-                    msg += it->second;
+                    // TRN Custom G-code error. %1% is the line number, %2% the reason.
+                    msg += Slic3r::format(_u8L("Parsing error at line %1%. %2%"), line_nr, Slic3r::I18N::translate(it->second));
                 }
             }
             msg += '\n';
@@ -1877,15 +1878,15 @@ namespace client
         static void init(const expr &x) {
             if (x.type() != expr::TYPE_EMPTY) {
                 if (!x.numeric_type())
-                    x.throw_exception("Interpolation value must be a number.");
+                    x.throw_exception(L("Interpolation value must be a number."));
             }
         }
         static void add_pair(const expr &x, const expr &y, InterpolateTableContext &table) {
             if (x.type() != expr::TYPE_EMPTY) {
                 if (! x.numeric_type())
-                    x.throw_exception("X value of a table point must be a number.");
+                    x.throw_exception(L("X value of a table point must be a number."));
                 if (! y.numeric_type())
-                    y.throw_exception("Y value of a table point must be a number.");
+                    y.throw_exception(L("Y value of a table point must be a number."));
                 table.table.push_back({ x.as_d(), x.it_range, y.as_d() });
             }
         }
@@ -1902,7 +1903,7 @@ namespace client
                 double x1 = table.table[i].x;
                 if (x0 > x1)
                     boost::throw_exception(qi::expectation_failure(
-                        table.table[i - 1].it_range_x.begin(), table.table[i].it_range_x.end(), spirit::info("X coordinates of the table must be increasing")));
+                        table.table[i - 1].it_range_x.begin(), table.table[i].it_range_x.end(), spirit::info(std::string("*") + L("X coordinates of the table must be increasing"))));
                 if (! evaluated && x >= x0 && x <= x1) {
                     double y0 = table.table[i - 1].y;
                     double y1 = table.table[i].y;
@@ -1925,7 +1926,7 @@ namespace client
                     out.set_d(table.table.back().y);
                 else
                     // The value is really outside the table range.
-                    expr_x.throw_exception("Interpolation value is outside the table range");
+                    expr_x.throw_exception(L("Interpolation value is outside the table range"));
             }
         }
     };
@@ -1939,30 +1940,30 @@ namespace client
 
     // Table to translate symbol tag to a human readable error message.
     std::map<std::string, std::string> MyContext::tag_to_error_message = {
-        { "eoi",                        "Unknown syntax error" },
-        { "start",                      "Unknown syntax error" },
-        { "text",                       "Invalid text." },
-        { "text_block",                 "Invalid text block." },
-        { "macro",                      "Invalid macro." },
-        { "repeat",                     "Unknown syntax error" },
-        { "if_else_output",             "Not an {if}{else}{endif} macro." },
-        { "switch_output",              "Not a {switch} macro." },
-        { "legacy_variable_expansion",  "Expecting a legacy variable expansion format" },
-        { "identifier",                 "Expecting an identifier." },
-        { "conditional_expression",     "Expecting a conditional expression." },
-        { "logical_or_expression",      "Expecting a boolean expression." },
-        { "logical_and_expression",     "Expecting a boolean expression." },
-        { "equality_expression",        "Expecting an expression." },
-        { "bool_expr_eval",             "Expecting a boolean expression."},
-        { "relational_expression",      "Expecting an expression." },
-        { "additive_expression",        "Expecting an expression." },
-        { "multiplicative_expression",  "Expecting an expression." },
-        { "unary_expression",           "Expecting an expression." },
-        { "optional_parameter",         "Expecting a closing brace or an optional parameter." },
-        { "one_of_list",                "Expecting a list of string patterns (simple text or rexep)" },
-        { "variable_reference",         "Expecting a variable reference."},
-        { "variable",                   "Expecting a variable name."},
-        { "regular_expression",         "Expecting a regular expression."}
+        { "eoi",                        L("Unknown syntax error") },
+        { "start",                      L("Unknown syntax error") },
+        { "text",                       L("Invalid text.") },
+        { "text_block",                 L("Invalid text block.") },
+        { "macro",                      L("Invalid macro.") },
+        { "repeat",                     L("Unknown syntax error") },
+        { "if_else_output",             L("Not an {if}{else}{endif} macro.") },
+        { "switch_output",              L("Not a {switch} macro.") },
+        { "legacy_variable_expansion",  L("Expecting a legacy variable expansion format") },
+        { "identifier",                 L("Expecting an identifier.") },
+        { "conditional_expression",     L("Expecting a conditional expression.") },
+        { "logical_or_expression",      L("Expecting a boolean expression.") },
+        { "logical_and_expression",     L("Expecting a boolean expression.") },
+        { "equality_expression",        L("Expecting an expression.") },
+        { "bool_expr_eval",             L("Expecting a boolean expression.")},
+        { "relational_expression",      L("Expecting an expression.") },
+        { "additive_expression",        L("Expecting an expression.") },
+        { "multiplicative_expression",  L("Expecting an expression.") },
+        { "unary_expression",           L("Expecting an expression.") },
+        { "optional_parameter",         L("Expecting a closing brace or an optional parameter.") },
+        { "one_of_list",                L("Expecting a list of string patterns (simple text or regexp)") },
+        { "variable_reference",         L("Expecting a variable reference.")},
+        { "variable",                   L("Expecting a variable name.")},
+        { "regular_expression",         L("Expecting a regular expression.")}
     };
 
     // For debugging the boost::spirit parsers. Print out the string enclosed in it_range.
@@ -2031,7 +2032,7 @@ namespace client
             first = it;
             return true;
         err:
-            MyContext::throw_exception("Invalid utf8 sequence", IteratorRange(first, last));
+            MyContext::throw_exception(L("Invalid utf8 sequence"), IteratorRange(first, last));
             return false;
         }
 
@@ -2057,7 +2058,7 @@ namespace client
                 return false;
             char c = *first;
             if (it - first > 1 || c < 0)
-                MyContext::throw_exception("Non-ASCII7 characters are only allowed inside text blocks and string literals, not inside code blocks.", IteratorRange(first, it));
+                MyContext::throw_exception(L("Non-ASCII7 characters are only allowed inside text blocks and string literals, not inside code blocks."), IteratorRange(first, it));
             if (c == '\r' || c == '\n' || c == '\t' || c == ' ') {
                 // Skip the whitespaces
                 ++ first;
@@ -2116,7 +2117,7 @@ namespace client
                         if (*it == '\\') {
                             if (++ it == end ||
                                 (*it != 'r' && *it != 'n' && *it != '"' && *it != '\\'))
-                                ctx->throw_exception("Invalid escape sequence", {std::prev(it), std::next(it) });
+                                ctx->throw_exception(L("Invalid escape sequence"), {std::prev(it), std::next(it) });
                             ++ len;
                             ++ it;
                         } else {