Cut redundant work and duplication from the preset cache paths

The schema fingerprint, filament library version and cache blob are no
longer recomputed, re-read or copied once per vendor on the startup path,
and the setup wizard's completeness check now sees vendors shipped as
caches alone. Duplicated reset/join/slurp blocks are folded into helpers.

.gitattributes

@@ -1,2 +1,7 @@
 # Set the default behavior, in case people don't have core.autocrlf set.
 * text=auto
+
+# Shell scripts are run by Git Bash on Windows CI, which cannot read a script
+# with CRLF line endings: it fails on the first line. Windows checkouts default
+# to core.autocrlf=true, so keep these LF whatever the platform.
+*.sh text eol=lf

.github/workflows/build_orca.yml

@@ -162,6 +162,14 @@ jobs:
           retention-days: 5
           if-no-files-found: error
 
+      - name: Build system preset cache (macOS)
+        if: runner.os == 'macOS' && !inputs.macos-combine-only
+        working-directory: ${{ github.workspace }}
+        shell: bash
+        # The bundle was already packed from resources/, so the caches have to be
+        # installed into it here; the source tree keeps its JSONs for later jobs.
+        run: ./scripts/build_preset_cache.sh -b build/${{ inputs.arch }} build/${{ inputs.arch }}/OrcaSlicer/OrcaSlicer.app/Contents/Resources/profiles
+
       - name: Pack macOS app bundle ${{ inputs.arch }}
         if: runner.os == 'macOS' && !inputs.macos-combine-only
         working-directory: ${{ github.workspace }}
@@ -390,6 +398,13 @@ jobs:
           if ($arch -eq "arm64") { .\build_release_vs.bat slicer arm64 tests } else { .\build_release_vs.bat slicer tests }
         shell: pwsh
 
+      - name: Build system preset cache (Windows)
+        if: runner.os == 'Windows'
+        shell: cmd
+        # Shipped into both the already-installed tree (portable zip, MSIX) and
+        # the checkout cpack re-installs from when it builds the NSIS installer.
+        run: scripts\build_preset_cache.bat "%BUILD_DIR%" "resources\profiles" "%BUILD_DIR%\OrcaSlicer\resources\profiles"
+
       - name: Pack unit tests Win
         if: runner.os == 'Windows'
         working-directory: ${{ github.workspace }}
@@ -539,6 +554,20 @@ jobs:
           retention-days: 5
           if-no-files-found: error
 
+      - name: Build system preset cache (Linux)
+        if: runner.os == 'Linux'
+        shell: bash
+        run: |
+          # Both were packed from resources/ before the caches existed, so the
+          # AppImage is unpacked first and the caches shipped into it and into
+          # the package tree; the source tree keeps its JSONs for later steps.
+          appimage=$(find build -maxdepth 1 -name "OrcaSlicer_Linux_AppImage*.AppImage" | head -1)
+          chmod +x "$appimage"
+          "$appimage" --appimage-extract
+          ./scripts/build_preset_cache.sh -b build build/package/resources/profiles squashfs-root/resources/profiles
+          appimagetool=$(find build -name "appimagetool.AppImage" | head -1)
+          ARCH=$(uname -m) "$appimagetool" --appimage-extract-and-run squashfs-root "$appimage"
+          rm -rf squashfs-root
         # Ship the freshly-built validator so slice_check_linux (build_all.yml)
         # can slice-sweep the shipped profiles with this PR's engine. Taken from
         # the aarch64 leg so the sweep also exercises the arm build; x86_64 on

.gitignore

@@ -49,3 +49,4 @@ internal_docs/
 # Python bytecode
 __pycache__/
 *.pyc
+*.opc

AGENTS.md

@@ -30,6 +30,7 @@ ctest --test-dir ./tests/fff_print
 - C++17, selective C++20. PascalCase classes, snake_case functions/variables
 - `#pragma once` for headers. Smart pointers and RAII preferred
 - Parallelization via TBB — be mindful of shared state
+- Always use `SetSizerAndFit(sizer)` instead of `SetSizer(sizer)` on top level window. Unless `SetSizer` must be called before the full layout is built, call `sizer->SetSizeHints(window)` afterwards in this case.
 
 ## Key Entry Points
 
@@ -59,7 +60,31 @@ ctest --test-dir ./tests/fff_print
 
 ## Localization & translations
 
-- Translation catalogs live in `localization/i18n/<lang>/OrcaSlicer_<lang>.po`.
+Catalogs live in `localization/i18n/<lang>/OrcaSlicer_<lang>.po`; the template is `OrcaSlicer.pot`.
-- When creating or reviewing translations, use the [Localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/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, file formats, G-code, macros/variables) are not translated.
+See the [Localization guide](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/localization_guide.md) for the human-facing version of these principles.
-- If a term's established translation changes, update both the affected `.po` files and the glossary so they stay in sync.
+
-- Only edit `msgstr` (never `msgid`); keep placeholders (`%s`, `%1%`, `\n`), context (`msgctxt`), and file encoding/line endings intact.
+### Terminology
+
+- Use the [Localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/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.
+- If a term's established translation changes, update both the affected `.po` files and the glossary (`localization_glossary.tsv`, then regenerate) so they stay in sync.
+- Translate the *meaning*, not the words. Check what the string actually controls before translating it — English reuses one word for different things. `Flow ratio` (multiplier), `Flow Rate` (throughput) and `Flow Dynamics` (pressure compensation) are three different terms; `extruder` may mean the toolhead, the feeder motor, or the nozzle depending on the string.
+- Reuse one template per recurring message shape (`Failed to connect to …`, `Are you sure you want to …?`), even where the English wording varies.
+
+### Editing rules
+
+- Only edit `msgstr` — **never** change `msgid`, and never "fix" wrong English in the translation alone. Report the source string instead.
+- Preserve exactly: placeholders (`%s`, `%d`, `%1%`, `%zu`, `%%`), every `\n` (count *and* position, including leading/trailing), leading/trailing spaces, HTML tags, `℃`, and the file's encoding and line endings.
+- **Never reorder positional arguments** in a `c-format` string. If the msgid is `%d` then `%s`, that order must hold — swapping them breaks at runtime.
+- `msgctxt` separates homonyms — always read it. `Back`/`Camera View` is the rear view of the 3D navigator, while `Back`/`Navigation` is the go-back button; `Top` exists in the *Alignment*, *Layers* and *Camera View* senses.
+- When a string needs disambiguating, add context in the source (`_L_CONTEXT`/`_u8L_CONTEXT`), don't work around it in the translation.
+- A literal `%` inside a string xgettext flagged `possible-c-format` will fail `msgfmt`. Fix it with a `// xgettext:no-c-format, no-boost-format` comment above the string in the source — do not mangle the translation or use `%%` in text that is never passed through printf.
+- Plural entries: read `nplurals` from the catalog's `Plural-Forms` header (it is **not** always 2 — ja/ko/zh/th/vi use 1, ru/cs/pl/lt use 3, uk uses 4). Each form must be genuinely inflected for its quantity; repeating one sentence across all forms is a bug in Slavic/Baltic languages, though it is correct for Turkish and Hungarian.
+- An entry whose `msgstr` equals its `msgid` is untranslated even though it is not empty; a plural entry with any empty form is likewise incomplete.
+- Mark machine-produced translations with an `# AI Translated` translator comment. Don't add it to a human translation you didn't actually rewrite.
+- Don't reflow or re-wrap unrelated entries — keep the diff limited to the strings you changed.
+
+### Verifying
+
+- `scripts/run_gettext.bat --full` (Windows) regenerates the template, merges every catalog and compiles the `.mo` files. It must exit 0.
+- Or check a single catalog with `msgfmt --check-format -o <out>.mo localization/i18n/<lang>/OrcaSlicer_<lang>.po`.
+- Fuzzy entries are not shown to users. If you correct one, clear its `fuzzy` flag, otherwise the fix never ships.

build_linux.sh

@@ -567,6 +567,8 @@ if [[ -n "${BUILD_ORCA}" ]] || [[ -n "${BUILD_TESTS}" ]] ; then
 	print_and_run cmake --build $BUILD_DIR --config "${BUILD_CONFIG}" --target OrcaSlicer
 	echo "Building OrcaSlicer_profile_validator .."
 	print_and_run cmake --build $BUILD_DIR --config "${BUILD_CONFIG}" --target OrcaSlicer_profile_validator
+	echo "Building generate_system_cache ..."
+	print_and_run cmake --build $BUILD_DIR --config "${BUILD_CONFIG}" --target generate_system_cache
 	./scripts/run_gettext.sh
     fi
     if [[ -n "${BUILD_TESTS}" ]] ; then

docs/HLSD/preset-cache.md

@@ -0,0 +1,218 @@
+# System Preset Cache — High Level Design
+
+## Why it exists
+
+OrcaSlicer ships tens of thousands of system preset JSON files. Every launch used to
+parse all of them: read each vendor profile, walk its machine, process and filament
+sub-files, resolve inheritance, and build the preset collections from scratch. That
+parse dominated startup, and it produced the same result every time, because system
+presets only change when the app is updated or a profile update is installed.
+
+The preset cache replaces that parse with a read. Each vendor's fully-resolved presets
+are serialized once — at build time, in CI — into a single binary file that the app
+loads directly into memory. Nothing is recomputed at startup unless something changed.
+
+The cache is **only ever an optimization**. Every rule below exists to guarantee that a
+cache is either provably equivalent to parsing the JSONs, or rejected. There is no
+"mostly right" cache.
+
+## The unit is one vendor
+
+A cache covers exactly one vendor. `BBL.opc` sits beside `BBL.json` and holds
+everything `BBL.json` and the `BBL/` sub-file tree would have produced.
+
+Per-vendor granularity is what makes the system practical:
+
+- A vendor whose profile is bumped invalidates only its own cache. The other 60-odd
+  vendors keep theirs.
+- The setup wizard, which loads vendors one at a time, gets the same speedup as
+  startup without a second code path.
+- A vendor with no cache, or a broken one, costs only that vendor a parse.
+
+A cache holds *system* presets only. User presets, project settings and modified
+presets are never serialized — they have their own storage and their own lifecycle.
+
+## Where the files live
+
+| Location | Contents on a shipped build | Role |
+|---|---|---|
+| `resources/profiles/` | `<vendor>.opc` alone — the profile and its preset JSONs both pruned | What the app ships with; the fallback everything falls back to |
+| `<data_dir>/system/` | `<vendor>.opc` alone, or `<vendor>.json` + `<vendor>/` after an update | What the user has installed |
+| `<data_dir>/system/` (dev build) | `<vendor>.json` + `<vendor>/` + `<vendor>.opc` written at runtime | A developer tree caches as it parses |
+
+Two forms of the same vendor therefore exist, and the system's central rule is that
+**a vendor's cache is the whole of it**. Where a cache ships or is installed, no profile
+and no preset JSONs sit beside it: the cache carries the presets, the vendor profile,
+and the version stamp that says which release it came from. A vendor is "installed" if
+either form is present, and its installed version is read from whichever form is there.
+
+What stays beside the caches in `resources/profiles/` is everything that is not a
+preset: each vendor's directory of printer thumbnails, cover images, bed models and
+hotend meshes, which are read from disk by path and were never part of the cache. Files
+that are not vendors at all, `blacklist.json` chief among them, are untouched.
+
+The alternative — shipping both and treating the cache as a sidecar — was rejected. It
+doubles the installed size, and it creates a class of bug where the two disagree and
+the app's behavior depends on which one a given code path happened to read.
+
+## What a cache file is
+
+A fixed-size header followed by one binary stream.
+
+The header carries a magic number, the cache format version, the payload size and a
+CRC32 of the payload. It exists so that a truncated download, a half-written file or a
+file from an entirely different program is rejected in microseconds, before anything
+tries to interpret it.
+
+The payload opens with the stamps that decide whether the cache may be used at all —
+format version, schema fingerprint, vendor name, vendor version, filament library
+version — and then the vendor's data: the vendor profiles, the five preset collections
+(print, SLA print, filament, SLA material, printer), the config and filament-id lookup
+maps, the obsolete-preset lists, and the count of errors the original parse hit.
+
+Two deliberate choices in the layout:
+
+- **Stamps come first**, so the question "what version is this vendor installed at?"
+  can be answered by reading the first kilobyte. The updater asks that question for
+  every vendor on every launch; reading tens of megabytes to answer it would give back
+  the startup time the cache saved.
+- **Defaults are not stored.** Every collection reconstructs its default presets the
+  way the JSON path does, and the cache carries only what a parse would have added on
+  top. This keeps the cache a record of the vendor's data, not a memory image of the
+  program's state.
+
+## When a cache may be used
+
+A cache is accepted only if every gate below passes. Any failure means "parse the
+JSONs instead" — never a hard error, never a partial load.
+
+**1. Integrity.** Magic number, plausible size, CRC32 over the payload.
+
+**2. Cache format version.** A single integer bumped by hand whenever the binary layout
+changes in a way nothing else would catch: reordering or retyping a serialized field,
+or changing what the cache's own stamps mean.
+
+**3. Schema fingerprint.** A checksum over the app version and the entire print-config
+option schema — every option's key, type, wire ordinal and enum values. This is the
+gate that makes the cache safe across development: adding a config option, changing its
+type, or reordering the enum values of an existing one all change the fingerprint, so
+caches from before the change are rejected without anyone having to remember to bump
+anything. It also means a cache never crosses app versions.
+
+**4. Vendor identity and version.** The cache names the vendor it holds and the profile
+version it was built from. It is accepted only if that version is at least as new as
+the profile now on disk. Where no profile sits beside the cache — the shipped,
+cache-only form — the comparison is skipped, because nothing on disk can be newer than
+a cache that is the installation.
+
+**5. Filament library version.** Every vendor's filaments inherit from the shared Orca
+filament library, so a vendor's cache is only valid against the library it was resolved
+against. Bumping the library invalidates every vendor's cache, which is correct and
+is why the library's version is stamped into all of them.
+
+A vendor profile with no parsable version is never cached and never served from a
+cache. There would be no way to tell later whether the cache had gone stale, and a
+cache nothing can invalidate is worse than no cache.
+
+## How a vendor is loaded
+
+When the app loads a vendor, it tries, in order:
+
+1. The cache in the directory it was asked to load from — normally `<data_dir>/system/`.
+2. The shipped cache in `resources/profiles/`.
+3. Parsing the JSONs — from the data directory if the profile is installed there, and
+   from `resources/profiles/` otherwise, which on a shipped build only has JSONs for a
+   vendor that has no cache.
+
+The second tier is what makes app upgrades work. After an upgrade, a cache the previous
+version installed fails the fingerprint gate; the new build's own shipped cache answers
+instead, and the user never sees a parse. The stale installed file is simply ignored
+until the next profile update overwrites it.
+
+If a parse does happen and the vendor's profile carries a version, the app writes the
+cache back beside where it looked for the vendor. That is how a developer build warms
+itself up on second launch, and how a vendor delivered by a profile update becomes
+cached without waiting for the next release.
+
+## How a vendor is installed
+
+Installing copies from `resources/profiles/` into `<data_dir>/system/`. A shipped build
+offers only a cache and a source tree only JSONs, but a partially-generated tree can
+have both, at different versions, so the installer picks the form that ships at the
+**newer version** and installs only that one:
+
+- Cache newer or equal, and readable → copy the `.opc`, and delete any profile and
+  vendor directory a previous install left behind, so nothing can shadow it.
+- Profile newer, or the cache unreadable or absent → copy the profile and the vendor's
+  preset JSONs exactly as the app did before caches existed, and delete any stale `.opc`.
+
+The result is that only one form of a vendor is ever present, and it is the newest one
+the build has. This matters most for the update check, which compares what is installed
+against what installing *would* lay down: if those two disagreed about which form
+counts, a vendor could reinstall on every launch forever, or silently never update.
+
+Profile updates delivered over the air always arrive as JSONs, and they win — an
+updated vendor's real profile lands in the data directory, the shipped cache is older
+and gets rejected, and the vendor is parsed and re-cached.
+
+## How the caches are produced
+
+Cache generation is a build step, not something a user ever runs.
+
+One script per platform does the whole job, and CI calls it once on each. It builds a
+small dev-utility that loads a profiles directory exactly as the app would, with cache
+writing enabled, dropping a `<vendor>.opc` beside every vendor profile it parses; then
+it copies those caches into each packaged application it was pointed at and deletes
+every preset JSON they replace — the vendor's own profile included. Only a vendor that
+actually has a cache is pruned, so a vendor the generator skipped keeps its JSONs and is
+simply parsed at startup.
+
+Because the schema fingerprint includes the app version, caches must be generated by
+the same build that ships them. Generation runs after the build, in the same job.
+
+## Behavior when things go wrong
+
+The system is designed so that no cache problem is fatal:
+
+- **Corrupt, truncated or foreign file** — rejected at the header, vendor parsed.
+- **Cache from another app version or schema** — rejected at the fingerprint, vendor
+  parsed or served from the shipped cache.
+- **Stale cache** — rejected on the version stamps, vendor parsed and re-cached.
+- **Failure part-way through reading** — the bundle is reset to a clean state before
+  falling back, so a half-loaded cache can never leak into the parsed result.
+- **A vendor that can be neither read nor parsed** — logged, and left out. The setup
+  wizard drops that vendor from its list and opens with the rest; startup records the
+  error alongside the vendors that did load. One broken vendor never takes the app down.
+
+The one genuine limit: on a shipped build a vendor is its cache and nothing else, so a
+rejected cache has nothing to fall back to for that vendor. This is by design — the
+alternative is shipping every preset twice — and it is why the acceptance gates are
+conservative and why CI generates the caches with the same build that ships them. The
+recovery path is a profile update, which delivers real JSONs.
+
+It also means nothing may quietly assume a `<vendor>.json` exists. Discovery, version
+checks and the update decision all read whichever form is present, and a code path that
+enumerates only `*.json` will find no vendors at all in a packaged build.
+
+## Maintenance rules
+
+- **Adding or changing a config option** needs nothing. The fingerprint covers it.
+- **Changing what a cache serializes**, or the order it serializes it in, requires
+  bumping the cache format version by hand.
+- **Bumping a vendor profile's version** invalidates that vendor's cache and nothing
+  else. Bumping the filament library invalidates all of them.
+- **Caches are never committed.** They are build artifacts, generated per build,
+  ignored by git.
+
+## Where this lives in the tree
+
+| Area | Files |
+|---|---|
+| Cache format, read/write, load and save | `src/libslic3r/PresetBundle.{hpp,cpp}` |
+| Per-preset serialization | `src/libslic3r/Preset.{hpp,cpp}` |
+| Vendor discovery, installed/shipped versions, installation | `src/libslic3r/PresetBundle.cpp` |
+| Update and reinstall decisions | `src/slic3r/Utils/PresetUpdater.cpp` |
+| Setup wizard and printer-selection dialog | `src/slic3r/GUI/ConfigWizard.cpp`, `src/slic3r/GUI/WebGuideDialog.cpp` |
+| Generator tool | `src/dev-utils/generate_system_cache.cpp` |
+| Build and packaging script | `scripts/build_preset_cache.{sh,bat}` |
+| Tests | `tests/libslic3r/test_vendor_cache.cpp` |

localization/i18n/OrcaSlicer.pot

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-07-23 15:24-0300\n"
+"POT-Creation-Date: 2026-07-26 21:59-0300\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -982,7 +982,7 @@ msgstr ""
 #, possible-boost-format
 msgid ""
 "Objects(%1%) have duplicated connectors. Some connectors may be missing in slicing result.\n"
-"Please report to PrusaSlicer team in which scenario this issue happened.\n"
+"Please report to the OrcaSlicer team in which scenario this issue happened.\n"
 "Thank you."
 msgstr ""
 
@@ -3385,7 +3385,6 @@ msgstr ""
 msgid "Innerloop"
 msgstr ""
 
-#. TRN To be shown in the main menu View->Top
 msgid "Top"
 msgstr ""
 
@@ -5470,10 +5469,24 @@ msgstr ""
 msgid "Align to Y axis"
 msgstr ""
 
+msgctxt "Camera View"
+msgid "Front"
+msgstr ""
+
 msgctxt "Camera View"
 msgid "Back"
 msgstr ""
 
+#. TRN To be shown in the main menu View->Top
+msgctxt "Camera View"
+msgid "Top"
+msgstr ""
+
+#. TRN To be shown in the main menu View->Bottom
+msgctxt "Camera View"
+msgid "Bottom"
+msgstr ""
+
 msgctxt "Camera View"
 msgid "Left"
 msgstr ""
@@ -5854,19 +5867,13 @@ msgstr ""
 msgid "Top View"
 msgstr ""
 
-#. TRN To be shown in the main menu View->Bottom
-msgid "Bottom"
-msgstr ""
-
 msgid "Bottom View"
 msgstr ""
 
-msgid "Front"
-msgstr ""
-
 msgid "Front View"
 msgstr ""
 
+msgctxt "Camera View"
 msgid "Rear"
 msgstr ""
 
@@ -14729,7 +14736,7 @@ msgstr ""
 msgid "Retract amount after wipe"
 msgstr ""
 
-#, possible-c-format
+#, no-c-format, no-boost-format
 msgid ""
 "The length of fast retraction after wipe, relative to retraction length.\n"
 "The value will be clamped by 100% minus the retract amount before the wipe value."

localization/i18n/en/OrcaSlicer_en.po

@@ -3,7 +3,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Orca Slicer\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-07-23 15:24-0300\n"
+"POT-Creation-Date: 2026-07-26 21:59-0300\n"
 "PO-Revision-Date: 2026-06-17 15:44-0300\n"
 "Last-Translator: Alexandre Folle de Menezes\n"
 "Language-Team: \n"
@@ -978,7 +978,7 @@ msgstr ""
 #, boost-format
 msgid ""
 "Objects(%1%) have duplicated connectors. Some connectors may be missing in slicing result.\n"
-"Please report to PrusaSlicer team in which scenario this issue happened.\n"
+"Please report to the OrcaSlicer team in which scenario this issue happened.\n"
 "Thank you."
 msgstr ""
 
@@ -3381,7 +3381,6 @@ msgstr ""
 msgid "Innerloop"
 msgstr ""
 
-#. TRN To be shown in the main menu View->Top
 msgid "Top"
 msgstr ""
 
@@ -5466,10 +5465,24 @@ msgstr ""
 msgid "Align to Y axis"
 msgstr ""
 
+msgctxt "Camera View"
+msgid "Front"
+msgstr ""
+
 msgctxt "Camera View"
 msgid "Back"
 msgstr ""
 
+#. TRN To be shown in the main menu View->Top
+msgctxt "Camera View"
+msgid "Top"
+msgstr ""
+
+#. TRN To be shown in the main menu View->Bottom
+msgctxt "Camera View"
+msgid "Bottom"
+msgstr ""
+
 msgctxt "Camera View"
 msgid "Left"
 msgstr ""
@@ -5850,19 +5863,13 @@ msgstr ""
 msgid "Top View"
 msgstr ""
 
-#. TRN To be shown in the main menu View->Bottom
-msgid "Bottom"
-msgstr ""
-
 msgid "Bottom View"
 msgstr ""
 
-msgid "Front"
-msgstr ""
-
 msgid "Front View"
 msgstr ""
 
+msgctxt "Camera View"
 msgid "Rear"
 msgstr ""
 
@@ -14725,7 +14732,7 @@ msgstr ""
 msgid "Retract amount after wipe"
 msgstr ""
 
-#, c-format
+#, no-c-format, no-boost-format
 msgid ""
 "The length of fast retraction after wipe, relative to retraction length.\n"
 "The value will be clamped by 100% minus the retract amount before the wipe value."

localization/i18n/es/OrcaSlicer_es.po

@@ -3,7 +3,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Orca Slicer\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-07-23 15:24-0300\n"
+"POT-Creation-Date: 2026-07-26 21:59-0300\n"
 "PO-Revision-Date: \n"
 "Last-Translator: Ian A. Bassi <>\n"
 "Language-Team: \n"
@@ -983,11 +983,11 @@ msgstr "Conector"
 #, boost-format
 msgid ""
 "Objects(%1%) have duplicated connectors. Some connectors may be missing in slicing result.\n"
-"Please report to PrusaSlicer team in which scenario this issue happened.\n"
+"Please report to the OrcaSlicer team in which scenario this issue happened.\n"
 "Thank you."
 msgstr ""
 "Los objetos(%1%) tienen conectores duplicados. Es posible que falten algunos conectores en el resultado del laminado.\n"
-"Informe al equipo de PrusaSlicer sobre el escenario en el que se produjo este problema.\n"
+"Informe al equipo de OrcaSlicer sobre el escenario en el que se produjo este problema.\n"
 "Gracias."
 
 msgid "Cut by Plane"
@@ -3459,7 +3459,6 @@ msgstr "Recámara"
 msgid "Innerloop"
 msgstr "Bucle interno"
 
-#. TRN To be shown in the main menu View->Top
 msgid "Top"
 msgstr "Superior"
 
@@ -5630,10 +5629,27 @@ msgstr "Evitar la zona de calibración del extrusor"
 msgid "Align to Y axis"
 msgstr "Alinear con el eje Y"
 
+# AI Translated
+msgctxt "Camera View"
+msgid "Front"
+msgstr "Frontal"
+
 msgctxt "Camera View"
 msgid "Back"
 msgstr "Posterior"
 
+# AI Translated
+#. TRN To be shown in the main menu View->Top
+msgctxt "Camera View"
+msgid "Top"
+msgstr "Superior"
+
+# AI Translated
+#. TRN To be shown in the main menu View->Bottom
+msgctxt "Camera View"
+msgid "Bottom"
+msgstr "Inferior"
+
 msgctxt "Camera View"
 msgid "Left"
 msgstr "Izquierda"
@@ -6020,19 +6036,14 @@ msgstr "Vista por Defecto"
 msgid "Top View"
 msgstr "Vista superior"
 
-#. TRN To be shown in the main menu View->Bottom
-msgid "Bottom"
-msgstr "Inferior"
-
 msgid "Bottom View"
 msgstr "Vista inferior"
 
-msgid "Front"
-msgstr "Frontal"
-
 msgid "Front View"
 msgstr "Vista frontal"
 
+# AI Translated
+msgctxt "Camera View"
 msgid "Rear"
 msgstr "Posterior"
 
@@ -15490,7 +15501,7 @@ msgstr "La longitud de la retracción rápida antes de la purga, en relación co
 msgid "Retract amount after wipe"
 msgstr "Cantidad de retracción después de la limpieza"
 
-#, c-format
+#, no-c-format, no-boost-format
 msgid ""
 "The length of fast retraction after wipe, relative to retraction length.\n"
 "The value will be clamped by 100% minus the retract amount before the wipe value."
@@ -20733,6 +20744,15 @@ msgstr ""
 "Evita la deformación\n"
 "¿Sabías que al imprimir materiales propensos a la deformación como el ABS, aumentar adecuadamente la temperatura de la cama térmica puede reducir la probabilidad de deformaciones?"
 
+#~ msgid "Bottom"
+#~ msgstr "Inferior"
+
+#~ msgid "Front"
+#~ msgstr "Frontal"
+
+#~ msgid "Rear"
+#~ msgstr "Posterior"
+
 #~ msgid "Enter"
 #~ msgstr "Enter"
 

scripts/build_preset_cache.bat

@@ -0,0 +1,122 @@
+@echo off
+rem Build the per-vendor system preset caches (one <vendor>.opc per vendor) by
+rem running the generate_system_cache.exe dev tool against a profiles directory,
+rem and make every profiles directory named on the command line ship-ready:
+rem install the caches into it and delete the preset JSONs they replace, so a
+rem build ships one copy of its presets instead of two.
+rem
+rem   scripts\build_preset_cache.bat [build_dir] [target_dir ...]
+rem
+rem   build_dir   defaults to "build"
+rem   target_dir  profiles directories to ship into. Caches are generated into
+rem               the source tree's resources\profiles, which is what every
+rem               packaging step copies from; a target may be that same
+rem               directory, which then only gets pruned.
+rem
+rem Shipping deletes, so it is a CI packaging step. A vendor's own <vendor>.json
+rem goes along with its preset JSONs: the cache carries the vendor profile and
+rem the version it was built at, so discovery, version checks and installing all
+rem read it there. Only a vendor that has a cache is pruned, so non-vendor JSONs
+rem (blacklist.json) are left alone, as are the vendor directories themselves -
+rem thumbnails, covers and bed models still live there.
+rem
+rem   set CONFIG=<cfg> to pin the build config for multi-config generators
+rem   (default: the config of the tool already in the build tree, else Release)
+setlocal enabledelayedexpansion
+
+set "REPO_ROOT=%~dp0.."
+set "BUILD_DIR=%~1"
+if "%BUILD_DIR%"=="" set "BUILD_DIR=build"
+if not exist "%BUILD_DIR%\" (
+    echo ERROR: build tree not found: %BUILD_DIR% 1>&2
+    exit /b 1
+)
+if not "%~1"=="" shift
+
+rem Newest match wins: a stale binary silently produces a stale cache layout.
+call :find_tool
+if not defined CONFIG (
+    for %%c in (Debug Release RelWithDebInfo MinSizeRel) do (
+        echo !TOOL! | findstr /i "\\%%c\\" >nul && set "CONFIG=%%c"
+    )
+)
+if not defined CONFIG set "CONFIG=Release"
+
+echo Building generate_system_cache in %BUILD_DIR% (%CONFIG%)
+cmake --build "%BUILD_DIR%" --config %CONFIG% --target generate_system_cache
+if errorlevel 1 (
+    echo ERROR: could not build generate_system_cache - configure the build tree with -DORCA_TOOLS=ON: 1>&2
+    echo        cmake -S "%REPO_ROOT%" -B "%BUILD_DIR%" -DORCA_TOOLS=ON 1>&2
+    exit /b 1
+)
+call :find_tool
+if not defined TOOL (
+    echo ERROR: generate_system_cache.exe not found under %BUILD_DIR% - build with -DORCA_TOOLS=ON 1>&2
+    exit /b 1
+)
+
+set "PROFILES=%REPO_ROOT%\resources\profiles"
+if not exist "%PROFILES%\" (
+    echo ERROR: profiles directory not found: %PROFILES% 1>&2
+    exit /b 1
+)
+for %%d in ("%PROFILES%") do set "PROFILES=%%~fd"
+
+rem Add the slicer's runtime DLL directory to PATH so generate_system_cache.exe
+rem can resolve its dependencies (TKernel.dll etc.) without a full install step.
+set "DLL_DIR="
+for /f "delims=" %%f in ('dir /s /b "%BUILD_DIR%\TKernel.dll" 2^>nul') do (
+    if not defined DLL_DIR set "DLL_DIR=%%~dpf"
+)
+if defined DLL_DIR set "PATH=%DLL_DIR%;%PATH%"
+
+echo Generating per-vendor preset caches in %PROFILES%
+rem Start clean so vendors that went away - and caches written by older tool
+rem versions - don't linger next to the freshly generated ones.
+del /q "%PROFILES%\*.opc" 2>nul
+del /q "%PROFILES%\*.cache" 2>nul
+"%TOOL%" --path "%PROFILES%" --log_level 2
+if errorlevel 1 exit /b %errorlevel%
+
+:next_target
+if "%~1"=="" exit /b 0
+call :ship "%~1"
+if errorlevel 1 exit /b 1
+shift
+goto :next_target
+
+:ship
+set "TARGET=%~1"
+if not exist "%TARGET%\" (
+    echo ERROR: profiles directory not found: %TARGET% 1>&2
+    exit /b 1
+)
+for %%d in ("%TARGET%") do set "TARGET=%%~fd"
+if /i not "%TARGET%"=="%PROFILES%" copy /y "%PROFILES%\*.opc" "%TARGET%\" >nul
+
+set /a SHIPPED=0
+set /a PRUNED=0
+for %%c in ("%PROFILES%\*.opc") do (
+    set /a SHIPPED+=1
+    set "VENDOR=%%~nc"
+    if exist "%TARGET%\!VENDOR!.json" (
+        del /q "%TARGET%\!VENDOR!.json"
+        set /a PRUNED+=1
+    )
+    if exist "%TARGET%\!VENDOR!\" (
+        for /f %%n in ('dir /s /b "%TARGET%\!VENDOR!\*.json" 2^>nul ^| find /c /v ""') do set /a PRUNED+=%%n
+        del /s /q "%TARGET%\!VENDOR!\*.json" >nul 2>&1
+        rem Deepest first, so a directory the delete above emptied goes too; rd
+        rem refuses the ones still holding covers or meshes.
+        for /f "delims=" %%d in ('dir /s /b /ad "%TARGET%\!VENDOR!" 2^>nul ^| sort /r') do rd "%%d" 2>nul
+    )
+)
+echo %TARGET%: !SHIPPED! caches, dropped !PRUNED! preset JSONs
+exit /b 0
+
+:find_tool
+set "TOOL="
+for /f "delims=" %%f in ('dir /s /b /o-d "%BUILD_DIR%\generate_system_cache.exe" 2^>nul') do (
+    if not defined TOOL set "TOOL=%%f"
+)
+exit /b 0

scripts/build_preset_cache.sh

@@ -0,0 +1,143 @@
+#!/usr/bin/env bash
+# Build the per-vendor system preset caches (one <vendor>.opc per vendor) by
+# running the generate_system_cache dev tool against a profiles directory, and
+# make every profiles directory named on the command line ship-ready: install
+# the caches into it and delete the preset JSONs they replace, so a build ships
+# one copy of its presets instead of two.
+#
+#   ./scripts/build_preset_cache.sh                     # caches into resources/profiles
+#   ./scripts/build_preset_cache.sh -b build/arm64      # search this build tree for the tool
+#   ./scripts/build_preset_cache.sh <dir> [<dir> ...]   # and ship into these profiles dirs
+#
+# Caches are generated into the source tree's resources/profiles, which is what
+# every packaging step copies from. Shipping deletes, so it is a CI packaging
+# step: pass packaged output directories, or the checkout of a build that is
+# about to be packaged from it.
+#
+# A vendor's own <vendor>.json goes along with its preset JSONs: the cache
+# carries the vendor profile and the version it was built at, so discovery,
+# version checks and installing all read it there. A shipped vendor is its cache
+# and nothing else. Only a vendor that has a cache is pruned, so an ungenerated
+# vendor keeps its JSONs and is simply parsed at startup; non-vendor JSONs
+# (blacklist.json) are left alone, as are the vendor directories themselves —
+# thumbnails, covers and bed models still live there.
+#
+#   -b <dir>    build tree holding the tool
+#               (default: build/arm64, build/x86_64, or build — first that exists)
+#   -p <dir>    profiles directory to generate caches into
+#               (default: <repo>/resources/profiles)
+#   -c <cfg>    build config for multi-config generators
+#               (default: the config of the tool already in the build tree, else
+#               the build tree's CMAKE_BUILD_TYPE)
+#   -n          skip the rebuild and run the tool already in the build tree
+#   -l <level>  tool log level (default: 2)
+set -euo pipefail
+
+repo_root="$(cd "$(dirname "$0")/.." && pwd -P)"
+build_dir=""
+profiles_dir=""
+config=""
+build_tool=1
+log_level=2
+
+while getopts "b:p:c:l:nh" opt; do
+    case $opt in
+        b) build_dir="$OPTARG" ;;
+        p) profiles_dir="$OPTARG" ;;
+        c) config="$OPTARG" ;;
+        n) build_tool=0 ;;
+        l) log_level="$OPTARG" ;;
+        h) sed -n '2,${/^#/!q;p;}' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+        *) exit 1 ;;
+    esac
+done
+shift $((OPTIND - 1))
+
+if [ -z "$build_dir" ]; then
+    for candidate in "$repo_root/build/arm64" "$repo_root/build/x86_64" "$repo_root/build"; do
+        if [ -d "$candidate" ]; then build_dir="$candidate"; break; fi
+    done
+fi
+if [ -z "$build_dir" ] || [ ! -d "$build_dir" ]; then
+    echo "ERROR: build tree not found (pass -b <build_dir>)" >&2
+    exit 1
+fi
+
+# Newest match wins: multi-config trees keep one binary per config, and a stale
+# one silently produces a stale cache layout.
+find_tool() {
+    local best="" f
+    while IFS= read -r f; do
+        [ -n "$f" ] || continue
+        if [ -z "$best" ] || [ "$f" -nt "$best" ]; then best="$f"; fi
+    done < <(find "$build_dir" -name generate_system_cache -type f 2>/dev/null)
+    printf '%s' "$best"
+}
+
+tool=$(find_tool)
+if [ -z "$config" ]; then
+    case "$tool" in
+        */Debug/*)          config=Debug ;;
+        */Release/*)        config=Release ;;
+        */RelWithDebInfo/*) config=RelWithDebInfo ;;
+        */MinSizeRel/*)     config=MinSizeRel ;;
+        *) config=$(sed -n 's/^CMAKE_BUILD_TYPE:[A-Z]*=\(.\+\)$/\1/p' "$build_dir/CMakeCache.txt" 2>/dev/null | head -1 || true) ;;
+    esac
+fi
+
+if [ "$build_tool" = 1 ]; then
+    echo "Building generate_system_cache in $build_dir${config:+ ($config)}"
+    build_args=(--build "$build_dir" --target generate_system_cache)
+    if [ -n "$config" ]; then build_args+=(--config "$config"); fi
+    if ! cmake "${build_args[@]}"; then
+        echo "ERROR: could not build generate_system_cache — configure the build tree with -DORCA_TOOLS=ON:" >&2
+        echo "       cmake -S \"$repo_root\" -B \"$build_dir\" -DORCA_TOOLS=ON" >&2
+        exit 1
+    fi
+    tool=$(find_tool)
+fi
+
+if [ -z "$tool" ]; then
+    echo "ERROR: generate_system_cache not found under $build_dir — build with -DORCA_TOOLS=ON" >&2
+    exit 1
+fi
+
+if [ -z "$profiles_dir" ]; then profiles_dir="$repo_root/resources/profiles"; fi
+if [ ! -d "$profiles_dir" ]; then
+    echo "ERROR: profiles directory not found: $profiles_dir" >&2
+    exit 1
+fi
+profiles_dir=$(cd "$profiles_dir" && pwd -P)
+
+# Start clean so vendors that went away — and caches written by older tool
+# versions — don't linger next to the freshly generated ones.
+echo "Generating per-vendor preset caches in $profiles_dir"
+rm -f "$profiles_dir"/*.opc "$profiles_dir"/*.cache
+"$tool" --path "$profiles_dir" --log_level "$log_level"
+
+for target in "$@"; do
+    resolved=$(cd "$target" 2>/dev/null && pwd -P) || {
+        echo "ERROR: profiles directory not found: $target" >&2
+        exit 1
+    }
+    if [ "$resolved" != "$profiles_dir" ]; then
+        cp "$profiles_dir"/*.opc "$resolved"/
+    fi
+
+    pruned=0
+    shipped=0
+    for cache in "$profiles_dir"/*.opc; do
+        vendor=$(basename "$cache" .opc)
+        shipped=$(( shipped + 1 ))
+        if [ -f "$resolved/$vendor.json" ]; then
+            rm -f "$resolved/$vendor.json"
+            pruned=$(( pruned + 1 ))
+        fi
+        [ -d "$resolved/$vendor" ] || continue
+        n=$(find "$resolved/$vendor" -name '*.json' | wc -l)
+        find "$resolved/$vendor" -name '*.json' -delete
+        find "$resolved/$vendor" -type d -empty -delete
+        pruned=$(( pruned + n ))
+    done
+    echo "$resolved: $shipped caches, dropped $pruned preset JSONs"
+done

src/dev-utils/CMakeLists.txt

@@ -20,6 +20,16 @@ if (SLIC3R_ENC_CHECK)
     )
 endif()
 
+if (ORCA_TOOLS)
+    set(_DEV_DEFS -DBOOST_ALL_NO_LIB -DBOOST_USE_WINAPI_VERSION=0x602 -DBOOST_SYSTEM_USE_UTF8)
+
+    # generate_system_cache: pre-generates per-vendor <vendor>.opc files under resources/profiles for CI bundling.
+    add_executable(generate_system_cache generate_system_cache.cpp)
+    target_link_libraries(generate_system_cache libslic3r boost_headeronly)
+    target_compile_definitions(generate_system_cache PRIVATE ${_DEV_DEFS})
+
+endif()
+
 # Function that adds source file encoding check to a target
 # using the above encoding-check binary
 

src/dev-utils/generate_system_cache.cpp

@@ -0,0 +1,84 @@
+#include "libslic3r/PresetBundle.hpp"
+#include "libslic3r/Preset.hpp"
+#include "libslic3r/Utils.hpp"
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/program_options.hpp>
+#include <iostream>
+
+using namespace Slic3r;
+namespace fs = boost::filesystem;
+namespace po = boost::program_options;
+
+int main(int argc, char* argv[])
+{
+    po::options_description desc("OrcaSlicer System Cache Generator\nUsage");
+    // clang-format off
+    desc.add_options()
+        ("help,h", "Show help")
+#ifdef __APPLE__
+        ("path,p", po::value<std::string>()->default_value("../../../../../../../resources/profiles"), "Path to profiles directory")
+#else
+        ("path,p", po::value<std::string>()->default_value("../../../resources/profiles"), "Path to profiles directory")
+#endif
+        ("log_level,l", po::value<int>()->default_value(2), "Log level (0=trace, 2=info, 4=error)");
+    // clang-format on
+
+    po::variables_map vm;
+    try {
+        po::store(po::parse_command_line(argc, argv, desc), vm);
+        if (vm.count("help")) { std::cout << desc << "\n"; return 0; }
+        po::notify(vm);
+    } catch (const po::error& e) {
+        std::cerr << "Error: " << e.what() << "\n" << desc << "\n";
+        return 1;
+    }
+
+    const std::string profiles_path = vm["path"].as<std::string>();
+    const int         log_level     = vm["log_level"].as<int>();
+
+    if (!fs::exists(profiles_path) || !fs::is_directory(profiles_path)) {
+        std::cerr << "Error: '" << profiles_path << "' is not a valid directory\n";
+        return 1;
+    }
+
+    set_logging_level(log_level);
+    set_data_dir(profiles_path);
+    set_resources_dir(fs::path(profiles_path).parent_path().make_preferred().string());
+
+    const fs::path user_dir = fs::path(data_dir()) / PRESET_USER_DIR;
+    if (!fs::exists(user_dir))
+        fs::create_directories(user_dir);
+
+    AppConfig app_config;
+    app_config.set("preset_folder", "default");
+
+    auto preset_bundle = std::make_unique<PresetBundle>();
+    preset_bundle->set_is_validation_mode(true);
+    preset_bundle->set_default_suppressed(true);
+    preset_bundle->set_generate_vendor_caches(true);
+
+    std::cout << "Loading system presets from: " << profiles_path << "\n";
+
+    try {
+        // In validation mode data_dir() is the profiles directory set above, so the
+        // loader writes each <vendor>.opc next to its <vendor>.json as it parses it.
+        preset_bundle->load_presets(app_config, ForwardCompatibilitySubstitutionRule::EnableSilent);
+    } catch (const std::exception& ex) {
+        std::cerr << "Failed to load presets: " << ex.what() << "\n";
+        return 1;
+    }
+
+    size_t cache_count = 0;
+    for (auto& entry : fs::directory_iterator(profiles_path))
+        if (boost::iends_with(entry.path().string(), ".opc"))
+            ++ cache_count;
+    if (cache_count == 0) {
+        std::cerr << "No vendor cache files were generated under " << profiles_path << "\n";
+        return 1;
+    }
+    std::cout << "Generated " << cache_count << " vendor cache file(s) under " << profiles_path << "\n";
+    return 0;
+}

src/libslic3r/Brim.cpp

@@ -32,15 +32,13 @@ static void append_and_translate(ExPolygons &dst, const ExPolygons &src, const P
     for (; dst_idx < dst.size(); ++dst_idx)
         dst[dst_idx].translate(instance_shift);
 }
-// BBS: generate brim area by objs
+// Orca: Translate the brim area into print coordinates and store it per instance.
-static void append_and_translate(ExPolygons& dst, const ExPolygons& src,
+static void append_and_translate(const ExPolygons& src, const PrintInstance& instance,
-    const PrintInstance& instance, size_t instance_idx, std::map<ObjectInstanceID, ExPolygons>& brimAreaMap) {
+    size_t instance_idx, std::map<ObjectInstanceID, ExPolygons>& brimAreaMap) {
     ExPolygons srcShifted = src;
     Point instance_shift = instance.shift_without_plate_offset();
-    for (size_t src_idx = 0; src_idx < srcShifted.size(); ++src_idx)
+    for (ExPolygon& expoly : srcShifted)
-        srcShifted[src_idx].translate(instance_shift);
+        expoly.translate(instance_shift);
-    srcShifted = diff_ex(srcShifted, dst);
-    //expolygons_append(dst, temp2);
     expolygons_append(brimAreaMap[{ instance.print_object->id(), instance_idx }], std::move(srcShifted));
 }
 
@@ -572,7 +570,7 @@ static ExPolygons outer_inner_brim_area(const Print& print,
                 for (size_t instance_idx = 0; instance_idx < object->instances().size(); ++instance_idx) {
                     const PrintInstance& instance = object->instances()[instance_idx];
                     if (!brim_area_object.empty())
-                        append_and_translate(brim_area, brim_area_object, instance, instance_idx, brimAreaMap);
+                        append_and_translate(brim_area_object, instance, instance_idx, brimAreaMap);
                     append_and_translate(no_brim_area, no_brim_area_object, instance);
                     append_and_translate(holes, holes_object, instance);
                     append_and_translate(objectIslands, objectIsland, instance);
@@ -875,6 +873,14 @@ void make_brim(const Print& print, PrintTryCancel try_cancel, Polygons& islands_
     ExPolygons           islands_area_ex = outer_inner_brim_area(print,
         float(flow.scaled_spacing()), brimAreaMap, objPrintVec, printExtruders);
 
+    if (!print.config().combine_brims) {
+        ExPolygons claimed_area;
+        for (auto& [_, areas] : brimAreaMap) {
+            areas = diff_ex(areas, claimed_area);
+            expolygons_append(claimed_area, areas);
+        }
+    }
+
     // BBS: Find boundingbox of the first layer
     for (const ObjectID printObjID : print.print_object_ids()) {
         BoundingBox bbx;

src/libslic3r/CMakeLists.txt

@@ -248,6 +248,8 @@ set(lisbslic3r_sources
     GCode/Thumbnails.hpp
     GCode/ToolOrdering.cpp
     GCode/ToolOrdering.hpp
+    GCode/OrderingStrategies.cpp
+    GCode/OrderingStrategies.hpp
     GCode/WipeTower2.cpp
     GCode/WipeTower2.hpp
     GCode/WipeTower.cpp

src/libslic3r/Config.hpp

@@ -27,6 +27,9 @@
 
 #include <cereal/access.hpp>
 #include <cereal/types/base_class.hpp>
+// The serialize() members below archive ConfigOption hierarchies through
+// cereal::base_class, whose registration machinery lives in polymorphic.hpp.
+#include <cereal/types/polymorphic.hpp>
 
 namespace Slic3r {
     struct FloatOrPercent

src/libslic3r/GCode.cpp

@@ -14,6 +14,7 @@
 #include "GCode/Thumbnails.hpp"
 #include "GCode/WipeTower.hpp"
 #include "ShortestPath.hpp"
+#include "GCode/OrderingStrategies.hpp"
 #include "Print.hpp"
 #include "Utils.hpp"
 #include "ClipperUtils.hpp"
@@ -2804,6 +2805,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
     m_role_based_fan_marker_layer.fill(-1);
 
     m_fan_mover.release();
+    m_ordering_cache.clear();
     
     m_writer.set_is_bbl_machine(is_bbl_printers);
 
@@ -3124,11 +3126,20 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
         // In non-sequential print, the printing extruders may have been modified by the extruder switches stored in Model::custom_gcode_per_print_z.
         // Therefore initialize the printing extruders from there.
         this->set_extruders(tool_ordering.all_extruders());
-        print_object_instances_ordering = 
+        print_object_instances_ordering =
-            // By default, order object instances using a nearest neighbor search.
+            // By default, order object instances using nearest-neighbor chaining plus
-            print.config().print_order == PrintOrder::Default ? chain_print_object_instances(print)
+            // 2-opt and crossing-removal post-processing.
+            (print.config().print_order == PrintOrder::Default ? chain_print_object_instances(print)
+            // Snake: serpentine row traversal + 2-opt
+            : (print.config().print_order == PrintOrder::Snake ? chain_print_object_instances_snake(print)
+            // Best of all: run every strategy, pick the shortest total path
+            : (print.config().print_order == PrintOrder::BestOfStrategies ? chain_print_object_instances_best_of(print)
             // Otherwise same order as the object list
-            : sort_object_instances_by_model_order(print);
+            : sort_object_instances_by_model_order(print))));
+
+
+
+
     }
     if (initial_extruder_id == (unsigned int)-1) {
         // Nothing to print!
@@ -5519,7 +5530,9 @@ LayerResult GCode::process_layer(
     //Calibration Layer-specific GCode
     switch (print.calib_mode()) {
         case CalibMode::Calib_PA_Tower: {
-            gcode += writer().set_pressure_advance(print.calib_params().start + static_cast<int>(print_z) * print.calib_params().step);
+            gcode += writer().set_pressure_advance(this->interpolate_value_across_layers(static_cast<float>(print.calib_params().start),
+                                                                                         static_cast<float>(print.calib_params().end),
+                                                                                         static_cast<float>(print.calib_params().step)));
             break;
         }
         case CalibMode::Calib_Temp_Tower: {
@@ -5527,7 +5540,12 @@ LayerResult GCode::process_layer(
             break;
         }
         case CalibMode::Calib_VFA_Tower: {
-            auto _speed = print.calib_params().start + std::floor(print_z / 5.0) * print.calib_params().step;
+            // Step the outer wall speed from start to end across the tower's layers. Plater::calib_VFA sizes the
+            // geometry so each speed step spans one visual block (a fixed number of layers), so the layer-based
+            // stepping stays aligned with the blocks regardless of nozzle size / layer height.
+            float _speed = this->interpolate_value_across_layers(static_cast<float>(print.calib_params().start),
+                                                                 static_cast<float>(print.calib_params().end),
+                                                                 static_cast<float>(print.calib_params().step));
             m_calib_config.set_key_value("outer_wall_speed", new ConfigOptionFloatsNullable({std::round(_speed)}));
             break;
         }
@@ -5959,41 +5977,128 @@ LayerResult GCode::process_layer(
     if (m_farthest_point_timelapse.enabled)
         compute_farthest_point(layers, most_used_extruder, support_filaments);
 
-    std::map<unsigned int, std::vector<InstanceToPrint>> filament_to_print_instances;
+    // Per filament: instances to print, and the visit sequence over them. Island-level ordering
+    // may visit an instance more than once per layer; otherwise one visit per instance.
+    std::map<unsigned int, std::pair<std::vector<InstanceToPrint>, std::vector<InstanceVisit>>> filament_to_print_instances;
     {
+        // Order individual islands rather than whole instances. Off for by-object sequencing,
+        // sequential printing, and the explicit AsObjectList order, which tour whole instances.
+        const bool island_level_ordering = print.config().print_sequence != PrintSequence::ByObject &&
+            single_object_instance_idx == size_t(-1) &&
+            print.config().print_order != PrintOrder::AsObjectList;
         for (unsigned int filament_id : layer_tools.extruders) {
             auto objects_by_extruder_it = by_extruder.find(filament_id);
             if (objects_by_extruder_it == by_extruder.end()) continue;
 
+            auto &filament_plan = filament_to_print_instances[filament_id];
+
+            if (!island_level_ordering) {
+                // One visit per instance, printing all of its islands.
+                filament_plan.first = sort_print_object_instances(objects_by_extruder_it->second, layers, ordering, single_object_instance_idx);
+                filament_plan.second.reserve(filament_plan.first.size());
+                for (size_t i = 0; i < filament_plan.first.size(); ++i)
+                    filament_plan.second.push_back({i, {}, true});
+                continue;
+            }
+
             int   plate_idx = print.get_plate_index();
             Point wt_pos(print.config().wipe_tower_x.get_at(plate_idx), print.config().wipe_tower_y.get_at(plate_idx));
 
+            // Build the instances and one tour node per non-empty island (a single node for
+            // instances without chainable islands). Positions quantized to 1 mm so small
+            // centroid drift between layers still hits the tour cache below.
             std::vector<GCode::ObjectByExtruder> &objects_by_extruder = objects_by_extruder_it->second;
-            std::vector<const PrintObject *>      print_objects;
+            std::vector<InstanceToPrint> &instances = filament_plan.first;
-            for (int obj_idx = 0; obj_idx < objects_by_extruder.size(); obj_idx++) {
+            std::vector<IslandOrderNode> nodes;
-                auto &object_by_extruder = objects_by_extruder[obj_idx];
+            std::vector<size_t>          node_instances;
+            auto quantize_to_mm = [](const Point &pt) -> Point {
+                const coord_t grid = coord_t(scale_(1.));
+                // Round to the nearest 1 mm symmetrically (integer division truncates toward
+                // zero, which would make the bucket straddling the origin twice as wide).
+                auto q = [grid](coord_t v) -> coord_t {
+                    return ((v >= 0 ? v + grid / 2 : v - grid / 2) / grid) * grid;
+                };
+                return Point(q(pt.x()), q(pt.y()));
+            };
+            for (ObjectByExtruder &object_by_extruder : objects_by_extruder) {
                 if (object_by_extruder.islands.empty() && (object_by_extruder.support == nullptr || object_by_extruder.support->empty())) continue;
 
-                print_objects.push_back(print.get_object(obj_idx));
+                const size_t       layer_id     = &object_by_extruder - objects_by_extruder.data();
+                const PrintObject *print_object = layers[layer_id].original_object;
+                if (print_object == nullptr)
+                    continue;
+                const Layer *obj_layer = layers[layer_id].object_layer;
+                std::vector<ObjectByExtruder::Island> &islands = object_by_extruder.islands;
+                const bool islands_chainable = obj_layer != nullptr && islands.size() == obj_layer->lslices.size() + 1;
+                for (size_t instance_id = 0; instance_id < print_object->instances().size(); ++instance_id) {
+                    const size_t instance_idx = instances.size();
+                    instances.emplace_back(object_by_extruder, layer_id, *print_object, instance_id,
+                                           print_object->instances()[instance_id].model_instance->get_labeled_id());
+                    const Point &shift = print_object->instances()[instance_id].shift;
+                    const size_t first_node = nodes.size();
+                    if (islands_chainable)
+                        for (size_t i = 0; i + 1 < islands.size(); ++i)
+                            if (!islands[i].by_region.empty()) {
+                                nodes.push_back({print_object->id(), instance_id, i,
+                                                 quantize_to_mm(obj_layer->lslices[i].contour.centroid() + shift)});
+                                node_instances.emplace_back(instance_idx);
+                            }
+                    if (nodes.size() == first_node) {
+                        // No chainable islands: tour the whole instance as one stop.
+                        nodes.push_back({print_object->id(), instance_id, size_t(-1), quantize_to_mm(shift)});
+                        node_instances.emplace_back(instance_idx);
+                    }
+                }
             }
 
-            std::vector<const PrintInstance *> new_ordering = chain_print_object_instances(print_objects, &wt_pos);
+            // Reuse the cached tour while this filament's island layout is unchanged.
-            std::reverse(new_ordering.begin(), new_ordering.end());
+            auto &cache_entry = m_ordering_cache[filament_id];
+            if (!(cache_entry.first == nodes)) {
+                cache_entry.first = nodes;
+                Points node_points;
+                node_points.reserve(nodes.size());
+                for (const IslandOrderNode &node : nodes)
+                    node_points.emplace_back(node.pos);
+                std::vector<size_t> tour = order_points_with_strategy(node_points, print.config().print_order, &wt_pos);
+                // Chained starting near the wipe tower, reversed so the layer ends near it.
+                std::reverse(tour.begin(), tour.end());
 
-            if (print.config().print_sequence == PrintSequence::ByObject) {
+                // Group consecutive tour stops of the same instance into visits.
-                filament_to_print_instances[filament_id] = sort_print_object_instances(objects_by_extruder_it->second, layers, ordering, single_object_instance_idx);
+                std::vector<InstanceVisit> visits;
-            } else {
+                std::vector<bool> instance_seen(instances.size(), false);
-                
+                std::vector<int>  last_visit_of_instance(instances.size(), -1);
-                // PrintSequence::ByLayer to use global ordering ( per object ordering ) if intra-layer order PrintOrder::AsObjectList is specified while keeping behaviour of PrintSequence::ByLayer
+                for (size_t node_idx : tour) {
-                const std::vector<const PrintInstance*>* ordering_for_filament = (print.config().print_order == PrintOrder::AsObjectList && ordering != nullptr) ? ordering: &new_ordering;
+                    const size_t instance_idx = node_instances[node_idx];
-                filament_to_print_instances[filament_id] = sort_print_object_instances(objects_by_extruder_it->second, layers, ordering_for_filament, single_object_instance_idx);
+                    if (visits.empty() || visits.back().instance_idx != instance_idx) {
+                        visits.push_back({instance_idx, {}, !instance_seen[instance_idx]});
+                        instance_seen[instance_idx] = true;
+                    }
+                    if (nodes[node_idx].island_idx != size_t(-1))
+                        visits.back().islands.emplace_back(nodes[node_idx].island_idx);
+                    last_visit_of_instance[instance_idx] = int(visits.size()) - 1;
+                }
+                // The trailing catch-all island has no geometry to chain by; append it to the
+                // instance's last visit.
+                for (size_t i = 0; i < instances.size(); ++i) {
+                    if (last_visit_of_instance[i] < 0)
+                        continue;
+                    InstanceVisit &last_visit = visits[size_t(last_visit_of_instance[i])];
+                    if (last_visit.islands.empty())
+                        // A visit without explicit islands already prints everything.
+                        continue;
+                    std::vector<ObjectByExtruder::Island> &islands = instances[i].object_by_extruder.islands;
+                    if (!islands.back().by_region.empty())
+                        last_visit.islands.emplace_back(islands.size() - 1);
+                }
+                cache_entry.second = std::move(visits);
             }
+            filament_plan.second = cache_entry.second;
         }
     }
 
     std::set<size_t> layer_object_label_ids;
     for (auto iter = filament_to_print_instances.begin(); iter != filament_to_print_instances.end(); ++iter) {
-        for (const InstanceToPrint &instance : iter->second) {
+        for (const InstanceToPrint &instance : iter->second.first) {
             layer_object_label_ids.insert(instance.label_object_id);
         }
     }
@@ -6063,7 +6168,7 @@ LayerResult GCode::process_layer(
 
         if (print.config().print_sequence == PrintSequence::ByLayer && m_enable_exclude_object && print.config().support_object_skip_flush.value) {
             std::vector<size_t> filament_instances_id;
-            for (InstanceToPrint &instance : filament_to_print_instances[extruder_id]) filament_instances_id.emplace_back(instance.label_object_id);
+            for (InstanceToPrint &instance : filament_to_print_instances[extruder_id].first) filament_instances_id.emplace_back(instance.label_object_id);
             m_filament_instances_code = _encode_label_ids_to_base64(filament_instances_id);
         }
 
@@ -6144,7 +6249,9 @@ LayerResult GCode::process_layer(
         if (layer_tools.has_wipe_tower && m_wipe_tower)
             m_last_processor_extrusion_role = erWipeTower;
 
-        std::vector<InstanceToPrint> &instances_to_print = filament_to_print_instances[extruder_id];
+        auto &filament_plan = filament_to_print_instances[extruder_id];
+        std::vector<InstanceToPrint>     &instances_to_print = filament_plan.first;
+        const std::vector<InstanceVisit> &instance_visits    = filament_plan.second;
 
         // We are almost ready to print. However, we must go through all the objects twice to print the overridden extrusions first (infill/perimeter wiping feature):
         std::vector<ObjectByExtruder::Island::Region> by_region_per_copy_cache;
@@ -6152,10 +6259,11 @@ LayerResult GCode::process_layer(
             if (is_anything_overridden && print_wipe_extrusions == 0)
                 gcode+="; PURGING FINISHED\n";
 
-            for (InstanceToPrint &instance_to_print : instances_to_print) {
+            for (const InstanceVisit &visit : instance_visits) {
+                InstanceToPrint &instance_to_print = instances_to_print[visit.instance_idx];
                 const auto& inst = instance_to_print.print_object.instances()[instance_to_print.instance_id];
                 const LayerToPrint &layer_to_print = layers[instance_to_print.layer_id];
-                if (print_wipe_extrusions == (is_anything_overridden ? 1 : 0)) {
+                if (visit.first_visit && print_wipe_extrusions == (is_anything_overridden ? 1 : 0)) {
                     gcode += generate_object_skirt_group(print, instance_to_print.print_object, instance_to_print.instance_id, layer_tools, layer, extruder_id);
                     gcode += generate_object_brim(print, instance_to_print.print_object, instance_to_print.instance_id, first_layer);
                 }
@@ -6208,7 +6316,7 @@ LayerResult GCode::process_layer(
                     m_avoid_crossing_perimeters.use_external_mp_once();
                 m_last_obj_copy = this_object_copy;
                 this->set_origin(unscale(offset));
-                if (instance_to_print.object_by_extruder.support != nullptr) {
+                if (visit.first_visit && instance_to_print.object_by_extruder.support != nullptr) {
                     m_layer = layers[instance_to_print.layer_id].support_layer;
                     m_object_layer_over_raft = false;
 
@@ -6242,9 +6350,42 @@ LayerResult GCode::process_layer(
                     m_layer = layer_to_print.layer();
                     m_object_layer_over_raft = object_layer_over_raft;
                 }
-                //FIXME order islands?
                 // Sequential tool path ordering of multiple parts within the same object, aka. perimeter tracking (#5511)
-                for (ObjectByExtruder::Island &island : instance_to_print.object_by_extruder.islands) {
+                // Island print order. Use the islands the tour assigned to this visit; if none,
+                // chain all islands nearest-neighbor from the current nozzle position (last_pos(),
+                // in this instance's frame after set_origin() above). Empty islands are skipped;
+                // the trailing catch-all island has no centroid to chain by and always goes last.
+                std::vector<ObjectByExtruder::Island> &islands = instance_to_print.object_by_extruder.islands;
+                std::vector<size_t> island_order = visit.islands;
+                if (island_order.empty()) {
+                    island_order.reserve(islands.size());
+                    if (layer_to_print.object_layer != nullptr && islands.size() == layer_to_print.object_layer->lslices.size() + 1) {
+                        for (size_t i = 0; i + 1 < islands.size(); ++i)
+                            if (!islands[i].by_region.empty())
+                                island_order.emplace_back(i);
+                        if (island_order.size() > 1) {
+                            Points island_centroids;
+                            island_centroids.reserve(island_order.size());
+                            for (size_t i : island_order)
+                                island_centroids.emplace_back(layer_to_print.object_layer->lslices[i].contour.centroid());
+                            const Point start_near = this->last_pos();
+                            std::vector<size_t> chain = chain_points(island_centroids, this->last_pos_defined() ? &start_near : nullptr);
+                            std::vector<size_t> ordered;
+                            ordered.reserve(island_order.size());
+                            for (size_t k : chain)
+                                ordered.emplace_back(island_order[k]);
+                            island_order = std::move(ordered);
+                        }
+                        if (!islands.back().by_region.empty())
+                            island_order.emplace_back(islands.size() - 1);
+                    } else {
+                        // Unexpected islands layout, keep the stored order.
+                        for (size_t i = 0; i < islands.size(); ++i)
+                            island_order.emplace_back(i);
+                    }
+                }
+                for (size_t island_idx : island_order) {
+                    ObjectByExtruder::Island &island = islands[island_idx];
                     const auto& by_region_specific = is_anything_overridden ? island.by_region_per_copy(by_region_per_copy_cache, static_cast<unsigned int>(instance_to_print.instance_id), extruder_id, print_wipe_extrusions != 0) : island.by_region;
                     // When starting a new object, use the external motion planner for the first travel move.
                     const Point& offset = instance_to_print.print_object.instances()[instance_to_print.instance_id].shift;
@@ -8209,29 +8350,22 @@ std::string GCode::extrusion_role_to_string_for_parser(const ExtrusionRole & rol
 }
 
 // Calculate the interpolated value for the current layer between start_value and end_value.
-// Step will create equal layers steps from first to last value.
+// Step > 0 splits the range into equal-width bands from first to last value (both inclusive).
 // Step = 0 means gradual interpolation finishing at last value.
 float GCode::interpolate_value_across_layers(float start_value, float end_value, float step) const
 {
     if (m_layer_index <= 1) {
         return start_value;
     }
-    else {
+    const float ratio = m_layer_index / (m_layer_count - 1.f);
-        bool use_steps = step > 0.f;
+    if (step > 0.f) {
-        if (use_steps) {
+        // Discrete equal-width bands. band is clamped to the last band so the result can't overshoot the range:
-            if (start_value > end_value) {
+        // at the top layer ratio * n_bands == n_bands, which would otherwise index one band past the end.
-                start_value += step;
+        const int n_bands = std::lround(std::abs(end_value - start_value) / step) + 1;
-            } else {
+        const int band    = std::min(n_bands - 1, static_cast<int>(ratio * n_bands));
-                end_value += step;
+        return start_value + (end_value >= start_value ? 1.f : -1.f) * band * step;
-            }
-        }
-        float ratio = m_layer_index / (m_layer_count - 1.f);
-        float value = start_value + ratio * (end_value - start_value);
-        if (use_steps) {
-            value = trunc(value / step) * step;
-        }
-        return value;
     }
+    return start_value + ratio * (end_value - start_value);
 }
 
 std::string encodeBase64(uint64_t value)

src/libslic3r/GCode.hpp

@@ -539,6 +539,40 @@ private:
     // Cache for custom seam enforcers/blockers for each layer.
     SeamPlacer                          m_seam_placer;
 
+    // One stop of the island-level tour: consecutive islands of a single instance. An instance
+    // can have several visits per layer when its islands are toured non-consecutively.
+    struct InstanceVisit
+    {
+        // Index into the per-filament InstanceToPrint vector.
+        size_t              instance_idx;
+        // Islands to print, in order (indices into ObjectByExtruder::islands). Empty: print all
+        // islands, ordered at extrusion time.
+        std::vector<size_t> islands;
+        // First visit of this instance this layer; skirt, brim and support are emitted here.
+        bool                first_visit;
+    };
+
+    // One node of the island-level tour, also used as cache key: identity plus quantized position.
+    struct IslandOrderNode
+    {
+        ObjectID object_id;
+        size_t   instance_id;
+        // Index into ObjectByExtruder::islands, or size_t(-1) for an instance without chainable
+        // islands (e.g. support only), which is toured as a single stop.
+        size_t   island_idx;
+        // Island centroid in G-code coordinates, quantized to 1 mm for cache stability.
+        Point    pos;
+        bool operator==(const IslandOrderNode &rhs) const {
+            return object_id == rhs.object_id && instance_id == rhs.instance_id &&
+                   island_idx == rhs.island_idx && pos == rhs.pos;
+        }
+    };
+
+    // Cache the per-filament island tour to avoid recomputing while the layer's island layout is
+    // unchanged. Key: filament_id. Value: {nodes the tour was computed from, resulting visits}.
+    std::map<unsigned int, std::pair<std::vector<IslandOrderNode>, std::vector<InstanceVisit>>>
+                                        m_ordering_cache;
+
     ExtrusionQualityEstimator m_extrusion_quality_estimator;
 
 

src/libslic3r/GCode/OrderingStrategies.cpp

@@ -0,0 +1,435 @@
+// Print-object ordering strategies: implementation.
+// Consolidates TSP post-processing, Snake, and Best-of-Strategies.
+
+#include "OrderingStrategies.hpp"
+#include "../Geometry.hpp"
+#include "../ShortestPath.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <numeric>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace Slic3r {
+
+/* ====================================================================
+ * TSP post-processing utilities
+ * ==================================================================== */
+
+bool tsp_2opt_improve(std::vector<size_t>& path, const Points& centers, int max_passes)
+{
+    size_t pn = path.size();
+    if (pn <= 2) return false;
+
+    // Pre-compute edge lengths once per pass to avoid redundant norm() calls.
+    auto recompute_edges = [&]() {
+        std::vector<double> el(pn);
+        for (size_t i = 0; i < pn; ++i) {
+            size_t ni = (i + 1) % pn;
+            el[i] = (centers[path[i]].cast<double>() - centers[path[ni]].cast<double>()).norm();
+        }
+        return el;
+    };
+    std::vector<double> el = recompute_edges();
+
+    // Pre-compute squared edge lengths for early rejection in the inner loop.
+    auto recompute_edges_sq = [&]() {
+        std::vector<double> elsq(pn);
+        for (size_t i = 0; i < pn; ++i) {
+            size_t ni = (i + 1) % pn;
+            elsq[i] = (centers[path[i]].cast<double>() - centers[path[ni]].cast<double>()).squaredNorm();
+        }
+        return elsq;
+    };
+    std::vector<double> elsq = recompute_edges_sq();
+
+    bool improved = false;
+    for (int pass = 0; max_passes <= 0 || pass < max_passes; ++pass) {
+        size_t best_i = pn, best_j = pn;
+        double best_gain = 0;
+
+        for (size_t i = 0; i < pn; ++i) {
+            const Vec2d& pi   = centers[path[i]].cast<double>();
+            const Vec2d& p_in = centers[path[(i + 1) % pn]].cast<double>();
+            double d_i = el[i];
+            double d_i_sq = elsq[i];
+
+            for (size_t j = i + 2; j < pn; ++j) {
+                size_t j_next = (j + 1) % pn;
+                // Skip the swap that would reverse the entire cycle (removes both
+                // edges (0,1) and (pn-1,0), equivalent to traversing the cycle backwards).
+                if (i == 0 && j_next == 0) continue;
+
+                const Vec2d& pj   = centers[path[j]].cast<double>();
+                const Vec2d& p_jn = centers[path[j_next]].cast<double>();
+                double d_j = el[j];
+
+                // Early rejection using squared distances (avoids 2 sqrt calls).
+                double new_a_sq = (pj - pi).squaredNorm();
+                double new_b_sq = (p_jn - p_in).squaredNorm();
+                if (new_a_sq >= d_i_sq && new_b_sq >= elsq[j]) continue;
+
+                double new_a = std::sqrt(new_a_sq);
+                double new_b = std::sqrt(new_b_sq);
+                double gain = d_i + d_j - new_a - new_b;
+
+                if (gain > best_gain) {
+                    best_gain = gain;
+                    best_i = i; best_j = j;
+                }
+            }
+        }
+
+        if (best_i == pn) break;
+        improved = true;
+        // Reverse the best swap segment
+        std::reverse(path.begin() + best_i + 1, path.begin() + best_j + 1);
+
+        // Recompute edge lengths after reversal
+        el = recompute_edges();
+        elsq = recompute_edges_sq();
+    }
+    return improved;
+}
+
+// Fast bounding-box overlap test (rejects most non-intersecting pairs).
+static inline bool bboxes_overlap(const Point& a, const Point& b, const Point& c, const Point& d)
+{
+    return !(std::max(a.x(), b.x()) < std::min(c.x(), d.x()) ||
+             std::max(c.x(), d.x()) < std::min(a.x(), b.x()) ||
+             std::max(a.y(), b.y()) < std::min(c.y(), d.y()) ||
+             std::max(c.y(), d.y()) < std::min(a.y(), b.y()));
+}
+
+bool tsp_remove_crossings(std::vector<size_t>& path, const Points& centers)
+{
+    size_t pn = path.size();
+    if (pn <= 3) return false;
+
+    // Treat path as a cycle: include the closing edge (pn-1 -> 0), consistent with the other
+    // TSP helpers (2-opt, closing-edge rotation) that operate on the full cycle.
+    size_t n_edges = pn;
+
+    // Scan for first crossing; returns {i, j} or {npos, npos} if none.
+    auto find_crossing = [&]() -> std::pair<size_t, size_t> {
+        for (size_t i = 0; i < n_edges; ++i) {
+            const Point& ai = centers[path[i]];
+            const Point& bi = centers[path[(i + 1) % pn]];
+
+            for (size_t j = i + 2; j < n_edges; ++j) {
+                // Skip the (0, pn-1) pair: edges (0,1) and (pn-1,0) share node 0.
+                if (i == 0 && j == pn - 1) continue;
+
+                const Point& aj = centers[path[j]];
+                const Point& bj = centers[path[(j + 1) % pn]];
+
+                if (!bboxes_overlap(ai, bi, aj, bj)) continue;
+                if (Geometry::segments_intersect(ai, bi, aj, bj))
+                    return {i, j};
+            }
+        }
+        return {std::numeric_limits<size_t>::max(), std::numeric_limits<size_t>::max()};
+    };
+
+    // Process crossings one at a time: find first, reverse it, restart scan.
+    // Cap iterations to prevent infinite loops on collinear/overlapping segments.
+    int max_iters = static_cast<int>(pn * pn);
+    bool improved = false;
+    while (max_iters-- > 0) {
+        auto [ci, cj] = find_crossing();
+        if (ci == std::numeric_limits<size_t>::max()) break;
+        improved = true;
+        std::reverse(path.begin() + ci + 1, path.begin() + cj + 1);
+    }
+    return improved;
+}
+
+void tsp_rotate_minimize_closing(std::vector<size_t>& path, const Points& centers)
+{
+    size_t pn = path.size();
+    size_t best_start = 0;
+    double best_closing2 = std::numeric_limits<double>::max();
+    for (size_t start = 0; start < pn; ++start) {
+        size_t last = (start + pn - 1) % pn;
+        double d2 = (centers[path[start]].cast<double>() - centers[path[last]].cast<double>()).squaredNorm();
+        if (d2 < best_closing2) { best_closing2 = d2; best_start = start; }
+    }
+    std::rotate(path.begin(), path.begin() + best_start, path.end());
+}
+
+/* ====================================================================
+ * Snake ordering
+ * ==================================================================== */
+
+struct SnakeRow { double avg_y; std::vector<size_t> indices; };
+
+// --- Row threshold computation ---
+// Extract unique Y values and use the median gap between them to determine
+// the row threshold.
+static double compute_row_threshold(const std::vector<double>& sorted_ys,
+                                    double y_min, double y_max,
+                                    size_t n,
+                                    double fraction_of_y_range,
+                                    double min_threshold_um)
+{
+    constexpr double MIN_GAP_FILTER = 1.0;  // ignore sub-micron gaps (coord_t = 1/100mm)
+
+    // Extract unique Y values
+    std::vector<double> unique_ys;
+    unique_ys.reserve(sorted_ys.size());
+    unique_ys.push_back(sorted_ys[0]);
+    for (size_t i = 1; i < sorted_ys.size(); ++i) {
+        if (sorted_ys[i] - sorted_ys[i - 1] > MIN_GAP_FILTER)
+            unique_ys.push_back(sorted_ys[i]);
+    }
+
+    double fallback_threshold = (y_max - y_min) * fraction_of_y_range;
+    if (unique_ys.size() <= 1) {
+        return std::max(fallback_threshold, min_threshold_um);
+    }
+
+    // Compute gaps between consecutive unique Y values
+    std::vector<double> gaps;
+    gaps.reserve(unique_ys.size() - 1);
+    for (size_t i = 1; i < unique_ys.size(); ++i)
+        gaps.push_back(unique_ys[i] - unique_ys[i - 1]);
+
+    if (gaps.empty()) {
+        return std::max(fallback_threshold, min_threshold_um);
+    }
+
+    // Sort gaps to find the median
+    std::sort(gaps.begin(), gaps.end());
+    double median_gap = gaps[gaps.size() / 2];
+    double min_gap = gaps.front();
+
+    // Threshold: half the gap between consecutive unique Y values.
+    double threshold = (median_gap < min_gap * 1.5) ? min_gap * 0.5 : median_gap * 0.5;
+
+    bool has_row_structure;
+    if (unique_ys.size() * 2 <= n) {
+        has_row_structure = true;
+    } else {
+        // Single-column or sparse: uniform gaps indicate a deliberate grid
+        double max_gap = *std::max_element(gaps.begin(), gaps.end());
+        has_row_structure = (max_gap < min_gap * 2.0);
+    }
+
+    if (has_row_structure) {
+        // For grid-like data, use the gap-based threshold directly.
+        return threshold;
+    }
+
+    return std::max(fallback_threshold, min_threshold_um);
+}
+
+// --- Row grouping ---
+// Bin points into rows by quantising Y / threshold
+static std::vector<SnakeRow> group_into_rows(const Points& centers, double row_threshold)
+{
+    size_t n = centers.size();
+    std::unordered_map<int64_t, std::vector<size_t>> row_map;
+    for (size_t i = 0; i < n; ++i) {
+        int64_t y_key = static_cast<int64_t>(std::floor(static_cast<double>(centers[i].y()) / row_threshold));
+        row_map[y_key].push_back(i);
+    }
+
+    std::vector<SnakeRow> rows;
+    rows.reserve(row_map.size());
+    for (auto& [key, indices] : row_map) {
+        double avg_y = std::accumulate(indices.begin(), indices.end(), 0.0,
+            [&](double acc, size_t idx) { return acc + static_cast<double>(centers[idx].y()); })
+            / indices.size();
+        rows.push_back({avg_y, std::move(indices)});
+    }
+
+    std::sort(rows.begin(), rows.end(),
+              [](const SnakeRow& a, const SnakeRow& b) { return a.avg_y < b.avg_y; });
+
+    return rows;
+}
+
+// Sort each row by X and greedily pick the direction (left->right or right->left)
+// that minimises the transition distance from the previous row's endpoint.
+static std::vector<size_t> build_serpentine_path(const Points& centers,
+                                                  std::vector<SnakeRow>& rows)
+{
+    std::vector<size_t> path;
+    path.reserve(centers.size());
+
+    for (size_t ri = 0; ri < rows.size(); ++ri) {
+        auto& row = rows[ri].indices;
+        std::sort(row.begin(), row.end(),
+                  [&](size_t a, size_t b) { return centers[a].x() < centers[b].x(); });
+
+        if (ri == 0) {
+            path.insert(path.end(), row.begin(), row.end());
+        } else {
+            const Point& prev_end = centers[path.back()];
+            double dist_to_left  = (prev_end.cast<double>() - centers[row.front()].cast<double>()).squaredNorm();
+            double dist_to_right = (prev_end.cast<double>() - centers[row.back()].cast<double>()).squaredNorm();
+
+            if (dist_to_left <= dist_to_right)
+                path.insert(path.end(), row.begin(), row.end());
+            else
+                path.insert(path.end(), row.rbegin(), row.rend());
+        }
+    }
+
+    return path;
+}
+
+// Row-based serpentine traversal: detect rows, bin points, snake through them.
+static std::vector<size_t> row_serpentine_path(const Points& centers,
+                                                double fraction_of_y_range = 0.02,
+                                                double min_threshold_um = 1e4)
+{
+    if (centers.empty()) return {};
+
+    size_t n = centers.size();
+
+    // Collect and sort Y coordinates.
+    std::vector<double> sorted_ys;
+    sorted_ys.reserve(n);
+    for (const auto& p : centers) sorted_ys.push_back(static_cast<double>(p.y()));
+    std::sort(sorted_ys.begin(), sorted_ys.end());
+
+    auto [ymin, ymax] = std::minmax_element(sorted_ys.begin(), sorted_ys.end());
+    double y_min = *ymin, y_max = *ymax;
+
+    double row_threshold = compute_row_threshold(sorted_ys, y_min, y_max, n,
+                                                  fraction_of_y_range, min_threshold_um);
+
+    auto rows = group_into_rows(centers, row_threshold);
+    return build_serpentine_path(centers, rows);
+}
+
+std::vector<size_t> snake_core(const Points& centers)
+{
+    if (centers.empty()) return {};
+
+    std::vector<size_t> path = row_serpentine_path(centers);
+
+    for (int iter = 0; iter < 3; ++iter) {
+        bool improved = tsp_2opt_improve(path, centers);
+        improved |= tsp_remove_crossings(path, centers);
+        if (!improved) break;
+    }
+
+    return path;
+}
+
+std::vector<const PrintInstance*> chain_print_object_instances_snake(const std::vector<const PrintObject*>& print_objects, const Point* start_near)
+{
+    return chain_instances_with_core(print_objects, start_near, snake_core);
+}
+
+std::vector<const PrintInstance*> chain_print_object_instances_snake(const Print& print)
+{
+    return chain_print_object_instances_snake(print.objects().vector(), nullptr);
+}
+
+/* ====================================================================
+ * Best-of-strategies meta-strategy
+ * ==================================================================== */
+
+std::vector<const PrintInstance*> chain_print_object_instances_best_of(const std::vector<const PrintObject*>& print_objects, const Point* start_near)
+{
+    if (print_objects.empty())
+        return {};
+
+    // Run all strategies.
+    std::vector<std::vector<const PrintInstance*>> candidates;
+    candidates.push_back(chain_print_object_instances(print_objects, start_near));
+    candidates.push_back(chain_print_object_instances_snake(print_objects, start_near));
+
+    // Compute metrics for each candidate.
+    struct Candidate { double total_len; double max_edge; };
+    std::vector<Candidate> metrics;
+    metrics.reserve(candidates.size());
+
+    for (size_t i = 0; i < candidates.size(); ++i) {
+        double total = 0.0;
+        double mx = 0.0;
+        for (size_t j = 0; j < candidates[i].size(); ++j) {
+            size_t k = (j + 1) % candidates[i].size();
+            double d = (candidates[i][j]->shift.cast<double>() - candidates[i][k]->shift.cast<double>()).norm();
+            total += d;
+            if (d > mx) mx = d;
+        }
+        metrics.push_back({total, mx});
+    }
+
+    // Pick shortest total path; tiebreak on smallest max edge.
+    auto best_it = std::min_element(metrics.begin(), metrics.end(),
+        [](const Candidate& a, const Candidate& b) {
+            return a.total_len < b.total_len ||
+                   (a.total_len == b.total_len && a.max_edge < b.max_edge);
+        });
+    size_t best = static_cast<size_t>(std::distance(metrics.begin(), best_it));
+
+    return candidates[best];
+}
+
+std::vector<const PrintInstance*> chain_print_object_instances_best_of(const Print& print)
+{
+    return chain_print_object_instances_best_of(print.objects().vector(), nullptr);
+}
+
+/* ====================================================================
+ * Island-level ordering entry point
+ * ==================================================================== */
+
+std::vector<size_t> order_points_with_strategy(const Points& points, PrintOrder print_order, const Point* start_near)
+{
+    if (points.empty())
+        return {};
+
+    if (print_order != PrintOrder::Snake && print_order != PrintOrder::BestOfStrategies)
+        // Nearest neighbor + post-processing; honours start_near natively.
+        return chain_points_with_postprocessing(points, start_near);
+
+    auto run_snake = [&points, start_near]() {
+        std::vector<size_t> path = snake_core(points);
+        if (start_near != nullptr && !path.empty()) {
+            // Start the cycle at the point closest to start_near.
+            size_t best_start = 0;
+            double best_d2 = std::numeric_limits<double>::max();
+            for (size_t k = 0; k < points.size(); ++k) {
+                double d2 = (points[k].cast<double>() - start_near->cast<double>()).squaredNorm();
+                if (d2 < best_d2) { best_d2 = d2; best_start = k; }
+            }
+            auto it = std::find(path.begin(), path.end(), best_start);
+            if (it != path.begin() && it != path.end())
+                std::rotate(path.begin(), it, path.end());
+        } else {
+            tsp_rotate_minimize_closing(path, points);
+        }
+        return path;
+    };
+
+    if (print_order == PrintOrder::Snake)
+        return run_snake();
+
+    // Best-of: pick the shortest total cycle; tiebreak on smallest max edge.
+    std::vector<std::vector<size_t>> candidates;
+    candidates.emplace_back(chain_points_with_postprocessing(points, start_near));
+    candidates.emplace_back(run_snake());
+
+    size_t best      = 0;
+    double best_len  = std::numeric_limits<double>::max();
+    double best_edge = std::numeric_limits<double>::max();
+    for (size_t i = 0; i < candidates.size(); ++i) {
+        double len  = tsp_cycle_path_length(candidates[i], points);
+        double edge = tsp_max_edge_length(candidates[i], points);
+        if (len < best_len || (len == best_len && edge < best_edge)) {
+            best_len = len; best_edge = edge; best = i;
+        }
+    }
+    return candidates[best];
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/OrderingStrategies.hpp

@@ -0,0 +1,148 @@
+// Print-object ordering strategies and shared TSP post-processing utilities.
+
+#ifndef slic3r_OrderingStrategies_hpp_
+#define slic3r_OrderingStrategies_hpp_
+
+#include "../libslic3r.h"
+#include "../Point.hpp"
+
+#ifndef SLIC3R_TEST_HARNESS
+#include "../Print.hpp"
+#endif
+
+#include <algorithm>
+#include <limits>
+#include <utility>
+#include <vector>
+
+namespace Slic3r {
+
+// --- Path improvement (operate on index vectors into `centers`) ---
+
+// 2-opt improvement: reverses segments that reduce total cycle path length.
+// Returns true if any improvement was made.
+bool tsp_2opt_improve(std::vector<size_t>& path, const Points& centers, int max_passes = 10);
+
+// Crossing removal: reverse any segment pair whose edges geometrically cross.
+// Returns true if any crossing was removed.
+bool tsp_remove_crossings(std::vector<size_t>& path, const Points& centers);
+
+// Rotate the cycle so the closing edge (last -> first) is minimized.
+void tsp_rotate_minimize_closing(std::vector<size_t>& path, const Points& centers);
+
+// Total Euclidean path length of a cycle (including closing edge).
+inline double tsp_cycle_path_length(const std::vector<size_t>& path, const Points& centers)
+{
+    if (path.size() < 2) return 0.0;
+    double total = 0.0;
+    for (size_t i = 0; i < path.size(); ++i) {
+        size_t next = (i + 1) % path.size();
+        total += (centers[path[i]].cast<double>() - centers[path[next]].cast<double>()).norm();
+    }
+    return total;
+}
+
+// Maximum edge length of a cycle (including closing edge).
+inline double tsp_max_edge_length(const std::vector<size_t>& path, const Points& centers)
+{
+    if (path.size() < 2) return 0.0;
+    double mx = 0.0;
+    for (size_t i = 0; i < path.size(); ++i) {
+        size_t next = (i + 1) % path.size();
+        double d = (centers[path[i]].cast<double>() - centers[path[next]].cast<double>()).norm();
+        if (d > mx) mx = d;
+    }
+    return mx;
+}
+
+
+
+#ifndef SLIC3R_TEST_HARNESS
+
+// --- Wrapper boilerplate ---
+
+// Collect instance centers from PrintObjects, optionally pre-rotate to honour
+// start_near, call a core algorithm, and map the result back to PrintInstance*.
+template<typename CoreFn>
+std::vector<const PrintInstance*> chain_instances_with_core(
+    const std::vector<const PrintObject*>& print_objects,
+    const Point* start_near,
+    CoreFn&& core_fn)
+{
+    Points instance_centers;
+    std::vector<std::pair<size_t, size_t>> instances;
+    for (size_t i = 0; i < print_objects.size(); ++i) {
+        const PrintObject& object = *print_objects[i];
+        for (size_t j = 0; j < object.instances().size(); ++j) {
+            instance_centers.emplace_back(object.instances()[j].shift);
+            instances.emplace_back(i, j);
+        }
+    }
+
+    if (instance_centers.empty()) return {};
+
+    // If start_near is provided, pre-rotate so closest point is first.
+    if (start_near != nullptr) {
+        size_t best_start = 0;
+        double best_d2 = std::numeric_limits<double>::max();
+        for (size_t k = 0; k < instance_centers.size(); ++k) {
+            double d2 = (instance_centers[k].cast<double>() - start_near->cast<double>()).squaredNorm();
+            if (d2 < best_d2) { best_d2 = d2; best_start = k; }
+        }
+        std::rotate(instance_centers.begin(), instance_centers.begin() + best_start, instance_centers.end());
+        std::rotate(instances.begin(), instances.begin() + best_start, instances.end());
+    }
+
+    auto path = core_fn(instance_centers);
+
+    // Rotate the cycle so the first element is the best starting point.
+    // When start_near is provided, pick the point closest to it (preserving
+    // the pre-rotation). Otherwise minimise the closing edge.
+    if (start_near != nullptr && !path.empty()) {
+        // Pre-rotation already put the closest point at index 0.
+        // Find where index 0 appears in the path and rotate it to the front.
+        auto it = std::find(path.begin(), path.end(), size_t(0));
+        if (it != path.begin())
+            std::rotate(path.begin(), it, path.end());
+    } else {
+        tsp_rotate_minimize_closing(path, instance_centers);
+    }
+
+    std::vector<const PrintInstance*> out;
+    out.reserve(path.size());
+    for (size_t step : path) {
+        out.emplace_back(&print_objects[instances[step].first]->instances()[instances[step].second]);
+    }
+    return out;
+}
+
+#endif // SLIC3R_TEST_HARNESS
+
+// --- Core algorithms (operate on raw Points, return index permutations) ---
+
+// Snake ordering: row grouping + serpentine traversal + post-processing.
+std::vector<size_t> snake_core(const Points& centers);
+
+#ifndef SLIC3R_TEST_HARNESS
+
+// --- Production wrappers ---
+
+// Snake ordering.
+std::vector<const PrintInstance*> chain_print_object_instances_snake(const std::vector<const PrintObject*>& print_objects, const Point* start_near);
+std::vector<const PrintInstance*> chain_print_object_instances_snake(const Print& print);
+
+// Best-of-strategies: run all strategies and return the shortest result.
+// Primary: shortest total path; secondary tiebreaker: smallest max edge.
+std::vector<const PrintInstance*> chain_print_object_instances_best_of(const std::vector<const PrintObject*>& print_objects, const Point* start_near);
+std::vector<const PrintInstance*> chain_print_object_instances_best_of(const Print& print);
+
+// Order raw points with the selected strategy, returning an index permutation. Island-level
+// counterpart of the chain_print_object_instances_* helpers. The returned cycle starts at the
+// point closest to start_near; orders without a dedicated strategy use nearest-neighbor chaining.
+std::vector<size_t> order_points_with_strategy(const Points& points, PrintOrder print_order, const Point* start_near);
+
+#endif // SLIC3R_TEST_HARNESS
+
+} // namespace Slic3r
+
+#endif /* slic3r_OrderingStrategies_hpp_ */

src/libslic3r/Preset.cpp

@@ -147,6 +147,17 @@ Semver get_version_from_json(std::string file_path)
         return Semver();
         //throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file_path, err.what()));
     }
+    catch(...) {
+        return Semver();
+    }
+}
+
+std::string get_vendor_cache_version(const std::string& json_path)
+{
+    // The version a vendor's cache is stamped with. A profile without a parsable
+    // version cannot be judged for staleness, so it is simply never cached.
+    const Semver ver = get_version_from_json(json_path);
+    return ver.valid() ? ver.to_string() : std::string();
 }
 
 //BBS: add a function to load the key-values from xxx.json

src/libslic3r/Preset.hpp

@@ -16,6 +16,8 @@
 #include "Semver.hpp"
 #include "ProjectTask.hpp"
 
+#include <cereal/access.hpp>
+
 //BBS: change system directories
 #define PRESET_SYSTEM_DIR      "system"
 #define PRESET_USER_DIR        "user"
@@ -114,6 +116,10 @@ extern Semver get_version_from_json(std::string file_path);
 //BBS: add a function to load the key-values from xxx.json
 extern int get_values_from_json(std::string file_path, std::vector<std::string>& keys, std::map<std::string, std::string>& key_values);
 
+// Returns the version a vendor JSON's preset cache is stamped with: its Semver
+// string, or an empty string when the profile carries no usable version.
+extern std::string get_vendor_cache_version(const std::string& json_path);
+
 extern ConfigFileType guess_config_file_type(const boost::property_tree::ptree &tree);
 
 extern void extend_default_config_length(DynamicPrintConfig& config, const bool set_nil_to_default, const DynamicPrintConfig& defaults);
@@ -131,6 +137,10 @@ public:
         PrinterVariant() {}
         PrinterVariant(const std::string &name) : name(name) {}
         std::string                 name;
+
+        // All fields, declaration order — keep in sync; bump CACHE_VERSION on change.
+        template<class Archive>
+        void serialize(Archive& ar) { ar(name); }                       // PrinterVariant
     };
 
     struct PrinterModel {
@@ -139,7 +149,7 @@ public:
         std::string                 name;
         //BBS: this is internal id for the printer. Currently only used for searching in database
         std::string                 model_id;
-        PrinterTechnology           technology;
+        PrinterTechnology           technology = ptFFF;
         std::string                 family;
         std::vector<PrinterVariant> variants;
         std::vector<std::string>	default_materials;
@@ -162,6 +172,17 @@ public:
         }
 
         const PrinterVariant* variant(const std::string &name) const { return const_cast<PrinterModel*>(this)->variant(name); }
+
+        // All fields, declaration order — keep in sync; bump CACHE_VERSION on change.
+        template<class Archive>
+        void serialize(Archive& ar)                                     // PrinterModel
+        {
+            ar(id, name, model_id, technology, family, variants, default_materials,
+               not_support_bed_types, bed_model, bed_texture, image_bed_type,
+               bottom_texture_end_name, use_double_extruder_default_texture,
+               bottom_texture_rect, bottom_texture_rect_longer, middle_texture_rect,
+               hotend_model);
+        }
     };
     std::vector<PrinterModel>          models;
 
@@ -173,6 +194,14 @@ public:
 
     bool 		valid() const { return ! name.empty() && ! id.empty() && config_version.valid(); }
 
+    // All fields, declaration order — keep in sync; bump CACHE_VERSION on change.
+    template<class Archive>
+    void serialize(Archive& ar)                                         // VendorProfile
+    {
+        ar(name, id, config_version, config_update_url, changelog_url,
+           models, default_filaments, default_sla_materials);
+    }
+
     // Load VendorProfile from an ini file.
     // If `load_all` is false, only the header with basic info (name, version, URLs) is loaded.
     static VendorProfile from_ini(const boost::filesystem::path &path, bool load_all=true);
@@ -425,12 +454,30 @@ public:
 
     // BBS: move constructor to public
     Preset(Type type, const std::string &name, bool is_default = false) : type(type), is_default(is_default), name(name) {}
-
+    // Default constructor is public so cereal can default-construct elements when
-protected:
+    // deserializing std::vector<Preset> (std::allocator is not a cereal::access friend).
     Preset() = default;
 
+protected:
     friend class        PresetCollection;
     friend class        PresetBundle;
+    friend class        cereal::access;
+
+    // Hand-written cereal serialization for the per-vendor binary cache.
+    // Lists every data member except the two raw pointers:
+    //   - loading_substitutions: transient parse state, never cached
+    //   - vendor: re-pointed on load from the vendor id stored alongside each preset
+    // Keep this list in sync with the member declarations, in declaration order;
+    // bump CACHE_VERSION in PresetBundle.cpp when it changes.
+    template<class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(type, is_default, is_external, is_system, is_visible, is_dirty,
+           is_compatible, is_project_embedded, name, file, loaded, config,
+           alias, renamed_from, m_excluded_from, m_from_orca_filament_lib,
+           bundle_id, version, ini_str, setting_id, filament_id, user_id,
+           base_id, sync_info, description, updated_time, key_values);
+    }
 };
 
 bool is_compatible_with_print  (const PresetWithVendorProfile &preset, const PresetWithVendorProfile &active_print, const PresetWithVendorProfile &active_printer);

src/libslic3r/PresetBundle.cpp

@@ -1,7 +1,18 @@
 #include <cassert>
+#include <chrono>
 #include <ctime>
+#include <sstream>
 
 #include "PresetBundle.hpp"
+
+#include <boost/crc.hpp>
+#include <boost/iostreams/device/array.hpp>
+#include <boost/iostreams/stream.hpp>
+#include <cereal/archives/binary.hpp>
+#include <cereal/types/map.hpp>
+#include <cereal/types/set.hpp>
+#include <cereal/types/string.hpp>
+#include <cereal/types/vector.hpp>
 #include "PrintConfig.hpp"
 #include "libslic3r.h"
 #include "I18N.hpp"
@@ -564,6 +575,8 @@ PresetsConfigSubstitutions PresetBundle::load_presets(AppConfig &config, Forward
 
     //BBS: add config related logs
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" enter, substitution_rule %1%, preferred printer_model_id %2%")%substitution_rule%preferred_selection.printer_model_id;
+    const auto startup_t0 = std::chrono::steady_clock::now();
+
     //BBS: change system config to json
     std::tie(substitutions, errors_cummulative) = this->load_system_presets_from_json(substitution_rule);
 
@@ -589,6 +602,12 @@ PresetsConfigSubstitutions PresetBundle::load_presets(AppConfig &config, Forward
 
     set_calibrate_printer("");
 
+    {
+        const auto total_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - startup_t0).count();
+        BOOST_LOG_TRIVIAL(info) << "PresetBundle: all presets loaded in " << total_ms << " ms";
+    }
+
     //BBS: add config related logs
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" finished, returned substitutions %1%")%substitutions.size();
     return substitutions;
@@ -1001,6 +1020,8 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
     bundles.m_bundles.clear();
     bundles.WriteUnlock();
 
+    const auto user_load_t0 = std::chrono::steady_clock::now();
+
     // Load bundle metadata from _local directory first
     fs::path local_dir(folder / PRESET_LOCAL_DIR);
     if (fs::exists(local_dir)) {
@@ -1019,7 +1040,6 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
             metadata.filament_presets.clear();
             metadata.printer_presets.clear();
 
-            // Add the profiles
             this->prints.load_presets(bundle_dir, PRESET_PRINT_NAME, substitutions, substitution_rule, [&](Preset& preset) {
                 metadata.print_presets.push_back(preset.name);
             }, PresetOrigin(PresetOrigin::Kind::LocalBundle, metadata.id));
@@ -1056,7 +1076,6 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
             metadata.printer_presets.clear();
             metadata.is_subscribed = true;
 
-            // Load presets from bundle (same logic as __local__)
             this->prints.load_presets(bundle_dir, PRESET_PRINT_NAME, substitutions, substitution_rule, [&](Preset& preset) {
                 metadata.print_presets.push_back(preset.name);
             }, PresetOrigin(PresetOrigin::Kind::SubscribedBundle, metadata.id));
@@ -1077,34 +1096,41 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
         }
     }
 
-
     // BBS do not load sla_print
-    // BBS: change directoties by design
+    // BBS: change directories by design
-    try {
+
-        std::string print_selected_preset_name = prints.get_selected_preset().name;
+    {
-        this->prints.load_presets(dir_user_presets, PRESET_PRINT_NAME, substitutions, substitution_rule);
+        const auto json_t0 = std::chrono::steady_clock::now();
-        prints.select_preset_by_name(print_selected_preset_name, false);
+        try {
-    } catch (const std::runtime_error &err) {
+            std::string sel = prints.get_selected_preset().name;
-        errors_cummulative += err.what();
+            this->prints.load_presets(dir_user_presets, PRESET_PRINT_NAME, substitutions, substitution_rule);
+            prints.select_preset_by_name(sel, false);
+        } catch (const std::runtime_error& err) { errors_cummulative += err.what(); }
+        try {
+            std::string sel = filaments.get_selected_preset().name;
+            this->filaments.load_presets(dir_user_presets, PRESET_FILAMENT_NAME, substitutions, substitution_rule);
+            filaments.select_preset_by_name(sel, false);
+        } catch (const std::runtime_error& err) { errors_cummulative += err.what(); }
+        try {
+            std::string sel = printers.get_selected_preset().name;
+            this->printers.load_presets(dir_user_presets, PRESET_PRINTER_NAME, substitutions, substitution_rule);
+            printers.select_preset_by_name(sel, false);
+        } catch (const std::runtime_error& err) { errors_cummulative += err.what(); }
+        if (!errors_cummulative.empty()) throw Slic3r::RuntimeError(errors_cummulative);
+
+        const auto json_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - json_t0).count();
+        BOOST_LOG_TRIVIAL(info) << "PresetBundle: user presets loaded from JSON in " << json_ms << " ms";
     }
-    try {
+
-        std::string filament_selected_preset_name = filaments.get_selected_preset().name;
+    {
-        this->filaments.load_presets(dir_user_presets, PRESET_FILAMENT_NAME, substitutions, substitution_rule);
+        const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-        filaments.select_preset_by_name(filament_selected_preset_name, false);
+            std::chrono::steady_clock::now() - user_load_t0).count();
-    } catch (const std::runtime_error &err) {
+        BOOST_LOG_TRIVIAL(info) << "PresetBundle: user + bundle presets loaded in " << ms << " ms";
-        errors_cummulative += err.what();
     }
-    try {
+
-        std::string printer_selected_preset_name = printers.get_selected_preset().name;
-        this->printers.load_presets(dir_user_presets, PRESET_PRINTER_NAME, substitutions, substitution_rule);
-        printers.select_preset_by_name(printer_selected_preset_name, false);
-    } catch (const std::runtime_error &err) {
-        errors_cummulative += err.what();
-    }
-    if (!errors_cummulative.empty()) throw Slic3r::RuntimeError(errors_cummulative);
     this->update_multi_material_filament_presets();
     this->update_compatible(PresetSelectCompatibleType::Never);
-
     set_calibrate_printer("");
 
     return PresetsConfigSubstitutions();
@@ -1210,13 +1236,10 @@ bool PresetBundle::apply_vendor_config(
         : std::map<std::string, std::string>();
 
     // Find vendors that need installation
-    const auto vendor_dir = (fs::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
-
     std::vector<std::string> install_bundles;
     for (const auto &it : new_vendors) {
         if (it.second.size() > 0) {
-            auto vendor_file = vendor_dir / (it.first + ".json");
+            if (!is_vendor_installed(it.first)) {
-            if (!fs::exists(vendor_file)) {
                 install_bundles.emplace_back(it.first);
             }
         }
@@ -2225,6 +2248,186 @@ void PresetBundle::remove_users_preset(AppConfig &config, std::map<std::string,
 }
 
 
+// The version of the filament library in effect: the installed profile, the
+// installed cache that stands in for one, or — with nothing installed yet — the
+// profile that ships. A vendor cache embeds filaments resolved against the
+// library, so it is judged against this and never left unconstrained; a cache
+// built against an older library would otherwise slip through unnoticed.
+static std::string effective_lib_version(const boost::filesystem::path& installed_dir)
+{
+    const std::string lib(PresetBundle::ORCA_FILAMENT_LIBRARY);
+    // The library ships as a cache like every other vendor, so neither directory
+    // is guaranteed to hold its profile; ask each for whichever form it has.
+    for (const boost::filesystem::path& dir : {installed_dir, boost::filesystem::path(resources_dir()) / "profiles"}) {
+        if (boost::filesystem::exists(dir / (lib + ".json")))
+            return get_vendor_cache_version((dir / (lib + ".json")).string());
+        const std::string stamped = PresetBundle::peek_vendor_cache_version((dir / (lib + ".opc")).string(), lib);
+        if (! stamped.empty())
+            return stamped;
+    }
+    return {};
+}
+
+bool is_vendor_installed(const std::string& vendor)
+{
+    const boost::filesystem::path dir = boost::filesystem::path(data_dir()) / PRESET_SYSTEM_DIR;
+    return boost::filesystem::exists(dir / (vendor + ".json")) || boost::filesystem::exists(dir / (vendor + ".opc"));
+}
+
+Semver installed_vendor_version(const std::string& vendor)
+{
+    const boost::filesystem::path dir  = boost::filesystem::path(data_dir()) / PRESET_SYSTEM_DIR;
+    const boost::filesystem::path json = dir / (vendor + ".json");
+    if (boost::filesystem::exists(json))
+        return get_version_from_json(json.string());
+    const auto ver = Semver::parse(PresetBundle::peek_vendor_cache_version((dir / (vendor + ".opc")).string(), vendor));
+    return ver ? *ver : Semver();
+}
+
+void remove_installed_vendor(const std::string& vendor)
+{
+    const boost::filesystem::path dir = boost::filesystem::path(data_dir()) / PRESET_SYSTEM_DIR;
+    boost::filesystem::remove(dir / (vendor + ".json"));
+    boost::filesystem::remove(dir / (vendor + ".opc"));
+    if (boost::filesystem::exists(dir / vendor))
+        boost::filesystem::remove_all(dir / vendor);
+}
+
+std::set<std::string> vendor_names_in(const boost::filesystem::path& dir)
+{
+    std::set<std::string> names;
+    for (auto& dir_entry : boost::filesystem::directory_iterator(dir)) {
+        const auto& path = dir_entry.path();
+        if (Slic3r::is_json_file(path.string()) || path.extension() == ".opc")
+            names.insert(path.stem().string());
+    }
+    return names;
+}
+
+// A vendor's preset cache is the whole of its installation: it carries the presets,
+// the vendor profile and the version they were built at, so where one ships nothing
+// else needs copying. Unless the profile beside it claims a newer version — a cache
+// generated before that profile was bumped is out of date, and a cache that cannot
+// be read is no installation at all — and the vendor is installed the way it was
+// before caches existed, as its profile and the preset JSONs it points at. Returns
+// the version the cache is stamped with, invalid when it is not the form to install.
+static Semver installable_cache_version(const boost::filesystem::path& dir, const std::string& vendor)
+{
+    const auto cache_ver = Semver::parse(PresetBundle::peek_vendor_cache_version((dir / (vendor + ".opc")).string(), vendor));
+    if (! cache_ver)
+        return Semver::invalid();
+    const Semver profile_ver = get_version_from_json((dir / (vendor + ".json")).string());
+    return profile_ver.valid() && *cache_ver < profile_ver ? Semver::invalid() : *cache_ver;
+}
+
+Semver resource_vendor_version(const std::string& vendor)
+{
+    const boost::filesystem::path dir = boost::filesystem::path(resources_dir()) / "profiles";
+    const Semver ver = installable_cache_version(dir, vendor);
+    return ver.valid() ? ver : get_version_from_json((dir / (vendor + ".json")).string());
+}
+
+bool install_vendor_bundles_from_resources(
+    const std::vector<std::string>& bundle_names,
+    const std::string& resource_subdir,
+    const std::string& data_subdir)
+{
+    namespace fs = boost::filesystem;
+
+    fs::path rsrc_path = fs::path(Slic3r::resources_dir()) / resource_subdir;
+    fs::path vendor_path = fs::path(Slic3r::data_dir()) / data_subdir;
+
+    BOOST_LOG_TRIVIAL(info) << "Installing " << bundle_names.size() << " bundles from resources...";
+
+    for (const auto &bundle : bundle_names) {
+        try {
+            // Install the JSON file
+            auto path_in_rsrc = (rsrc_path / bundle).replace_extension(".json");
+            auto path_in_vendors = (vendor_path / bundle).replace_extension(".json");
+            auto cache_in_rsrc = (rsrc_path / bundle).replace_extension(".opc");
+            auto cache_in_vendors = (vendor_path / bundle).replace_extension(".opc");
+
+            // Either form of the vendor will do: a build may ship it as a cache alone.
+            if (!fs::exists(path_in_rsrc) && !fs::exists(cache_in_rsrc)) {
+                BOOST_LOG_TRIVIAL(warning) << "Bundle not found in resources: " << bundle;
+                return false;
+            }
+
+            // Create target directory if needed
+            if (!fs::exists(vendor_path))
+                fs::create_directories(vendor_path);
+
+            std::string error_message;
+            bool installed_cache = false;
+            if (installable_cache_version(rsrc_path, bundle).valid()) {
+                installed_cache = copy_file(cache_in_rsrc.string(), cache_in_vendors.string(), error_message, false) == CopyFileResult::SUCCESS;
+                if (! installed_cache)
+                    BOOST_LOG_TRIVIAL(warning) << "Failed to copy " << bundle << ".opc: " << error_message;
+            } else {
+                boost::system::error_code ec;
+                fs::remove(cache_in_vendors, ec);
+            }
+
+            if (! installed_cache) {
+                CopyFileResult cfr = copy_file(path_in_rsrc.string(), path_in_vendors.string(), error_message, false);
+                if (cfr != CopyFileResult::SUCCESS) {
+                    BOOST_LOG_TRIVIAL(error) << "Failed to copy " << bundle << ".json: " << error_message;
+                    return false;
+                }
+            } else {
+                // Left in place, an earlier install's profile would shadow the cache.
+                boost::system::error_code ec;
+                fs::remove(path_in_vendors, ec);
+            }
+
+            // Copy the vendor directory (if it exists)
+            auto dir_in_rsrc = rsrc_path / bundle;
+            auto dir_in_vendors = vendor_path / bundle;
+
+            // Whatever is installed came from an earlier version of this vendor and
+            // would be parsed in place of the one being installed now.
+            if (fs::exists(dir_in_vendors))
+                fs::remove_all(dir_in_vendors);
+
+            if (! installed_cache && fs::exists(dir_in_rsrc) && fs::is_directory(dir_in_rsrc)) {
+                fs::create_directories(dir_in_vendors);
+
+                // Copy with file filter (same as PresetUpdater::install_bundles_rsrc)
+                // Filter out certain file types: .stl, .png, .svg, .jpeg, .jpg, .3mf
+                auto file_filter = [](const std::string name) -> bool {
+                    return boost::iends_with(name, ".stl") ||
+                           boost::iends_with(name, ".png") ||
+                           boost::iends_with(name, ".svg") ||
+                           boost::iends_with(name, ".jpeg") ||
+                           boost::iends_with(name, ".jpg") ||
+                           boost::iends_with(name, ".3mf");
+                };
+
+                copy_directory_recursively(dir_in_rsrc, dir_in_vendors, file_filter);
+            }
+
+            BOOST_LOG_TRIVIAL(info) << "Successfully installed bundle: " << bundle;
+
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(error) << "Exception installing bundle " << bundle << ": " << e.what();
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// m_printer_hold_alias survives reset() (and a cache body that failed partway
+// in), so every full-bundle rebuild clears all five collections' maps by hand.
+void PresetBundle::clear_printer_hold_aliases()
+{
+    this->prints.m_printer_hold_alias.clear();
+    this->sla_prints.m_printer_hold_alias.clear();
+    this->filaments.m_printer_hold_alias.clear();
+    this->sla_materials.m_printer_hold_alias.clear();
+    this->printers.m_printer_hold_alias.clear();
+}
+
 //BBS: add json related logic, load system presets from json
 std::pair<PresetsConfigSubstitutions, std::string> PresetBundle::load_system_presets_from_json(ForwardCompatibilitySubstitutionRule compatibility_rule)
 {
@@ -2243,22 +2446,19 @@ std::pair<PresetsConfigSubstitutions, std::string> PresetBundle::load_system_pre
     if (validation_mode)
         dir = (boost::filesystem::path(data_dir())).make_preferred();
 
+    const auto load_t0 = std::chrono::steady_clock::now();
+
+    // The vendors below are loaded whole and against each other — the filament
+    // library first, then every other vendor with it as the base — so each parse
+    // is complete enough to be worth caching.
+    m_generate_vendor_caches = m_generate_vendor_caches || ! validation_mode;
+
     PresetsConfigSubstitutions  substitutions;
     std::string                 errors_cummulative;
-    bool                        first = true;
+    bool first = true;
-    std::vector<std::string> vendor_names;
+    // Sorted, so any duplicate-preset warning below comes out in the same order on
-    // store all vendor names in vendor_names
+    // every run.
-    for (auto& dir_entry : boost::filesystem::directory_iterator(dir)) {
+    const std::set<std::string> vendor_names = vendor_names_in(dir);
-        std::string vendor_file = dir_entry.path().string();
-        if (!Slic3r::is_json_file(vendor_file))
-            continue;
-
-        std::string vendor_name = dir_entry.path().filename().string();
-
-        // Remove the .json suffix.
-        vendor_name.erase(vendor_name.size() - 5);
-        vendor_names.push_back(vendor_name);
-    }
     // Separate ORCA_FILAMENT_LIBRARY from other vendors. It must be loaded
     // first because other vendors' filaments may inherit from it via the
     // `base_bundle` lookup in parse_subfile. The remaining vendors are
@@ -2274,8 +2474,13 @@ std::pair<PresetsConfigSubstitutions, std::string> PresetBundle::load_system_pre
     }
 
     // Step 1: Load ORCA_FILAMENT_LIBRARY into `this` synchronously.
-    if (!orca_lib_vendor.empty()) {
+    if (! orca_lib_vendor.empty()) {
         try {
+            // Match a fresh launch before parsing: hold aliases and the error
+            // counter survive reset(), and would otherwise leak prior-cycle
+            // state into the library cache the load below writes.
+            this->clear_printer_hold_aliases();
+            this->m_errors = 0;
             append(substitutions, this->load_vendor_configs_from_json(dir.string(), orca_lib_vendor, PresetBundle::LoadSystem, compatibility_rule).first);
             first = false;
         } catch (const std::runtime_error &err) {
@@ -2293,15 +2498,20 @@ std::pair<PresetsConfigSubstitutions, std::string> PresetBundle::load_system_pre
     std::vector<PresetsConfigSubstitutions>         parallel_substitutions(other_vendors.size());
     std::vector<std::string>                        parallel_errors(other_vendors.size());
 
+    // The filament library version every vendor below is judged against. Fixed
+    // from here on — step 1 was the last thing that could touch the library on
+    // disk — so resolve it once instead of once per vendor.
+    const std::string lib_version = effective_lib_version(dir);
+
     tbb::parallel_for(tbb::blocked_range<size_t>(0, other_vendors.size()),
         [&](const tbb::blocked_range<size_t>& range) {
             for (size_t i = range.begin(); i < range.end(); ++i) {
                 auto bundle = std::make_unique<PresetBundle>();
                 bundle->set_is_validation_mode(validation_mode);
+                bundle->set_generate_vendor_caches(m_generate_vendor_caches);
                 try {
                     auto result = bundle->load_vendor_configs_from_json(
-                        dir.string(), other_vendors[i], PresetBundle::LoadSystem,
+                        dir.string(), other_vendors[i], PresetBundle::LoadSystem, compatibility_rule, this, lib_version);
-                        compatibility_rule, this);
                     parallel_substitutions[i] = std::move(result.first);
                     parallel_bundles[i] = std::move(bundle);
                 } catch (const std::runtime_error &err) {
@@ -2346,6 +2556,11 @@ std::pair<PresetsConfigSubstitutions, std::string> PresetBundle::load_system_pre
 	}
 
 	this->update_system_maps();
+
+    const auto load_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::steady_clock::now() - load_t0).count();
+    BOOST_LOG_TRIVIAL(info) << "PresetBundle: " << vendor_names.size() << " vendor(s) loaded in " << load_ms << " ms";
+
     //BBS: add config related logs
     BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" finished, errors_cummulative %1%")%errors_cummulative;
     return std::make_pair(std::move(substitutions), errors_cummulative);
@@ -4762,18 +4977,38 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool
 
 //BBS: Load a config bundle file from json
 std::pair<PresetsConfigSubstitutions, size_t> PresetBundle::load_vendor_configs_from_json(
-    const std::string &path, const std::string &vendor_name, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle)
+    const std::string &dir, const std::string &vendor_name, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle,
+    const std::string &lib_version_hint)
 {
     // Enable substitutions for user config bundle, throw an exception when loading a system profile.
     ConfigSubstitutionContext  substitution_context { compatibility_rule };
     PresetsConfigSubstitutions substitutions;
 
     //BBS: add config related logs
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" enter, path %1%, compatibility_rule %2%")%path.c_str()%compatibility_rule;
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" enter, path %1%, compatibility_rule %2%")%dir.c_str()%compatibility_rule;
     if (flags.has(LoadConfigBundleAttribute::ResetUserProfile) || flags.has(LoadConfigBundleAttribute::LoadSystem))
         // Reset this bundle, delete user profile files if SaveImported.
         this->reset(flags.has(LoadConfigBundleAttribute::SaveImported));
 
+    // Orca: only a whole-vendor load has a cache — the vendor-only and filament-only
+    // scans want a slice of one. Validation reads the JSONs whatever is cached.
+    const boost::filesystem::path dir_path(dir);
+    const bool cacheable = flags.has(LoadConfigBundleAttribute::LoadSystem) && ! flags.has(LoadConfigBundleAttribute::LoadFilamentOnly);
+    if (cacheable && ! validation_mode && this->load_vendor_cache(dir_path, vendor_name, lib_version_hint)) {
+        size_t presets_loaded = 0;
+        for (const PresetCollection* coll : std::initializer_list<const PresetCollection*>{
+                 &this->prints, &this->sla_prints, &this->filaments, &this->sla_materials, &this->printers })
+            presets_loaded += coll->m_presets.size() - coll->m_num_default_presets;
+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", %1% served from its preset cache, %2% presets")%vendor_name%presets_loaded;
+        return std::make_pair(std::move(substitutions), presets_loaded);
+    }
+
+    // Orca: a build that ships preset caches installs them without the preset
+    // JSONs, so a vendor left to be parsed is parsed from the profiles in
+    // resources. An update does deliver JSONs into `dir`, and those win.
+    const std::string path = (validation_mode || boost::filesystem::exists(dir_path / (vendor_name + ".json")))
+        ? dir : (boost::filesystem::path(resources_dir()) / "profiles").string();
+
     // 1) load the vroot json and construct the vendor profile
     VendorProfile vendor_profile(vendor_name);
     std::string root_file = path + "/" + vendor_name + ".json";
@@ -5331,6 +5566,22 @@ std::pair<PresetsConfigSubstitutions, size_t> PresetBundle::load_vendor_configs_
         }
     }
 
+    // Orca: leave the vendor's cache in step with the profile just parsed, so the
+    // next run reads it instead. It is written where the vendor was looked for,
+    // even when the profile came from resources, and stamped with the version that
+    // profile claims — a profile without one cannot be judged for staleness later,
+    // and a cache nothing can invalidate is worse than none.
+    if (cacheable && m_generate_vendor_caches && vendor_profile.config_version.valid()) {
+        const std::string version = vendor_profile.config_version.to_string();
+        // The library is its own reference point; every other vendor's cache holds
+        // filaments resolved against it, and is stamped with the version in effect.
+        const std::string lib_version = vendor_name == ORCA_FILAMENT_LIBRARY ? version
+            : ! lib_version_hint.empty() ? lib_version_hint : effective_lib_version(dir_path);
+        if (! lib_version.empty() &&
+            ! this->save_vendor_cache((dir_path / (vendor_name + ".opc")).string(), vendor_name, version, lib_version))
+            BOOST_LOG_TRIVIAL(warning) << "PresetBundle: failed to save vendor cache for " << vendor_name;
+    }
+
     //BBS: add config related logs
     BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", finished, presets_loaded %1%")%presets_loaded;
     return std::make_pair(std::move(substitutions), presets_loaded);
@@ -5953,4 +6204,318 @@ bool BundleMetadata::save_to_json(const std::string& path) const
         return false;
     }
 }
+// ---- Preset cache file format (shared by the per-vendor cache) ----------
+
+namespace {
+
+#pragma pack(push, 1)
+struct CacheFileHeader {
+    uint32_t magic;
+    uint32_t version;
+    uint64_t data_size;
+    uint32_t crc32;
+};
+#pragma pack(pop)
+static_assert(sizeof(CacheFileHeader) == 20, "CacheFileHeader must be 20 bytes");
+
+constexpr uint32_t CACHE_MAGIC   = 0x4F52435A; // "ORCZ"
+// Bump when the wire format changes in a way the schema fingerprint cannot
+// detect: reordering, removing, or retyping a field of a hand-written
+// serialize() (Preset, VendorProfile and its nested types), or when the
+// cache's own layout or the meaning of its stamps changes (e.g. the move from
+// one whole-bundle cache to one cache per vendor).
+constexpr uint32_t CACHE_VERSION = 4;
+
+// A cache stays usable as long as it was built from a vendor profile — and a
+// filament library — at least as new as the ones now on disk. Profiles without
+// a version cannot be judged this way and are never served from cache; where no
+// profile sits beside the cache at all, nothing can be newer than it.
+static bool cache_covers_version(const std::string& cached, const std::string& on_disk)
+{
+    if (on_disk == PresetBundle::CACHE_ANY_VERSION)
+        return true;
+    const auto cached_ver  = Semver::parse(cached);
+    const auto on_disk_ver = Semver::parse(on_disk);
+    return cached_ver && on_disk_ver && *cached_ver >= *on_disk_ver;
+}
+
+// Fingerprint of everything that determines the cache wire format: the app
+// version and the DynamicPrintConfig option schema (key/type/ordinal/enum
+// values — serialization_key_ordinal IS the config wire format). Any mismatch
+// means bytes written by another build could deserialize into the wrong
+// fields, so the cache is rejected wholesale before its body is read.
+const std::string& compute_cache_schema_fingerprint()
+{
+    // Constant for the lifetime of the process (print_config_def is immutable
+    // after static initialization), and asked for once per cache load and save.
+    static const std::string fingerprint = [] {
+        std::string schema;
+        schema += SLIC3R_VERSION;
+        schema += ';';
+        for (const auto& [key, def] : print_config_def.options) {   // std::map => stable order
+            schema += key;
+            schema += '#'; schema += std::to_string(int(def.type));
+            schema += '@'; schema += std::to_string(def.serialization_key_ordinal);
+            for (const std::string& ev : def.enum_values) { schema += ','; schema += ev; }
+            schema += ';';
+        }
+        boost::crc_32_type crc;
+        crc.process_bytes(schema.data(), schema.size());
+        return std::to_string(crc.checksum());
+    }();
+    return fingerprint;
+}
+
+} // anonymous namespace
+
+// static
+bool PresetBundle::read_cache_blob(const std::string& path, std::string& out_blob)
+{
+    try {
+        boost::nowide::ifstream ifs(path, std::ios::binary);
+        if (!ifs.is_open())
+            return false;
+        CacheFileHeader fhdr;
+        if (!ifs.read(reinterpret_cast<char*>(&fhdr), sizeof(fhdr)))
+            return false;
+        if (fhdr.magic != CACHE_MAGIC)
+            return false;
+        if (fhdr.data_size == 0 || fhdr.data_size > 512u * 1024u * 1024u)
+            return false;
+        out_blob.assign(fhdr.data_size, '\0');
+        if (!ifs.read(&out_blob[0], static_cast<std::streamsize>(fhdr.data_size)))
+            return false;
+        boost::crc_32_type crc;
+        crc.process_bytes(out_blob.data(), out_blob.size());
+        if (crc.checksum() != fhdr.crc32) {
+            BOOST_LOG_TRIVIAL(warning) << "SystemPresetsCache: CRC mismatch: " << path;
+            return false;
+        }
+        return true;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "SystemPresetsCache: read failed (" << path << "): " << e.what();
+        return false;
+    }
+}
+
+// static
+bool PresetBundle::write_cache_blob(const std::string& path, const std::string& blob)
+{
+    boost::crc_32_type crc;
+    crc.process_bytes(blob.data(), blob.size());
+    try {
+        boost::filesystem::create_directories(boost::filesystem::path(path).parent_path());
+        boost::nowide::ofstream ofs(path, std::ios::binary | std::ios::trunc);
+        if (!ofs.is_open()) {
+            BOOST_LOG_TRIVIAL(warning) << "SystemPresetsCache: cannot open for writing: " << path;
+            return false;
+        }
+        CacheFileHeader fhdr;
+        fhdr.magic     = CACHE_MAGIC;
+        fhdr.version   = CACHE_VERSION;
+        fhdr.data_size = static_cast<uint64_t>(blob.size());
+        fhdr.crc32     = crc.checksum();
+        ofs.write(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
+        ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
+        ofs.close();   // flush; close() raises failbit on error
+        if (! ofs.good())
+            BOOST_LOG_TRIVIAL(warning) << "SystemPresetsCache: write failed (" << path << ")";
+        return ofs.good();
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "SystemPresetsCache: write failed (" << path << "): " << e.what();
+        return false;
+    }
+}
+
+// ---- Per-vendor preset cache ---------------------------------------------
+
+// Serializes every non-default, non-external preset of one collection plus
+// its m_printer_hold_alias. Defaults are constructor-derived state and are
+// skipped; load re-installs the loaded presets after the constructor's
+// defaults, exactly like the JSON parse path (reset-to-defaults + sorted
+// append).
+void PresetBundle::save_collection(cereal::BinaryOutputArchive& ar, const PresetCollection& coll)
+{
+    uint64_t count = 0;
+    for (const Preset& p : coll.m_presets)
+        if (! p.is_default && ! p.is_external)
+            ++ count;
+    ar(count);
+    for (const Preset& p : coll.m_presets) {
+        if (p.is_default || p.is_external)
+            continue;
+        std::string vendor_id = p.vendor ? p.vendor->id : std::string();
+        ar(vendor_id, p);
+    }
+    // unordered containers -> sorted, for byte-deterministic output (parity test)
+    std::map<std::string, std::set<std::string>> hold;
+    for (const auto& entry : coll.m_printer_hold_alias)
+        hold.emplace(entry.first, std::set<std::string>(entry.second.begin(), entry.second.end()));
+    ar(hold);
+}
+
+void PresetBundle::load_collection(cereal::BinaryInputArchive& ar, PresetCollection& coll, const VendorMap& vendors)
+{
+    coll.m_printer_hold_alias.clear();
+    // Drop everything but the constructor-installed defaults, like PresetCollection::reset().
+    coll.m_presets.erase(coll.m_presets.begin() + coll.m_num_default_presets, coll.m_presets.end());
+    // Mirror PresetCollection::reset(), which follows the same truncation with
+    // select_preset(0): re-point selection/edited-preset state at the default
+    // preset before the loaded presets are appended below, so a cache hit onto
+    // an already-populated bundle (e.g. a reload) leaves selection state
+    // identical to the JSON-parse path instead of carrying over a stale index.
+    coll.select_preset(0);
+    uint64_t count = 0;
+    ar(count);
+    for (uint64_t i = 0; i < count; ++ i) {
+        std::string vendor_id;
+        Preset preset(coll.m_type, std::string());
+        ar(vendor_id, preset);
+        if (! vendor_id.empty()) {
+            auto it = vendors.find(vendor_id);
+            if (it == vendors.end())
+                throw std::runtime_error("vendor cache references unknown vendor: " + vendor_id);
+            preset.vendor = &it->second;
+        }
+        coll.m_presets.emplace_back(std::move(preset));
+    }
+    std::map<std::string, std::set<std::string>> hold;
+    ar(hold);
+    for (auto& entry : hold)
+        coll.m_printer_hold_alias.emplace(entry.first, std::unordered_set<std::string>(entry.second.begin(), entry.second.end()));
+}
+
+// ---- Per-vendor preset cache implementation ------------------------------
+
+bool PresetBundle::save_vendor_cache(const std::string& cache_path, const std::string& vendor_name,
+                                     const std::string& vendor_version, const std::string& lib_version) const
+{
+    try {
+        std::ostringstream body(std::ios::binary);
+        {
+            cereal::BinaryOutputArchive ar(body);
+            ar(CACHE_VERSION);
+            ar(compute_cache_schema_fingerprint());
+            ar(vendor_name, vendor_version, lib_version);
+            ar(this->vendors);
+            save_collection(ar, this->prints);
+            save_collection(ar, this->sla_prints);
+            save_collection(ar, this->filaments);
+            save_collection(ar, this->sla_materials);
+            save_collection(ar, this->printers);
+            ar(this->m_config_maps, this->m_filament_id_maps);
+            ar(this->obsolete_presets.prints, this->obsolete_presets.sla_prints,
+               this->obsolete_presets.filaments, this->obsolete_presets.sla_materials,
+               this->obsolete_presets.printers);
+            ar(this->m_errors);
+        }
+        return write_cache_blob(cache_path, body.str());
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "PresetBundle: failed to save vendor cache " << cache_path << ": " << e.what();
+        return false;
+    }
+}
+
+// static
+std::string PresetBundle::peek_vendor_cache_version(const std::string& cache_path, const std::string& expected_vendor_name)
+{
+    try {
+        boost::nowide::ifstream ifs(cache_path, std::ios::binary);
+        CacheFileHeader fhdr;
+        if (! ifs.read(reinterpret_cast<char*>(&fhdr), sizeof(fhdr)) || fhdr.magic != CACHE_MAGIC)
+            return {};
+        // Only the head of the body is read, and its CRC left unverified: the stamps
+        // sit at the front, this answers "what version is this vendor at?" once per
+        // vendor on every update check, and reading tens of megabytes to do so is not
+        // worth it. A stamp that comes out garbled fails to parse as a version, which
+        // is the same answer as none.
+        std::string head(static_cast<size_t>(std::min<uint64_t>(fhdr.data_size, 1024)), '\0');
+        if (! ifs.read(&head[0], static_cast<std::streamsize>(head.size())))
+            return {};
+        std::istringstream body(head, std::ios::binary);
+        cereal::BinaryInputArchive ar(body);
+        uint32_t cache_version = 0;
+        ar(cache_version);
+        std::string fingerprint, vendor_name, vendor_version;
+        ar(fingerprint);
+        ar(vendor_name, vendor_version);
+        // The fingerprint is deliberately not checked: the version a cache carries
+        // is what this build installed, whether or not this build can still read it.
+        if (cache_version != CACHE_VERSION || vendor_name != expected_vendor_name)
+            return {};
+        return vendor_version;
+    } catch (const std::exception&) {
+        return {};
+    }
+}
+
+bool PresetBundle::load_vendor_cache(const boost::filesystem::path& dir, const std::string& vendor_name, const std::string& lib_version_hint)
+{
+    // Whichever cache answers is judged against the vendor as installed in `dir`:
+    // the profile there, or — with none, as when the cache is the whole of the
+    // installation — nothing, since nothing on disk can then be newer than it.
+    // Plus the filament library in effect, which a vendor's filaments were
+    // resolved against when its cache was built.
+    const boost::filesystem::path profile = dir / (vendor_name + ".json");
+    const std::string version = boost::filesystem::exists(profile) ? get_vendor_cache_version(profile.string())
+                                                                   : std::string(CACHE_ANY_VERSION);
+    const std::string lib_version = ! lib_version_hint.empty() ? lib_version_hint : effective_lib_version(dir);
+    const boost::filesystem::path rsrc = boost::filesystem::path(resources_dir()) / "profiles";
+    return this->load_vendor_cache((dir / (vendor_name + ".opc")).string(), vendor_name, version, lib_version)
+        || (dir != rsrc && this->load_vendor_cache((rsrc / (vendor_name + ".opc")).string(), vendor_name, version, lib_version));
+}
+
+bool PresetBundle::load_vendor_cache(const std::string& cache_path, const std::string& expected_vendor_name,
+                                     const std::string& expected_vendor_version, const std::string& expected_lib_version)
+{
+    std::string blob;
+    if (! read_cache_blob(cache_path, blob))
+        return false;
+    try {
+        // Read in place: an istringstream would copy the blob (tens of MB for
+        // the largest vendors) once more just to stream over it.
+        boost::iostreams::stream<boost::iostreams::array_source> body(blob.data(), blob.size());
+        cereal::BinaryInputArchive ar(body);
+        uint32_t cache_version = 0;
+        ar(cache_version);
+        if (cache_version != CACHE_VERSION)
+            return false;
+        std::string fingerprint;
+        ar(fingerprint);
+        if (fingerprint != compute_cache_schema_fingerprint())
+            return false;
+        std::string vendor_name, vendor_version, lib_version;
+        ar(vendor_name, vendor_version, lib_version);
+        if (vendor_name != expected_vendor_name ||
+            ! cache_covers_version(vendor_version, expected_vendor_version) ||
+            ! cache_covers_version(lib_version, expected_lib_version))
+            return false;
+        ar(this->vendors);
+        load_collection(ar, this->prints,        this->vendors);
+        load_collection(ar, this->sla_prints,    this->vendors);
+        load_collection(ar, this->filaments,     this->vendors);
+        load_collection(ar, this->sla_materials, this->vendors);
+        load_collection(ar, this->printers,      this->vendors);
+        ar(this->m_config_maps, this->m_filament_id_maps);
+        ar(this->obsolete_presets.prints, this->obsolete_presets.sla_prints,
+           this->obsolete_presets.filaments, this->obsolete_presets.sla_materials,
+           this->obsolete_presets.printers);
+        ar(this->m_errors);
+        return true;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "PresetBundle: rejecting vendor cache " << cache_path << ": " << e.what();
+        // Restore a clean state so the caller can fall back to the JSON parse.
+        this->reset(false);
+        this->vendors.clear();
+        this->m_config_maps.clear();
+        this->m_filament_id_maps.clear();
+        this->m_errors = 0;
+        // A mid-body failure may have left collections the deserialization never
+        // reached (each load_collection clears its own collection's map only when
+        // it runs) with stale aliases.
+        this->clear_printer_hold_aliases();
+        return false;
+    }
+}
+
 } // namespace Slic3r

src/libslic3r/PresetBundle.hpp

@@ -6,6 +6,7 @@
 #include "enum_bitmask.hpp"
 
 #include <memory>
+#include <set>
 #include <shared_mutex>
 #include <unordered_map>
 #include <optional>
@@ -13,6 +14,11 @@
 #include <boost/filesystem/path.hpp>
 #include <unordered_set>
 
+namespace cereal {
+	class BinaryInputArchive;
+	class BinaryOutputArchive;
+}
+
 #define DEFAULT_USER_FOLDER_NAME "default"
 #define BUNDLE_STRUCTURE_JSON_NAME "bundle_structure.json"
 
@@ -170,6 +176,44 @@ struct PresetBundleMetadata
 class PresetBundle
 {
 public:
+    // ---- Per-vendor preset cache --------------------------------------------
+    // One cache file per vendor (plus the Orca filament library), stamped with
+    // the vendor's own profile version rather than a directory scan.
+
+    // The cache is not something a caller loads from: a vendor is loaded with
+    // load_vendor_configs_from_json, which comes from the cache whenever one covers
+    // it. What is public here is what the cache's own tests drive directly.
+
+    // Save this bundle's slice belonging to one vendor (vendor_name at
+    // vendor_version), built against the given filament library version.
+    bool save_vendor_cache(const std::string& cache_path, const std::string& vendor_name,
+                          const std::string& vendor_version, const std::string& lib_version) const;
+
+    // Expected version meaning "no profile sits beside this cache", so nothing can
+    // be newer than it and only its own integrity decides whether it is used. Not
+    // the same as an empty version, which means a profile is there but unreadable.
+    static constexpr const char* CACHE_ANY_VERSION = "*";
+
+    // Load a validated per-vendor cache into this bundle. Rejects (returns
+    // false) unless the cache version, schema fingerprint and vendor name match
+    // and the cache was built from a vendor profile and filament library at
+    // least as new as the expected ones. Profiles without a version (empty
+    // string) are never served from cache.
+    bool load_vendor_cache(const std::string& cache_path, const std::string& expected_vendor_name,
+                          const std::string& expected_vendor_version, const std::string& expected_lib_version);
+
+    // Read the profile version a cache was stamped with, without deserializing its
+    // presets. Empty if the file is unreadable, not a cache this build understands,
+    // or not this vendor's. This is how an installed vendor's version is known when
+    // only its cache is installed.
+    static std::string peek_vendor_cache_version(const std::string& cache_path, const std::string& expected_vendor_name);
+
+    // Enable writing a per-vendor cache after a JSON parse (off by default). Only
+    // for bundles whose parses are complete — load_system_presets_from_json loads
+    // the filament library first and every other vendor against it, so its parses
+    // qualify; a wizard's one-off parse of a single vendor does not.
+    void set_generate_vendor_caches(bool enable) { m_generate_vendor_caches = enable; }
+
     static DynamicPrintConfig construct_full_config(Preset                         &in_printer_preset,
                                                     Preset                         &in_print_preset,
                                                     const DynamicPrintConfig       &project_config,
@@ -444,8 +488,15 @@ public:
     /*std::pair<PresetsConfigSubstitutions, size_t> load_configbundle(
         const std::string &path, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule);*/
     //Orca: load config bundle from json, pass the base bundle to support cross vendor inheritance
+    // Orca: `dir` is where the vendor is looked for — its own directory, whether or
+    // not the profile JSONs are still there. A whole-vendor load comes from the
+    // vendor's preset cache whenever one covers the profile on disk, and is parsed
+    // from the JSONs (falling back to the ones in resources) only when none does.
+    // `lib_version_hint` is the filament library version in effect, when the caller
+    // loads many vendors and has already resolved it once; empty resolves it here.
     std::pair<PresetsConfigSubstitutions, size_t> load_vendor_configs_from_json(
-        const std::string &path, const std::string &vendor_name, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle = nullptr);
+        const std::string &dir, const std::string &vendor_name, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle = nullptr,
+        const std::string &lib_version_hint = {});
 
     // Export a config bundle file containing all the presets and the names of the active presets.
     //void                        export_configbundle(const std::string &path, bool export_system_settings = false, bool export_physical_printers = false);
@@ -521,7 +572,38 @@ public:
     // compatible_prints references a deleted (unknown) or renamed (old) preset name.
     bool check_preset_references() const;
 
+    // Merge one vendor's presets with the other vendor's presets, report duplicates.
+    // Public so per-vendor-cache consumers (e.g. the setup wizard) can assemble a
+    // bundle out of several per-vendor caches loaded into separate PresetBundle instances.
+    std::vector<std::string>    merge_presets(PresetBundle &&other);
+
 private:
+    // Load one vendor from its preset cache: the one in `dir`, or — when that is
+    // missing or stale — the one shipped in resources/profiles, both judged against
+    // the vendor as installed in `dir` and against the filament library in effect
+    // (resolved here unless the caller passes the already-resolved version).
+    // False, with this bundle left clean, when neither is usable and the vendor has
+    // to be parsed. This is how load_vendor_configs_from_json reads a cache.
+    bool load_vendor_cache(const boost::filesystem::path& dir, const std::string& vendor_name, const std::string& lib_version_hint = {});
+
+    // Read raw cache blob: verify magic, size, CRC.
+    static bool read_cache_blob(const std::string& path, std::string& out_blob);
+    // Write a cache blob with the standard 20-byte file header. False when the
+    // file could not be opened or written whole.
+    static bool write_cache_blob(const std::string& path, const std::string& blob);
+
+    // (De)serialization of one collection's slice for the per-vendor cache:
+    // every non-default, non-external preset (system or user) plus
+    // m_printer_hold_alias. See save_vendor_cache/load_vendor_cache.
+    static void save_collection(cereal::BinaryOutputArchive& ar, const PresetCollection& coll);
+    static void load_collection(cereal::BinaryInputArchive& ar, PresetCollection& coll, const VendorMap& vendors);
+
+    // Clear every collection's m_printer_hold_alias, which reset() leaves alone.
+    void clear_printer_hold_aliases();
+
+    // Whether to (re)write a per-vendor cache after a JSON parse.
+    bool m_generate_vendor_caches { false };
+
     // Orca: validation only - flag any printer with two or more compatible
     // filament presets sharing one filament_id (ambiguous AMS subtype match).
     bool check_duplicate_filament_subtypes() const;
@@ -529,8 +611,6 @@ private:
     //std::pair<PresetsConfigSubstitutions, std::string> load_system_presets(ForwardCompatibilitySubstitutionRule compatibility_rule);
     //BBS: add json related logic
     std::pair<PresetsConfigSubstitutions, std::string> load_system_presets_from_json(ForwardCompatibilitySubstitutionRule compatibility_rule);
-    // Merge one vendor's presets with the other vendor's presets, report duplicates.
-    std::vector<std::string>    merge_presets(PresetBundle &&other);
     // Update the multicolor information for filaments.
     void update_filament_multi_color();
     // Update renamed_from and alias maps of system profiles.
@@ -565,6 +645,38 @@ private:
 
 ENABLE_ENUM_BITMASK_OPERATORS(PresetBundle::LoadConfigBundleAttribute)
 
+// True if `vendor` is installed in data_dir()/system. A build that ships preset
+// caches installs the cache alone, so it — not the profile — marks a vendor
+// installed, and either one on its own counts.
+extern bool is_vendor_installed(const std::string& vendor);
+
+// The version of the installed vendor: what its profile claims, or what its cache
+// was stamped with where only the cache is installed. Invalid Semver if neither is.
+extern Semver installed_vendor_version(const std::string& vendor);
+
+// Remove every form `vendor` can be installed as from data_dir()/system: its
+// profile, its preset cache, and its preset directory.
+extern void remove_installed_vendor(const std::string& vendor);
+
+// The vendors `dir` holds, sorted: one is named by its profile or, in a build that
+// ships preset caches instead of the raw profile JSONs, by its cache alone.
+extern std::set<std::string> vendor_names_in(const boost::filesystem::path& dir);
+
+// The version a build ships `vendor` at: whichever of its preset cache and its
+// profile is newer, that being the one installing lays down. Invalid Semver if the
+// build ships neither.
+extern Semver resource_vendor_version(const std::string& vendor);
+
+// Install vendors from the resources directory into the data directory, each as
+// its preset cache or as its profile and preset JSONs — whichever of the two the
+// build ships at the newer version. Anything the previous install of that vendor
+// left behind goes, so only the form just installed is there to be loaded.
+// bundle_names: vendor names, without extension.
+// Returns false on the first vendor that cannot be installed.
+extern bool install_vendor_bundles_from_resources(const std::vector<std::string>& bundle_names,
+                                                  const std::string& resource_subdir = "profiles",
+                                                  const std::string& data_subdir     = "system");
+
 } // namespace Slic3r
 
 #endif /* slic3r_PresetBundle_hpp_ */

src/libslic3r/PrintConfig.cpp

@@ -331,6 +331,8 @@ CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(PrintSequence)
 static t_config_enum_values s_keys_map_PrintOrder{
     { "default",     int(PrintOrder::Default) },
     { "as_obj_list", int(PrintOrder::AsObjectList)},
+    { "best_of",       int(PrintOrder::BestOfStrategies)},
+    { "snake", int(PrintOrder::Snake)},
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(PrintOrder)
 
@@ -1999,12 +2001,30 @@ void PrintConfigDef::init_fff_params()
 
     def = this->add("print_order", coEnum);
     def->label = L("Intra-layer order");
-    def->tooltip = L("Print order within a single layer.");
+    def->tooltip = L("Order in which object instances are visited within a single layer, which controls how much "
+                     "travel is spent moving between them.\n\n"
+                     "Default: nearest-neighbor chaining, refined with 2-opt and crossing removal. A good general "
+                     "choice.\n"
+                     "As object list: instances are printed in the same order as the object list, without any path "
+                     "optimization. Use it when you need a predictable, manually controlled order.\n"
+                     "Best of all (shortest path): every strategy is evaluated and the shortest one is used. The "
+                     "object instance order is decided once for the whole print, while the ordering of individual "
+                     "islands is decided per layer, so different layers may end up using different strategies. "
+                     "Slightly slower to slice.\n"
+                     "Snake: serpentine row-by-row traversal, refined with 2-opt. Well suited to regular grids of "
+                     "many small parts.\n\n"
+                     "With multiple filaments or tools in the same layer, minimizing tool changes takes priority: "
+                     "objects are grouped by filament first and this setting only orders the instances within each "
+                     "filament group, so the overall sequence may not look like the shortest path across the plate.");
     def->enum_keys_map = &ConfigOptionEnum<PrintOrder>::get_enum_values();
     def->enum_values.push_back("default");
     def->enum_values.push_back("as_obj_list");
+    def->enum_values.push_back("best_of");
+    def->enum_values.push_back("snake");
     def->enum_labels.push_back(L("Default"));
     def->enum_labels.push_back(L("As object list"));
+    def->enum_labels.push_back(L("Best of all (shortest path)"));
+    def->enum_labels.push_back(L("Snake"));
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionEnum<PrintOrder>(PrintOrder::Default));
 
@@ -5629,6 +5649,7 @@ void PrintConfigDef::init_fff_params()
     // Orca:
     def = this->add("retract_after_wipe", coPercents);
     def->label = L("Retract amount after wipe");
+    // xgettext:no-c-format, no-boost-format
     def->tooltip = L("The length of fast retraction after wipe, relative to retraction length.\n"
                      "The value will be clamped by 100% minus the retract amount before the wipe value.");
     def->sidetext = "%";

src/libslic3r/PrintConfig.hpp

@@ -214,6 +214,8 @@ enum class PrintOrder
 {
     Default,
     AsObjectList,
+    BestOfStrategies,    // run all custom strategies, pick the shortest total path
+    Snake,               // snake-like row traversal (back-and-forth) + 2-opt
     Count,
 };
 
@@ -2408,7 +2410,8 @@ namespace cereal {
             archive(serialization_key_ordinal);
             assert(serialization_key_ordinal > 0);
             auto it = Slic3r::print_config_def.by_serialization_key_ordinal.find(serialization_key_ordinal);
-            assert(it != Slic3r::print_config_def.by_serialization_key_ordinal.end());
+            if (it == Slic3r::print_config_def.by_serialization_key_ordinal.end())
+                throw std::runtime_error("VendorCache: unknown serialization_key_ordinal " + std::to_string(serialization_key_ordinal) + " - cache is stale");
             config.set_key_value(it->second->opt_key, it->second->load_option_from_archive(archive));
         }
     }

src/libslic3r/Semver.hpp

@@ -190,6 +190,19 @@ public:
 		os << self.to_string();
 		return os;
 	}
+
+	// cereal: round-trip through the standard 3-part string (major.minor.patch).
+	// to_string() uses a BBS 4-part format that semver_parse() cannot read back.
+	template<class Archive>
+	std::string save_minimal(const Archive&) const { return to_string_sf(); }
+	template<class Archive>
+	void load_minimal(const Archive&, const std::string& s) {
+		auto v = Semver::parse(s);
+		if (! v)
+			throw std::runtime_error("Semver: cannot parse serialized version: " + s);
+		*this = std::move(*v);
+	}
+
 private:
 	semver_t ver;
 

src/libslic3r/ShortestPath.cpp

@@ -10,6 +10,7 @@
 #include "KDTreeIndirect.hpp"
 #include "MutablePriorityQueue.hpp"
 #include "Print.hpp"
+#include "GCode/OrderingStrategies.hpp"
 
 #include <cmath>
 #include <cassert>
@@ -1103,7 +1104,7 @@ std::vector<size_t> chain_expolygons(const ExPolygons &input_exploy) {
 	return chain_points(points);
 }
 
-std::vector<size_t> chain_points(const Points &points, Point *start_near)
+std::vector<size_t> chain_points(const Points &points, const Point *start_near)
 {
 	auto segment_end_point = [&points](size_t idx, bool /* first_point */) -> const Point& { return points[idx]; };
 	std::vector<std::pair<size_t, bool>> ordered = chain_segments_greedy<Point, decltype(segment_end_point)>(segment_end_point, points.size(), start_near);
@@ -1111,9 +1112,26 @@ std::vector<size_t> chain_points(const Points &points, Point *start_near)
 	out.reserve(ordered.size());
 	for (auto &segment_and_reversal : ordered)
 		out.emplace_back(segment_and_reversal.first);
+
 	return out;
 }
 
+std::vector<size_t> chain_points_with_postprocessing(const Points &points, const Point *start_near)
+{
+	std::vector<size_t> path = chain_points(points, start_near);
+	// Alternate 2-opt and crossing removal until convergence.
+	// 2-opt can create new crossings, and crossing removal can create new
+	// opportunities for 2-opt improvement. Break early if neither improves.
+	for (int iter = 0; iter < 3; ++iter) {
+		bool improved = tsp_2opt_improve(path, points);
+		improved |= tsp_remove_crossings(path, points);
+		if (!improved) break;
+	}
+    if (start_near == nullptr)
+        tsp_rotate_minimize_closing(path, points);
+	return path;
+}
+
 #ifndef NDEBUG
 	// #define DEBUG_SVG_OUTPUT
 #endif /* NDEBUG */
@@ -2025,12 +2043,13 @@ std::vector<const PrintInstance*> chain_print_object_instances(const std::vector
 			instances.emplace_back(i, j);
 		}
 	}
-	auto segment_end_point = [&object_reference_points](size_t idx, bool /* first_point */) -> const Point& { return object_reference_points[idx]; };
+	// Order objects using nearest neighbor + post-processing (crossing removal + 2-opt).
-	std::vector<std::pair<size_t, bool>> ordered = chain_segments_greedy<Point, decltype(segment_end_point)>(segment_end_point, instances.size(), start_near);
+	std::vector<size_t> path = chain_points_with_postprocessing(object_reference_points, start_near);
+
 	std::vector<const PrintInstance*> out;
-	out.reserve(instances.size());
+	out.reserve(path.size());
-	for (auto& segment_and_reversal : ordered) {
+	for (size_t idx : path) {
-		const std::pair<size_t, size_t>& inst = instances[segment_and_reversal.first];
+		const std::pair<size_t, size_t>& inst = instances[idx];
 		out.emplace_back(&print_objects[inst.first]->instances()[inst.second]);
 	}
 	return out;

src/libslic3r/ShortestPath.hpp

@@ -15,7 +15,9 @@ namespace Slic3r {
 		using PolyNodes = std::vector<PolyNode*, PointsAllocator<PolyNode*>>;
 	}
 
-std::vector<size_t> 				 chain_points(const Points &points, Point *start_near = nullptr);
+std::vector<size_t> 				 chain_points(const Points &points, const Point *start_near = nullptr);
+// Variant with post-processing (crossing removal + 2-opt) for object ordering.
+std::vector<size_t> 				 chain_points_with_postprocessing(const Points &points, const Point *start_near = nullptr);
 std::vector<size_t> 				 chain_expolygons(const ExPolygons &input_exploy);
 
 std::vector<std::pair<size_t, bool>> chain_extrusion_entities(std::vector<ExtrusionEntity*> &entities, const Point *start_near = nullptr);

src/libslic3r/Support/SupportCommon.cpp

@@ -65,6 +65,15 @@ std::pair<SupportGeneratorLayersPtr, SupportGeneratorLayersPtr> generate_interfa
         const bool                 smooth_supports        = support_params.support_style != smsGrid;
         SupportGeneratorLayersPtr &interface_layers       = base_and_interface_layers.first;
         SupportGeneratorLayersPtr &base_interface_layers  = base_and_interface_layers.second;
+        // The user-facing interface layer counts include the contact layer. Internally,
+        // contact layers are generated separately, so only the remaining layers are
+        // projected into intermediate interface/base-interface layers here.
+        const size_t num_top_interface_layers    = support_params.has_top_contacts    ? support_params.num_top_interface_layers    - 1 : 0;
+        const size_t num_bottom_interface_layers = support_params.has_bottom_contacts ? support_params.num_bottom_interface_layers - 1 : 0;
+        const size_t num_top_base_interface_layers    = std::min(support_params.num_top_base_interface_layers,    num_top_interface_layers);
+        const size_t num_bottom_base_interface_layers = std::min(support_params.num_bottom_base_interface_layers, num_bottom_interface_layers);
+        const size_t num_top_interface_layers_only    = num_top_interface_layers    - num_top_base_interface_layers;
+        const size_t num_bottom_interface_layers_only = num_bottom_interface_layers - num_bottom_base_interface_layers;
 
         interface_layers.assign(intermediate_layers.size(), nullptr);
         if (support_params.has_base_interfaces())
@@ -124,6 +133,8 @@ std::pair<SupportGeneratorLayersPtr, SupportGeneratorLayersPtr> generate_interfa
         };
         tbb::parallel_for(tbb::blocked_range<int>(0, int(intermediate_layers.size())),
             [&bottom_contacts, &top_contacts, &top_interface_layers, &top_base_interface_layers, &intermediate_layers, &insert_layer, &support_params,
+             num_top_interface_layers, num_bottom_interface_layers, num_top_base_interface_layers, num_bottom_base_interface_layers,
+             num_top_interface_layers_only, num_bottom_interface_layers_only,
              snug_supports, &interface_layers, &base_interface_layers](const tbb::blocked_range<int>& range) {
                 // Gather the top / bottom contact layers intersecting with num_interface_layers resp. num_interface_layers_only intermediate layers above / below
                 // this intermediate layer.
@@ -142,16 +153,16 @@ std::pair<SupportGeneratorLayersPtr, SupportGeneratorLayersPtr> generate_interfa
                     Polygons polygons_top_contact_projected_base;
                     Polygons polygons_bottom_contact_projected_interface;
                     Polygons polygons_bottom_contact_projected_base;
-                    if (support_params.num_top_interface_layers > 0) {
+                    if (num_top_interface_layers > 0) {
                         // Top Z coordinate of a slab, over which we are collecting the top / bottom contact surfaces
-                        coordf_t top_z              = intermediate_layers[std::min(num_intermediate - 1, idx_intermediate_layer + int(support_params.num_top_interface_layers) - 1)]->print_z;
+                        coordf_t top_z              = intermediate_layers[std::min(num_intermediate - 1, idx_intermediate_layer + int(num_top_interface_layers) - 1)]->print_z;
-                        coordf_t top_inteface_z     = std::numeric_limits<coordf_t>::max();
+                        coordf_t top_interface_z     = std::numeric_limits<coordf_t>::max();
-                        if (support_params.num_top_base_interface_layers > 0)
+                        if (num_top_base_interface_layers > 0)
                             // Some top base interface layers will be generated.
-                            top_inteface_z = support_params.num_top_interface_layers_only() == 0 ?
+                            top_interface_z = num_top_interface_layers_only == 0 ?
                                 // Only base interface layers to generate.
                                 - std::numeric_limits<coordf_t>::max() :
-                                intermediate_layers[std::min(num_intermediate - 1, idx_intermediate_layer + int(support_params.num_top_interface_layers_only()) - 1)]->print_z;
+                                intermediate_layers[std::min(num_intermediate - 1, idx_intermediate_layer + int(num_top_interface_layers_only) - 1)]->print_z;
                         // Move idx_top_contact_first up until above the current print_z.
                         idx_top_contact_first = idx_higher_or_equal(top_contacts, idx_top_contact_first, [&intermediate_layer](const SupportGeneratorLayer *layer){ return layer->print_z >= intermediate_layer.print_z; }); //  - EPSILON
                         // Collect the top contact areas above this intermediate layer, below top_z.
@@ -160,22 +171,22 @@ std::pair<SupportGeneratorLayersPtr, SupportGeneratorLayersPtr> generate_interfa
                             //FIXME maybe this adds one interface layer in excess?
                             if (top_contact_layer.bottom_z - EPSILON > top_z)
                                 break;
-                            polygons_append(top_contact_layer.bottom_z - EPSILON > top_inteface_z ? polygons_top_contact_projected_base : polygons_top_contact_projected_interface,
+                            polygons_append(top_contact_layer.bottom_z - EPSILON > top_interface_z ? polygons_top_contact_projected_base : polygons_top_contact_projected_interface,
                                 // For snug supports, project the overhang polygons covering the whole overhang, so that they will merge without a gap with support polygons of the other layers.
                                 // For grid supports, merging of support regions will be performed by the projection into grid.
                                 snug_supports ? *top_contact_layer.overhang_polygons : top_contact_layer.polygons);
                         }
                     }
-                    if (support_params.num_bottom_interface_layers > 0) {
+                    if (num_bottom_interface_layers > 0) {
                         // Bottom Z coordinate of a slab, over which we are collecting the top / bottom contact surfaces
-                        coordf_t bottom_z           = intermediate_layers[std::max(0, idx_intermediate_layer - int(support_params.num_bottom_interface_layers) + 1)]->bottom_z;
+                        coordf_t bottom_z           = intermediate_layers[std::max(0, idx_intermediate_layer - int(num_bottom_interface_layers) + 1)]->bottom_z;
                         coordf_t bottom_interface_z = - std::numeric_limits<coordf_t>::max();
-                        if (support_params.num_bottom_base_interface_layers > 0)
+                        if (num_bottom_base_interface_layers > 0)
                             // Some bottom base interface layers will be generated.
-                            bottom_interface_z = support_params.num_bottom_interface_layers_only() == 0 ?
+                            bottom_interface_z = num_bottom_interface_layers_only == 0 ?
                                 // Only base interface layers to generate.
                                 std::numeric_limits<coordf_t>::max() :
-                                intermediate_layers[std::max(0, idx_intermediate_layer - int(support_params.num_bottom_interface_layers_only()))]->bottom_z;
+                                intermediate_layers[std::max(0, idx_intermediate_layer - int(num_bottom_interface_layers_only))]->bottom_z;
                         // Move idx_bottom_contact_first up until touching bottom_z.
                         idx_bottom_contact_first = idx_higher_or_equal(bottom_contacts, idx_bottom_contact_first, [bottom_z](const SupportGeneratorLayer *layer){ return layer->print_z >= bottom_z - EPSILON; });
                         // Collect the top contact areas above this intermediate layer, below top_z.
@@ -1563,13 +1574,17 @@ void generate_support_toolpaths(
         // Pointer to the 1st layer interface filler.
         auto filler_first_layer     = filler_first_layer_ptr ? filler_first_layer_ptr.get() : filler_interface.get();
         // Filler for the 1st layer interface, if different from filler_interface.
-        auto filler_raft_contact_ptr = std::unique_ptr<Fill>(range.begin() == n_raft_layers && config.support_interface_top_layers.value == 0 ?
+        const bool top_interfaces_enabled    = support_params.num_top_interface_layers > 0;
+        const bool bottom_interfaces_enabled = support_params.num_bottom_interface_layers > 0;
+        const coordf_t base_interface_density = top_interfaces_enabled || !bottom_interfaces_enabled ?
+            support_params.top_interface_density : support_params.bottom_interface_density;
+        auto filler_raft_contact_ptr = std::unique_ptr<Fill>(range.begin() == n_raft_layers && !top_interfaces_enabled ?
             Fill::new_from_type(support_params.raft_interface_fill_pattern) : nullptr);
         // Pointer to the 1st layer interface filler.
         auto filler_raft_contact     = filler_raft_contact_ptr ? filler_raft_contact_ptr.get() : filler_interface.get();
         // Filler for the base interface (to be used for soluble interface / non soluble base, to produce non soluble interface layer below soluble interface layer).
         auto filler_base_interface  = std::unique_ptr<Fill>(base_interface_layers.empty() ? nullptr :
-            Fill::new_from_type(support_params.top_interface_density > 0.95 || support_params.with_sheath ? ipRectilinear : ipSupportBase));
+            Fill::new_from_type(base_interface_density > 0.95 || support_params.with_sheath ? ipRectilinear : ipSupportBase));
         auto filler_support         = std::unique_ptr<Fill>(Fill::new_from_type(support_params.base_fill_pattern));
         filler_interface->set_bounding_box(bbox_object);
         if (filler_first_layer_ptr)
@@ -1583,10 +1598,7 @@ void generate_support_toolpaths(
         {
             SupportLayer &support_layer = *support_layers[support_layer_id];
             LayerCache   &layer_cache   = layer_caches[support_layer_id];
-            const float   support_interface_angle = (config.support_interface_pattern == smipRectilinearInterlaced) ?
+            const float   support_interface_angle = support_params.support_interface_angle(support_layer.interface_id());
-                support_params.raft_interface_angle(support_layer.interface_id()) :
-                ((support_params.support_style == smsGrid || config.support_interface_pattern == smipRectilinear) ?
-                support_params.interface_angle : support_params.raft_interface_angle(support_layer.interface_id()));
 
             // Find polygons with the same print_z.
             SupportGeneratorLayerExtruded &bottom_contact_layer = layer_cache.bottom_contact_layer;
@@ -1619,7 +1631,9 @@ void generate_support_toolpaths(
             bool raft_layer = slicing_params.interface_raft_layers && top_contact_layer.layer && is_approx(top_contact_layer.layer->print_z, slicing_params.raft_contact_top_z);
             // ORCA: Organic tree uses projected contacts to build the interface stack; avoid extra bottom-contact extrusion.
             const bool organic_tree = support_params.support_style == SupportMaterialStyle::smsTreeOrganic;
-            if (config.support_interface_top_layers == 0) {
+            const bool top_interfaces = support_params.num_top_interface_layers > 0;
+            const bool bottom_interfaces = support_params.num_bottom_interface_layers > 0;
+            if (!top_interfaces) {
                 // If no top interface layers were requested, we treat the contact layer exactly as a generic base layer.
                 // Don't merge the raft contact layer though.
                 if (support_params.can_merge_support_regions && ! raft_layer) {
@@ -1642,15 +1656,29 @@ void generate_support_toolpaths(
                 if (top_contact_layer.could_merge(interface_layer) && ! raft_layer)
                     top_contact_layer.merge(std::move(interface_layer));
             }
-            if ((config.support_interface_top_layers == 0 || config.support_interface_bottom_layers == 0) && support_params.can_merge_support_regions) {
+            if (!bottom_interfaces && support_params.can_merge_support_regions) {
                 if (base_layer.could_merge(bottom_contact_layer))
                     base_layer.merge(std::move(bottom_contact_layer));
                 else if (base_layer.empty() && ! bottom_contact_layer.empty() && ! bottom_contact_layer.layer->bridging)
                     base_layer = std::move(bottom_contact_layer);
             } else if (bottom_contact_layer.could_merge(top_contact_layer) && ! raft_layer) {
-                top_contact_layer.merge(std::move(bottom_contact_layer));
+                if (top_interfaces && bottom_interfaces) {
+                    top_contact_layer.merge(std::move(bottom_contact_layer));
+                } else if (bottom_interfaces) {
+                    top_contact_layer.set_polygons_to_extrude(
+                        diff(top_contact_layer.polygons_to_extrude(), bottom_contact_layer.polygons_to_extrude()));
+                } else {
+                    bottom_contact_layer.set_polygons_to_extrude(
+                        diff(bottom_contact_layer.polygons_to_extrude(), top_contact_layer.polygons_to_extrude()));
+                }
             } else if (bottom_contact_layer.could_merge(interface_layer) && ! organic_tree) {
-                bottom_contact_layer.merge(std::move(interface_layer));
+                const bool interface_layer_is_bottom = interface_layer.layer->layer_type == SupporLayerType::BottomInterface;
+                if (bottom_interfaces && interface_layer_is_bottom) {
+                    bottom_contact_layer.merge(std::move(interface_layer));
+                } else {
+                    bottom_contact_layer.set_polygons_to_extrude(
+                        diff(bottom_contact_layer.polygons_to_extrude(), interface_layer.polygons_to_extrude()));
+                }
             }
 
             // Orca: For organic trees the support-material regions are generated from
@@ -1730,12 +1758,12 @@ void generate_support_toolpaths(
                         interface_as_base ? ExtrusionRole::erSupportMaterial : ExtrusionRole::erSupportMaterialInterface, interface_flow);
                 }
             };
-            const bool top_interfaces = support_params.num_top_interface_layers > 0;
-            const bool bottom_interfaces = top_interfaces && support_params.num_bottom_interface_layers > 0;
             extrude_interface(top_contact_layer,    raft_layer ? InterfaceLayerType::RaftContact : top_interfaces ? InterfaceLayerType::TopContact : InterfaceLayerType::InterfaceAsBase);
             if (!organic_tree)
                 extrude_interface(bottom_contact_layer, bottom_interfaces ? InterfaceLayerType::BottomContact : InterfaceLayerType::InterfaceAsBase);
-            extrude_interface(interface_layer,      top_interfaces ? InterfaceLayerType::Interface : InterfaceLayerType::InterfaceAsBase);
+            const bool interface_layer_enabled = !interface_layer.empty() &&
+                (interface_layer.layer->layer_type == SupporLayerType::BottomInterface ? bottom_interfaces : top_interfaces);
+            extrude_interface(interface_layer,      interface_layer_enabled ? InterfaceLayerType::Interface : InterfaceLayerType::InterfaceAsBase);
             // Base interface layers under soluble interfaces
             if ( ! base_interface_layer.empty() && ! base_interface_layer.polygons_to_extrude().empty()) {
                 Fill *filler = filler_base_interface.get();
@@ -1745,7 +1773,7 @@ void generate_support_toolpaths(
                 Flow interface_flow = support_params.support_material_flow.with_height(float(base_interface_layer.layer->height));
                 filler->angle   = support_interface_angle;
                 filler->spacing = support_params.support_material_interface_flow.spacing();
-                    filler->link_max_length = coord_t(scale_(filler->spacing * link_max_length_factor / support_params.top_interface_density));
+                filler->link_max_length = coord_t(scale_(filler->spacing * link_max_length_factor / base_interface_density));
                 fill_expolygons_generate_paths(
                     // Destination
                     base_interface_layer.extrusions,
@@ -1753,7 +1781,7 @@ void generate_support_toolpaths(
                     // Regions to fill
                     union_safety_offset_ex(base_interface_layer.polygons_to_extrude()),
                     // Filler and its parameters
-                    filler, float(support_params.top_interface_density),
+                    filler, float(base_interface_density),
                     // Extrusion parameters
                     ExtrusionRole::erSupportMaterial, interface_flow);
             }

src/libslic3r/Support/SupportParameters.hpp

@@ -34,7 +34,7 @@ struct SupportParameters {
 
 	    {
 	        this->num_top_interface_layers    = std::max(0, object_config.support_interface_top_layers.value);
-	        this->num_bottom_interface_layers = number_of_support_interface_bottom_layers(object_config);
+	        this->num_bottom_interface_layers = std::max(0, number_of_support_interface_bottom_layers(object_config));
 	        this->has_top_contacts              = num_top_interface_layers    > 0;
 	        this->has_bottom_contacts           = num_bottom_interface_layers > 0;
             // BBS: if support interface and support base do not use the same filament, add a base layer to improve their adhesion
@@ -46,15 +46,15 @@ struct SupportParameters {
             if (non_soluble_base_top) { // ORCA: Try to support soluble dense interfaces with non-soluble dense interfaces.
                 this->num_top_base_interface_layers = size_t(std::min(int(num_top_interface_layers) / 2, 2));
             } else {
-                this->num_top_base_interface_layers =
+                // Keep at least one configured layer on the interface filament.
-                    (different_support_interface_filament && this->zero_gap_interface_top) ? 1 : 0;
+                this->num_top_base_interface_layers = different_support_interface_filament && num_top_interface_layers > 1 ? 1 : 0;
             }
 
             if (non_soluble_base_bottom) { // ORCA: Try to support soluble dense interfaces with non-soluble dense interfaces.
                 this->num_bottom_base_interface_layers = size_t(std::min(int(num_bottom_interface_layers) / 2, 2));
             } else {
-                this->num_bottom_base_interface_layers =
+                // Keep at least one configured layer on the interface filament.
-                    (different_support_interface_filament && this->zero_gap_interface_bottom) ? 1 : 0;
+                this->num_bottom_base_interface_layers = different_support_interface_filament && num_bottom_interface_layers > 1 ? 1 : 0;
             }
 	    }
         this->first_layer_flow = Slic3r::support_material_1st_layer_flow(&object, float(slicing_params.first_print_layer_height));
@@ -74,7 +74,7 @@ struct SupportParameters {
         for (auto layer : object.layers())
             this->support_layer_height_min = std::min(this->support_layer_height_min, std::max(0.01, layer->height));
         
-        if (object_config.support_interface_top_layers.value == 0) {
+        if (this->num_top_interface_layers == 0 && this->num_bottom_interface_layers == 0) {
             // No interface layers allowed, print everything with the base support pattern.
             this->support_material_interface_flow = this->support_material_flow;
         }
@@ -120,8 +120,8 @@ struct SupportParameters {
         this->raft_interface_density = std::min(1., this->raft_interface_flow.spacing() / raft_interface_spacing);
         this->support_spacing = object_config.support_base_pattern_spacing.value + this->support_material_flow.spacing();
         this->support_density = std::min(1., this->support_material_flow.spacing() / this->support_spacing);
-        if (object_config.support_interface_top_layers.value == 0) {
+        if (this->num_top_interface_layers == 0) {
-            // No interface layers allowed, print everything with the base support pattern.
+            // No top interface layers allowed; keep unused top interface parameters aligned with base support.
             this->top_interface_spacing = this->support_spacing;
             this->top_interface_density = this->support_density;
         }
@@ -133,16 +133,20 @@ struct SupportParameters {
             this->support_density > 0.95 || this->with_sheath ? ipRectilinear : ipSupportBase;
         this->interface_fill_pattern = (this->top_interface_density > 0.95 ? ipRectilinear : ipSupportBase);
         this->raft_interface_fill_pattern = this->raft_interface_density > 0.95 ? ipRectilinear : ipSupportBase;
+        const coordf_t contact_interface_density = this->num_top_interface_layers > 0 ?
+            this->top_interface_density : this->bottom_interface_density;
+        const bool zero_gap_contact_interface = this->num_top_interface_layers > 0 ?
+            this->zero_gap_interface_top : this->zero_gap_interface_bottom;
         if (object_config.support_interface_pattern == smipGrid)
             this->contact_fill_pattern = ipGrid;
         else if (object_config.support_interface_pattern == smipRectilinearInterlaced)
             this->contact_fill_pattern = ipRectilinear;
         else
             this->contact_fill_pattern =
-            (object_config.support_interface_pattern == smipAuto && this->zero_gap_interface_top) ||
+            (object_config.support_interface_pattern == smipAuto && zero_gap_contact_interface) ||
             object_config.support_interface_pattern == smipConcentric ?
             ipConcentric :
-            (this->top_interface_density > 0.95 ? ipRectilinear : ipSupportBase);
+            (contact_interface_density > 0.95 ? ipRectilinear : ipSupportBase);
 
         this->raft_angle_1st_layer  = 0.f;
         this->raft_angle_base       = 0.f;
@@ -188,6 +192,7 @@ struct SupportParameters {
                                                                                                           std::numeric_limits<double>::max();
 
         support_style = object_config.support_style;
+        support_interface_pattern = object_config.support_interface_pattern;
         if (support_style != smsDefault) {
             if ((support_style == smsSnug || support_style == smsGrid) && is_tree(object_config.support_type)) support_style = smsDefault;
             if ((support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid || support_style == smsTreeOrganic) &&
@@ -211,9 +216,9 @@ struct SupportParameters {
     bool                    has_top_contacts;
     // Is there at least a bottom contact layer extruded below support base?
     bool                    has_bottom_contacts;
-    // Number of top interface layers without counting the contact layer.
+    // User-configured number of top interface layers, including the contact layer.
     size_t                  num_top_interface_layers;
-    // Number of bottom interface layers without counting the contact layer.
+    // User-configured number of bottom interface layers, including the contact layer.
     size_t                  num_bottom_interface_layers;
     // Number of top base interface layers.
     size_t                  num_top_base_interface_layers;
@@ -235,7 +240,7 @@ struct SupportParameters {
 	Flow 					support_material_interface_flow;
 	// Flow at the bottom interfaces and contacts.
 	Flow 					support_material_bottom_interface_flow;
-	// Flow at raft inteface & contact layers.
+	// Flow at raft interface & contact layers.
 	Flow    				raft_interface_flow;
     coordf_t support_extrusion_width;
 	// Is merging of regions allowed? Could the interface & base support regions be printed with the same extruder?
@@ -262,6 +267,7 @@ struct SupportParameters {
     // Density of the base support layers.
     coordf_t 				support_density;
     SupportMaterialStyle    support_style = smsDefault;
+    SupportMaterialInterfacePattern support_interface_pattern = smipAuto;
 
     // Pattern of the sparse infill including sparse raft layers.
     InfillPattern           base_fill_pattern;
@@ -280,9 +286,33 @@ struct SupportParameters {
     float 					raft_angle_base;
     float 					raft_angle_interface;
 
-    // Produce a raft interface angle for a given SupportLayer::interface_id()
+    // Produce a +/-45deg alternating raft interface angle for a given SupportLayer::interface_id().
     float 					raft_interface_angle(size_t interface_id) const 
-    	{ return this->raft_angle_interface + ((interface_id & 1) ? float(- M_PI / 4.) : float(+ M_PI / 4.)); }
+    	{ return this->raft_angle_interface + ((interface_id & 1) ? float(- M_PI_4) : float(+ M_PI_4)); }
+
+    // Produce support interface angle for a given SupportLayer::interface_id().
+    // Angle will be shifted/rotated based on interface pattern.
+    float 					support_interface_angle(size_t interface_id) const 
+    	{ 
+            float angle;
+            
+            switch (this->support_interface_pattern) {
+                case SupportMaterialInterfacePattern::smipRectilinear:
+                    angle = support_style == SupportMaterialStyle::smsSnug ? this->interface_angle - float(M_PI_4) : this->interface_angle;
+                    break;
+                case SupportMaterialInterfacePattern::smipRectilinearInterlaced:
+                    angle = this->interface_angle + ((interface_id & 1) ? float(M_PI_4) : float(-M_PI_4));
+                    break;
+                case SupportMaterialInterfacePattern::smipGrid:
+                    angle = this->base_angle;
+                    break;
+                default:
+                    angle = this->interface_angle;
+                    break;
+            }
+
+            return angle;
+        }
 		
     bool independent_layer_height = false;
     const double thresh_big_overhang = Slic3r::sqr(scale_(10));

src/libslic3r/Support/TreeModelVolumes.cpp

@@ -469,7 +469,7 @@ void TreeModelVolumes::calculateCollision(const coord_t radius, const LayerIndex
             });
 
             // 2) Sum over top / bottom ranges.
-            const bool processing_last_mesh = outline_idx == layer_outline_indices.size();
+            const bool processing_last_mesh = outline_idx == layer_outline_indices.back();
             tbb::parallel_for(tbb::blocked_range<LayerIndex>(data.begin(), data.end()),
                 [&collision_areas_offsetted, &outlines, &machine_border = m_machine_border, &anti_overhang = m_anti_overhang, radius, 
                     xy_distance, z_distance_bottom_layers, z_distance_top_layers, min_resolution = m_min_resolution, &data, processing_last_mesh, &throw_on_cancel]

src/libslic3r/Support/TreeSupport.cpp

@@ -1511,7 +1511,9 @@ void TreeSupport::generate_toolpaths()
                     // ORCA: reset interface Fill state per area group to keep angles deterministic.
                     filler_interface->fixed_angle = false;
                     filler_interface->layer_id = size_t(-1);
-                    filler_interface->angle = base_support_angle + M_PI_2; // default interface angle is perpendicular to support angle
+                    filler_Roof1stLayer->fixed_angle = false;
+                    filler_Roof1stLayer->layer_id = size_t(-1);
+                    filler_interface->angle = m_support_params.support_interface_angle(area_group.interface_id);
                     if (area_group.type != SupportLayer::BaseType) {
                         // interface
                         if (layer_id == 0) {
@@ -1537,8 +1539,10 @@ void TreeSupport::generate_toolpaths()
                         fill_params.density = interface_density;
                         // Note: spacing means the separation between two lines as if they are tightly extruded
                         filler_Roof1stLayer->spacing = interface_flow.spacing();
-                        filler_Roof1stLayer->angle = base_support_angle;
+                        filler_Roof1stLayer->angle = m_support_params.support_interface_angle(area_group.interface_id);
                         fill_params.dont_sort = true;
+                        filler_Roof1stLayer->fixed_angle = (m_object_config->support_interface_pattern == smipRectilinearInterlaced ||
+                                                            m_object_config->support_interface_pattern == smipRectilinear);
                         Flow interface_base_flow = interface_as_base ? support_flow : interface_flow;
                         ExtrusionRole interface_role = interface_as_base ? erSupportMaterial : erSupportMaterialInterface;
                         // generate a perimeter first to support interface better
@@ -1556,18 +1560,11 @@ void TreeSupport::generate_toolpaths()
                         fill_params.density = bottom_interface_density;
                         filler_interface->spacing = interface_flow.spacing();
 
-                        if (m_object_config->support_interface_pattern == smipGrid) {
+                        fill_params.dont_sort = (m_object_config->support_interface_pattern == smipGrid ||
-                            filler_interface->angle = base_support_angle;
+                                                m_object_config->support_interface_pattern == smipRectilinearInterlaced);   
-                            fill_params.dont_sort = true;
-                        }
-
-                        if (m_object_config->support_interface_pattern == smipRectilinearInterlaced) {
-                            // ORCA: explicit 0/90 alternation for rectilinear interlaced interfaces.
-                            filler_interface->fixed_angle = true;
-                            filler_interface->angle = base_support_angle + ((area_group.interface_id & 1) * M_PI_2);
-                            fill_params.dont_sort = true;
-                        }
 
+                        filler_interface->fixed_angle = (m_object_config->support_interface_pattern == smipRectilinearInterlaced ||
+                                                        m_object_config->support_interface_pattern == smipRectilinear);
 
                         Flow interface_base_flow = interface_as_base ? support_flow : interface_flow;
                         ExtrusionRole interface_role = interface_as_base ? erSupportMaterial : erSupportMaterialInterface;
@@ -1579,17 +1576,11 @@ void TreeSupport::generate_toolpaths()
                         fill_params.density       = interface_density;
                         filler_interface->spacing = interface_flow.spacing();
 
-                        if (m_object_config->support_interface_pattern == smipGrid) {
+                        fill_params.dont_sort = (m_object_config->support_interface_pattern == smipGrid ||
-                            filler_interface->angle = base_support_angle;
+                                                m_object_config->support_interface_pattern == smipRectilinearInterlaced);   
-                            fill_params.dont_sort = true;
-                        }
 
-                        if (m_object_config->support_interface_pattern == smipRectilinearInterlaced) {
+                        filler_interface->fixed_angle = (m_object_config->support_interface_pattern == smipRectilinearInterlaced ||
-                            // ORCA: explicit 0/90 alternation for rectilinear interlaced interfaces.
+                                                        m_object_config->support_interface_pattern == smipRectilinear);
-                            filler_interface->fixed_angle = true;
-                            filler_interface->angle = base_support_angle + ((area_group.interface_id & 1) * M_PI_2);
-                            fill_params.dont_sort = true;
-                        }
 
                         Flow interface_base_flow = interface_as_base ? support_flow : interface_flow;
                         ExtrusionRole interface_role = interface_as_base ? erSupportMaterial : erSupportMaterialInterface;
@@ -2014,6 +2005,9 @@ void TreeSupport::draw_circles()
     // generate areas
     const coordf_t layer_height = config.layer_height.value;
     const size_t top_interface_layers = m_support_params.num_top_interface_layers;
+    const int top_base_interface_layers = std::min<int>(
+        int(m_support_params.num_top_base_interface_layers),
+        top_interface_layers > 0 ? int(top_interface_layers) - 1 : 0);
     const size_t bottom_interface_layers = number_of_support_interface_bottom_layers(config);
     const double nozzle_diameter = m_object->print()->config().nozzle_diameter.get_at(0);
     const coordf_t line_width = config.get_abs_value("support_line_width", nozzle_diameter);
@@ -2054,12 +2048,14 @@ void TreeSupport::draw_circles()
 
                 ExPolygons& base_areas = ts_layer->base_areas;
                 ExPolygons& roof_areas = ts_layer->roof_areas;
+                ExPolygons roof_base_areas;
                 ExPolygons& roof_1st_layer = ts_layer->roof_1st_layer;
                 ExPolygons& floor_areas = ts_layer->floor_areas;
                 ExPolygons& roof_gap_areas = ts_layer->roof_gap_areas;
                 coordf_t         max_layers_above_base = 0;
                 coordf_t         max_layers_above_roof = 0;
                 coordf_t         max_layers_above_roof1 = 0;
+                size_t           first_base_roof_area = 0;
                 bool             floor_interface_as_base = false;
                 bool has_circle_node = false;
                 bool need_extra_wall = false;
@@ -2094,8 +2090,6 @@ void TreeSupport::draw_circles()
                         break;
 
                     const SupportNode& node = *p_node;
-                    // ORCA: Cap top interface height in mm based on per-node support layer height.
-                    const coordf_t top_interface_height = coordf_t(top_interface_layers) * node.height;
                     ExPolygons area;
                     // Generate directly from overhang polygon if one of the following is true:
                     // 1) node is a normal part of hybrid support
@@ -2159,18 +2153,16 @@ void TreeSupport::draw_circles()
 
                     if (obj_layer_nr>0 && node.distance_to_top < 0)
                         append(roof_gap_areas, area);
-                    // ORCA: Roof1stLayer must also fit inside the mm cap.
                     else if (obj_layer_nr > 0 && node.support_roof_layers_below == 1 &&
-                             (node.dist_mm_to_top - this->top_z_distance) < top_interface_height + EPSILON && node.is_sharp_tail==false)
+                             node.is_sharp_tail == false)
                     {
                         append(roof_1st_layer, area);
                         max_layers_above_roof1 = std::max(max_layers_above_roof1, node.dist_mm_to_top);
                     }
-                    // ORCA: Roof layers must also fit inside the mm cap.
                     else if (obj_layer_nr > 0 && node.support_roof_layers_below > 1 &&
-                             (node.dist_mm_to_top - this->top_z_distance) < top_interface_height + EPSILON && node.is_sharp_tail == false)
+                             node.is_sharp_tail == false)
                     {
-                        append(roof_areas, area);
+                        append(node.support_roof_layers_below <= top_base_interface_layers ? roof_base_areas : roof_areas, area);
                         max_layers_above_roof = std::max(max_layers_above_roof, node.dist_mm_to_top);
                     }
                     else
@@ -2184,9 +2176,17 @@ void TreeSupport::draw_circles()
                 //m_object->print()->set_status(65, (boost::format( _u8L("Support: generate polygons at layer %d")) % layer_nr).str());
 
                 // join roof segments
-                roof_areas     = diff_clipped(offset2_ex(roof_areas, line_width_scaled, -line_width_scaled), get_collision(false));
+                roof_areas     = diff_clipped(closing_ex(roof_areas, line_width_scaled), get_collision(false));
                 roof_areas     = intersection_ex(roof_areas, m_machine_border);
-                roof_1st_layer = diff_clipped(offset2_ex(roof_1st_layer, line_width_scaled, -line_width_scaled), get_collision(false));
+                roof_base_areas = diff_clipped(closing_ex(roof_base_areas, line_width_scaled), get_collision(false));
+                roof_base_areas = intersection_ex(roof_base_areas, m_machine_border);
+                if (!roof_base_areas.empty() && !roof_areas.empty())
+                    roof_base_areas = diff_ex(roof_base_areas,
+                        ClipperUtils::clip_clipper_polygons_with_subject_bbox(roof_areas, get_extents(roof_base_areas)));
+
+                first_base_roof_area = roof_areas.size();
+                append(roof_areas, std::move(roof_base_areas));
+                roof_1st_layer = diff_clipped(closing_ex(roof_1st_layer, line_width_scaled), get_collision(false));
 
                 // roof_1st_layer and roof_areas may intersect, so need to subtract roof_areas from roof_1st_layer
                 roof_1st_layer = diff_ex(roof_1st_layer, ClipperUtils::clip_clipper_polygons_with_subject_bbox(roof_areas,get_extents(roof_1st_layer)));
@@ -2366,9 +2366,11 @@ void TreeSupport::draw_circles()
                     area_groups.back().need_infill = overlaps({ expoly }, area_poly);
                     area_groups.back().need_extra_wall = need_extra_wall && !area_groups.back().need_infill;
                 }
-                for (auto& expoly : ts_layer->roof_areas) {
+                for (size_t roof_idx = 0; roof_idx < ts_layer->roof_areas.size(); ++roof_idx) {
+                    auto &expoly = ts_layer->roof_areas[roof_idx];
                     //if (area(expoly) < SQ(scale_(1))) continue;
                     area_groups.emplace_back(&expoly, SupportLayer::RoofType, max_layers_above_roof);
+                    area_groups.back().interface_as_base = roof_idx >= first_base_roof_area;
                 }
                 for (auto &expoly : ts_layer->floor_areas) {
                     //if (area(expoly) < SQ(scale_(1))) continue;
@@ -2378,6 +2380,7 @@ void TreeSupport::draw_circles()
                 for (auto &expoly : ts_layer->roof_1st_layer) {
                     //if (area(expoly) < SQ(scale_(1))) continue;
                     area_groups.emplace_back(&expoly, SupportLayer::Roof1stLayer, max_layers_above_roof1);
+                    area_groups.back().interface_as_base = top_base_interface_layers > 0;
                 }
 
                 for (auto &area_group : area_groups) {
@@ -2406,7 +2409,6 @@ void TreeSupport::draw_circles()
             }
         });
         // ORCA: normalize interface_id sequencing to follow printed interface layers only.
-        const int top_base_layers = int(m_support_params.num_top_base_interface_layers);
         const bool interlaced = m_object_config->support_interface_pattern == smipRectilinearInterlaced;
         int roof_interface_id = 0;
         int floor_interface_id = 0;
@@ -2425,7 +2427,6 @@ void TreeSupport::draw_circles()
                 if (area_group.type == SupportLayer::RoofType || area_group.type == SupportLayer::Roof1stLayer) {
                     if (interlaced)
                         area_group.interface_id = roof_interface_id;
-                    area_group.interface_as_base = top_base_layers > 0 && roof_interface_id < top_base_layers;
                     has_roof_interface = true;
                 } else if (area_group.type == SupportLayer::FloorType) {
                     if (interlaced)
@@ -2897,7 +2898,7 @@ void TreeSupport::drop_nodes()
                     node_parent->merged_neighbours.push_front(node_parent == p_node ? neighbour : p_node);
                     const bool to_buildplate = !is_inside_ex(get_collision(0, obj_layer_nr_next), next_position);
                     SupportNode* next_node = m_ts_data->create_node(next_position, node_parent->distance_to_top + 1, obj_layer_nr_next,
-                        node_parent->support_roof_layers_below - (node_parent->distance_to_top > 0 ? 1 : 0),
+                        node_parent->support_roof_layers_below - (node_parent->distance_to_top >= 0 ? 1 : 0),
                         to_buildplate, node_parent, print_z_next, height_next);
                     get_max_move_dist(next_node);
                     m_ts_data->m_mutex.lock();
@@ -2949,7 +2950,7 @@ void TreeSupport::drop_nodes()
                     for(auto& overhang:overhangs_next) {
                         Point        next_pt     = overhang.contour.centroid();
                         SupportNode *next_node   = m_ts_data->create_node(next_pt, p_node->distance_to_top + 1, obj_layer_nr_next,
-                                                                          p_node->support_roof_layers_below - (p_node->distance_to_top > 0 ? 1 : 0),
+                                                                          p_node->support_roof_layers_below - (p_node->distance_to_top >= 0 ? 1 : 0),
                                                                           to_buildplate, p_node, print_z_next, height_next);
                         next_node->max_move_dist = 0;
                         next_node->overhang = std::move(overhang);
@@ -3096,7 +3097,7 @@ void TreeSupport::drop_nodes()
                 auto              next_collision = get_collision(0, obj_layer_nr_next);
                 const bool   to_buildplate  = !is_inside_ex(m_ts_data->m_layer_outlines[obj_layer_nr_next], next_layer_vertex);
                 SupportNode *     next_node     = m_ts_data->create_node(next_layer_vertex, node.distance_to_top + 1, obj_layer_nr_next,
-                    node.support_roof_layers_below - (node.distance_to_top > 0 ? 1 : 0),
+                    node.support_roof_layers_below - (node.distance_to_top >= 0 ? 1 : 0),
                     to_buildplate, p_node, print_z_next, height_next);
                 // don't increase radius if next node will collide partially with the object (STUDIO-7883)
                 to_outside             = projection_onto(next_collision, next_node->position);
@@ -3376,21 +3377,6 @@ std::vector<LayerHeightData> TreeSupport::plan_layer_heights()
         }
     }
 
-    // ORCA: Recompute support_roof_layers_below from remaining interface height (independent heights).
-    const int top_layers = m_object->config().support_interface_top_layers.value;
-    if (m_support_params.independent_layer_height && top_layers > 0) {
-        const coordf_t interface_height_mm = coordf_t(top_layers) * m_slicing_params.layer_height;
-        for (int layer_nr = 0; layer_nr < contact_nodes.size(); layer_nr++) {
-            if (contact_nodes[layer_nr].empty()) continue;
-            for (SupportNode *node : contact_nodes[layer_nr]) {
-                if (node->height <= EPSILON) continue;
-                const coordf_t remaining_mm = interface_height_mm - (node->dist_mm_to_top - this->top_z_distance);
-                const int layers_fit = remaining_mm < -EPSILON ? 0 : int(std::floor((remaining_mm + EPSILON) / node->height));
-                node->support_roof_layers_below = std::min(layers_fit, top_layers);
-            }
-        }
-    }
-
     // log layer_heights
     for (size_t i = 0; i < layer_heights.size(); i++) {
         //if (layer_heights[i].height > EPSILON)
@@ -3498,7 +3484,7 @@ void TreeSupport::generate_contact_points()
                 if (force_add || !already_inserted.count(hash_pos)) {
                     already_inserted.emplace(hash_pos);
                     bool to_buildplate = true;
-                    size_t roof_layers = add_interface ? (support_roof_layers > 0 ? support_roof_layers - 1 : 0) : 0;  // subtract 1 because the contact node itself counts as one layer
+                    size_t roof_layers = add_interface ? support_roof_layers : 0;
                     // add a new node as a virtual node which acts as the invisible gap between support and object
                     // distance_to_top=-1: it's virtual
                     // print_z=object_layer->bottom_z: it directly contacts the bottom

src/libslic3r/Support/TreeSupport3D.cpp

@@ -706,7 +706,7 @@ static std::optional<std::pair<Point, size_t>> polyline_sample_next_point_at_dis
     filler->spacing  = flow.spacing();
     filler->angle = roof ?
         //fixme support_layer.interface_id() instead of layer_idx
-        (support_params.interface_angle + (layer_idx & 1) ? float(- M_PI / 4.) : float(+ M_PI / 4.)) :
+        (support_params.interface_angle + ((layer_idx & 1) ? float(- M_PI_4) : float(+ M_PI_4))) :
         support_params.base_angle;
 
     // ORCA: use top-specific interface density after separating top/bottom settings.

src/libslic3r/Support/TreeSupportCommon.hpp

@@ -62,7 +62,7 @@ struct TreeSupportMeshGroupSettings {
         this->support_line_width        = support_material_flow(&print_object, config.layer_height).scaled_width();
         this->support_roof_line_width   = support_material_interface_flow(&print_object, config.layer_height).scaled_width();
         const int bottom_interface_layers = number_of_support_interface_bottom_layers(config);
-        this->support_bottom_enable     = config.support_interface_top_layers.value > 0 && bottom_interface_layers > 0;
+        this->support_bottom_enable     = bottom_interface_layers > 0;
         this->support_bottom_height     = this->support_bottom_enable ?
             bottom_interface_layers * this->layer_height :
             0;
@@ -705,7 +705,7 @@ public:
     SupportGeneratorLayersPtr&  top_contacts_mutable() { return this->top_contacts; }
 
 public:
-    // Insert the contact layer and some of the inteface and base interface layers below.
+    // Insert the contact layer and some of the interface and base interface layers below.
     void add_roofs(std::vector<Polygons> &&new_roofs, const size_t insert_layer_idx)
     {
         if (! new_roofs.empty()) {

src/libslic3r/Utils.hpp

@@ -722,15 +722,6 @@ void copy_directory_recursively(const boost::filesystem::path& source,
                                 std::function<bool(const std::string)> filter = nullptr,
                                 bool merge_mode                               = false);
 
-// Install vendor bundles from resources directory to data directory
-// bundle_names: vector of vendor bundle names (without .json extension)
-// resource_subdir: subdirectory under resources_dir() (default: "profiles")
-// data_subdir: subdirectory under data_dir() (default: "system")
-// Returns: true if all bundles installed successfully, false otherwise
-bool install_vendor_bundles_from_resources(const std::vector<std::string>& bundle_names,
-                                           const std::string& resource_subdir = "profiles",
-                                           const std::string& data_subdir     = "system");
-
 // Orca: Since 1.7.9 Boost deprecated save_string_file and load_string_file, copy and modified from boost 1.7.8
 void save_string_file(const boost::filesystem::path& p, const std::string& str);
 void load_string_file(const boost::filesystem::path& p, std::string& str);

src/libslic3r/calib.hpp

@@ -42,10 +42,22 @@ struct Calib_Params
     std::string shaper_type;
     std::vector<double> accelerations;
     std::vector<double> speeds;
+    // Resolved layer height for the VFA tower (0 = auto: nozzle_diameter / 2). Each speed block is a
+    // fixed number of layers tall, so this also determines the physical block height / tower height.
+    double vfa_layer_height = 0.0;
+    // Scale the calibration model to the nozzle diameter and set the layer height accordingly (temp tower / VFA).
+    // When false the 0.4 mm / 0.2 mm reference model is printed as-is.
+    bool nozzle_based_resize = true;
 
     CalibMode mode;
 };
 
+// Number of printed layers per speed block in the VFA tower. The base model has 5 mm blocks designed
+// for a 0.2 mm layer height (0.4 mm nozzle), i.e. 25 layers per block.
+static constexpr int vfa_layers_per_block = 25;
+static constexpr double vfa_base_block_height = 5.0;
+static constexpr double vfa_base_nozzle_diameter = 0.4;
+
 enum FlowRatioCalibrationType {
     COMPLETE_CALIBRATION = 0,
     FINE_CALIBRATION,

src/libslic3r/utils.cpp

@@ -1724,76 +1724,6 @@ void copy_directory_recursively(const boost::filesystem::path& source,
     return;
 }
 
-bool install_vendor_bundles_from_resources(
-    const std::vector<std::string>& bundle_names,
-    const std::string& resource_subdir,
-    const std::string& data_subdir)
-{
-    namespace fs = boost::filesystem;
-
-    fs::path rsrc_path = fs::path(Slic3r::resources_dir()) / resource_subdir;
-    fs::path vendor_path = fs::path(Slic3r::data_dir()) / data_subdir;
-
-    BOOST_LOG_TRIVIAL(info) << "Installing " << bundle_names.size() << " bundles from resources...";
-
-    for (const auto &bundle : bundle_names) {
-        try {
-            // Install the JSON file
-            auto path_in_rsrc = (rsrc_path / bundle).replace_extension(".json");
-            auto path_in_vendors = (vendor_path / bundle).replace_extension(".json");
-
-            if (!fs::exists(path_in_rsrc)) {
-                BOOST_LOG_TRIVIAL(warning) << "Bundle not found in resources: " << bundle;
-                return false;
-            }
-
-            // Create target directory if needed
-            if (!fs::exists(vendor_path))
-                fs::create_directories(vendor_path);
-
-            // Copy JSON file
-            std::string error_message;
-            CopyFileResult cfr = copy_file(path_in_rsrc.string(), path_in_vendors.string(), error_message, false);
-            if (cfr != CopyFileResult::SUCCESS) {
-                BOOST_LOG_TRIVIAL(error) << "Failed to copy " << bundle << ".json: " << error_message;
-                return false;
-            }
-
-            // Copy the vendor directory (if it exists)
-            auto dir_in_rsrc = rsrc_path / bundle;
-            auto dir_in_vendors = vendor_path / bundle;
-
-            if (fs::exists(dir_in_rsrc) && fs::is_directory(dir_in_rsrc)) {
-                // Remove existing directory
-                if (fs::exists(dir_in_vendors))
-                    fs::remove_all(dir_in_vendors);
-                fs::create_directories(dir_in_vendors);
-
-                // Copy with file filter (same as PresetUpdater::install_bundles_rsrc)
-                // Filter out certain file types: .stl, .png, .svg, .jpeg, .jpg, .3mf
-                auto file_filter = [](const std::string name) -> bool {
-                    return boost::iends_with(name, ".stl") ||
-                           boost::iends_with(name, ".png") ||
-                           boost::iends_with(name, ".svg") ||
-                           boost::iends_with(name, ".jpeg") ||
-                           boost::iends_with(name, ".jpg") ||
-                           boost::iends_with(name, ".3mf");
-                };
-
-                copy_directory_recursively(dir_in_rsrc, dir_in_vendors, file_filter);
-            }
-
-            BOOST_LOG_TRIVIAL(info) << "Successfully installed bundle: " << bundle;
-
-        } catch (const std::exception& e) {
-            BOOST_LOG_TRIVIAL(error) << "Exception installing bundle " << bundle << ": " << e.what();
-            return false;
-        }
-    }
-
-    return true;
-}
-
 void save_string_file(const boost::filesystem::path& p, const std::string& str)
 {
     boost::nowide::ofstream file;

src/slic3r/Config/Snapshot.cpp

@@ -432,14 +432,9 @@ const Snapshot&	SnapshotDB::take_snapshot(const AppConfig &app_config, Snapshot:
                 cfg.models_variants_installed.erase(it ++);
             else
                 ++ it;
-        // Read the active config bundle, parse the config version.
+        // Orca: the version the vendor is installed at, read from its profile or —
-        PresetBundle bundle;
+        // where the cache is the whole installation — from the cache's own stamp.
-        //BBS: change directoties by design
+        cfg.version.config_version = installed_vendor_version(cfg.name);
-        //bundle.load_configbundle((data_dir / PRESET_SYSTEM_DIR / (cfg.name + ".ini")).string(), PresetBundle::LoadConfigBundleAttribute::LoadVendorOnly, ForwardCompatibilitySubstitutionRule::EnableSilent);
-        bundle.load_vendor_configs_from_json((data_dir/PRESET_SYSTEM_DIR).string(), cfg.name, PresetBundle::LoadConfigBundleAttribute::LoadVendorOnly, ForwardCompatibilitySubstitutionRule::EnableSilent);
-        for (const auto &vp : bundle.vendors)
-            if (vp.second.id == cfg.name)
-                cfg.version.config_version = vp.second.config_version;
         snapshot.vendor_configs.emplace_back(std::move(cfg));
     }
 

src/slic3r/GUI/BindDialog.cpp

@@ -192,7 +192,7 @@ PingCodeBindDialog::PingCodeBindDialog(Plater* plater /*= nullptr*/)
 
 
 
-    SetSizer(sizer_main);
+    SetSizerAndFit(sizer_main);
     Layout();
     Fit();
 
@@ -670,7 +670,7 @@ PingCodeBindDialog::~PingCodeBindDialog() {
      m_sizer_main->Add(m_sw_bind_failed_info, 0, wxALIGN_CENTER, 0);
      m_sizer_main->Add(m_simplebook, 0, wxALIGN_RIGHT | wxRIGHT | wxBOTTOM, ButtonProps::ChoiceButtonGap());
 
-     SetSizer(m_sizer_main);
+     SetSizerAndFit(m_sizer_main);
      Layout();
      Fit();
      Centre(wxBOTH);
@@ -992,7 +992,7 @@ UnBindMachineDialog::UnBindMachineDialog(Plater *plater /*= nullptr*/)
      m_sizer_main->Add(m_sizer_button, 0, wxALIGN_RIGHT | wxRIGHT, ButtonProps::ChoiceButtonGap());
      m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(20));
 
-     SetSizer(m_sizer_main);
+     SetSizerAndFit(m_sizer_main);
      Layout();
      Fit();
      Centre(wxBOTH);

src/slic3r/GUI/CaliHistoryDialog.cpp

@@ -632,9 +632,8 @@ EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(wxWindow
 
     main_sizer->Add(top_panel, 1, wxEXPAND | wxALL, FromDIP(20));
 
-    SetSizer(main_sizer);
+    SetSizerAndFit(main_sizer);
     Layout();
-    Fit();
     CenterOnParent();
 
     wxGetApp().UpdateDlgDarkUI(this);
@@ -910,9 +909,8 @@ NewCalibrationHistoryDialog::NewCalibrationHistoryDialog(wxWindow *parent, const
 
     main_sizer->Add(top_panel, 1, wxEXPAND | wxALL, FromDIP(20));
 
-    SetSizer(main_sizer);
+    SetSizerAndFit(main_sizer);
     Layout();
-    Fit();
     CenterOnParent();
 
     wxGetApp().UpdateDlgDarkUI(this);

src/slic3r/GUI/Calibration.cpp

@@ -162,7 +162,7 @@ CalibrationDialog::CalibrationDialog(Plater *plater)
     body_panel->Layout();
 
     m_sizer_main->Add(body_panel, 0, wxEXPAND | wxALL, FromDIP(25));
-    SetSizer(m_sizer_main);
+    SetSizerAndFit(m_sizer_main);
     Layout();
     Fit();
 

src/slic3r/GUI/CloneDialog.cpp

@@ -112,9 +112,8 @@ CloneDialog::CloneDialog(wxWindow *parent)
 
     v_sizer->Add(bottom_sizer, 0, wxEXPAND);
 
-    this->SetSizer(v_sizer);
+    this->SetSizerAndFit(v_sizer);
     this->Layout();
-    v_sizer->Fit(this);
 
     wxGetApp().UpdateDlgDarkUI(this);
 

src/slic3r/GUI/ConfigWizard.cpp

@@ -66,41 +66,41 @@ using Config::SnapshotDB;
 
 // Configuration data structures extensions needed for the wizard
 //BBS: set BBL as default
-bool Bundle::load(fs::path source_path, bool ais_in_resources, bool ais_bbl_bundle)
+bool Bundle::load(fs::path dir, const std::string &vendor_name, bool ais_in_resources, bool ais_bbl_bundle)
 {
     this->preset_bundle = std::make_unique<PresetBundle>();
     this->is_in_resources = ais_in_resources;
     this->is_bbl_bundle = ais_bbl_bundle;
 
-    std::string path_string = source_path.string();
-    std::string parent_path = source_path.parent_path().string();
     //BBS: add json logic for vendor bundles
-    std::string vendor_name = source_path.filename().string();
+    // Orca: served from the vendor's preset cache where one covers it — which is
-    if (Slic3r::is_json_file(path_string)) {
+    // how a shipped build carries its vendors — and parsed from the JSONs otherwise.
-        // Remove the .json suffix.
+    // A vendor that can be neither read nor parsed — a cache the build cannot use
-        vendor_name.erase(vendor_name.size() - 5);
+    // with the preset JSONs behind it pruned, say — is one the wizard cannot offer.
-    }
+    // Every other vendor still can be, so it is left out rather than thrown over.
-    else
+    size_t presets_loaded = 0;
+    try {
+        auto [config_substitutions, loaded] = preset_bundle->load_vendor_configs_from_json(
+            dir.string(), vendor_name, PresetBundle::LoadConfigBundleAttribute::LoadSystem, ForwardCompatibilitySubstitutionRule::Disable);
+        UNUSED(config_substitutions);
+        // No substitutions shall be reported when loading a system config bundle, no substitutions are allowed.
+        assert(config_substitutions.empty());
+        presets_loaded = loaded;
+    } catch (const std::exception &e) {
+        BOOST_LOG_TRIVIAL(fatal) << boost::format("Vendor bundle: `%1%`: cannot be loaded, leaving it out: %2%") % vendor_name % e.what();
         return false;
-
+    }
-    // Throw when parsing invalid configuration. Only valid configuration is supposed to be provided over the air.
-    //BBS: add json logic for vendor bundles
-    auto [config_substitutions, presets_loaded] = preset_bundle->load_vendor_configs_from_json(
-        parent_path, vendor_name, PresetBundle::LoadConfigBundleAttribute::LoadSystem, ForwardCompatibilitySubstitutionRule::Disable);
-    UNUSED(config_substitutions);
-    // No substitutions shall be reported when loading a system config bundle, no substitutions are allowed.
-    assert(config_substitutions.empty());
     auto first_vendor = preset_bundle->vendors.begin();
     if (first_vendor == preset_bundle->vendors.end()) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No vendor information defined, cannot install.") % path_string;
+        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No vendor information defined, cannot install.") % vendor_name;
         return false;
     }
     if (presets_loaded == 0) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No profile loaded.") % path_string;
+        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No profile loaded.") % vendor_name;
         return false;
-    } 
+    }
 
-    BOOST_LOG_TRIVIAL(trace) << boost::format("Vendor bundle: `%1%`: %2% profiles loaded.") % path_string % presets_loaded;
+    BOOST_LOG_TRIVIAL(trace) << boost::format("Vendor bundle: `%1%`: %2% profiles loaded.") % vendor_name % presets_loaded;
     this->vendor_profile = &first_vendor->second;
     return true;
 }
@@ -125,15 +125,10 @@ BundleMap BundleMap::load()
 
     //Orca: add custom as default
     //Orca: add json logic for vendor bundle
-    auto orca_bundle_path = (vendor_dir / PresetBundle::ORCA_DEFAULT_BUNDLE).replace_extension(".json");
-    auto orca_bundle_rsrc = false;
-    if (!boost::filesystem::exists(orca_bundle_path)) {
-        orca_bundle_path = (rsrc_vendor_dir / PresetBundle::ORCA_DEFAULT_BUNDLE).replace_extension(".json");
-        orca_bundle_rsrc = true;
-    }
     {
+        const bool from_rsrc = ! is_vendor_installed(PresetBundle::ORCA_DEFAULT_BUNDLE);
         Bundle bbl_bundle;
-        if (bbl_bundle.load(std::move(orca_bundle_path), orca_bundle_rsrc, true))
+        if (bbl_bundle.load(from_rsrc ? rsrc_vendor_dir : vendor_dir, PresetBundle::ORCA_DEFAULT_BUNDLE, from_rsrc, true))
             res.emplace(PresetBundle::ORCA_DEFAULT_BUNDLE, std::move(bbl_bundle));
     }
 
@@ -141,18 +136,13 @@ BundleMap BundleMap::load()
     // and then additionally from resources/profiles.
     bool is_in_resources = false;
     for (auto dir : { &vendor_dir, &rsrc_vendor_dir }) {
-        for (const auto &dir_entry : boost::filesystem::directory_iterator(*dir)) {
+        for (const std::string &id : vendor_names_in(*dir)) {
-            //BBS: add json logic for vendor bundle
+            // Don't load this bundle if we've already loaded it.
-            if (Slic3r::is_json_file(dir_entry.path().string())) {
+            if (res.find(id) != res.end()) { continue; }
-                std::string id = dir_entry.path().stem().string();  // stem() = filename() without the trailing ".json" part
 
-                // Don't load this bundle if we've already loaded it.
+            Bundle bundle;
-                if (res.find(id) != res.end()) { continue; }
+            if (bundle.load(*dir, id, is_in_resources))
-
+                res.emplace(id, std::move(bundle));
-                Bundle bundle;
-                if (bundle.load(dir_entry.path(), is_in_resources))
-                    res.emplace(std::move(id), std::move(bundle));
-            }
         }
 
         is_in_resources = true;

src/slic3r/GUI/ConfigWizard_private.hpp

@@ -71,9 +71,11 @@ struct Bundle
 	Bundle() = default;
 	Bundle(Bundle&& other);
 
+	// Load the vendor `vendor_name` as it is installed in `dir`, from its preset
+	// cache or its profile JSONs, whichever is usable.
 	// Returns false if not loaded. Reason for that is logged as boost::log error.
 	//BBS: set BBL as default
-	bool load(fs::path source_path, bool is_in_resources, bool is_bbl_bundle = false);
+	bool load(fs::path dir, const std::string &vendor_name, bool is_in_resources, bool is_bbl_bundle = false);
 
 	const std::string& vendor_id() const { return vendor_profile->id; }
 };

src/slic3r/GUI/ConnectPrinter.cpp

@@ -80,9 +80,8 @@ ConnectPrinterDialog::ConnectPrinterDialog(wxWindow *parent, wxWindowID id, cons
 
     main_sizer->Add(sizer_top);
 
-    this->SetSizer(main_sizer);
+    this->SetSizerAndFit(main_sizer);
     this->Layout();
-    this->Fit();
     CentreOnParent();
 
     m_textCtrl_code->Bind(wxEVT_TEXT, &ConnectPrinterDialog::on_input_enter, this);

src/slic3r/GUI/CreatePresetsDialog.cpp

@@ -2201,25 +2201,14 @@ bool CreatePrinterPresetDialog::load_system_and_user_presets_with_curr_model(Pre
     } else {
         selected_vendor_id = m_printer_preset_vendor_selected.id;
 
-        if (boost::filesystem::exists(boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR / selected_vendor_id)) {
-            preset_path = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).string();
-        } else if (boost::filesystem::exists(boost::filesystem::path(Slic3r::resources_dir()) / "profiles" / selected_vendor_id)) {
-            preset_path = (boost::filesystem::path(Slic3r::resources_dir()) / "profiles").string();
-        }
-
-        if (preset_path.empty()) {
-            BOOST_LOG_TRIVIAL(info) << "Preset path was not found";
-            MessageDialog dlg(this, _L("Preset path was not found; please reselect vendor."), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"),
-                              wxYES_NO | wxYES_DEFAULT | wxCENTRE);
-            dlg.ShowModal();
-            return false;
-        }
-
         try {
             // Pass the app's preset bundle (which already holds OrcaFilamentLibrary) as the base
             // bundle so vendor filaments that inherit OFL bases resolve via the existing
             // cross-vendor inheritance path.
-            temp_preset_bundle.load_vendor_configs_from_json(preset_path, selected_vendor_id,
+            // Orca: served from the vendor's preset cache where one covers it — a shipped
+            // build carries that instead of the raw preset JSONs — and parsed otherwise.
+            temp_preset_bundle.load_vendor_configs_from_json((boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).string(),
+                                                             selected_vendor_id,
                                                              PresetBundle::LoadConfigBundleAttribute::LoadSystem,
                                                              ForwardCompatibilitySubstitutionRule::EnableSilent,
                                                              wxGetApp().preset_bundle);

src/slic3r/GUI/DownloadProgressDialog.cpp

@@ -112,9 +112,8 @@ DownloadProgressDialog::DownloadProgressDialog(wxString title)
     m_simplebook_status->AddPage(m_panel_download_failed, wxEmptyString, false);
     m_simplebook_status->AddPage(m_panel_install_failed, wxEmptyString, false);
 
-    SetSizer(m_sizer_main);
+    SetSizerAndFit(m_sizer_main);
     Layout();
-    Fit();
     CentreOnParent();
 
     Bind(wxEVT_CLOSE_WINDOW, &DownloadProgressDialog::on_close, this);

src/slic3r/GUI/ExtrusionCalibration.cpp

@@ -261,7 +261,7 @@ void ExtrusionCalibration::create()
     top_sizer->Add(FromDIP(24), 0);
     top_sizer->Add(sizer_main, 1, wxEXPAND);
     top_sizer->Add(FromDIP(24), 0);
-    SetSizer(top_sizer);
+    SetSizerAndFit(top_sizer);
 
     // set default nozzle
     m_comboBox_nozzle_dia->SetSelection(1);
@@ -271,7 +271,6 @@ void ExtrusionCalibration::create()
     set_step(1);
 
     Layout();
-    Fit();
 
     m_k_val->GetTextCtrl()->Bind(wxEVT_TEXT_ENTER, [this](wxCommandEvent& e) {
         input_value_finish();

src/slic3r/GUI/FilamentPickerDialog.cpp

@@ -105,9 +105,8 @@ FilamentPickerDialog::FilamentPickerDialog(wxWindow *parent, const wxString& fil
     container_sizer->Add(main_sizer, 1, wxEXPAND | wxALL, FromDIP(10));
     container_sizer->Add(dlg_btns, 0, wxEXPAND);
 
-    SetSizer(container_sizer);
+    SetSizerAndFit(container_sizer);
     Layout();
-    container_sizer->Fit(this);
 
     // Position the dialog relative to the parent window
     if (GetParent()) {

src/slic3r/GUI/GLCanvas3D.cpp

@@ -6047,10 +6047,10 @@ void GLCanvas3D::_render_3d_navigator()
     strcpy(style.AxisLabels[ImGuizmo::Axis::Axis_X], "Y"); // ORCA use uppercase to match text on tranform widgets
     strcpy(style.AxisLabels[ImGuizmo::Axis::Axis_Y], "Z"); // ORCA use uppercase to match text on tranform widgets
     strcpy(style.AxisLabels[ImGuizmo::Axis::Axis_Z], "X"); // ORCA use uppercase to match text on tranform widgets
-    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_FRONT], _utf8("Front").c_str());
+    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_FRONT], _u8L_CONTEXT("Front", "Camera View").c_str());
     strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_BACK], _u8L_CONTEXT("Back", "Camera View").c_str());
-    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_TOP], _utf8("Top").c_str());
+    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_TOP], _u8L_CONTEXT("Top", "Camera View").c_str());
-    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_BOTTOM], _utf8("Bottom").c_str());
+    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_BOTTOM], _u8L_CONTEXT("Bottom", "Camera View").c_str());
     strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_LEFT], _u8L_CONTEXT("Left", "Camera View").c_str());
     strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_RIGHT], _u8L_CONTEXT("Right", "Camera View").c_str());
 

src/slic3r/GUI/Gizmos/GLGizmoCut.cpp

@@ -3502,7 +3502,7 @@ static void check_objects_after_cut(const ModelObjectPtrs& objects)
         names += ", " + from_u8(err_objects_names[i]);
     WarningDialog(wxGetApp().plater(), format_wxstr(_L("Objects(%1%) have duplicated connectors. "
                                 "Some connectors may be missing in slicing result.\n"
-                                "Please report to PrusaSlicer team in which scenario this issue happened.\n"
+                                "Please report to the OrcaSlicer team in which scenario this issue happened.\n"
                                 "Thank you."), names)).ShowModal();
 }
 

src/slic3r/GUI/MainFrame.cpp

@@ -2654,14 +2654,14 @@ static void add_common_view_menu_items(wxMenu* view_menu, MainFrame* mainFrame,
         "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
     //view_menu->AppendSeparator();
     //TRN To be shown in the main menu View->Top
-    append_menu_item(view_menu, wxID_ANY, _L("Top") + "\t" + ctrl + "1", _L("Top View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("top"); },
+    append_menu_item(view_menu, wxID_ANY, _L_CONTEXT("Top", "Camera View") + "\t" + ctrl + "1", _L("Top View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("top"); },
         "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
     //TRN To be shown in the main menu View->Bottom
-    append_menu_item(view_menu, wxID_ANY, _L("Bottom") + "\t" + ctrl + "2", _L("Bottom View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("bottom"); },
+    append_menu_item(view_menu, wxID_ANY, _L_CONTEXT("Bottom", "Camera View") + "\t" + ctrl + "2", _L("Bottom View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("bottom"); },
         "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
-    append_menu_item(view_menu, wxID_ANY, _L("Front") + "\t" + ctrl + "3", _L("Front View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("front"); },
+    append_menu_item(view_menu, wxID_ANY, _L_CONTEXT("Front", "Camera View") + "\t" + ctrl + "3", _L("Front View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("front"); },
         "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
-    append_menu_item(view_menu, wxID_ANY, _L("Rear") + "\t" + ctrl + "4", _L("Rear View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("rear"); },
+    append_menu_item(view_menu, wxID_ANY, _L_CONTEXT("Rear", "Camera View") + "\t" + ctrl + "4", _L("Rear View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("rear"); },
         "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
     append_menu_item(view_menu, wxID_ANY, _L_CONTEXT("Left", "Camera View") + "\t" + ctrl + "5", _L("Left View"),[mainFrame](wxCommandEvent &) {mainFrame->select_view("left"); },
         "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);

src/slic3r/GUI/MsgDialog.cpp

@@ -65,7 +65,7 @@ MsgDialog::MsgDialog(wxWindow *parent, const wxString &title, const wxString &he
     main_sizer->Add(btn_sizer, 0, wxBOTTOM | wxRIGHT | wxEXPAND | wxTOP, FromDIP(10));
 
     apply_style(style);
-	SetSizerAndFit(main_sizer);
+	SetSizer(main_sizer);
     wxGetApp().UpdateDlgDarkUI(this);
 }
 
@@ -221,6 +221,7 @@ void MsgDialog::apply_style(long style)
 
 void MsgDialog::finalize()
 {
+    GetSizer()->SetSizeHints(this);
     Layout();
     Fit();
     CenterOnParent();
@@ -547,7 +548,7 @@ DeleteConfirmDialog::DeleteConfirmDialog(wxWindow *parent, const wxString &title
     m_del_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) { EndModal(wxID_OK); });
     m_cancel_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) { EndModal(wxID_CANCEL); });
 
-    SetSizer(m_main_sizer);
+    SetSizerAndFit(m_main_sizer);
     Layout();
     Fit();
     wxGetApp().UpdateDlgDarkUI(this);
@@ -582,7 +583,7 @@ Newer3mfVersionDialog::Newer3mfVersionDialog(wxWindow *parent, const Semver *fil
     main_sizer->Add(content_sizer, 0, wxEXPAND | wxALL, FromDIP(5));
     main_sizer->Add(get_btn_sizer(), 0, wxEXPAND | wxALL, FromDIP(5));
 
-    this->SetSizer(main_sizer);
+    this->SetSizerAndFit(main_sizer);
     Layout();
     Fit();
     wxGetApp().UpdateDlgDarkUI(this);
@@ -745,9 +746,8 @@ NetworkErrorDialog::NetworkErrorDialog(wxWindow* parent)
     sizer_main->Add(sizer_button, 1, wxEXPAND | wxLEFT | wxRIGHT, 15);
     sizer_main->Add(0, 0, 0, wxTOP, 18);
 
-    SetSizer(sizer_main);
+    SetSizerAndFit(sizer_main);
     Layout();
-    sizer_main->Fit(this);
     Centre(wxBOTH);
 }
 

src/slic3r/GUI/NetworkPluginDialog.cpp

@@ -47,6 +47,7 @@ NetworkPluginDownloadDialog::NetworkPluginDownloadDialog(wxWindow* parent, Mode
     } else {
         create_missing_plugin_ui();
     }
+    main_sizer->SetSizeHints(this);
     Layout();
     Fit();
     CentreOnParent();

src/slic3r/GUI/NetworkTestDialog.cpp

@@ -47,7 +47,7 @@ NetworkTestDialog::NetworkTestDialog(wxWindow* parent, wxWindowID id, const wxSt
 
 	init_bind();
 
-	this->SetSizer(main_sizer);
+	this->SetSizerAndFit(main_sizer);
 	this->Layout();
 
 	this->Centre(wxBOTH);

src/slic3r/GUI/PartSkipDialog.cpp

@@ -270,7 +270,7 @@ PartSkipDialog::PartSkipDialog(wxWindow *parent) : DPIDialog(parent, wxID_ANY, _
     m_simplebook->AddPage(m_book_third_panel, _("dialog page"), false);
     m_sizer->Add(m_simplebook, 1, wxEXPAND | wxALL, 5);
 
-    SetSizer(m_sizer);
+    SetSizerAndFit(m_sizer);
     m_zoom_in_btn->Bind(wxEVT_BUTTON, &PartSkipDialog::OnZoomIn, this);
     m_zoom_out_btn->Bind(wxEVT_BUTTON, &PartSkipDialog::OnZoomOut, this);
     m_switch_drag_btn->Bind(wxEVT_BUTTON, &PartSkipDialog::OnSwitchDrag, this);
@@ -281,7 +281,6 @@ PartSkipDialog::PartSkipDialog(wxWindow *parent) : DPIDialog(parent, wxID_ANY, _
     m_all_checkbox->Bind(wxEVT_TOGGLEBUTTON, &PartSkipDialog::OnAllCheckbox, this);
 
     Layout();
-    Fit();
     CentreOnParent();
 }
 

src/slic3r/GUI/Plater.cpp

@@ -14183,7 +14183,7 @@ void Plater::calib_temp(const Calib_Params& params) {
         }
     }
 
-    if (std::abs(nozzle_scale - 1.0) > EPSILON)
+    if (params.nozzle_based_resize && std::abs(nozzle_scale - 1.0) > EPSILON)
         model().objects[0]->scale(nozzle_scale, nozzle_scale, nozzle_scale);
 
     model().objects[0]->ensure_on_bed();
@@ -14191,7 +14191,9 @@ void Plater::calib_temp(const Calib_Params& params) {
     printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
     set_config_values<int, ConfigOptionInts>(filament_config, "nozzle_temperature_initial_layer", (int) start_temp);
     set_config_values<int, ConfigOptionInts>(filament_config, "nozzle_temperature", (int) start_temp);
-    model().objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(nozzle_diameter/2));
+    // When resizing is disabled the 0.4 mm / 0.2 mm reference model is printed as-is (preset layer height kept).
+    if (params.nozzle_based_resize)
+        model().objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(nozzle_diameter/2));
     model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
     model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(5.0));
     model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
@@ -14202,7 +14204,8 @@ void Plater::calib_temp(const Calib_Params& params) {
 
     auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
     print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
-    print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(nozzle_diameter/2));
+    if (params.nozzle_based_resize)
+        print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(nozzle_diameter/2));
 
 
     changed_objects({ 0 });
@@ -14366,6 +14369,42 @@ void Plater::calib_VFA(const Calib_Params& params)
     auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
     auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
     auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
+
+    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
+    size_t nozzle_id = static_cast<size_t>(std::max(params.extruder_id, 0));
+    double nozzle_diameter = vfa_base_nozzle_diameter;
+    if (nozzle_diameter_config && !nozzle_diameter_config->values.empty()) {
+        nozzle_id = std::min(nozzle_id, nozzle_diameter_config->values.size() - 1);
+        nozzle_diameter = nozzle_diameter_config->values[nozzle_id];
+    }
+    if (nozzle_diameter <= 0.0)
+        nozzle_diameter = vfa_base_nozzle_diameter;
+
+    // Resolved layer height: use the (possibly auto-adjusted) value from the dialog, else default to nozzle/2.
+    double layer_height = params.vfa_layer_height > 0.0 ? params.vfa_layer_height : nozzle_diameter / 2.0;
+
+    // cut upper (on the unscaled model, using the base block height); the scaling below keeps the physical
+    // block height (vfa_layers_per_block * layer_height) in sync with the speed stepping in GCode::process_layer.
+    // Subtract EPSILON (as the temperature tower does) so the cut lands just below the flat block surface instead
+    // of exactly on it, which would otherwise add a degenerate extra layer.
+    auto obj_bb = model().objects[0]->bounding_box_exact();
+    auto height = vfa_base_block_height * ((params.end - params.start) / params.step + 1) - EPSILON;
+    if (height < obj_bb.size().z()) {
+        cut_horizontal(0, 0, height, ModelObjectCutAttribute::KeepLower);
+    }
+
+    // When resizing is enabled, XY scales with the nozzle (footprint / line width) and Z scales so each base
+    // block becomes vfa_layers_per_block layers of the resolved layer height. When disabled the 0.4 mm / 0.2 mm
+    // reference model is printed as-is (preset layer height kept).
+    if (params.nozzle_based_resize) {
+        const double xy_scale = nozzle_diameter / vfa_base_nozzle_diameter;
+        const double z_scale  = (vfa_layers_per_block * layer_height) / vfa_base_block_height;
+        if (std::abs(xy_scale - 1.0) > EPSILON || std::abs(z_scale - 1.0) > EPSILON)
+            model().objects[0]->scale(xy_scale, xy_scale, z_scale);
+    }
+
+    model().objects[0]->ensure_on_bed();
+
     printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
     filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats { 0.0 });
     set_config_values<bool, ConfigOptionBoolsNullable>(print_config, "enable_overhang_speed", false);
@@ -14379,6 +14418,10 @@ void Plater::calib_VFA(const Calib_Params& params)
     print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
     print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
     print_config->set_key_value("precise_z_height", new ConfigOptionBool(false));
+    if (params.nozzle_based_resize) {
+        print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
+        model().objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
+    }
     model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
     model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
     model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
@@ -14389,14 +14432,11 @@ void Plater::calib_VFA(const Calib_Params& params)
     wxGetApp().get_tab(Preset::TYPE_PRINT)->update_ui_from_settings();
     wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_ui_from_settings();
 
-    // cut upper
+    // Pass the resolved layer height on (only meaningful when resized). GCode's VFA stepping is layer-based, so
-    auto obj_bb = model().objects[0]->bounding_box_exact();
+    // it does not require it, but keep it consistent with the geometry.
-    auto height = 5 * ((params.end - params.start) / params.step + 1);
+    Calib_Params calib_params = params;
-    if (height < obj_bb.size().z()) {
+    calib_params.vfa_layer_height = params.nozzle_based_resize ? layer_height : 0.0;
-        cut_horizontal(0, 0, height, ModelObjectCutAttribute::KeepLower);
+    p->background_process.fff_print()->set_calib_params(calib_params);
-    }
-
-    p->background_process.fff_print()->set_calib_params(params);
 }
 
 void Plater::calib_input_shaping_freq(const Calib_Params& params)
@@ -15094,7 +15134,7 @@ ProjectDropDialog::ProjectDropDialog(const std::string &filename)
 
     m_sizer_main->Add(dlg_btns, 0, wxEXPAND);
 
-    SetSizer(m_sizer_main);
+    SetSizerAndFit(m_sizer_main);
     Layout();
     Fit();
     Centre(wxBOTH);

src/slic3r/GUI/PrintOptionsDialog.cpp

@@ -28,7 +28,7 @@ PrintOptionsDialog::PrintOptionsDialog(wxWindow* parent)
 {
     this->SetDoubleBuffered(true);
     SetBackgroundColour(*wxWHITE);
-    SetSize(FromDIP(480),FromDIP(520));
+    // SetMinSize(FromDIP(wxSize{wxDefaultCoord,520}));
 
 
     m_scrollwindow = new wxScrolledWindow(this, wxID_ANY);
@@ -50,7 +50,8 @@ PrintOptionsDialog::PrintOptionsDialog(wxWindow* parent)
     m_scrollwindow->FitInside();
 
     this->Layout();
-    // mainSizer->Fit(this);
+    mainSizer->SetMinSize(wxDefaultCoord, FromDIP(520));
+    mainSizer->Fit(this);
     //this->Fit();
 
      m_cb_ai_monitoring->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent &evt) {
@@ -1670,12 +1671,9 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
     /*inset data*/
     sizer->Add(single_panel, 0, wxEXPAND, 0);
     sizer->Add(multiple_panel, 0, wxEXPAND, 0);
-    SetSizer(sizer);
-    Layout();
-    Fit();
-
     single_panel->Hide();
-
+    SetSizerAndFit(sizer);
+    Layout();
     wxGetApp().UpdateDlgDarkUI(this);
 }
 
@@ -1752,6 +1750,7 @@ bool PrinterPartsDialog::Show(bool show)
             }
         }
 
+        GetSizer()->SetSizeHints(this);
         Layout();
         Fit();
     }

src/slic3r/GUI/PublishDialog.cpp

@@ -119,7 +119,7 @@ PublishDialog::PublishDialog(Plater *plater)
     top_sizer->Add(m_main_sizer, 1, wxALL | wxEXPAND, 0);
     top_sizer->Add(FromDIP(30), 0, 0, wxEXPAND, 0);
 
-    this->SetSizer(top_sizer);
+    this->SetSizerAndFit(top_sizer);
     this->Layout();
 
     this->Centre(wxBOTH);

src/slic3r/GUI/StepMeshDialog.cpp

@@ -310,10 +310,9 @@ StepMeshDialog::StepMeshDialog(wxWindow* parent, Slic3r::Step& file, double line
 
     bSizer->Add(bSizer_button, 1, wxEXPAND);
 
-    this->SetSizer(bSizer);
+    this->SetSizerAndFit(bSizer);
     update_mesh_number_text();
     this->Layout();
-    bSizer->Fit(this);
 
     this->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
         SetFocusIgnoringChildren();

src/slic3r/GUI/TroubleshootDialog.cpp

@@ -354,7 +354,7 @@ TroubleshootDialog::TroubleshootDialog()
     m_sizer->AddSpacer(FromDIP(20));
     m_sizer->Add(right_sizer, 0, wxEXPAND | wxTOP | wxBOTTOM | wxRIGHT, FromDIP(15));
 
-    SetSizer(m_sizer);
+    SetSizerAndFit(m_sizer);
     Layout();
     Fit();
     CenterOnParent();

src/slic3r/GUI/TroubleshootDialog.hpp

@@ -168,6 +168,9 @@ private:
         }
         wxClientDC dc(this);
         int cWidth = GetClientSize().GetWidth();
+        // Don't compute/commit a size based on a not-yet-laid-out width
+        // Mirrors the guard in OnPaint() so both use the same wrap results
+        if (cWidth < 50) return;
 
         int y = 0;
         for (size_t i = 0; i < m_lines.size(); ++i) {

src/slic3r/GUI/UnsavedChangesDialog.cpp

@@ -773,7 +773,7 @@ std::vector<std::string> DiffViewCtrl::selected_options()
 
 static std::string none{"none"};
 #define UNSAVE_CHANGE_DIALOG_SCROLL_WINDOW_SIZE wxSize(FromDIP(490), FromDIP(374))
-#define UNSAVE_CHANGE_DIALOG_ACTION_LINE_SIZE wxSize(FromDIP(490), FromDIP(60))
+#define UNSAVE_CHANGE_DIALOG_ACTION_LINE_SIZE wxSize(FromDIP(490), -1)
 #define UNSAVE_CHANGE_DIALOG_FIRST_VALUE_WIDTH FromDIP(190)
 #define UNSAVE_CHANGE_DIALOG_VALUE_WIDTH FromDIP(150)
 #define UNSAVE_CHANGE_DIALOG_ITEM_HEIGHT FromDIP(24)
@@ -1075,11 +1075,6 @@ void UnsavedChangesDialog::build(Preset::Type type, PresetCollection *dependent_
     m_sizer_main->Add(m_sizer_button, 0, wxEXPAND | wxTOP, 6);
     m_sizer_main->Add(0, 0, 1, wxTOP, 18);
 
-    SetSizer(m_sizer_main);
-    Layout();
-    Fit();
-    Centre(wxBOTH);
-
     if (params) {
         if (params->left_to_right)
             update_tree(type, params->config, params->from, params->to);
@@ -1095,6 +1090,11 @@ void UnsavedChangesDialog::build(Preset::Type type, PresetCollection *dependent_
     //topSizer->SetSizeHints(this);
 
     show_info_line(Action::Undef);
+
+    SetSizerAndFit(m_sizer_main);
+    Layout();
+    Fit();
+    // Centre(wxBOTH);
 }
 
 void UnsavedChangesDialog::show_info_line(Action action, std::string preset_name)
@@ -1499,6 +1499,7 @@ void UnsavedChangesDialog::update(Preset::Type type, PresetCollection* dependent
     }
 
     m_action_line->SetLabel(action_msg);
+    m_action_line->Wrap(UNSAVE_CHANGE_DIALOG_SCROLL_WINDOW_SIZE.x);
 
     update_tree(type, presets);
     update_list();

src/slic3r/GUI/UpdateDialogs.cpp

@@ -213,9 +213,8 @@ MsgUpdateConfig::MsgUpdateConfig(const std::vector<Update> &updates, bool force_
     m_scrollwindw_release_note->Layout();
 
 
-    SetSizer(m_sizer_main);
+    SetSizerAndFit(m_sizer_main);
     Layout();
-    m_sizer_main->Fit(this);
 
     Centre(wxBOTH);
 	wxGetApp().UpdateDlgDarkUI(this);

src/slic3r/GUI/WebGuideDialog.cpp

@@ -1,7 +1,9 @@
 #include "WebGuideDialog.hpp"
 #include "ConfigWizard.hpp"
 
+#include <boost/algorithm/string/join.hpp>
 #include <boost/filesystem/operations.hpp>
+#include <boost/nowide/fstream.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/iostreams/detail/select.hpp>
 #include <boost/log/trivial.hpp>
@@ -9,6 +11,7 @@
 #include "I18N.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "libslic3r/Config.hpp"
+#include "libslic3r/Preset.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/wxExtensions.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
@@ -41,8 +44,6 @@ using namespace nlohmann;
 
 namespace Slic3r { namespace GUI {
 
-json m_ProfileJson;
-
 static wxString update_custom_filaments()
 {
     json m_Res                                                                     = json::object();
@@ -190,12 +191,10 @@ GuideFrame::GuideFrame(GUI_App *pGUI, long style)
 
 GuideFrame::~GuideFrame()
 {
-    m_destroy = true;
+    *m_cancel_token = true; // stop the loading thread and any queued CallAfter lambdas before join
-    if (m_load_task && m_load_task->joinable()) {
+    if (m_load_task && m_load_task->joinable())
         m_load_task->join();
-        delete m_load_task;
+    m_load_task.reset();
-        m_load_task = nullptr;
-    }
     if (m_browser) {
         delete m_browser;
         m_browser = nullptr;
@@ -301,15 +300,71 @@ void GuideFrame::OnNavigationRequest(wxWebViewEvent &evt)
 /**
  * Callback invoked when a navigation request was accepted
  */
+// The empty shape every profile-loading path starts from or falls back to.
+void GuideFrame::reset_profile_json()
+{
+    m_ProfileJson["model"]    = json::array();
+    m_ProfileJson["machine"]  = json::object();
+    m_ProfileJson["filament"] = json::object();
+    m_ProfileJson["process"]  = json::array();
+}
+
+void GuideFrame::init_guide_paths()
+{
+    m_ProfileJson = json::parse("{}");
+    reset_profile_json();
+
+    vendor_dir      = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
+    rsrc_vendor_dir = (boost::filesystem::path(resources_dir()) / "profiles").make_preferred();
+    orca_bundle_rsrc = true;
+
+    if (boost::filesystem::exists(vendor_dir)) {
+        for (const auto& entry : boost::filesystem::directory_iterator(vendor_dir)) {
+            if (!boost::filesystem::is_directory(entry) &&
+                boost::iequals(entry.path().extension().string(), ".json") &&
+                !boost::iequals(entry.path().stem().string(), PresetBundle::ORCA_FILAMENT_LIBRARY)) {
+                orca_bundle_rsrc = false;
+                break;
+            }
+        }
+    }
+
+    auto lib_json = boost::filesystem::path(PresetBundle::ORCA_FILAMENT_LIBRARY).replace_extension(".json");
+    m_OrcaFilaLibPath = boost::filesystem::exists(vendor_dir / lib_json)
+        ? (vendor_dir      / PresetBundle::ORCA_FILAMENT_LIBRARY).string()
+        : (rsrc_vendor_dir / PresetBundle::ORCA_FILAMENT_LIBRARY).string();
+}
+
+void GuideFrame::on_profile_loaded()
+{
+    // Must be called on the main thread.
+    SaveProfileData();
+    const std::string strAll = m_ProfileJson.dump(-1, ' ', false, json::error_handler_t::ignore);
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished, json contents:\n" << strAll;
+    json res;
+    res["command"]     = "userguide_profile_load_finish";
+    res["sequence_id"] = "10001";
+    RunScript(wxString::Format("HandleStudio(%s)", res.dump(-1, ' ', true)));
+}
+
 void GuideFrame::OnNavigationComplete(wxWebViewEvent &evt)
 {
     //wxLogMessage("%s", "Navigation complete; url='" + evt.GetURL() + "'");
     if (!bFirstComplete) {
-        m_load_task = new boost::thread(boost::bind(&GuideFrame::LoadProfileData, this));
-       // boost::thread LoadProfileThread(boost::bind(&GuideFrame::LoadProfileData, this));
-        //LoadProfileThread.detach();
-
         bFirstComplete = true;
+        try {
+            init_guide_paths();
+            if (BuildProfileDataFromPresetBundle()) {
+                if (!*m_cancel_token)
+                    on_profile_loaded();
+            } else {
+                // Presets not yet in memory — delegate to background thread.
+                m_load_task = std::make_unique<boost::thread>(boost::bind(&GuideFrame::LoadProfileData, this));
+            }
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", init error: " << e.what();
+            m_load_task = std::make_unique<boost::thread>(boost::bind(&GuideFrame::LoadProfileData, this));
+        }
     }
 
     m_browser->Show();
@@ -762,11 +817,9 @@ bool GuideFrame::apply_config(AppConfig *app_config, PresetBundle *preset_bundle
     bool check_unsaved_preset_changes = false;
     std::vector<std::string> install_bundles;
     std::vector<std::string> remove_bundles;
-    const auto vendor_dir = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
     for (const auto &it : enabled_vendors) {
         if (it.second.size() > 0) {
-            auto vendor_file = vendor_dir/(it.first + ".json");
+            if (!is_vendor_installed(it.first)) {
-            if (!fs::exists(vendor_file)) {
                 install_bundles.emplace_back(it.first);
             }
         }
@@ -777,8 +830,7 @@ bool GuideFrame::apply_config(AppConfig *app_config, PresetBundle *preset_bundle
         if (it.second.size() > 0) {
             if (enabled_vendors.find(it.first) != enabled_vendors.end())
                 continue;
-            auto vendor_file = vendor_dir/(it.first + ".json");
+            if (is_vendor_installed(it.first)) {
-            if (fs::exists(vendor_file)) {
                 remove_bundles.emplace_back(it.first);
             }
         }
@@ -1127,99 +1179,244 @@ int GuideFrame::GetFilamentInfo( std::string VendorDirectory, json & pFilaList,
     return status;
 }
 
-int GuideFrame::LoadProfileData()
+bool GuideFrame::BuildProfileJson(const PresetBundle& bundle, bool require_all_resource_vendors)
 {
     try {
-        m_ProfileJson             = json::parse("{}");
+        // Models from vendor profiles
-        m_ProfileJson["model"]    = json::array();
+        for (const auto& [vendor_id, vp] : bundle.vendors) {
-        m_ProfileJson["machine"]  = json::object();
+            for (const auto& model : vp.models) {
-        m_ProfileJson["filament"] = json::object();
+                std::string nozzle_str;
-        m_ProfileJson["process"]  = json::array();
+                for (const auto& v : model.variants) {
+                    if (!nozzle_str.empty()) nozzle_str += ";";
+                    nozzle_str += v.name;
+                }
+                const std::string materials_str = boost::algorithm::join(model.default_materials, ";");
+                boost::filesystem::path cover_path =
+                    (boost::filesystem::path(resources_dir()) / "profiles" / vp.id / (model.id + "_cover.png"))
+                        .make_preferred();
+                if (!boost::filesystem::exists(cover_path))
+                    cover_path =
+                        (boost::filesystem::path(resources_dir()) / "web/image/printer" / (model.id + "_cover.png"))
+                            .make_preferred();
 
-        vendor_dir      = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
+                json entry;
-        rsrc_vendor_dir = (boost::filesystem::path(resources_dir()) / "profiles").make_preferred();
+                entry["model"]           = model.id;
-
+                entry["name"]            = model.name;
-        // Orca: add custom as default
+                entry["vendor"]          = vp.id;
-        // Orca: add json logic for vendor bundle
+                entry["nozzle_diameter"] = nozzle_str;
-        orca_bundle_rsrc = true;
+                entry["materials"]       = materials_str;
-
+                entry["cover"]           = cover_path.string();
-        // search if there exists a .json file in vendor_dir folder, if exists, set orca_bundle_rsrc to false
+                entry["nozzle_selected"] = "";
-        for (const auto& entry : boost::filesystem::directory_iterator(vendor_dir)) {
+                entry["sub_path"]        = "";
-            if (!boost::filesystem::is_directory(entry) && boost::iequals(entry.path().extension().string(), ".json") && !boost::iequals(entry.path().stem().string(), PresetBundle::ORCA_FILAMENT_LIBRARY)) {
+                m_ProfileJson["model"].push_back(entry);
-                orca_bundle_rsrc = false;
-                break;
             }
         }
 
-        // load the default filament library first
+        // Machine map: preset name -> {model, nozzle variant}
-        std::set<std::string> loaded_vendors;
+        for (const Preset& p : bundle.printers()) {
-        auto filament_library_name = boost::filesystem::path(PresetBundle::ORCA_FILAMENT_LIBRARY).replace_extension(".json");
+            if (!p.is_system || !p.vendor) continue;
-        if (boost::filesystem::exists(vendor_dir / filament_library_name)) {
+            const auto* printer_model   = p.config.option<ConfigOptionString>("printer_model");
-            m_OrcaFilaLibPath = (vendor_dir / PresetBundle::ORCA_FILAMENT_LIBRARY).string();
+            const auto* printer_variant = p.config.option<ConfigOptionString>("printer_variant");
-            LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (vendor_dir / filament_library_name).string());
+            if (!printer_model || printer_model->value.empty() || !printer_variant) continue;
-        } else {
-            m_OrcaFilaLibPath = (rsrc_vendor_dir / PresetBundle::ORCA_FILAMENT_LIBRARY).string();
-            LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (rsrc_vendor_dir / filament_library_name).string());
-        }
-        loaded_vendors.insert(PresetBundle::ORCA_FILAMENT_LIBRARY);
 
-        //load custom bundle from user data path
+            json mach;
-        boost::filesystem::directory_iterator endIter;
+            mach["model"]  = printer_model->value;
-        for (boost::filesystem::directory_iterator iter(vendor_dir); iter != endIter; iter++) {
+            mach["nozzle"] = printer_variant->value;
-            if (!boost::filesystem::is_directory(*iter)) {
+            m_ProfileJson["machine"][p.name] = mach;
-                wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
-                strVendor          = strVendor.AfterLast('\\');
-                strVendor          = strVendor.AfterLast('/');
-
-                wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
-                if(strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
-                    continue;
-
-                LoadProfileFamily(w2s(strVendor), iter->path().string());
-                loaded_vendors.insert(w2s(strVendor));
-            }
-            if (m_destroy)
-                return 0;
         }
 
-        boost::filesystem::directory_iterator others_endIter;
+        // Filament map from system filament presets (vendor/type already resolved in config)
-        for (boost::filesystem::directory_iterator iter(rsrc_vendor_dir); iter != others_endIter; iter++) {
+        const json& machines = m_ProfileJson["machine"];
-            if (!boost::filesystem::is_directory(*iter)) {
+        for (const Preset& p : bundle.filaments()) {
-                wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
+            if (!p.is_system || !p.vendor) continue;
-                strVendor          = strVendor.AfterLast('\\');
+            const auto* fila_vendor     = p.config.option<ConfigOptionStrings>("filament_vendor");
-                strVendor          = strVendor.AfterLast('/');
+            const auto* fila_type       = p.config.option<ConfigOptionStrings>("filament_type");
-                wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
+            const auto* compat_printers = p.config.option<ConfigOptionStrings>("compatible_printers");
-                if (strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
-                    continue;
 
-                LoadProfileFamily(w2s(strVendor), iter->path().string());
+            std::string vendor = (fila_vendor && !fila_vendor->values.empty()) ? fila_vendor->values[0] : "";
-                loaded_vendors.insert(w2s(strVendor));
+            std::string type   = (fila_type   && !fila_type->values.empty())   ? fila_type->values[0]   : "";
+
+            std::string model_list;
+            if (compat_printers) {
+                for (const std::string& pname : compat_printers->values) {
+                    auto it = machines.find(pname);
+                    if (it != machines.end()) {
+                        const std::string m = (*it)["model"];
+                        const std::string n = (*it)["nozzle"];
+                        model_list += "[" + m + "++" + n + "]";
+                    }
+                }
             }
-            if (m_destroy)
+
-                return 0;
+            json ff;
+            ff["name"]     = p.name;
+            ff["sub_path"] = p.file;
+            ff["vendor"]   = vendor;
+            ff["type"]     = type;
+            ff["models"]   = model_list;
+            ff["selected"] = 0;
+            m_ProfileJson["filament"][p.name] = ff;
         }
 
-        wxGetApp().CallAfter([this] {
+        // Process list from visible system print presets
-            if (!m_destroy) {
+        for (const Preset& p : bundle.prints()) {
-                //sync to appconfig first to populate current selections
+            if (!p.is_system || !p.vendor || !p.is_visible) continue;
-                SaveProfileData();
+            json entry;
+            entry["name"]     = p.name;
+            entry["sub_path"] = p.file;
+            m_ProfileJson["process"].push_back(entry);
+        }
 
-                //sync to web after selections are populated
+        if (require_all_resource_vendors) {
-                std::string strAll = m_ProfileJson.dump(-1, ' ', false, json::error_handler_t::ignore);
+            // If rsrc_vendor_dir has vendors (profile JSONs, or the preset caches a
+            // packaged build ships instead) not covered by the current bundle, the
+            // bundle is incomplete (e.g. dev env where data_dir/system only has
+            // OrcaFilamentLibrary+Custom). Fall back so the slow path reads both dirs.
+            try {
+                for (const std::string& name : vendor_names_in(rsrc_vendor_dir)) {
+                    if (bundle.vendors.find(name) == bundle.vendors.end()) {
+                        BOOST_LOG_TRIVIAL(info) << "GuideFrame: vendor '" << name
+                            << "' in resources but not in preset_bundle — falling back to JSON loading";
+                        reset_profile_json();
+                        return false;
+                    }
+                }
+            } catch (const std::exception&) {}
+        }
 
-                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished, json contents: " << std::endl << strAll;
+        BOOST_LOG_TRIVIAL(info) << "GuideFrame: built profile data ("
-                json m_Res           = json::object();
+                                << m_ProfileJson["model"].size()    << " models, "
-                m_Res["command"]     = "userguide_profile_load_finish";
+                                << m_ProfileJson["machine"].size()  << " machines, "
-                m_Res["sequence_id"] = "10001";
+                                << m_ProfileJson["filament"].size() << " filaments)";
-                wxString strJS       = wxString::Format("HandleStudio(%s)", m_Res.dump(-1, ' ', true));
+        return !m_ProfileJson["machine"].empty();
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "GuideFrame::BuildProfileJson failed: " << e.what()
+                                   << " — falling back to JSON loading";
+        reset_profile_json();
+        return false;
+    }
+}
 
-                RunScript(strJS);
+bool GuideFrame::BuildProfileDataFromPresetBundle()
+{
+    PresetBundle* pb = wxGetApp().preset_bundle;
+    if (!pb || pb->vendors.empty())
+        return false;
+    return BuildProfileJson(*pb, /*require_all_resource_vendors=*/true);
+}
+
+bool GuideFrame::BuildProfileDataFromVendors()
+{
+    try {
+        // Same vendor set and precedence as the JSON scan in LoadProfileData: a
+        // vendor in the user's system dir shadows the bundled one of that name.
+        // A vendor is named by its profile or, where a build ships preset caches
+        // instead, by its cache alone — so both forms name one here.
+        std::map<std::string, boost::filesystem::path> vendor_files;
+        auto collect = [&vendor_files](const boost::filesystem::path& dir) {
+            boost::system::error_code ec;
+            if (!boost::filesystem::exists(dir, ec))
+                return;
+            for (const auto& e : boost::filesystem::directory_iterator(dir, ec))
+                if (Slic3r::is_json_file(e.path().string()) || e.path().extension() == ".opc")
+                    vendor_files.emplace(e.path().stem().string(), e.path());   // first wins
+        };
+        collect(vendor_dir);
+        collect(rsrc_vendor_dir);
+
+        // Each vendor comes from its preset cache where one covers it, which is what
+        // makes this worth doing instead of the scan below; the filament library goes
+        // first because the others' filaments inherit from it, and resolving those on
+        // the vendors the cache does not cover needs it already loaded.
+        PresetBundle bundle;
+        auto load_vendor = [this](PresetBundle& into, const std::string& vendor, const PresetBundle* base) {
+            into.load_vendor_configs_from_json(vendor_dir.string(), vendor, PresetBundle::LoadSystem,
+                                               ForwardCompatibilitySubstitutionRule::EnableSilent, base);
+        };
+        const std::string filament_library(PresetBundle::ORCA_FILAMENT_LIBRARY);
+        if (vendor_files.count(filament_library))
+            load_vendor(bundle, filament_library, nullptr);
+        for (const auto& entry : vendor_files) {
+            if (*m_cancel_token)
+                return false;   // as in the scan below: a vendor without a cache is parsed, and that takes time
+            const std::string& vendor = entry.first;
+            // A cache is only ever written for a versioned vendor; a JSON has to be
+            // asked, so that an unversioned one (blacklist.json) carrying no presets
+            // is passed over.
+            if (vendor == filament_library ||
+                (entry.second.extension() != ".opc" && get_vendor_cache_version(entry.second.string()).empty()))
+                continue;
+            PresetBundle tmp;
+            load_vendor(tmp, vendor, &bundle);
+            bundle.merge_presets(std::move(tmp));
+        }
+        if (bundle.vendors.empty())
+            return false;
+        return BuildProfileJson(bundle, /*require_all_resource_vendors=*/false);
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: " << e.what();
+        reset_profile_json();
+        return false;
+    }
+}
+
+int GuideFrame::LoadProfileData()
+{
+    // Background thread: the fast path in OnNavigationComplete failed (presets not yet loaded).
+    // Loading order (fastest to slowest):
+    //   1. Load every vendor, from its preset cache wherever one covers it
+    //   2. Read all vendor JSONs by hand
+    try {
+        if (!BuildProfileDataFromVendors()) {
+            // Last resort — read all vendor JSONs
+            std::set<std::string> loaded_vendors;
+            auto filament_library_name = boost::filesystem::path(PresetBundle::ORCA_FILAMENT_LIBRARY).replace_extension(".json");
+            if (boost::filesystem::exists(vendor_dir / filament_library_name))
+                LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (vendor_dir / filament_library_name).string());
+            else
+                LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (rsrc_vendor_dir / filament_library_name).string());
+            loaded_vendors.insert(PresetBundle::ORCA_FILAMENT_LIBRARY);
+
+            boost::filesystem::directory_iterator endIter;
+            for (boost::filesystem::directory_iterator iter(vendor_dir); iter != endIter; iter++) {
+                if (!boost::filesystem::is_directory(*iter)) {
+                    wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
+                    strVendor          = strVendor.AfterLast('\\');
+                    strVendor          = strVendor.AfterLast('/');
+                    wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
+                    if (strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
+                        continue;
+                    LoadProfileFamily(w2s(strVendor), iter->path().string());
+                    loaded_vendors.insert(w2s(strVendor));
+                }
+                if (*m_cancel_token) return 0;
             }
+
+            boost::filesystem::directory_iterator others_endIter;
+            for (boost::filesystem::directory_iterator iter(rsrc_vendor_dir); iter != others_endIter; iter++) {
+                if (!boost::filesystem::is_directory(*iter)) {
+                    wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
+                    strVendor          = strVendor.AfterLast('\\');
+                    strVendor          = strVendor.AfterLast('/');
+                    wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
+                    if (strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
+                        continue;
+                    LoadProfileFamily(w2s(strVendor), iter->path().string());
+                    loaded_vendors.insert(w2s(strVendor));
+                }
+                if (*m_cancel_token) return 0;
+            }
+        }
+
+        // Capture the cancel token by value (shared_ptr) so the lambda doesn't
+        // touch `this` if GuideFrame is destroyed before the event fires.
+        auto tok = m_cancel_token;
+        wxGetApp().CallAfter([this, tok] {
+            if (!*tok)
+                on_profile_loaded();
         });
-    } catch (std::exception& e) {
+    } catch (const std::exception& e) {
-        // wxLogMessage("GUIDE: load_profile_error  %s ", e.what());
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", error: " << e.what();
-        //  wxMessageBox(e.what(), "", MB_OK);
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", error: " << e.what() << std::endl;
     }
 
     filament_info_cache.clear();

src/slic3r/GUI/WebGuideDialog.hpp

@@ -30,10 +30,14 @@
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/Utils/PresetUpdater.hpp"
 
+#include <atomic>
+#include <memory>
 #include <unordered_map>
 
 #include <nlohmann/json.hpp>
 
+#include <boost/thread.hpp>
+
 namespace Slic3r { namespace GUI {
 
 class GuideFrame : public DPIDialog
@@ -78,6 +82,12 @@ public:
     int LoadProfileData();
     int SaveProfileData();
     int LoadProfileFamily(std::string strVendor, std::string strFilePath);
+    void init_guide_paths();
+    void on_profile_loaded();
+    bool BuildProfileJson(const PresetBundle& bundle, bool require_all_resource_vendors);
+    bool BuildProfileDataFromPresetBundle();
+    bool BuildProfileDataFromVendors();
+    void reset_profile_json();
     int SaveProfile();
     int GetFilamentInfo( std::string VendorDirectory,json & pFilaList, std::string filepath, std::string &sVendor, std::string &sType);
 
@@ -112,8 +122,11 @@ private:
 
     //First Load
     bool bFirstComplete{false};
-    bool m_destroy{false};
+    // Set once in the destructor. Read through `this` by the loading thread
-    boost::thread* m_load_task{ nullptr };
+    // (joined before `this` dies) and captured as the shared_ptr by CallAfter
+    // lambdas so they don't touch `this` after the object is freed.
+    std::shared_ptr<std::atomic<bool>> m_cancel_token{std::make_shared<std::atomic<bool>>(false)};
+    std::unique_ptr<boost::thread> m_load_task;
 
     // User Config
     bool PrivacyUse;
@@ -123,6 +136,7 @@ private:
     bool InstallNetplugin;
     bool network_plugin_ready {false};
 
+    json m_ProfileJson;
     json m_OrcaFilaList;
     std::string m_OrcaFilaLibPath;
 

src/slic3r/GUI/calib_dlg.cpp

@@ -8,7 +8,9 @@
 #include "Widgets/HyperLink.hpp"
 #include <string>
 #include <vector>
+#include <cmath>
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Flow.hpp"
 #include "libslic3r/Utils.hpp"
 
 namespace Slic3r { namespace GUI {
@@ -34,6 +36,23 @@ int GetTextMax(wxWindow* parent, const std::vector<wxString>& labels)
     return text_size.x + parent->FromDIP(10);
 }
 
+CheckBox* add_scale_checkbox(wxWindow* parent, wxSizer* settings_sizer)
+{
+    auto row  = new wxBoxSizer(wxHORIZONTAL);
+    auto cb   = new CheckBox(parent);
+    cb->SetValue(true);
+    auto text = new wxStaticText(parent, wxID_ANY, _L("Auto-scale for nozzle"), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT);
+    cb->SetToolTip(_L("This model is designed around a 0.4 mm nozzle with a 0.2 mm layer height. \n"
+                      "When the scaling option is enabled (recommended), it dynamically resizes to match your current nozzle diameter"
+                      " and an appropriate layer height, making the test both accurate and easy to read.\n"
+                      "Turn scaling off only if you wish to print the reference model exactly as-is."));
+    text->SetToolTip(cb->GetToolTipText());
+    row->Add(cb  , 0, wxALL | wxALIGN_CENTER_VERTICAL, parent->FromDIP(2));
+    row->Add(text, 0, wxALL | wxALIGN_CENTER_VERTICAL, parent->FromDIP(2));
+    settings_sizer->Add(row, 0, wxLEFT | wxTOP, parent->FromDIP(3));
+    return cb;
+}
+
 std::vector<std::string> get_shaper_type_values()
 {
     if (auto* preset_bundle = wxGetApp().preset_bundle) {
@@ -402,6 +421,9 @@ Temp_Calibration_Dlg::Temp_Calibration_Dlg(wxWindow* parent, wxWindowID id, Plat
     temp_step_sizer->Add(m_tiStep      , 0, wxALL | wxALIGN_CENTER_VERTICAL, FromDIP(2));
     settings_sizer->Add(temp_step_sizer, 0, wxLEFT, FromDIP(3));
 
+    // Resize the model to the nozzle diameter (recommended)
+    m_cbResize = add_scale_checkbox(this, settings_sizer);
+
     settings_sizer->AddSpacer(FromDIP(5));
 
     v_sizer->Add(settings_sizer, 0, wxTOP | wxRIGHT | wxLEFT | wxEXPAND, FromDIP(10));
@@ -475,6 +497,7 @@ void Temp_Calibration_Dlg::on_start(wxCommandEvent& event) {
     }
     m_params.start = start;
     m_params.end = end;
+    m_params.nozzle_based_resize = m_cbResize->GetValue();
     m_params.mode = CalibMode::Calib_Temp_Tower;
     m_plater->calib_temp(m_params);
     EndModal(wxID_OK);
@@ -691,6 +714,22 @@ VFA_Test_Dlg::VFA_Test_Dlg(wxWindow* parent, wxWindowID id, Plater* plater)
     vol_step_sizer->Add(m_tiStep     , 0, wxALL | wxALIGN_CENTER_VERTICAL, FromDIP(2));
     settings_sizer->Add(vol_step_sizer, 0, wxLEFT, FromDIP(3));
 
+    // Resize the model to the nozzle diameter (recommended)
+    m_cbResize = add_scale_checkbox(this, settings_sizer);
+
+    // Auto-adjust parameters to the filament's max volumetric speed
+    auto auto_adjust_sizer = new wxBoxSizer(wxHORIZONTAL);
+    m_cbAutoAdjust = new CheckBox(this);
+    m_cbAutoAdjust->SetValue(true);
+    auto auto_adjust_text = new wxStaticText(this, wxID_ANY, _L("Auto-adjust to max volumetric speed"), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT);
+    m_cbAutoAdjust->SetToolTip(_L("If the end speed would exceed the filament's maximum volumetric speed, automatically lower the layer "
+                                  "height (keeping standard values and staying within the machine's limits) to reach it. If even the "
+                                  "minimum layer height is not enough, lower the end speed instead."));
+    auto_adjust_text->SetToolTip(m_cbAutoAdjust->GetToolTipText());
+    auto_adjust_sizer->Add(m_cbAutoAdjust  , 0, wxALL | wxALIGN_CENTER_VERTICAL, FromDIP(2));
+    auto_adjust_sizer->Add(auto_adjust_text, 0, wxALL | wxALIGN_CENTER_VERTICAL, FromDIP(2));
+    settings_sizer->Add(auto_adjust_sizer, 0, wxLEFT | wxTOP, FromDIP(3));
+
     settings_sizer->AddSpacer(FromDIP(5));
 
     v_sizer->Add(settings_sizer, 0, wxTOP | wxRIGHT | wxLEFT | wxEXPAND, FromDIP(10));
@@ -732,6 +771,136 @@ void VFA_Test_Dlg::on_start(wxCommandEvent& event)
         return;
     }
 
+    // If the requested end speed would exceed the filament's maximum volumetric speed, the slicer clamps the
+    // outer wall speed, so the upper blocks of the tower would all print at the same (clamped) speed instead of
+    // the requested one. Depending on the "Auto-adjust" option, either fix it automatically or just warn.
+    m_params.vfa_layer_height    = 0.0; // 0 = auto (nozzle/2); overridden below when auto-adjusting
+    m_params.nozzle_based_resize = m_cbResize->GetValue();
+    if (const auto* preset_bundle = wxGetApp().preset_bundle) {
+        const auto& printer_config  = preset_bundle->printers.get_edited_preset().config;
+        const auto& print_config    = preset_bundle->prints.get_edited_preset().config;
+        const auto& filament_config = preset_bundle->filaments.get_edited_preset().config;
+
+        const int extruder_id = std::max(m_params.extruder_id, 0);
+        auto get_at = [extruder_id](const ConfigOptionFloats* opt, double fallback) {
+            if (opt == nullptr || opt->values.empty())
+                return fallback;
+            return opt->values[std::min(static_cast<size_t>(extruder_id), opt->values.size() - 1)];
+        };
+
+        const double nozzle_diameter = get_at(printer_config.option<ConfigOptionFloats>("nozzle_diameter"), vfa_base_nozzle_diameter);
+        double preset_lh = nozzle_diameter / 2.0;
+        if (const auto* lh_opt = print_config.option<ConfigOptionFloat>("layer_height"))
+            if (lh_opt->value > 0.0)
+                preset_lh = lh_opt->value;
+        // Layer height the tower will actually print at: nozzle/2 when resizing, else the preset value.
+        const double default_lh      = m_params.nozzle_based_resize ? nozzle_diameter / 2.0 : preset_lh;
+        const double max_vol_speed   = get_at(filament_config.option<ConfigOptionFloats>("filament_max_volumetric_speed"), 0.0);
+        const double machine_min_lh  = get_at(printer_config.option<ConfigOptionFloats>("min_layer_height"), 0.0);
+        const double machine_max_lh  = get_at(printer_config.option<ConfigOptionFloats>("max_layer_height"), 0.0);
+
+        double line_width = print_config.get_abs_value("outer_wall_line_width", nozzle_diameter);
+        if (line_width <= 0.0)
+            line_width = print_config.get_abs_value("line_width", nozzle_diameter);
+        if (line_width <= 0.0)
+            line_width = nozzle_diameter;
+
+        // Max outer-wall speed printable at a given layer height without exceeding the volumetric limit.
+        auto speed_limit_for_lh = [&](double lh) -> double {
+            const double mm3_per_mm = Flow(line_width, lh, nozzle_diameter).mm3_per_mm();
+            return mm3_per_mm > 0.0 ? max_vol_speed / mm3_per_mm : 1e9;
+        };
+
+        auto confirm_clamp = [&](const wxString& question) -> bool {
+            MessageDialog msg_dlg(nullptr,
+                wxString::Format(_L("The end speed (%.0f mm/s) exceeds the filament's maximum volumetric speed "
+                                    "(%.1f mm³/s), which limits the outer wall to about %.0f mm/s at this line width and "
+                                    "layer height.\n Speeds above this will be clamped, so the upper blocks of the tower "
+                                    "will not print at the requested speed.\n\n%s"),
+                                 m_params.end, max_vol_speed, speed_limit_for_lh(default_lh), question),
+                _L("VFA test"), wxICON_WARNING | wxYES_NO | wxNO_DEFAULT);
+            return msg_dlg.ShowModal() == wxID_YES;
+        };
+
+        if (max_vol_speed > 0.0 && nozzle_diameter > 0.0 && m_params.end > speed_limit_for_lh(default_lh)) {
+            // The layer-height auto-adjust only applies when resizing is enabled (it changes the layer height).
+            if (m_cbAutoAdjust->GetValue() && m_params.nozzle_based_resize) {
+                // Candidate layer heights are the ones actually used by the process profiles compatible with the
+                // current printer (clamped to the machine's layer-height limits, when set). A smaller layer height
+                // means a smaller cross-section, hence a higher printable speed under the volumetric limit; pick the
+                // largest candidate that still reaches the end speed to keep the change from the default minimal.
+                std::vector<double> candidates;
+                for (const auto& preset : preset_bundle->prints.get_presets()) {
+                    if (!preset.is_compatible || preset.is_default)
+                        continue;
+                    const auto* lh_opt = preset.config.option<ConfigOptionFloat>("layer_height");
+                    if (lh_opt == nullptr || lh_opt->value <= 0.0)
+                        continue;
+                    const double lh = lh_opt->value;
+                    if ((machine_min_lh > 0.0 && lh < machine_min_lh - 1e-6) ||
+                        (machine_max_lh > 0.0 && lh > machine_max_lh + 1e-6))
+                        continue;
+                    candidates.push_back(lh);
+                }
+                std::sort(candidates.begin(), candidates.end());
+                candidates.erase(std::unique(candidates.begin(), candidates.end(),
+                                             [](double a, double b) { return std::abs(a - b) < 1e-6; }),
+                                 candidates.end());
+
+                // Largest candidate <= the default layer height that still reaches the end speed (smallest change).
+                double chosen_lh = 0.0;
+                for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
+                    if (*it > default_lh + 1e-6)
+                        continue; // never increase the layer height above the default
+                    if (speed_limit_for_lh(*it) >= m_params.end) { chosen_lh = *it; break; }
+                }
+
+                if (chosen_lh > 0.0) {
+                    // Reducing the layer height is enough to reach the requested end speed.
+                    m_params.vfa_layer_height = chosen_lh;
+                    MessageDialog msg_dlg(nullptr,
+                        wxString::Format(_L("The end speed (%.0f mm/s) exceeds the filament's maximum volumetric speed "
+                                            "(%.1f mm³/s) at the default layer height (%.2f mm).\n\n"
+                                            "The layer height has been reduced to %.2f mm (a value used by this printer's "
+                                            "profiles) so the tower can reach the requested speed."),
+                                         m_params.end, max_vol_speed, default_lh, chosen_lh),
+                        _L("VFA test"), wxICON_INFORMATION | wxOK);
+                    msg_dlg.ShowModal();
+                } else if (!candidates.empty()) {
+                    // Even the smallest available layer height cannot reach the end speed; propose a lower end speed
+                    // based on that layer height, the line width and the maximum volumetric speed.
+                    const double min_lh    = candidates.front();
+                    const double reachable = speed_limit_for_lh(min_lh);
+                    double new_end = std::floor(reachable / m_params.step) * m_params.step; // snap down to a step multiple
+                    if (new_end < m_params.start + m_params.step)
+                        new_end = m_params.start + m_params.step;
+                    MessageDialog msg_dlg(nullptr,
+                        wxString::Format(_L("Even at the smallest layer height used by this printer's profiles (%.2f mm) the "
+                                            "end speed (%.0f mm/s) exceeds the filament's maximum volumetric speed "
+                                            "(%.1f mm³/s).\n\n"
+                                            "The layer height will be set to %.2f mm and the end speed lowered to %.0f mm/s.\n\n"
+                                            "Continue?"),
+                                         min_lh, m_params.end, max_vol_speed, min_lh, new_end),
+                        _L("VFA test"), wxICON_WARNING | wxYES_NO | wxNO_DEFAULT);
+                    if (msg_dlg.ShowModal() != wxID_YES)
+                        return;
+                    m_params.end              = new_end;
+                    m_params.vfa_layer_height = min_lh;
+                } else {
+                    // No compatible process profiles to draw layer heights from: warn and let the user decide.
+                    if (!confirm_clamp(_L("Continue anyway?")))
+                        return;
+                }
+            } else {
+                // Auto-adjust off, or resizing disabled (which forbids changing the layer height): just warn.
+                if (!confirm_clamp(m_params.nozzle_based_resize
+                        ? _L("Enable \"Auto-adjust\" to fix this automatically, or continue anyway?")
+                        : _L("Enable \"Auto-scale for nozzle\" and \"Auto-adjust\" to fix this automatically, or continue anyway?")))
+                    return;
+            }
+        }
+    }
+
     m_params.mode = CalibMode::Calib_VFA_Tower;
     m_plater->calib_VFA(m_params);
     EndModal(wxID_OK);

src/slic3r/GUI/calib_dlg.hpp

@@ -65,6 +65,7 @@ protected:
     TextInput* m_tiStart;
     TextInput* m_tiEnd;
     TextInput* m_tiStep;
+    CheckBox*  m_cbResize;
     Plater* m_plater;
 };
 
@@ -99,6 +100,8 @@ protected:
     TextInput* m_tiStart;
     TextInput* m_tiEnd;
     TextInput* m_tiStep;
+    CheckBox*  m_cbAutoAdjust;
+    CheckBox*  m_cbResize;
     Plater* m_plater;
 };
 

src/slic3r/Utils/Bonjour.cpp

@@ -871,7 +871,7 @@ void Bonjour::priv::lookup_perform()
 
 	std::vector<LookupSocket*> sockets;
 
-	// resolve intefaces - from PR#6646
+	// resolve interfaces - from PR#6646
 	std::vector<boost::asio::ip::address> interfaces;
 	asio::ip::udp::resolver resolver(*io_service);
 	boost::system::error_code ec;

src/slic3r/Utils/CalibUtils.cpp

@@ -1265,6 +1265,19 @@ void CalibUtils::calib_VFA(const CalibInfo &calib_info, wxString &error_message)
     DynamicPrintConfig filament_config = calib_info.filament_prest->config;
     DynamicPrintConfig printer_config  = calib_info.printer_prest->config;
 
+    const ConfigOptionFloats* nozzle_diameter_config = printer_config.option<ConfigOptionFloats>("nozzle_diameter");
+    size_t nozzle_id = static_cast<size_t>(std::max(params.extruder_id, 0));
+    double nozzle_diameter = vfa_base_nozzle_diameter;
+    if (nozzle_diameter_config && !nozzle_diameter_config->values.empty()) {
+        nozzle_id = std::min(nozzle_id, nozzle_diameter_config->values.size() - 1);
+        nozzle_diameter = nozzle_diameter_config->values[nozzle_id];
+    }
+    if (nozzle_diameter <= 0.0)
+        nozzle_diameter = vfa_base_nozzle_diameter;
+
+    // Resolved layer height: use the (possibly auto-adjusted) value if provided, else default to nozzle/2.
+    double layer_height = params.vfa_layer_height > 0.0 ? params.vfa_layer_height : nozzle_diameter / 2.0;
+
     filament_config.set_key_value("slow_down_layer_time", new ConfigOptionInts{0});
     filament_config.set_key_value("filament_max_volumetric_speed", new ConfigOptionFloats{200});
     filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
@@ -1280,13 +1293,18 @@ void CalibUtils::calib_VFA(const CalibInfo &calib_info, wxString &error_message)
     print_config.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
     print_config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
     print_config.set_key_value("spiral_mode", new ConfigOptionBool(true));
+    print_config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
+    model.objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
     model.objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
     model.objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
     model.objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
-    // cut upper
+    // cut upper (on the unscaled model, using the base block height); the scaling below keeps the physical
+    // block height (vfa_layers_per_block * layer_height) in sync with the speed stepping in GCode::process_layer.
+    // Subtract EPSILON (as the temperature tower does) so the cut lands just below the flat block surface instead
+    // of exactly on it, which would otherwise add a degenerate extra layer.
     auto obj_bb = model.objects[0]->bounding_box_exact();
-    auto height = 5 * ((params.end - params.start) / params.step + 1);
+    auto height = vfa_base_block_height * ((params.end - params.start) / params.step + 1) - EPSILON;
     if (height < obj_bb.size().z()) {
         cut_model(model, height, ModelObjectCutAttribute::KeepLower);
     }
@@ -1295,6 +1313,13 @@ void CalibUtils::calib_VFA(const CalibInfo &calib_info, wxString &error_message)
         return;
     }
 
+    // XY scales with the nozzle; Z scales so each base block becomes vfa_layers_per_block layers of layer_height.
+    const double xy_scale = nozzle_diameter / vfa_base_nozzle_diameter;
+    const double z_scale  = (vfa_layers_per_block * layer_height) / vfa_base_block_height;
+    if (std::abs(xy_scale - 1.0) > EPSILON || std::abs(z_scale - 1.0) > EPSILON)
+        model.objects[0]->scale(xy_scale, xy_scale, z_scale);
+    model.objects[0]->ensure_on_bed();
+
     DynamicPrintConfig full_config;
     full_config.apply(FullPrintConfig::defaults());
     full_config.apply(print_config);
@@ -1303,7 +1328,10 @@ void CalibUtils::calib_VFA(const CalibInfo &calib_info, wxString &error_message)
 
     init_multi_extruder_params_for_cali(full_config, calib_info);
 
-    process_and_store_3mf(&model, full_config, params, error_message);
+    // Pass the resolved layer height on so the GCode speed stepping matches the geometry.
+    Calib_Params store_params = params;
+    store_params.vfa_layer_height = layer_height;
+    process_and_store_3mf(&model, full_config, store_params, error_message);
     if (!error_message.empty())
         return;
 

src/slic3r/Utils/PresetUpdater.cpp

@@ -1042,47 +1042,43 @@ void PresetUpdater::priv::check_installed_vendor_profiles() const
     std::set<std::string> bundles;
     // Orca: always install filament library
     bundles.insert(PresetBundle::ORCA_FILAMENT_LIBRARY);
-    for (auto &dir_entry : boost::filesystem::directory_iterator(rsrc_path)) {
+    // A vendor is named by its profile or, where the build ships preset caches
-        const auto &path = dir_entry.path();
+    // instead of the raw profile JSONs, by its cache alone.
-        std::string file_path = path.string();
+    for (const std::string &vendor_name : vendor_names_in(rsrc_path)) {
-        if (is_json_file(file_path)) {
+        if (bundles.find(vendor_name) != bundles.end())continue;
-            const auto path_in_vendor = vendor_path / path.filename();
-            std::string vendor_name = path.filename().string();
-            // Remove the .json suffix.
-            vendor_name.erase(vendor_name.size() - 5);
-            if (bundles.find(vendor_name) != bundles.end())continue;
 
-            const auto is_vendor_enabled = (vendor_name == PresetBundle::ORCA_DEFAULT_BUNDLE) // always update configs from resource to vendor for ORCA_DEFAULT_BUNDLE
+        const auto is_vendor_enabled = (vendor_name == PresetBundle::ORCA_DEFAULT_BUNDLE) // always update configs from resource to vendor for ORCA_DEFAULT_BUNDLE
-                                           || (enabled_vendors.find(vendor_name) != enabled_vendors.end());
+                                       || (enabled_vendors.find(vendor_name) != enabled_vendors.end());
-            if (enabled_config_update) {
+        if (enabled_config_update) {
-                if ( fs::exists(path_in_vendor)) {
+            if (is_vendor_installed(vendor_name)) {
-                    if (is_vendor_enabled) {
+                if (is_vendor_enabled) {
-                        Semver resource_ver = get_version_from_json(file_path);
+                    // Orca: whichever form of the vendor resources ships at the newer
-                        Semver vendor_ver = get_version_from_json(path_in_vendor.string());
+                    // version is the one installing lays down, and the one to judge
+                    // what is installed against.
+                    Semver resource_ver = resource_vendor_version(vendor_name);
+                    // Orca: a vendor installed as a preset cache has no profile
+                    // beside it; the version it was installed at is in the cache.
+                    Semver vendor_ver = installed_vendor_version(vendor_name);
 
-                        bool version_match = ((resource_ver.maj() == vendor_ver.maj()) && (resource_ver.min() == vendor_ver.min()));
+                    bool version_match = ((resource_ver.maj() == vendor_ver.maj()) && (resource_ver.min() == vendor_ver.min()));
 
-                        if (!version_match || (vendor_ver < resource_ver)) {
+                    if (!version_match || (vendor_ver < resource_ver)) {
-                            BOOST_LOG_TRIVIAL(info) << "[Orca Updater]:found vendor "<<vendor_name<<" newer version "<<resource_ver.to_string() <<" from resource, old version "<<vendor_ver.to_string();
+                        BOOST_LOG_TRIVIAL(info) << "[Orca Updater]:found vendor "<<vendor_name<<" newer version "<<resource_ver.to_string() <<" from resource, old version "<<vendor_ver.to_string();
-                            bundles.insert(vendor_name);
+                        bundles.insert(vendor_name);
-                        }
-                    }
-                    else {
-                        //need to be removed because not installed
-                        fs::remove(path_in_vendor);
-                        const auto path_of_vendor = vendor_path / vendor_name;
-                        if (fs::exists(path_of_vendor))
-                            fs::remove_all(path_of_vendor);
                     }
                 }
-                else if (is_vendor_enabled) {
+                else {
-                    bundles.insert(vendor_name);
+                    //need to be removed because not installed
+                    remove_installed_vendor(vendor_name);
                 }
             }
             else if (is_vendor_enabled) {
                 bundles.insert(vendor_name);
             }
         }
+        else if (is_vendor_enabled) {
+            bundles.insert(vendor_name);
+        }
     }
 
     if (bundles.size() > 0) {
@@ -1162,11 +1158,12 @@ Updates PresetUpdater::priv::get_config_updates(const Semver &old_slic3r_version
             auto filament_in_cache = (cache_profile_path / vendor_name / PRESET_FILAMENT_NAME);
             auto machine_in_cache = (cache_profile_path / vendor_name / PRESET_PRINTER_NAME);
 
-            if (( fs::exists(path_in_vendor))
+            if (is_vendor_installed(vendor_name)
                 || fs::exists(print_in_cache)
                 || fs::exists(filament_in_cache)
                 || fs::exists(machine_in_cache)) {
-                Semver vendor_ver = get_version_from_json(path_in_vendor.string());
+                // Orca: a vendor installed as a preset cache carries its version there.
+                Semver vendor_ver = installed_vendor_version(vendor_name);
 
                 std::map<std::string, std::string> key_values;
                 std::vector<std::string> keys(3);

tests/fff_print/test_skirt_brim.cpp

@@ -153,6 +153,24 @@ TEST_CASE("Object brims are generated per instance", "[SkirtBrim]")
     }
 }
 
+TEST_CASE("Uncombined neighboring brims precede their respective objects", "[SkirtBrim]")
+{
+    Print print;
+    Model model;
+    place_two_cubes_apart(0, {
+        { "skirt_loops",   0 },
+        { "brim_type",     "outer_only" },
+        { "brim_width",    5 },
+        { "combine_brims", 0 },
+    }, print, model);
+    print.process();
+
+    REQUIRE(print.skirt_brim_groups().size() == 1);
+    REQUIRE(print.skirt_brim_groups().front().brims.size() == 2);
+    CHECK(role_sequence(gcode(print), { "brim", "perimeter" }) ==
+          std::vector<std::string>{ "brim", "perimeter", "brim", "perimeter" });
+}
+
 TEST_CASE("Combine brims merges neighboring object instances", "[SkirtBrim]")
 {
     Print print;

tests/libslic3r/CMakeLists.txt

@@ -17,6 +17,7 @@ add_executable(${_TEST_NAME}_tests
     test_preset_bundle_loading.cpp
     test_preset_setting_id.cpp
     test_preset_diff.cpp
+    test_vendor_cache.cpp
     test_elephant_foot_compensation.cpp
     test_geometry.cpp
     test_multimaterial_segmentation.cpp
@@ -32,6 +33,7 @@ add_executable(${_TEST_NAME}_tests
     test_timeutils.cpp
     test_voronoi.cpp
     test_optimizers.cpp
+    test_ordering_strategies.cpp
     # test_png_io.cpp
     test_indexed_triangle_set.cpp
     ../libnest2d/printer_parts.cpp

tests/libslic3r/test_ordering_strategies.cpp

@@ -0,0 +1,297 @@
+#include <catch2/catch_all.hpp>
+
+#define SLIC3R_TEST_HARNESS
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/GCode/OrderingStrategies.hpp"
+#include "libslic3r/Geometry.hpp"
+
+#include <algorithm>
+#include <unordered_set>
+
+using namespace Slic3r;
+
+// --- Helpers ---
+
+static double euclidean_path_length(const std::vector<size_t>& path, const Points& centers)
+{
+    return tsp_cycle_path_length(path, centers);
+}
+
+static bool has_crossings(const std::vector<size_t>& path, const Points& centers)
+{
+    size_t pn = path.size();
+    if (pn < 4) return false;
+    for (size_t i = 0; i < pn; ++i) {
+        size_t i_next = (i + 1) % pn;
+        for (size_t j = i + 2; j < pn; ++j) {
+            if (j == i_next) continue;
+            if (j == (pn - 1) && i == 0) continue;
+            size_t j_next = (j + 1) % pn;
+            if (Geometry::segments_intersect(
+                    centers[path[i]], centers[path[i_next]],
+                    centers[path[j]], centers[path[j_next]])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static bool is_permutation(const std::vector<size_t>& path, size_t n)
+{
+    if (path.size() != n) return false;
+    std::unordered_set<size_t> seen(path.begin(), path.end());
+    for (size_t i = 0; i < n; ++i) {
+        if (seen.count(i) != 1) return false;
+    }
+    return true;
+}
+
+// --- Test fixtures ---
+
+static Points make_grid_4x4()
+{
+    Points pts;
+    for (int row = 0; row < 4; ++row)
+        for (int col = 0; col < 4; ++col)
+            pts.emplace_back(100000 * col, 100000 * row);
+    return pts;
+}
+
+static Points make_linear_5()
+{
+    Points pts;
+    for (int i = 0; i < 5; ++i)
+        pts.emplace_back(100000 * i, 0);
+    return pts;
+}
+
+static Points make_ring_8()
+{
+    Points pts;
+    constexpr double R = 100000.0;
+    for (int i = 0; i < 8; ++i) {
+        double angle = 2.0 * M_PI * i / 8.0;
+        pts.emplace_back(static_cast<coord_t>(R * std::cos(angle)),
+                         static_cast<coord_t>(R * std::sin(angle)));
+    }
+    return pts;
+}
+
+static Points make_random_16()
+{
+    // Deterministic "random" points via simple hash.
+    Points pts;
+    for (int i = 0; i < 16; ++i) {
+        uint32_t h = static_cast<uint32_t>(i * 2654435761u);
+        coord_t x = static_cast<coord_t>((h >> 16) & 0xFFFF) * 10;
+        coord_t y = static_cast<coord_t>(h & 0xFFFF) * 10;
+        pts.emplace_back(x, y);
+    }
+    return pts;
+}
+
+// --- TSP Post-Processing Tests ---
+
+TEST_CASE("tsp_2opt_improve reduces path length", "[TSPPostProcessing]") {
+    Points centers = make_random_16();
+    std::vector<size_t> path(centers.size());
+    // Reverse half the path to create a deliberately bad ordering.
+    for (size_t i = 0; i < path.size(); ++i) path[i] = i;
+    std::reverse(path.begin(), path.end() - path.size() / 2);
+
+    double before = euclidean_path_length(path, centers);
+    tsp_2opt_improve(path, centers);
+    double after = euclidean_path_length(path, centers);
+
+    REQUIRE(is_permutation(path, centers.size()));
+    CHECK(after <= before);
+}
+
+TEST_CASE("tsp_remove_crossings eliminates crossings", "[TSPPostProcessing]") {
+    Points centers = make_random_16();
+    std::vector<size_t> path(centers.size());
+    for (size_t i = 0; i < path.size(); ++i) path[i] = i;
+    // Create a crossing by reversing a middle segment.
+    if (path.size() >= 4) {
+        std::reverse(path.begin() + 1, path.end() - 1);
+    }
+
+    tsp_remove_crossings(path, centers);
+    CHECK(!has_crossings(path, centers));
+    REQUIRE(is_permutation(path, centers.size()));
+}
+
+
+
+TEST_CASE("tsp_rotate_minimize_closing shortens closing edge", "[TSPPostProcessing]") {
+    Points centers = make_random_16();
+    std::vector<size_t> path(centers.size());
+    for (size_t i = 0; i < path.size(); ++i) path[i] = i;
+
+    // Compute all possible closing edge lengths.
+    size_t pn = path.size();
+    double min_closing2 = std::numeric_limits<double>::max();
+    for (size_t start = 0; start < pn; ++start) {
+        size_t last = (start + pn - 1) % pn;
+        double d2 = (centers[path[start]].cast<double>() - centers[path[last]].cast<double>()).squaredNorm();
+        if (d2 < min_closing2) min_closing2 = d2;
+    }
+
+    tsp_rotate_minimize_closing(path, centers);
+
+    // Closing edge should be the minimum possible.
+    double actual_closing2 = (centers[path.front()].cast<double>() - centers[path.back()].cast<double>()).squaredNorm();
+    CHECK(actual_closing2 == min_closing2);
+    REQUIRE(is_permutation(path, centers.size()));
+}
+
+TEST_CASE("tsp_cycle_path_length is correct for triangle", "[TSPPostProcessing]") {
+    Points pts;
+    pts.emplace_back(0, 0);
+    pts.emplace_back(100000, 0);
+    pts.emplace_back(50000, 86602); // equilateral ~100mm sides
+
+    std::vector<size_t> path = {0, 1, 2};
+    double len = tsp_cycle_path_length(path, pts);
+    // Perimeter of equilateral triangle with side ~100000.
+    REQUIRE(len > 290000);
+    REQUIRE(len < 310000);
+}
+
+TEST_CASE("tsp_max_edge_length finds longest edge", "[TSPPostProcessing]") {
+    Points pts;
+    pts.emplace_back(0, 0);
+    pts.emplace_back(100000, 0);
+    pts.emplace_back(50000, 0);
+
+    std::vector<size_t> path = {0, 1, 2};
+    double mx = tsp_max_edge_length(path, pts);
+    // Longest edge is 0->1 = 100000.
+    CHECK(mx == Catch::Approx(100000).margin(1));
+}
+
+// --- Core Strategy Tests: Empty / Small Inputs ---
+
+TEST_CASE("snake_core handles empty input", "[Snake]") {
+    Points centers;
+    auto path = snake_core(centers);
+    REQUIRE(path.empty());
+}
+
+TEST_CASE("snake_core handles single point", "[Snake]") {
+    Points pts{{100, 200}};
+    CHECK(snake_core(pts) == std::vector<size_t>{0});
+}
+
+TEST_CASE("snake_core handles two points", "[Snake]") {
+    Points pts{{100, 200}, {300, 400}};
+    auto p2 = snake_core(pts);
+
+    REQUIRE(is_permutation(p2, 2));
+}
+
+// --- Core Strategy Tests: Grid Layout ---
+
+TEST_CASE("snake produces good path on grid", "[Snake]") {
+    Points centers = make_grid_4x4();
+    auto path = snake_core(centers);
+
+    REQUIRE(is_permutation(path, centers.size()));
+    CHECK(!has_crossings(path, centers));
+}
+
+// --- Core Strategy Tests: Variable Row Spacing ---
+
+TEST_CASE("snake handles variable Y spacing", "[Snake]") {
+    // Rows at Y = 0, 50, 100, 1000 (large gap between last two rows).
+    // The adaptive row detection should identify the tight cluster (0, 50, 100)
+    // and the isolated row (1000) without splitting them incorrectly.
+    Points pts;
+    pts.emplace_back(0, 0);       pts.emplace_back(100000, 0);
+    pts.emplace_back(0, 50000);   pts.emplace_back(100000, 50000);
+    pts.emplace_back(0, 100000);  pts.emplace_back(100000, 100000);
+    pts.emplace_back(0, 1000000); pts.emplace_back(100000, 1000000);
+
+    auto path = snake_core(pts);
+    REQUIRE(is_permutation(path, pts.size()));
+    CHECK(!has_crossings(path, pts));
+}
+
+// --- Core Strategy Tests: All Points Same Y ---
+
+TEST_CASE("snake handles all points on same Y", "[Snake]") {
+    // All points share the same Y coordinate. This exercises the
+    // division-by-zero guard (ys.size() == 1).
+    Points pts;
+    for (int i = 0; i < 6; ++i)
+        pts.emplace_back(100000 * i, 50000);
+
+    auto path = snake_core(pts);
+    REQUIRE(is_permutation(path, pts.size()));
+}
+
+// --- Core Strategy Tests: Collinear Points ---
+
+TEST_CASE("snake_core handles collinear points", "[Snake]") {
+    Points centers = make_linear_5();
+
+    auto p2 = snake_core(centers);
+
+    REQUIRE(is_permutation(p2, centers.size()));
+}
+
+// --- Core Strategy Tests: Ring Layout ---
+
+TEST_CASE("snake_core produces valid paths on ring", "[Snake]") {
+    Points centers = make_ring_8();
+
+    auto p2 = snake_core(centers);
+
+    REQUIRE(is_permutation(p2, centers.size()));
+}
+
+// --- Core Strategy Tests: Random Layout ---
+
+TEST_CASE("snake_core produces valid paths on random input", "[Snake]") {
+    Points centers = make_random_16();
+
+    auto p2 = snake_core(centers);
+
+    REQUIRE(is_permutation(p2, centers.size()));
+}
+
+// --- Quality Comparison Tests ---
+
+TEST_CASE("snake has no crossings on random input", "[Snake]") {
+    Points centers = make_random_16();
+    auto path = snake_core(centers);
+
+    REQUIRE(is_permutation(path, centers.size()));
+    CHECK(!has_crossings(path, centers));
+}
+
+// --- Edge Cases ---
+
+TEST_CASE("snake_core handles duplicate points", "[Snake]") {
+    Points pts;
+    pts.emplace_back(100, 200);
+    pts.emplace_back(100, 200); // duplicate
+    pts.emplace_back(300, 400);
+
+    auto p2 = snake_core(pts);
+
+    REQUIRE(p2.size() == pts.size());
+}
+
+TEST_CASE("snake_core handles three points", "[Snake]") {
+    Points pts;
+    pts.emplace_back(0, 0);
+    pts.emplace_back(100000, 0);
+    pts.emplace_back(50000, 86602);
+
+    auto p2 = snake_core(pts);
+
+    REQUIRE(is_permutation(p2, 3));
+}

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -146,7 +146,7 @@ TEST_CASE("Current vendor type tolerates missing printer model", "[Preset][Bundl
 {
     PresetBundle bundle;
 
-    VendorProfile orca_vendor("ORCA");
+    VendorProfile orca_vendor; orca_vendor.id = "ORCA";
     VendorProfile::PrinterModel model;
     model.name = "Orca Test";
     orca_vendor.models.emplace_back(model);