Fix camera teleporting back sometimes

Add infinite pan
Fix overlapping brims (#14991 )
2026-09-16 21:42:43 +00:00 · 2026-07-30 09:07:39 +02:00 · 2026-07-29 10:46:39 +02:00 · 2026-07-28 17:46:14 -03:00 · 2026-07-28 14:32:55 +08:00 · 2026-07-27 20:11:44 -03:00
75 changed files with 48541 additions and 26648 deletions
@@ -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`.
- 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.
- 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.
+Catalogs live in `localization/i18n/<lang>/OrcaSlicer_<lang>.po`; the template is `OrcaSlicer.pot`.
+See the [Localization guide](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/localization_guide.md) for the human-facing version of these principles.
+
+### 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.
@@ -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."
@@ -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."
@@ -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"

@@ -233,6 +233,9 @@ void AppConfig::set_defaults()
    if (get("reverse_mouse_wheel_zoom").empty())
        set_bool("reverse_mouse_wheel_zoom", false);

+    if (get("infinite_camera_drag").empty())
+        set_bool("infinite_camera_drag", false);
+
    if (get("enable_append_color_by_sync_ams").empty())
        set_bool("enable_append_color_by_sync_ams", true);
    if (get("enable_merge_color_by_sync_ams").empty())
@@ -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
-static void append_and_translate(ExPolygons& dst, const ExPolygons& src,
-    const PrintInstance& instance, size_t instance_idx, std::map<ObjectInstanceID, ExPolygons>& brimAreaMap) {
+// Orca: Translate the brim area into print coordinates and store it per instance.
+static void append_and_translate(const ExPolygons& src, const PrintInstance& instance,
+    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)
-        srcShifted[src_idx].translate(instance_shift);
-    srcShifted = diff_ex(srcShifted, dst);
-    //expolygons_append(dst, temp2);
+    for (ExPolygon& expoly : srcShifted)
+        expoly.translate(instance_shift);
    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;
@@ -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
@@ -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 = 
-            // By default, order object instances using a nearest neighbor search.
-            print.config().print_order == PrintOrder::Default ? chain_print_object_instances(print)
+        print_object_instances_ordering =
+            // By default, order object instances using nearest-neighbor chaining plus
+            // 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;
-            for (int obj_idx = 0; obj_idx < objects_by_extruder.size(); obj_idx++) {
-                auto &object_by_extruder = objects_by_extruder[obj_idx];
+            std::vector<InstanceToPrint> &instances = filament_plan.first;
+            std::vector<IslandOrderNode> nodes;
+            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);
-            std::reverse(new_ordering.begin(), new_ordering.end());
+            // Reuse the cached tour while this filament's island layout is unchanged.
+            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) {
-                filament_to_print_instances[filament_id] = sort_print_object_instances(objects_by_extruder_it->second, layers, ordering, single_object_instance_idx);
-            } else {
-                
-                // PrintSequence::ByLayer to use global ordering ( per object ordering ) if intra-layer order PrintOrder::AsObjectList is specified while keeping behaviour of PrintSequence::ByLayer
-                const std::vector<const PrintInstance*>* ordering_for_filament = (print.config().print_order == PrintOrder::AsObjectList && ordering != nullptr) ? ordering: &new_ordering;
-                filament_to_print_instances[filament_id] = sort_print_object_instances(objects_by_extruder_it->second, layers, ordering_for_filament, single_object_instance_idx);
+                // Group consecutive tour stops of the same instance into visits.
+                std::vector<InstanceVisit> visits;
+                std::vector<bool> instance_seen(instances.size(), false);
+                std::vector<int>  last_visit_of_instance(instances.size(), -1);
+                for (size_t node_idx : tour) {
+                    const size_t instance_idx = node_instances[node_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 {
-        bool use_steps = step > 0.f;
-        if (use_steps) {
-            if (start_value > end_value) {
-                start_value += step;
-            } else {
-                end_value += 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;
+    const float ratio = m_layer_index / (m_layer_count - 1.f);
+    if (step > 0.f) {
+        // Discrete equal-width bands. band is clamped to the last band so the result can't overshoot the range:
+        // at the top layer ratio * n_bands == n_bands, which would otherwise index one band past the end.
+        const int n_bands = std::lround(std::abs(end_value - start_value) / step) + 1;
+        const int band    = std::min(n_bands - 1, static_cast<int>(ratio * n_bands));
+        return start_value + (end_value >= start_value ? 1.f : -1.f) * band * step;
    }
+    return start_value + ratio * (end_value - start_value);
 }

 std::string encodeBase64(uint64_t value)
@@ -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;


@@ -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
@@ -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_ */
@@ -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 = "%";
@@ -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,
 };

@@ -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]; };
-	std::vector<std::pair<size_t, bool>> ordered = chain_segments_greedy<Point, decltype(segment_end_point)>(segment_end_point, instances.size(), start_near);
+	// Order objects using nearest neighbor + post-processing (crossing removal + 2-opt).
+	std::vector<size_t> path = chain_points_with_postprocessing(object_reference_points, start_near);
+
 	std::vector<const PrintInstance*> out;
-	out.reserve(instances.size());
-	for (auto& segment_and_reversal : ordered) {
-		const std::pair<size_t, size_t>& inst = instances[segment_and_reversal.first];
+	out.reserve(path.size());
+	for (size_t idx : path) {
+		const std::pair<size_t, size_t>& inst = instances[idx];
 		out.emplace_back(&print_objects[inst.first]->instances()[inst.second]);
 	}
 	return out;
@@ -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);
@@ -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_inteface_z     = std::numeric_limits<coordf_t>::max();
-                        if (support_params.num_top_base_interface_layers > 0)
+                        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_interface_z     = std::numeric_limits<coordf_t>::max();
+                        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) ?
-                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()));
+            const float   support_interface_angle = support_params.support_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);
            }
@@ -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 =
-                    (different_support_interface_filament && this->zero_gap_interface_top) ? 1 : 0;
+                // Keep at least one configured layer on the interface filament.
+                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 =
-                    (different_support_interface_filament && this->zero_gap_interface_bottom) ? 1 : 0;
+                // Keep at least one configured layer on the interface filament.
+                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) {
-            // No interface layers allowed, print everything with the base support pattern.
+        if (this->num_top_interface_layers == 0) {
+            // 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));
@@ -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]
@@ -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) {
-                            filler_interface->angle = base_support_angle;
-                            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;
-                        }
+                        fill_params.dont_sort = (m_object_config->support_interface_pattern == smipGrid ||
+                                                m_object_config->support_interface_pattern == smipRectilinearInterlaced);   

+                        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) {
-                            filler_interface->angle = base_support_angle;
-                            fill_params.dont_sort = true;
-                        }
+                        fill_params.dont_sort = (m_object_config->support_interface_pattern == smipGrid ||
+                                                m_object_config->support_interface_pattern == smipRectilinearInterlaced);   

-                        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;
@@ -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
@@ -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.
@@ -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()) {
@@ -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,
@@ -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);
@@ -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);
@@ -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();

@@ -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);

@@ -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);
@@ -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);
@@ -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();
@@ -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()) {
@@ -4535,6 +4535,16 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
    else if (evt.Dragging() || is_camera_rotate(evt, button_mappings) || is_camera_pan(evt, button_mappings)) {
        m_mouse.dragging = true;

+        // Orca: this event reports the position the pointer was teleported to by the infinite
+        // camera drag. Restart the drag from there, so the jump is not turned into a camera
+        // movement. Dropping the origin also keeps the drag consistent on platforms which
+        // silently ignore the warp request (Wayland), where the pointer never actually moved.
+        if (m_mouse.drag.pointer_wrapped) {
+            m_mouse.drag.pointer_wrapped = false;
+            m_mouse.set_start_position_2D_as_invalid();
+            m_mouse.set_start_position_3D_as_invalid();
+        }
+
        if (m_layers_editing.state != LayersEditing::Unknown && layer_editing_object_idx != -1) {
            if (m_layers_editing.state == LayersEditing::Editing) {
                _perform_layer_editing_action(&evt);
@@ -4616,6 +4626,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                camera.auto_type(Camera::EType::Perspective);
                m_dirty = true;
                m_mouse.ignore_right_up = true;  // will be reset on button up event even if not right button is pressed
+                _wrap_mouse_pointer_on_canvas_border(pos, Point(m_mouse.drag.start_position_3D.x(), m_mouse.drag.start_position_3D.y()));
            }

            m_camera_movement = true;
@@ -4642,6 +4653,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                camera.set_target(camera.get_target() + orig - cur_pos);
                m_dirty = true;
                m_mouse.ignore_right_up = true;  // will be reset on button up event even if not right button is pressed
+                _wrap_mouse_pointer_on_canvas_border(pos, m_mouse.drag.start_position_2D);
            }

            m_camera_movement = true;
@@ -5529,6 +5541,7 @@ void GLCanvas3D::mouse_up_cleanup()
    m_moving = false;
    m_camera_movement = false;
    m_mouse.drag.move_volume_idx = -1;
+    m_mouse.drag.pointer_wrapped = false;
    m_mouse.set_start_position_3D_as_invalid();
    m_mouse.set_start_position_2D_as_invalid();
    m_mouse.dragging = false;
@@ -6047,10 +6060,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_BOTTOM], _utf8("Bottom").c_str());
+    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_TOP], _u8L_CONTEXT("Top", "Camera View").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());

@@ -10226,6 +10239,55 @@ Vec3d GLCanvas3D::_mouse_to_bed_3d(const Point& mouse_pos)
    return mouse_ray(mouse_pos).intersect_plane(0.0);
 }

+// Orca: Blender-like infinite camera drag. Once a pan/orbit drag drives the pointer into a canvas
+// border it is teleported to the opposite one, so that the movement is only limited by how long
+// the user keeps dragging and not by the window (or screen) bounds. prev_pos is the position the
+// drag is coming from, which tells which border the pointer is being pushed against.
+// The drag is flagged instead of being offset by the jump, because the warp request is not
+// honoured everywhere - Wayland compositors ignore it, in which case the pointer stays at the
+// border and the drag simply stops there, exactly as it does with this feature disabled.
+void GLCanvas3D::_wrap_mouse_pointer_on_canvas_border(const Point& mouse_pos, const Point& prev_pos)
+{
+    if (m_canvas == nullptr || !wxGetApp().app_config->get_bool("infinite_camera_drag"))
+        return;
+
+    const Size cnv_size = get_canvas_size();
+
+    auto wrapped_coord = [](int coord, int prev_coord, int size) {
+        // The pointer is teleported once it comes this close to a border. The margin is
+        // proportional to the canvas because the pointer can travel a long way between two
+        // motion events of a fast drag, and a thin border would be stepped over.
+        const int border = std::clamp(size / 32, 12, 48);
+        // It then lands this far from the opposite border. A fixed inset is used rather than the
+        // mirrored crossing point: the latter leaves the pointer as close to the opposite border
+        // as it just came to this one, so grazing a border would wrap back and forth.
+        const int inset = std::clamp(size / 8, 48, 160);
+        // Nothing to wrap into if the canvas is too small to land clear of both borders.
+        if (size <= 2 * inset)
+            return coord;
+        // Only the axis the drag actually pushes into a border is wrapped, so that panning along
+        // a border - horizontally over the bottom of the canvas, say - does not wrap the other one.
+        if (coord > size - border && coord > prev_coord)
+            return inset;
+        if (coord < border && coord < prev_coord)
+            return size - inset;
+        return coord;
+    };
+
+    const Point wrapped(wrapped_coord(static_cast<int>(mouse_pos.x()), static_cast<int>(prev_pos.x()), cnv_size.get_width()),
+                        wrapped_coord(static_cast<int>(mouse_pos.y()), static_cast<int>(prev_pos.y()), cnv_size.get_height()));
+    if (wrapped == mouse_pos)
+        return;
+
+    Vec2d logical_pos = wrapped.cast<double>();
+#if ENABLE_RETINA_GL
+    const double factor = m_retina_helper->get_scale_factor();
+    logical_pos /= factor;
+#endif // ENABLE_RETINA_GL
+    m_canvas->WarpPointer(static_cast<int>(std::lround(logical_pos.x())), static_cast<int>(std::lround(logical_pos.y())));
+    m_mouse.drag.pointer_wrapped = true;
+}
+
 // While it looks like we can call
 // this->reload_scene(true, true)
 // the two functions are quite different:
@@ -333,6 +333,9 @@ class GLCanvas3D
            int move_volume_idx{ -1 };
            bool move_requires_threshold{ false };
            Point move_start_threshold_position_2D{ Invalid_2D_Point };
+            // Orca: set when the pointer has been teleported to the opposite canvas border
+            // by the infinite camera drag, see GLCanvas3D::_wrap_mouse_pointer_on_canvas_border()
+            bool pointer_wrapped{ false };
        };

        bool dragging{ false };
@@ -1221,6 +1224,10 @@ public:
 private:
    bool _is_shown_on_screen() const;

+    // Orca: teleports the pointer to the opposite canvas border when a camera drag pushes it
+    // into one, so that panning/orbiting is not limited by the window bounds.
+    void _wrap_mouse_pointer_on_canvas_border(const Point& mouse_pos, const Point& prev_pos);
+
    void _update_slice_error_status();

    void _switch_toolbars_icon_filename();
@@ -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();
 }

@@ -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);
@@ -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);
 }

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

@@ -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
-    auto obj_bb = model().objects[0]->bounding_box_exact();
-    auto height = 5 * ((params.end - params.start) / params.step + 1);
-    if (height < obj_bb.size().z()) {
-        cut_horizontal(0, 0, height, ModelObjectCutAttribute::KeepLower);
-    }
-
-    p->background_process.fff_print()->set_calib_params(params);
+    // Pass the resolved layer height on (only meaningful when resized). GCode's VFA stepping is layer-based, so
+    // it does not require it, but keep it consistent with the geometry.
+    Calib_Params calib_params = params;
+    calib_params.vfa_layer_height = params.nozzle_based_resize ? layer_height : 0.0;
+    p->background_process.fff_print()->set_calib_params(calib_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);
@@ -1785,6 +1785,9 @@ void PreferencesDialog::create_items()
    auto reverse_mouse_zoom    = create_item_checkbox(_L("Reverse mouse zoom"), _L("If enabled, reverses the direction of zoom with mouse wheel."), "reverse_mouse_wheel_zoom");
    g_sizer->Add(reverse_mouse_zoom);

+    auto item_infinite_camera_drag = create_item_checkbox(_L("Infinite camera drag"), _L("If enabled, the mouse pointer is teleported to the opposite side of the 3D view when it reaches a border while panning or orbiting, so camera movement is not limited by the window bounds."), "infinite_camera_drag");
+    g_sizer->Add(item_infinite_camera_drag);
+
    std::vector<wxString> ButtonDragActions = {_L("None"), _L("Pan"), _L("Rotate")};
    auto item_left_mouse_drag  = create_item_combobox(_L("Left Mouse Drag"), _L("Set the action that dragging the left mouse button should perform."), "left_mouse_drag_action", ButtonDragActions);
    g_sizer->Add(item_left_mouse_drag);
@@ -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();
    }
@@ -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);
@@ -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();
@@ -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();
@@ -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) {
@@ -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();
@@ -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);
@@ -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);
@@ -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;
 };

@@ -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;
@@ -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;

@@ -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;
@@ -32,6 +32,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
@@ -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));
+}
Author	SHA1	Message	Date
ExPikaPaka	8baefa4bdc	Fix camera teleporting back sometimes	2026-07-30 09:07:39 +02:00
ExPikaPaka	2b09c512d7	Add infinite pan	2026-07-29 10:46:39 +02:00
Kiss Lorand	29d4513694	Fix overlapping brims (#14991 )	2026-07-28 17:46:14 -03:00
Noisyfox Claude yw4z	5ede9711f5	Fix GTK3 dialog min size: SetSizer → SetSizerAndFit for dialogs without explicit SetMinSize (#14948 ) * For dialog without explicitly `SetMinSize`, we should use `SetSizerAndFit` instead, otherwise the dialog will not show correctly on GTK3. (OrcaSlicer/OrcaSlicer#14561) - and if `SetSizer` is called before the full layout has been built, then an extra `SetSizeHints` should be called before layout/fit so the min size can be properly set automatically based on children's min sizes accordingly. * Fix GTK3 dialog min size: SetSizer → SetSizerAndFit for dialogs without explicit SetMinSize Replace SetSizer() with SetSizerAndFit() in 11 dialog constructors that neither call SetMinSize() nor SetSizeHints(), ensuring proper minimum size propagation from child widgets on GTK3. SetSizerAndFit internally calls sizer->SetSizeHints(window), which sets the window's minimum size based on children — the same fix applied to ProjectDropDialog in `8a7662083e`. Also drop sizer->Fit(this) calls where present, since they only resize but don't set the min size hint needed by GTK3. Co-Authored-By: Claude <noreply@anthropic.com> * Update code style * Update TroubleshootDialog.hpp * Fix unsaved preset dialog layout * Fix MsgDialog layout * Fix other 3 instances in MsgDialog.cpp * Fix a few more instances * Fix printer option dialog too big on Windows --------- Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: yw4z <ywsyildiz@gmail.com>	2026-07-28 14:32:55 +08:00
Ian Bassi	6bcb809dd0	Calibrations improvements (#14759 )	2026-07-27 20:11:44 -03:00
Ian Bassi	33dfb66aa5	Cyclic ordering improvement (#14784 )	2026-07-27 19:58:54 -03:00
Maksym PyrozhokandIan Bassi	ef7bfeda9c	Cyclic ordering (#13578 ) Co-authored-by: Ian Bassi <ian.bassi@outlook.com>	2026-07-27 19:52:29 -03:00
Ian Bassi Felix14_v2 π²	47ccca7f72	Full Orca translation via AI (tagged) (#14970 ) Co-authored-by: Felix14_v2 <75726196+Felix14-v2@users.noreply.github.com> Co-authored-by: π² <189209038+pi-squared-studio@users.noreply.github.com>	2026-07-27 19:31:33 -03:00
Kiss Lorand	04e13200aa	Support bugfixes (#14678 )	2026-07-26 19:16:19 -03:00