Defer Plugin Dock Panes Until the Plater Is Shown

A plugin enabled at startup loads before the main frame exists, so a
dock panel it opens from on_load was dropped by the one-shot CallAfter
that found no plater. Opened a moment later, before the frame was laid
out, the pane was sized against the unsized frame and track_docked_size
kept that width. Poll until the plater is shown on screen, then build
the pane; release the reserved id instead when the app is closing.

.claude/skills/orca-profiles/references/extruder-variants.md

@@ -105,11 +105,12 @@ Rules:
    `single_extruder_multi_material` off, and in the app when the printer tab loads a printer with a
    different number of extruders, the pair is rebuilt from `extruder_variant_list` (one
    `Direct Drive Standard` per extruder when the list is absent) and the variant arrays are resized to
-   the rebuilt pair, padded with their first value or cut. The resize skips the `machine_max_*` limits
-   and `hotend_heating_rate` / `hotend_cooling_rate`: they keep their width, and an extruder beyond it
-   reads their first value, so extruder 2 and up of a list-less printer take extruder 1's normal limit
-   as their silent one too. With the three in agreement that changes nothing; a pair written without
-   the list is replaced. A listed variant the pair lacks is a menu choice that reads variant index 0.
+   the rebuilt pair, padded with their first value or cut. The `machine_max_*` limits are padded the
+   same way, so extruder 2 and up of a list-less printer take extruder 1's normal limit as their
+   silent one too. The resize skips `hotend_heating_rate` / `hotend_cooling_rate`: they keep their
+   width, and an extruder beyond it reads their first value. With the three in agreement that changes
+   nothing; a pair written without the list is replaced. A listed variant the pair lacks is a menu
+   choice that reads variant index 0.
    - The pair without `extruder_variant_list` slices, but the sidebar offers no variant switch and
      the app cannot add variants to a list-less process: nothing is lost while every extruder
      has exactly one variant, and every further variant is unreachable.

resources/images/delete_all_filaments.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M5.5,14.5c-1.105,0-2-3.686-2-7s.895-7,2-7" style="fill:none;stroke:#009688;stroke-linecap:round;stroke-linejoin:round"/><line x1="8.67" y1="4.67" x2="14.33" y2="10.33" style="fill:none;stroke:#949494;stroke-linecap:square;stroke-linejoin:round"/><line x1="14.33" y1="4.67" x2="8.67" y2="10.33" style="fill:none;stroke:#949494;stroke-linecap:square;stroke-linejoin:round"/><path d="M3.5,13.7c-.294.511-.636.8-1,.8-1.1,0-2-3.686-2-7s.9-7,2-7c.365,0,.707.293,1,.805" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/><path d="M6.727,4.5c.334-2.208,1-4,1.773-4,.354,0,.686.378.974,1" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/><path d="M9.474,13.5c-.288.622-.62,1-.974,1-.77,0-1.439-1.792-1.773-4" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/></svg>

resources/shaders/110/texture_displacement_shaded.fs

@@ -29,13 +29,19 @@ uniform vec3      palette_lab[64];
 uniform vec3      palette_rgb[64];
 uniform int       palette_count;
 uniform bool      pure_only;      // match against single filaments only (flat-colour image)
-// How each entry prints. Every entry names a single filament: a mix is given its own mixed filament
-// slot, whose components the slicer alternates per print layer, so the fragment just looks that slot's
-// colour up.
+// How each entry prints. A pure entry is one filament (a == b); a mix interleaves filaments a and b,
+// num parts of a in every den, and the print shows that interleave rather than the entry's average
+// colour. The fragment resolves it exactly as GLGizmoTextureDisplacement::make_mix_resolver() does
+// per triangle on the CPU, so the preview shows the pattern the bake will print.
 uniform int       palette_a[64];
 uniform int       palette_b[64];
+uniform int       palette_num[64];
+uniform int       palette_den[64];
 uniform vec3      filament_rgb[16];
 uniform int       filament_count;
+uniform int       mix_mode;     // ColorMixMode: 0 Z bands, 1 XY dither, 2 auto
+uniform float     layer_height; // mm; one Z band per print layer
+uniform float     dither_cell;  // mm; one XY dither cell
 uniform sampler2D color_tex;     // the layer's colour image, sampled at the same uv as the height
 uniform bool      has_color_tex;
 uniform bool volume_mirrored;
@@ -223,16 +229,63 @@ int nearest_palette_entry(vec3 rgb)
 }
 
 // One 2x2 Bayer cell, {0, 2; 3, 1}, for x and y in {0, 1}.
+float bayer2(float x, float y) { return 2.0 * x + 3.0 * y - 4.0 * x * y; }
 
-// The colour the printer lays down at world point `pos` for palette entry `index`. Every entry names a
-// single filament: a mix is given its own mixed filament slot, whose components the slicer alternates
-// per print layer, so there is nothing left to interleave here.
-vec3 printed_color(int index)
+// The colour the printer lays down at world point `pos` for palette entry `index`: its filament, or
+// for a mix whichever of its two filaments this point falls on. Mirrors make_mix_resolver() on the
+// CPU, floors on the band/cell size included. All the modular arithmetic is done in floats with
+// mod(), which wraps negative coordinates the way the CPU's ((v % n) + n) % n does and needs no
+// integer % (not available on every GLSL 1.10 target).
+vec3 printed_color(int index, vec3 pos, vec3 normal, vec3 footprint)
 {
     int a = palette_a[index];
-    if (a < 0 || a >= filament_count)
+    int b = palette_b[index];
+    if (a < 0 || a >= filament_count || b < 0 || b >= filament_count)
         return palette_rgb[index]; // no filament to resolve to: the entry's own colour
-    return filament_rgb[a];
+    if (a == b)
+        return filament_rgb[a];
+    float num = float(palette_num[index]);
+    float den = float(palette_den[index]);
+    // Auto: bands where the surface is steeper than ~45 degrees, the dominant filament elsewhere.
+    if (mix_mode == 2 && abs(normal.z) >= 0.7)
+        return filament_rgb[(num * 2.0 >= den) ? a : b];
+
+    // Pre-filter. The interleave is an ordered dither the eye is meant to blend away, and no dither
+    // blends when it is drawn at less than a few pixels per period - it aliases, which is what turned
+    // every upright wall into horizontal streaks: the Z band cycle is den * layer_height (around a
+    // millimetre), and every pixel of a row on a vertical wall shares one z, so each row came out as a
+    // 1-bit threshold of the image at that row's phase. `footprint` is mm of world position per pixel,
+    // so this is zoom- and resolution-correct rather than a tuned constant: where the print's own
+    // pattern is finer than this view can resolve, show what the print looks like from here, which is
+    // the entry's perceptual average. The Normal view remains where the per-facet truth lives.
+    float period = (mix_mode == 1) ? 2.0 * max(dither_cell, 0.01) : den * max(layer_height, 0.01);
+    float px     = (mix_mode == 1) ? max(footprint.x, footprint.y) : footprint.z;
+    float sharp  = clamp(period / max(4.0 * px, 1e-6) - 0.5, 0.0, 1.0);
+    if (sharp <= 0.0)
+        return palette_rgb[index];
+
+    vec3 picked;
+    if (mix_mode == 1) {
+        // Ordered 4x4 Bayer over floor(x / cell), floor(y / cell). The CPU's table
+        //     0  8  2 10
+        //    12  4 14  6
+        //     3 11  1  9
+        //    15  7 13  5
+        // is 4 * bayer2(x % 2, y % 2) + bayer2(x / 2, y / 2), which needs no array (GLSL 1.10 has
+        // no constant arrays).
+        float cell  = max(dither_cell, 0.01);
+        float gx    = mod(floor(pos.x / cell), 4.0);
+        float gy    = mod(floor(pos.y / cell), 4.0);
+        float bayer = 4.0 * bayer2(mod(gx, 2.0), mod(gy, 2.0)) + bayer2(floor(gx / 2.0), floor(gy / 2.0));
+        picked = filament_rgb[(num / den > (bayer + 0.5) / 16.0) ? a : b];
+    } else {
+        // Z bands: one per band height, the band's phase in the a/b cycle picks the filament. Both
+        // operands are integer-valued, so the half keeps "phase < num" exact under float rounding.
+        float slot  = floor(pos.z / max(layer_height, 0.01));
+        float phase = mod(slot, den);
+        picked = filament_rgb[(phase < num - 0.5) ? a : b];
+    }
+    return mix(palette_rgb[index], picked, sharp);
 }
 
 void main()
@@ -243,6 +296,9 @@ void main()
     // World millimetres throughout, like the bake - see the 140 variant.
     vec3 triangle_normal = normalize(cross(dFdx(world_pos.xyz), dFdy(world_pos.xyz)));
     vec3 tex_pos = world_pos.xyz - tex_anchor; // the frame the texture is projected in, as the bake does
+    // World mm per pixel, for pre-filtering the interleave in printed_color(). Taken here because the
+    // albedo branch at the end of main() is non-uniform control flow, where derivatives are undefined.
+    vec3 pos_fwidth = fwidth(world_pos.xyz);
     if (volume_mirrored)
         triangle_normal = -triangle_normal;
 
@@ -364,6 +420,6 @@ void main()
         // orientation and scale about the volume's origin, see texture_displacement_bake_frame()), so
         // measuring z from the bed instead shifted the band phase by the volume origin's height - a
         // different filament in the same place than the bake produces.
-        albedo = printed_color(nearest_palette_entry(texture2D(color_tex, color_uv).rgb));
+        albedo = printed_color(nearest_palette_entry(texture2D(color_tex, color_uv).rgb), tex_pos, triangle_normal, pos_fwidth);
     gl_FragColor = vec4(vec3(intensity.y) + albedo * intensity.x, uniform_color.a);
 }

resources/shaders/140/texture_displacement_shaded.fs

@@ -88,13 +88,19 @@ uniform vec3      palette_lab[64];
 uniform vec3      palette_rgb[64];
 uniform int       palette_count;
 uniform bool      pure_only;      // match against single filaments only (flat-colour image)
-// How each entry prints. Every entry names a single filament: a mix is given its own mixed filament
-// slot, whose components the slicer alternates per print layer, so the fragment just looks that slot's
-// colour up.
+// How each entry prints. A pure entry is one filament (a == b); a mix interleaves filaments a and b,
+// num parts of a in every den, and the print shows that interleave rather than the entry's average
+// colour. The fragment resolves it exactly as GLGizmoTextureDisplacement::make_mix_resolver() does
+// per triangle on the CPU, so the preview shows the pattern the bake will print.
 uniform int       palette_a[64];
 uniform int       palette_b[64];
+uniform int       palette_num[64];
+uniform int       palette_den[64];
 uniform vec3      filament_rgb[16];
 uniform int       filament_count;
+uniform int       mix_mode;     // ColorMixMode: 0 Z bands, 1 XY dither, 2 auto
+uniform float     layer_height; // mm; one Z band per print layer
+uniform float     dither_cell;  // mm; one XY dither cell
 uniform sampler2D color_tex;     // the layer's colour image, sampled at the same uv as the height
 uniform bool      has_color_tex;
 uniform bool volume_mirrored;
@@ -289,16 +295,63 @@ int nearest_palette_entry(vec3 rgb)
 }
 
 // One 2x2 Bayer cell, {0, 2; 3, 1}, for x and y in {0, 1}.
+float bayer2(float x, float y) { return 2.0 * x + 3.0 * y - 4.0 * x * y; }
 
-// The colour the printer lays down at world point `pos` for palette entry `index`. Every entry names a
-// single filament: a mix is given its own mixed filament slot, whose components the slicer alternates
-// per print layer, so there is nothing left to interleave here.
-vec3 printed_color(int index)
+// The colour the printer lays down at world point `pos` for palette entry `index`: its filament, or
+// for a mix whichever of its two filaments this point falls on. Mirrors make_mix_resolver() on the
+// CPU, floors on the band/cell size included. All the modular arithmetic is done in floats with
+// mod(), which wraps negative coordinates the way the CPU's ((v % n) + n) % n does and needs no
+// integer % (not available on every GLSL 1.10 target).
+vec3 printed_color(int index, vec3 pos, vec3 normal, vec3 footprint)
 {
     int a = palette_a[index];
-    if (a < 0 || a >= filament_count)
+    int b = palette_b[index];
+    if (a < 0 || a >= filament_count || b < 0 || b >= filament_count)
         return palette_rgb[index]; // no filament to resolve to: the entry's own colour
-    return filament_rgb[a];
+    if (a == b)
+        return filament_rgb[a];
+    float num = float(palette_num[index]);
+    float den = float(palette_den[index]);
+    // Auto: bands where the surface is steeper than ~45 degrees, the dominant filament elsewhere.
+    if (mix_mode == 2 && abs(normal.z) >= 0.7)
+        return filament_rgb[(num * 2.0 >= den) ? a : b];
+
+    // Pre-filter. The interleave is an ordered dither the eye is meant to blend away, and no dither
+    // blends when it is drawn at less than a few pixels per period - it aliases, which is what turned
+    // every upright wall into horizontal streaks: the Z band cycle is den * layer_height (around a
+    // millimetre), and every pixel of a row on a vertical wall shares one z, so each row came out as a
+    // 1-bit threshold of the image at that row's phase. `footprint` is mm of world position per pixel,
+    // so this is zoom- and resolution-correct rather than a tuned constant: where the print's own
+    // pattern is finer than this view can resolve, show what the print looks like from here, which is
+    // the entry's perceptual average. The Normal view remains where the per-facet truth lives.
+    float period = (mix_mode == 1) ? 2.0 * max(dither_cell, 0.01) : den * max(layer_height, 0.01);
+    float px     = (mix_mode == 1) ? max(footprint.x, footprint.y) : footprint.z;
+    float sharp  = clamp(period / max(4.0 * px, 1e-6) - 0.5, 0.0, 1.0);
+    if (sharp <= 0.0)
+        return palette_rgb[index];
+
+    vec3 picked;
+    if (mix_mode == 1) {
+        // Ordered 4x4 Bayer over floor(x / cell), floor(y / cell). The CPU's table
+        //     0  8  2 10
+        //    12  4 14  6
+        //     3 11  1  9
+        //    15  7 13  5
+        // is 4 * bayer2(x % 2, y % 2) + bayer2(x / 2, y / 2), which needs no array (GLSL 1.10 has
+        // no constant arrays).
+        float cell  = max(dither_cell, 0.01);
+        float gx    = mod(floor(pos.x / cell), 4.0);
+        float gy    = mod(floor(pos.y / cell), 4.0);
+        float bayer = 4.0 * bayer2(mod(gx, 2.0), mod(gy, 2.0)) + bayer2(floor(gx / 2.0), floor(gy / 2.0));
+        picked = filament_rgb[(num / den > (bayer + 0.5) / 16.0) ? a : b];
+    } else {
+        // Z bands: one per band height, the band's phase in the a/b cycle picks the filament. Both
+        // operands are integer-valued, so the half keeps "phase < num" exact under float rounding.
+        float slot  = floor(pos.z / max(layer_height, 0.01));
+        float phase = mod(slot, den);
+        picked = filament_rgb[(phase < num - 0.5) ? a : b];
+    }
+    return mix(palette_rgb[index], picked, sharp);
 }
 
 void main()
@@ -311,6 +364,9 @@ void main()
     // world position and perturb the world normal.
     vec3 triangle_normal = normalize(cross(dFdx(world_pos.xyz), dFdy(world_pos.xyz)));
     vec3 tex_pos = world_pos.xyz - tex_anchor; // the frame the texture is projected in, as the bake does
+    // World mm per pixel, for pre-filtering the interleave in printed_color(). Taken here because the
+    // albedo branch at the end of main() is non-uniform control flow, where derivatives are undefined.
+    vec3 pos_fwidth = fwidth(world_pos.xyz);
     if (volume_mirrored)
         triangle_normal = -triangle_normal;
 
@@ -452,6 +508,6 @@ void main()
         // orientation and scale about the volume's origin, see texture_displacement_bake_frame()), so
         // measuring z from the bed instead shifted the band phase by the volume origin's height - a
         // different filament in the same place than the bake produces.
-        albedo = printed_color(nearest_palette_entry(texture(color_tex, color_uv).rgb));
+        albedo = printed_color(nearest_palette_entry(texture(color_tex, color_uv).rgb), tex_pos, triangle_normal, pos_fwidth);
     out_color = vec4(vec3(intensity.y) + albedo * intensity.x, uniform_color.a);
 }

resources/web/guide/21/common.js

@@ -311,7 +311,7 @@ function CreatePrinterBlock(OneModel)
 
 	return	'<div class="PrinterBlock" onClick="ChooseModel(\''+vendor+'\',\''+OneModel['model']+'\')">'+
 			'	<div class="PImg">'+
-			'		<img class="ModelThumbnail" src="' + OneModel['cover'] + '" />'+
+			'		<img class="ModelThumbnail" src="' + OneModel['cover'] + '" onerror="this.onerror=null;this.src=\'../img/printer-dummy.png\';"/>'+
 			'	</div>'+
 			'	<div class="PrinterInfoMark">?</div>'+
 			'	<div class="PrinterInfo">'+

scripts/appimage_lib_policy.sh

@@ -23,7 +23,13 @@ appimage_is_host_library() {
 }
 
 appimage_is_elf_file() {
-    file -b "$1" 2>/dev/null | grep -q '^ELF '
+    # Read the four-byte ELF magic rather than asking file(1): this runs once per candidate, and an
+    # AppDir holds thousands of them (the bundled Python runtime alone is ~5k files, none of them
+    # ELF). Two processes per call made this ~14 s of a ~95 s image build on its own.
+    local magic
+    [[ -f "$1" && -r "$1" ]] || return 1
+    IFS= read -r -n 4 -d '' magic < "$1" 2>/dev/null
+    [[ $magic == $'\177ELF' ]]
 }
 
 appimage_list_direct_dependencies() {

scripts/disable_validation.entitlements

@@ -4,5 +4,10 @@
 <dict>
     <key>com.apple.security.cs.disable-library-validation</key>
     <true/>
+    <!-- The Bambu network plug-in's code protector rewrites one of its own signed code pages
+         after loading. Under the hardened runtime macOS kills the process when that page is
+         paged back in; this lets it run, as Bambu Studio's signature does. -->
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
 </dict>
 </plist>

src/OrcaSlicer.cpp

@@ -3618,6 +3618,9 @@ int CLI::run(int argc, char **argv)
                 {
                     if (opt_key == "compatible_prints" || opt_key == "compatible_printers" || opt_key == "model_id" || opt_key == "dev_model_name" || opt_key == "filament_settings_id")
                         continue;
+                    // rebuilt from every filament after this loop
+                    if (filament_dev_options.find(opt_key) != filament_dev_options.end())
+                        continue;
                     ConfigOption *opt = m_print_config.option(opt_key, true);
                     if (opt == nullptr) {
                         // opt_key does not exist in this ConfigBase and it cannot be created, because it is not defined by this->def().
@@ -3681,6 +3684,14 @@ int CLI::run(int argc, char **argv)
             }
         }
 
+        // The stored values cannot be told apart per filament, so they are kept as they are unless every slot has a config.
+        std::vector<const DynamicPrintConfig *> filament_configs(filament_count, nullptr);
+        for (size_t index = 0; index < load_filaments_config.size(); index++)
+            if (load_filaments_index[index] >= 1 && load_filaments_index[index] <= filament_count)
+                filament_configs[load_filaments_index[index] - 1] = &load_filaments_config[index];
+        if (std::find(filament_configs.begin(), filament_configs.end(), nullptr) == filament_configs.end())
+            set_filament_dev_options(m_print_config, filament_configs);
+
         if (m_print_config.option<ConfigOptionStrings>("filament_extruder_variant")) {
             std::vector<int>& filament_self_indice = m_print_config.option<ConfigOptionInts>("filament_self_index", true)->values;
             int index_size = m_print_config.option<ConfigOptionStrings>("filament_extruder_variant")->size();

src/dev-utils/platform/osx/entitlements.plist

@@ -5,5 +5,10 @@
   <!-- for dynamic loading of libraries without signature validation. Used for 3dconnection drivers.-->
   <key>com.apple.security.cs.disable-library-validation</key>  
   <true/>
+  <!-- The Bambu network plug-in's code protector rewrites one of its own signed code pages
+       after loading. Under the hardened runtime macOS kills the process when that page is
+       paged back in; this lets it run, as Bambu Studio's signature does. -->
+  <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+  <true/>
 </dict>
 </plist>

src/dev-utils/platform/unix/build_linux_image.sh.in

@@ -118,9 +118,13 @@ bundle_dependency_closure() {
     # (scripts/check_appimage_libs.sh).
     local -a search_dirs=("$dst_dir")
 
-    while [ ${#queue[@]} -gt 0 ]; do
-        target="${queue[0]}"
-        queue=("${queue[@]:1}")
+    # Walked with a read index rather than by reslicing the array: "${queue[@]:1}" rebuilds the whole
+    # queue on every pop, so draining it costs O(n^2). At the ~5k entries this bundle reaches that was
+    # ~22 s of the image build spent copying an array around.
+    local head=0
+    while [ "$head" -lt ${#queue[@]} ]; do
+        target="${queue[$head]}"
+        head=$((head + 1))
 
         if [ ! -e "$target" ] || ! appimage_is_elf_file "$target"; then
             continue

src/libslic3r/PrintConfig.cpp

@@ -10030,6 +10030,13 @@ static void extend_extruder_variant(DynamicPrintConfig& config, const unsigned i
             printer_extruder_variant_opt->values.insert(printer_extruder_variant_opt->values.end(), variants_list.begin(), variants_list.end());
         }
     }
+
+    // 3. Size the machine limits to the rebuilt variants, padded with their first value like the other variant keys.
+    // They are not extruder option keys, so the resize loop in set_num_extruders skips them.
+    const auto &defaults = FullPrintConfig::defaults();
+    for (const std::string &key : printer_options_with_variant_2)
+        if (auto *opt = config.option<ConfigOptionFloats>(key))
+            opt->resize(config.get_parameter_size(key, num_extruders), defaults.option(key));
 }
 
 void DynamicPrintConfig::set_num_extruders(unsigned int num_extruders)
@@ -10822,6 +10829,22 @@ void normalize_filament_values_to_variants(DynamicPrintConfig &config)
     }
 }
 
+void set_filament_dev_options(DynamicPrintConfig &config, const std::vector<const DynamicPrintConfig *> &filament_configs)
+{
+    for (const std::string &key : filament_dev_options) {
+        if (std::none_of(filament_configs.begin(), filament_configs.end(), [&key](const DynamicPrintConfig *filament) { return filament->has(key); }))
+            continue;
+        const ConfigOption *default_value = print_config_def.get(key)->default_value.get();
+        auto *dst = static_cast<ConfigOptionVectorBase *>(config.option(key, true));
+        dst->clear();
+        for (const DynamicPrintConfig *filament : filament_configs) {
+            const auto *src = static_cast<const ConfigOptionVectorBase *>(filament->has(key) ? filament->option(key) : default_value);
+            if (!src->empty())
+                dst->append(src);
+        }
+    }
+}
+
 
 //used for object/region config
 //use the smallest of multiple to single
@@ -11520,12 +11543,18 @@ void DynamicPrintConfig::update_non_diff_values_to_base_config(DynamicPrintConfi
     int cur_variant_count = cur_extruder_variants.size();
     int target_variant_count = target_extruder_variants.size();
 
+    // A base variant this config does not list (the base gained it after the config was saved, or the
+    // config lists none) takes this config's first variant of the same extruder, as a user preset's
+    // values do in update_diff_values_to_child_config. Left unmatched, the base's value would silently
+    // replace the user's.
     variant_index.resize(target_variant_count, -1);
     if (cur_variant_count == 0) {
         // Defensive: target_variant_count may be 0 if the preset doesn't carry extruder_variant_name.
         // In that case keep variant_index empty and let the downstream size checks produce a useful error.
         if (!variant_index.empty())
-            variant_index[0] = 0;
+            // This config's one value belongs to the extruder of the base's first variant.
+            variant_index = map_variant_indices(target_extruder_variants, target_extruder_ids, {},
+                                                target_extruder_ids.empty() ? std::vector<int>() : std::vector<int>{target_extruder_ids[0]});
     }
     else if ((cur_extruder_ids.size() > 0) && cur_variant_count != cur_extruder_ids.size()){
         //should not happen
@@ -11538,18 +11567,7 @@ void DynamicPrintConfig::update_non_diff_values_to_base_config(DynamicPrintConfi
              %extruder_variant_name %target_variant_count %extruder_id_name %target_extruder_ids.size();
     }
     else {
-        for (int i = 0; i < target_variant_count; i++)
-        {
-            for (int j = 0; j < cur_variant_count; j++)
-            {
-                if ((target_extruder_variants[i] == cur_extruder_variants[j])
-                    &&(target_extruder_ids.empty() || (target_extruder_ids[i] == cur_extruder_ids[j])))
-                {
-                    variant_index[i] = j;
-                    break;
-                }
-            }
-        }
+        variant_index = map_variant_indices(target_extruder_variants, target_extruder_ids, cur_extruder_variants, cur_extruder_ids);
     }
 
     for (auto& opt : keys) {
@@ -11574,6 +11592,13 @@ void DynamicPrintConfig::update_non_diff_values_to_base_config(DynamicPrintConfi
                     if (cur_variant_count > target_variant_count)
                         continue;
 
+                    // The variant lists are the base's layout itself, which every other value is
+                    // carried onto: a variant this config lacks keeps its own name and id.
+                    if (opt == extruder_id_name || opt == extruder_variant_name) {
+                        opt_src->set(opt_target);
+                        continue;
+                    }
+
                     int stride = 1;
                     if (key_set2.find(opt) != key_set2.end())
                         stride = 2;

src/libslic3r/PrintConfig.hpp

@@ -928,6 +928,11 @@ void normalize_filament_values_to_variants(DynamicPrintConfig &config);
 
 extern std::set<std::string> filament_dev_options;
 
+// Orca: a filament_dev_options option holds several values per filament, and how many is up to the
+// filament preset, so one filament's values cannot be replaced in place. This rebuilds each option from
+// filament_configs, one config per filament in slot order, as the filaments' values one after another.
+void set_filament_dev_options(DynamicPrintConfig &config, const std::vector<const DynamicPrintConfig *> &filament_configs);
+
 extern void update_static_print_config_from_dynamic(ConfigBase& config, const DynamicPrintConfig& dest_config, std::vector<int> variant_index, std::set<std::string>& key_set1, int stride = 1);
 extern void compute_filament_override_value(const std::string& opt_key, const ConfigOption *opt_old_machine, const ConfigOption *opt_new_machine, const ConfigOption *opt_new_filament, const DynamicPrintConfig& new_full_config,
     t_config_option_keys& diff_keys, DynamicPrintConfig& filament_overrides, std::vector<int>& f_map_indices);

src/libslic3r/TextureBake/TextureBakeDecimate.cpp

@@ -551,13 +551,9 @@ DecimateResult decimate(const TriSoup &geometry, size_t target_triangles, bool h
 
     // Rebuild from the surviving faces, with per-face normals.
     TriSoup &out = result.geometry;
-    if (!face_color.empty())
-        result.face_color.reserve(active_faces);
     for (size_t f = 0; f < face_count; ++f) {
         if (faces[f * 3] < 0)
             continue;
-        if (!face_color.empty())
-            result.face_color.push_back(f < face_color.size() ? face_color[f] : -1);
         const Vec3f a = pos[size_t(faces[f * 3])].cast<float>();
         const Vec3f b = pos[size_t(faces[f * 3 + 1])].cast<float>();
         const Vec3f c = pos[size_t(faces[f * 3 + 2])].cast<float>();

src/libslic3r/TextureBake/TextureBakeDecimate.hpp

@@ -46,13 +46,6 @@ using DecimateProgressFn = std::function<bool(double fraction)>;
 struct DecimateResult
 {
     TriSoup geometry;
-    // One entry per output face, carried from the `face_color` handed in: a colour difference is a
-    // crease, so no collapse ever merges two faces of different colour and every survivor keeps exactly
-    // the colour it came with. Empty when no `face_color` was given.
-    //
-    // This is what lets the caller colour the simplified mesh by *provenance* rather than by sampling it
-    // again: the input colours were masked by the paint on the fine mesh, where that mask is exact.
-    std::vector<int> face_color;
     // The locked faces alone met the target, so it was unreachable without touching preserved
     // geometry.
     bool locked_over_budget = false;

src/libslic3r/TextureBake/TextureBakeMesh.cpp

@@ -42,7 +42,7 @@ TriSoup to_soup(const indexed_triangle_set &its, const std::vector<uint8_t> &fac
     return out;
 }
 
-indexed_triangle_set to_indexed_triangle_set(const TriSoup &soup, std::vector<int> *face_color)
+indexed_triangle_set to_indexed_triangle_set(const TriSoup &soup)
 {
     indexed_triangle_set out;
     const size_t         n = soup.pos.size();
@@ -54,22 +54,12 @@ indexed_triangle_set to_indexed_triangle_set(const TriSoup &soup, std::vector<in
         if (map.inserted())
             out.vertices.push_back(soup.pos[i]);
     }
-    const bool       track_color = face_color != nullptr && !face_color->empty();
-    std::vector<int> kept_color;
-    if (track_color)
-        kept_color.reserve(face_color->size());
     for (size_t t = 0; t + 2 < n; t += 3) {
         // Welded-together corners carry no area.
         if (id[t] == id[t + 1] || id[t + 1] == id[t + 2] || id[t] == id[t + 2])
             continue;
         out.indices.emplace_back(id[t], id[t + 1], id[t + 2]);
-        if (track_color) {
-            const size_t src = t / 3;
-            kept_color.push_back(src < face_color->size() ? (*face_color)[src] : -1);
-        }
     }
-    if (track_color)
-        *face_color = std::move(kept_color);
     return out;
 }
 

src/libslic3r/TextureBake/TextureBakeMesh.hpp

@@ -15,10 +15,7 @@ namespace TextureBake {
 TriSoup to_soup(const indexed_triangle_set &its, const std::vector<uint8_t> &face_excluded = {});
 
 // Welds at the geometry grid.
-// `face_color`, when given, is read as one entry per soup triangle and rewritten to match the output.
-// Welding can leave a triangle with no area, and those are dropped here, so the two would otherwise
-// fall out of step.
-indexed_triangle_set to_indexed_triangle_set(const TriSoup &soup, std::vector<int> *face_color = nullptr);
+indexed_triangle_set to_indexed_triangle_set(const TriSoup &soup);
 
 } // namespace TextureBake
 } // namespace Slic3r

src/libslic3r/TextureBake/TextureBakePipeline.cpp

@@ -290,34 +290,6 @@ PipelineResult run_pipeline(const TriSoup &input, const HeightSampleFn &sample,
         return result;
     }
 
-    // Colour per face, taken here and carried from here on. This is the only point where the paint mask
-    // is exact: `exclude_weight` says which faces the paint left out, and the mesh is still the refined
-    // one the displacement produced. Everything downstream (the collapse, the T-junction repair) carries
-    // these along rather than sampling again, and the caller uses them as they are.
-    //
-    // It also gives the collapse its crease criterion: an edge between two colours is never collapsed
-    // across, which is what keeps a survivor's colour well defined.
-    if (color_sample) {
-        const size_t nf = displaced.triangle_count();
-        result.face_color.assign(nf, -1);
-        const bool have_w = !displaced.exclude_weight.empty();
-        tbb::parallel_for(tbb::blocked_range<size_t>(0, nf), [&](const tbb::blocked_range<size_t> &r) {
-            for (size_t t = r.begin(); t < r.end(); ++t) {
-                // Unpainted faces take no colour at all, which is what stops the texture appearing on
-                // surfaces the paint never covered.
-                if (have_w && (displaced.exclude_weight[t * 3] + displaced.exclude_weight[t * 3 + 1] +
-                               displaced.exclude_weight[t * 3 + 2]) / 3.f > 0.99f)
-                    continue; // stays FACE_UNPAINTED
-                const Vec3f &a = displaced.pos[t * 3], &b = displaced.pos[t * 3 + 1], &c = displaced.pos[t * 3 + 2];
-                const int    sampled = color_sample((a + b + c) / 3.f, displaced.nrm[t * 3]);
-                // Painted either way. The sampler expects a point on the base surface and these are on
-                // the displaced one, so off the patch by more than its tolerance it simply says "no
-                // colour" - which must not be confused with "not painted".
-                result.face_color[t] = (sampled >= 0) ? sampled : FACE_NO_COLOUR;
-            }
-        });
-    }
-
     // 4. Decimate - export only. A bake needs the face-parent map, which a collapse destroys.
     std::vector<int>   parent                   = std::move(sub.face_parent_id);
     const size_t       displaced_before_decimate = displaced.triangle_count();
@@ -351,8 +323,24 @@ PipelineResult run_pipeline(const TriSoup &input, const HeightSampleFn &sample,
         // unless the budget was lowered until decimation had to run. Only collapses costing less than
         // harvest_tol are taken, so this does not reach the relief.
         const bool harvest_only = !over_budget && settings.harvest_flat && displaced.triangle_count() > 0;
-        std::vector<int> &face_color = result.face_color;
         if (over_budget || harvest_only) {
+            // Colour per face on the fine mesh, so colour boundaries become creases the collapse
+            // respects. Excluded (unpainted) faces take no colour.
+            std::vector<int> face_color;
+            if (color_sample) {
+                const size_t nf = displaced.triangle_count();
+                face_color.assign(nf, -1);
+                const bool have_w = !displaced.exclude_weight.empty();
+                tbb::parallel_for(tbb::blocked_range<size_t>(0, nf), [&](const tbb::blocked_range<size_t> &r) {
+                    for (size_t t = r.begin(); t < r.end(); ++t) {
+                        if (have_w && (displaced.exclude_weight[t * 3] + displaced.exclude_weight[t * 3 + 1] +
+                                       displaced.exclude_weight[t * 3 + 2]) / 3.f > 0.99f)
+                            continue;
+                        const Vec3f &a = displaced.pos[t * 3], &b = displaced.pos[t * 3 + 1], &c = displaced.pos[t * 3 + 2];
+                        face_color[t] = color_sample((a + b + c) / 3.f, displaced.nrm[t * 3]);
+                    }
+                });
+            }
             // Harvesting alone is asked for by handing it the count it already has: nothing is then
             // over the target, so the loop only ever pops collapses under the tolerance.
             const size_t before = displaced.triangle_count();
@@ -362,7 +350,6 @@ PipelineResult run_pipeline(const TriSoup &input, const HeightSampleFn &sample,
             result.locked_over_budget = dec.locked_over_budget;
             result.budget_limited     = result.simplified = dec.target_cost_detail;
             displaced                 = std::move(dec.geometry);
-            face_color                = std::move(dec.face_color);
             lap("decimate", displaced, over_budget ? "over budget, simplified" : "flat faces harvested");
             BOOST_LOG_TRIVIAL(info) << "TextureBake decimate: " << before << " -> " << displaced.triangle_count()
                                     << (over_budget ? " (budget " : " (flat harvest, budget ") << target << ")";
@@ -390,7 +377,7 @@ PipelineResult run_pipeline(const TriSoup &input, const HeightSampleFn &sample,
 
     // 6. Close the T-junctions decimation left behind. Only meaningful when it ran.
     if (mode == PipelineMode::Export && parent.empty()) {
-        displaced = resolve_t_junctions(displaced, {}, &result.face_color);
+        displaced = resolve_t_junctions(displaced);
         lap("repair", displaced);
     }
 

src/libslic3r/TextureBake/TextureBakePipeline.hpp

@@ -108,27 +108,9 @@ using PipelineProgressFn = std::function<bool(const char *stage, double fraction
 // colour-boundary creases. Only consulted when the mesh is over budget.
 using ColorSampleFn = std::function<int(const Vec3f &centroid, const Vec3f &normal)>;
 
-// Sentinels for PipelineResult::face_color.
-static constexpr int FACE_UNPAINTED = -1; // the paint did not cover this face's origin
-static constexpr int FACE_NO_COLOUR = -2; // painted, but the sampler returned nothing at this point
-
 struct PipelineResult
 {
     TriSoup geometry;
-    // One entry per output face, carried through decimation, the T-junction repair and the weld.
-    // FACE_UNPAINTED means the paint never covered the geometry this face came from; anything else means
-    // it did, and is the palette index `color_sample` returned there (FACE_NO_COLOUR when it returned
-    // none). The distinction matters: the sampler answers for points on the *base* surface, and these
-    // are sampled on the displaced one, so a painted face can easily come back without a colour. Only
-    // the painted/unpainted split is reliable here, and that is what a caller should use it for.
-    //
-    // Empty unless the caller gave a `color_sample`.
-    //
-    // A caller that needs per-face colour must use this rather than sampling the result again. The
-    // result is displaced geometry: a point on it is no longer where its base surface was, so matching
-    // it back by proximity colours whatever base surface happens to be nearest - which on a part thinner
-    // than the relief depth is the *opposite* face, picking up the texture meant for the painted one.
-    std::vector<int> face_color;
     // Output face -> input face. Empty in Export mode, where decimation invalidates it.
     std::vector<int> face_parent_id;
     bool             safety_cap_hit     = false;

src/libslic3r/TextureBake/TextureBakeRepair.cpp

@@ -72,8 +72,7 @@ size_t count_area_slivers(const TriSoup &geometry)
     return n;
 }
 
-TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts,
-                            std::vector<int> *face_color)
+TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts)
 {
     const size_t n_tri  = geometry.triangle_count();
     const double on_tol2 = opts.on_seg_tol * opts.on_seg_tol;
@@ -99,12 +98,7 @@ TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts,
     // grid. A needle reads as watertight yet is deleted downstream, and dropping it leaves exactly
     // the on-edge-vertex topology the pass below closes.
     std::vector<std::array<int, 3>> faces;
-    // Parallel to `faces` throughout, so a split or a dropped degenerate keeps the two in step.
-    const bool       track_color = face_color != nullptr && !face_color->empty();
-    std::vector<int> colors;
     faces.reserve(n_tri);
-    if (track_color)
-        colors.reserve(n_tri);
     for (size_t t = 0; t < n_tri; ++t) {
         const int a = vid[t * 3], b = vid[t * 3 + 1], c = vid[t * 3 + 2];
         if (a == b || b == c || a == c)
@@ -114,8 +108,6 @@ TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts,
         if (u.cross(w).squaredNorm() < DEGENERATE_AREA_SQ)
             continue;
         faces.push_back({ a, b, c });
-        if (track_color)
-            colors.push_back(t < face_color->size() ? (*face_color)[t] : -1);
     }
 
     for (int iter = 0; iter < opts.max_iters; ++iter) {
@@ -174,16 +166,11 @@ TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts,
             break;
 
         std::vector<std::array<int, 3>> next;
-        std::vector<int>                next_colors;
         next.reserve(faces.size() + splits.size() * 2);
-        if (track_color)
-            next_colors.reserve(next.capacity());
         for (size_t fi = 0; fi < faces.size(); ++fi) {
             const auto it = splits.find(fi);
             if (it == splits.end()) {
                 next.push_back(faces[fi]);
-                if (track_color)
-                    next_colors.push_back(colors[fi]);
                 continue;
             }
             const auto &f  = faces[fi];
@@ -208,18 +195,11 @@ TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts,
                 seq.insert(seq.end(), sp.mids.rbegin(), sp.mids.rend());
                 seq.push_back(sp.a);
             }
-            for (size_t s = 0; s + 1 < seq.size(); ++s) {
+            for (size_t s = 0; s + 1 < seq.size(); ++s)
                 next.push_back({ seq[s], seq[s + 1], apex });
-                if (track_color)
-                    next_colors.push_back(colors[fi]); // every piece of a split face keeps its colour
-            }
         }
         faces.swap(next);
-        if (track_color)
-            colors.swap(next_colors);
     }
-    if (track_color)
-        *face_color = std::move(colors);
 
     TriSoup out;
     out.pos.reserve(faces.size() * 3);

src/libslic3r/TextureBake/TextureBakeRepair.hpp

@@ -43,12 +43,7 @@ struct RepairOptions
     int max_iters = 16;
 };
 
-// `face_color`, when given, is read as one entry per input face and rewritten to match the output: a
-// face split to close a T-junction hands its colour to every piece, and a degenerate face dropped on
-// the way takes its entry with it. Without this the caller would have no way to keep a per-face colour
-// across this pass, which changes the triangle count.
-TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts = {},
-                            std::vector<int> *face_color = nullptr);
+TriSoup resolve_t_junctions(const TriSoup &geometry, const RepairOptions &opts = {});
 
 } // namespace TextureBake
 } // namespace Slic3r

src/libslic3r/TextureDisplacement.cpp

@@ -2284,11 +2284,12 @@ indexed_triangle_set build_texture_displacement_v2(const indexed_triangle_set
     //
     // The *palette* index, not the printed filament. The decimation treats any edge whose two faces
     // differ as a crease (TextureBakeDecimate.cpp), so it must only ever see where the **perceived**
-    // colour changes. A mix is one perceived colour however its components are laid down, which is why
-    // it has to be the palette index here: back when this was handed a per-triangle interleave instead,
-    // every band boundary read as a crease, the collapse ran along those lines and left a stack of
-    // horizontal slivers, and the triangle budget went on drawing a pattern the eye is meant to blend
-    // away. Faces the paint excludes are skipped by the pipeline itself.
+    // colour changes - which is exactly what ColorResolveFn's own contract says the interleaving may
+    // never be fed into. Handing it the resolved filament made every Z band boundary a crease: on an
+    // upright wall that is one crease per band, so the collapse ran along those lines and left a stack
+    // of horizontal slivers, each printing in a single filament. Those were the horizontal colour
+    // lines in the baked result, and they also spent the triangle budget drawing a pattern the eye is
+    // meant to blend away. Faces the paint excludes are skipped by the pipeline itself.
     const TextureBake::ColorSampleFn color_sample =
         color_sampler ? TextureBake::ColorSampleFn([&color_sampler](const Vec3f &p, const Vec3f &n) {
                             return color_sampler(p, n);
@@ -2314,7 +2315,7 @@ indexed_triangle_set build_texture_displacement_v2(const indexed_triangle_set
         stats->triangles_budget  = result.triangles_budget;
         stats->budget_limited    = result.budget_limited;
     }
-    indexed_triangle_set out = TextureBake::to_indexed_triangle_set(result.geometry, &result.face_color);
+    indexed_triangle_set out = TextureBake::to_indexed_triangle_set(result.geometry);
     if (out.indices.empty())
         return mesh;
     if (flip_normals)
@@ -2335,8 +2336,6 @@ indexed_triangle_set build_texture_displacement_v2(const indexed_triangle_set
                 max_depth = std::max(max_depth, std::abs(layer.depth_mm));
             const float relief_tol = max_depth + paint_tol;
             std::vector<int> palette(out.indices.size(), -1);
-            const std::vector<int> &face_mask      = result.face_color;
-            const bool              have_face_mask = face_mask.size() == out.indices.size();
             tbb::parallel_for(tbb::blocked_range<size_t>(0, out.indices.size()), [&](const tbb::blocked_range<size_t> &r) {
                 for (size_t i = r.begin(); i < r.end(); ++i) {
                     const stl_triangle_vertex_indices &t = out.indices[i];
@@ -2352,19 +2351,8 @@ indexed_triangle_set build_texture_displacement_v2(const indexed_triangle_set
                     // reason; this path was the inconsistent one.
                     Vec3f       foot = centroid, base_n = Vec3f::UnitZ();
                     const float d2   = painted_closest(centroid, &foot, &base_n);
-                    // Which faces may be coloured comes from the pipeline, which recorded it on the
-                    // refined mesh where the paint mask is exact, and carried it through the collapse,
-                    // the T-junction repair and the weld. Proximity cannot answer this: a displaced face
-                    // is no longer where its base was, so on a part thinner than the relief depth the
-                    // nearest painted surface to the *opposite* face is the painted one, and the texture
-                    // appeared there too. Only the position to sample at still comes from the base
-                    // surface, for the projection reason above.
-                    if (have_face_mask) {
-                        if (face_mask[i] == TextureBake::FACE_UNPAINTED)
-                            continue;
-                    } else if (!all_painted && d2 >= relief_tol * relief_tol) {
+                    if (!all_painted && d2 >= relief_tol * relief_tol)
                         continue;
-                    }
                     palette[i] = sampler(foot, base_n);
                 }
             });
@@ -2386,7 +2374,7 @@ indexed_triangle_set build_texture_displacement_v2(const indexed_triangle_set
                 Vec3f        normal   = (b - a).cross(c - a);
                 const float  nl       = normal.norm();
                 normal                = (nl > 0.f) ? Vec3f(normal / nl) : Vec3f::UnitZ();
-                const int filament = palette[i];
+                const int filament = color->resolve ? color->resolve(palette[i], centroid, normal) : palette[i];
                 if (filament >= 0)
                     out_color[i] = uint8_t(std::min(filament + 1, 255));
             }
@@ -2843,7 +2831,8 @@ static indexed_triangle_set build_texture_displacement_in_place(
             Vec3f        normal   = (b - a).cross(c - a);
             const float  nl       = normal.norm();
             normal                = (nl > 0.f) ? Vec3f(normal / nl) : Vec3f::UnitZ();
-            const int filament = triangle_palette[i];
+            const int filament = color->resolve ? color->resolve(triangle_palette[i], centroid, normal)
+                                                : triangle_palette[i];
             if (filament >= 0)
                 out_color[i] = uint8_t(std::min(filament + 1, 255));
         }

src/libslic3r/TextureDisplacement.hpp

@@ -321,6 +321,25 @@ struct TextureDisplacementLayer
     }
 };
 
+// How a *mixed* palette entry - one that names two filaments rather than one - is turned into real
+// per-facet paint. An MMU extrudes one filament at a time, so an intermediate colour exists only by
+// interleaving two of them finely enough that the eye does the blending.
+enum class ColorMixMode : int
+{
+    // Horizontal bands: which of the two filaments a point takes depends on its height, so
+    // consecutive print layers alternate. This is how filament-blend prints actually work, and on a
+    // vertical-ish surface it reads as a genuinely smooth colour. On a near-horizontal surface a whole
+    // layer is one band, so the blend disappears - that is what XYDither is for.
+    ZBands   = 0,
+    // An ordered (Bayer) checkerboard across the surface, at any orientation. Independent of layer
+    // height, but its cell is around the size of one facet, so a fine mix can read as texture rather
+    // than as a clean blend.
+    XYDither = 1,
+    // Per triangle, by its orientation: bands where the surface is upright enough for consecutive
+    // layers to alternate, the checkerboard where it faces up or down and a layer would be one band.
+    // The default - a flat-topped part with a mix on top gets no blend at all from bands alone.
+    Auto     = 2,
+};
 
 // Settings that apply to the whole layer stack rather than to one layer, held per ModelVolume next
 // to texture_displacement_layers and consumed by build_texture_displacement().
@@ -387,6 +406,7 @@ struct TextureDisplacementOptions
     // image (TextureDetail::flat_colors): a texture of flat colours prints in single filaments, a
     // photograph or gradient in mixes. Off forces single filaments everywhere.
     bool         color_mix_enabled = true;
+    ColorMixMode color_mix_mode    = ColorMixMode::Auto;
     // Majority-filter passes over the assigned colours. See TextureColorRequest::despeckle_passes -
     // this is the control for it, and 2 is enough to clear the salt-and-pepper an image with detail
     // finer than the mesh leaves behind, without eating features that are genuinely a facet wide.
@@ -394,9 +414,11 @@ struct TextureDisplacementOptions
 
     template<class Archive> void serialize(Archive &ar)
     {
+        int mix_mode = int(color_mix_mode);
         ar(displace_border, smooth_enabled, smooth_strength, smooth_iterations, smooth_skip_border,
            pipeline_v2, v2_refine_mm, v2_regularize, v2_max_triangles_k,
-           v2_relocate, color_mix_enabled, color_despeckle);
+           v2_relocate, color_mix_enabled, mix_mode, color_despeckle);
+        color_mix_mode = ColorMixMode(mix_mode);
     }
 };
 
@@ -489,9 +511,17 @@ DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer
 // is. See GLGizmoTextureDisplacement::make_palette_quantizer().
 using ColorQuantizeFn = std::function<int(const Vec3f &)>;
 
+// Resolves a palette index plus a surface position to the filament index that position should print
+// in. A pure entry ignores the position; a mixed one interleaves its two filaments per ColorMixMode.
+//
+// Deliberately separate from ColorQuantizeFn, and deliberately *not* used by the subdivision's colour
+// criterion: that criterion asks where the **perceived** colour changes, and must not see the
+// interleaving. Refining on every band or dither-cell boundary would spend the whole triangle budget
+// drawing a pattern the eye is supposed to blend away.
+using ColorResolveFn = std::function<int(int palette_index, const Vec3f &pos, const Vec3f &normal)>;
 
 // One printable colour: either a loaded filament on its own, or a blend of two of them realised by
-// interleaving, which the slicer does per print layer. Plain data, so it can be captured into a job.
+// interleaving (see ColorMixMode). Plain data, so it can be captured into a background job.
 struct PrintableColor
 {
     Vec3f rgb   = Vec3f::Zero(); // what it looks like; for a mix, the perceptual average of the two
@@ -508,6 +538,9 @@ struct TextureColorSettings
 {
     std::vector<PrintableColor> palette;
     std::vector<PrintableColor> palette_pure; // the filaments alone, for flat-colour images
+    ColorMixMode                mix_mode         = ColorMixMode::ZBands;
+    float                       layer_height     = 0.2f; // sizes the Z bands
+    float                       dither_cell_mm   = 0.4f; // sizes the XY dither cells
     int                         despeckle_passes = 2;
 
     bool empty() const { return palette.empty(); }
@@ -747,6 +780,9 @@ struct TextureColorRequest
     // made of flat colours (TextureDetail::flat_colors) is matched with this one, so a tile or a logo
     // prints in single filaments while a photograph on another layer may still use mixes.
     ColorQuantizeFn quantize_pure;
+    // Palette index + position -> filament. Optional: without it a palette index is taken to be a
+    // filament index directly, which is the no-mixing case.
+    ColorResolveFn  resolve;
     // Majority-filter passes over the *perceived* colour, before any interleaving is resolved.
     //
     // Sampling a detailed image once per triangle leaves salt-and-pepper wherever the image's own

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp

@@ -1462,8 +1462,11 @@ void GLGizmoTextureDisplacement::render_shaded_preview_mesh()
         // How the entry prints: its filament, or for a mix the two it interleaves and in what ratio.
         shader->set_uniform(("palette_a" + idx).c_str(), e.a);
         shader->set_uniform(("palette_b" + idx).c_str(), e.b);
+        shader->set_uniform(("palette_num" + idx).c_str(), e.num);
+        shader->set_uniform(("palette_den" + idx).c_str(), e.den);
     }
     // The filaments those indices refer to, and the interleave the shader resolves a mix with - the
+    // same inputs make_mix_resolver() gets, so the preview shows the pattern that prints rather than
     // the mix's smooth average colour. m_palette_filaments is what m_shaded_preview_palette was built from.
     const int filament_count =
         (palette_count > 0) ? int(std::min(m_palette_filaments.size(), size_t(PALETTE_MAX_FILAMENTS))) : 0;
@@ -1472,6 +1475,9 @@ void GLGizmoTextureDisplacement::render_shaded_preview_mesh()
         const ColorRGBA &c = m_palette_filaments[size_t(i)];
         shader->set_uniform(("filament_rgb[" + std::to_string(i) + "]").c_str(), Vec3f(c.r(), c.g(), c.b()));
     }
+    shader->set_uniform("mix_mode", int(mv->texture_displacement_options.color_mix_mode));
+    shader->set_uniform("layer_height", color_band_mm(*mv)); // as color_settings_for()
+    shader->set_uniform("dither_cell", std::max(m_subdivide_color_mm, 0.05f) * 2.f); // as color_settings_for()
     if (color_tex != nullptr) {
         shader->set_uniform("color_tex", 1);
         glsafe(::glActiveTexture(GL_TEXTURE1));
@@ -2016,13 +2022,7 @@ void GLGizmoTextureDisplacement::queue_preview_job()
     // The filament list the result's indices refer to, captured with the job rather than read back
     // when it lands - loading a filament meanwhile must not recolour a preview computed against a
     // different list.
-    // Every extruder, not the palette's physical-only list: the bake writes the filament it resolved
-    // to, and a mix resolves to a *mixed filament slot*, which is an extruder past the physical ones.
-    // Grouping against the shorter list dropped every triangle carrying such a slot out of the mesh
-    // entirely - the relief vanished and left only the few triangles that happened to print in a plain
-    // filament. The palette still has to be built from physical filaments alone (see filament_palette()),
-    // which is why these two are not the same list.
-    const std::vector<ColorRGBA> filaments = wxGetApp().plater()->get_extruders_colors();
+    const std::vector<ColorRGBA> filaments = m_palette_filaments;
 
     m_preview_job_running = true;
     auto &worker = wxGetApp().plater()->get_ui_job_worker();
@@ -4219,44 +4219,19 @@ bool GLGizmoTextureDisplacement::any_layer_colors(const ModelVolume &mv)
     return false;
 }
 
-void GLGizmoTextureDisplacement::bind_mixes_to_filament_slots(std::vector<PaletteEntry> &palette)
-{
-    Sidebar *sidebar = &wxGetApp().plater()->sidebar();
-    if (sidebar == nullptr)
-        return;
-    for (PaletteEntry &e : palette) {
-        if (!e.is_mix())
-            continue;
-        // Components are 1-based in the config; the ratios are percentages summing to 100, which is the
-        // form create_mixed_filament_from_result() normalises from.
-        const int a_pct = int(std::lround(100.0 * double(e.num) / double(e.den)));
-        const int slot  = sidebar->ensure_mixed_filament({ unsigned(e.a + 1), unsigned(e.b + 1) },
-                                                         { a_pct, 100 - a_pct });
-        if (slot >= 0) {
-            e.a = e.b = slot;
-            e.num = e.den = 1;
-        } else {
-            // No room for another slot. Collapse to the component that dominates the blend, which is what
-            // the old per-triangle path did on a surface it could not band anyway.
-            const int dominant = (e.num * 2 >= e.den) ? e.a : e.b;
-            e.a = e.b = dominant;
-            e.num = e.den = 1;
-        }
-    }
-}
-
 TextureColorSettings GLGizmoTextureDisplacement::color_settings_for(const ModelVolume &mv)
 {
     TextureColorSettings out;
     if (!any_layer_colors(mv))
         return out; // nothing is colouring: every colour path stays switched off
     out.palette          = cached_palette();
-    out.palette_pure     = make_palette(m_palette_filaments, /* mixing */ false, PALETTE_MAX_ENTRIES);
-    // Done here rather than in cached_palette(): this runs when a preview or a bake is queued, off a
-    // user action, while that one is also touched from the render path - and creating filament slots
-    // there would mutate the project mid-frame.
-    bind_mixes_to_filament_slots(out.palette);
+    out.palette_pure     = make_palette(m_palette_filaments, /* mixing */ false);
+    out.mix_mode         = mv.texture_displacement_options.color_mix_mode;
     out.despeckle_passes = mv.texture_displacement_options.color_despeckle;
+    out.layer_height     = color_band_mm(mv);
+    // The dither cell is tied to the colour-detail target: a cell much smaller than a facet cannot be
+    // drawn at all, and one much larger stops reading as a blend and starts reading as a check.
+    out.dither_cell_mm   = std::max(m_subdivide_color_mm, 0.05f) * 2.f;
     return out;
 }
 
@@ -4269,15 +4244,10 @@ const std::vector<GLGizmoTextureDisplacement::PaletteEntry> &GLGizmoTextureDispl
     const ModelVolume *mv     = texture_volume();
     const bool         mixing = mv != nullptr && mv->texture_displacement_options.color_mix_enabled;
     std::vector<ColorRGBA> filaments = filament_palette();
-    // Every mix costs a filament slot once they are bound to one, and the mask can name only so many
-    // states, so the palette has to leave room beside the physical filaments it already counts.
-    const int cap = int(EnforcerBlockerType::ExtruderMax);
-    if (m_palette_cache.empty() || filaments != m_palette_filaments || mixing != m_palette_mixing ||
-        cap != m_palette_cap) {
+    if (m_palette_cache.empty() || filaments != m_palette_filaments || mixing != m_palette_mixing) {
         m_palette_filaments = std::move(filaments);
         m_palette_mixing    = mixing;
-        m_palette_cap       = cap;
-        m_palette_cache     = make_palette(m_palette_filaments, mixing, cap);
+        m_palette_cache     = make_palette(m_palette_filaments, mixing);
         m_palette_quantizer = make_palette_quantizer(m_palette_cache);
     }
     return m_palette_cache;
@@ -4285,29 +4255,40 @@ const std::vector<GLGizmoTextureDisplacement::PaletteEntry> &GLGizmoTextureDispl
 
 std::vector<ColorRGBA> GLGizmoTextureDisplacement::filament_palette()
 {
-    std::vector<ColorRGBA> all = wxGetApp().plater()->get_extruders_colors();
-
-    // Physical filaments only. The mixes this palette produces each become a mixed filament slot of
-    // their own (see bind_mixes_to_filament_slots()), and those slots are extruders too - so taking the
-    // list as it comes meant the next rebuild mixed *them* again, and handed components naming a
-    // virtual slot to a blend that can only name physical ones. That is what left entries reading
-    // "filament 1 plus nothing" and raised "Mixed filament has invalid or mismatched components".
-    const auto *is_mixed = wxGetApp().preset_bundle->project_config.option<ConfigOptionBools>("filament_is_mixed");
-    std::vector<ColorRGBA> palette;
-    palette.reserve(all.size());
-    for (size_t i = 0; i < all.size(); ++i)
-        if (is_mixed == nullptr || i >= is_mixed->values.size() || !is_mixed->values[i])
-            palette.push_back(all[i]);
-
-    // A paint mask can only name so many states, and every mix spends one beside these.
+    std::vector<ColorRGBA> palette = wxGetApp().plater()->get_extruders_colors();
+    // mmu_segmentation_facets encodes the filament in a 6-bit prefix code and stops at Extruder16.
     if (palette.size() > size_t(EnforcerBlockerType::ExtruderMax))
         palette.resize(size_t(EnforcerBlockerType::ExtruderMax));
     return palette;
 }
 
+float GLGizmoTextureDisplacement::color_band_mm(const ModelVolume &mv)
+{
+    const float lh   = print_layer_height();
+    const float edge = (mv.texture_displacement_options.v2_refine_mm > 0.f) ? mv.texture_displacement_options.v2_refine_mm
+                                                                           : v2_recommendation(mv).edge_mm;
+    if (edge <= 0.f || lh <= 0.f)
+        return lh;
+    // A refined triangle of edge e stacks in rows about 0.87 * e apart (an equilateral triangle's
+    // height), and a dither needs at least two rows per period to be a dither at all.
+    constexpr float ROW_PER_EDGE = 0.87f;
+    return lh * std::max(1.f, std::ceil(2.f * ROW_PER_EDGE * edge / lh));
+}
+
+float GLGizmoTextureDisplacement::print_layer_height()
+{
+    try {
+        const DynamicPrintConfig &cfg = wxGetApp().preset_bundle->prints.get_edited_preset().config;
+        if (const ConfigOptionFloat *opt = cfg.option<ConfigOptionFloat>("layer_height"); opt != nullptr)
+            if (opt->value > 1e-3)
+                return float(opt->value);
+    } catch (...) {
+    }
+    return 0.2f;
+}
 
 std::vector<GLGizmoTextureDisplacement::PaletteEntry> GLGizmoTextureDisplacement::make_palette(
-    const std::vector<ColorRGBA> &filaments, bool mixing, int max_entries)
+    const std::vector<ColorRGBA> &filaments, bool mixing)
 {
     std::vector<PaletteEntry> out;
     const int                 n = int(filaments.size());
@@ -4324,7 +4305,7 @@ std::vector<GLGizmoTextureDisplacement::PaletteEntry> GLGizmoTextureDisplacement
     const int pairs = n * (n - 1) / 2;
     int       steps = 0;
     for (int s = 5; s >= 1; --s)
-        if (n + pairs * s <= max_entries) {
+        if (n + pairs * s <= PALETTE_MAX_ENTRIES) {
             steps = s;
             break;
         }
@@ -4346,6 +4327,51 @@ std::vector<GLGizmoTextureDisplacement::PaletteEntry> GLGizmoTextureDisplacement
     return out;
 }
 
+ColorResolveFn GLGizmoTextureDisplacement::make_mix_resolver(const std::vector<PaletteEntry> &palette,
+                                                             ColorMixMode mode, float layer_height,
+                                                             float cell_mm)
+{
+    if (palette.empty())
+        return nullptr;
+    auto        entries = std::make_shared<std::vector<PaletteEntry>>(palette);
+    const float band    = std::max(layer_height, 0.01f);
+    const float cell    = std::max(cell_mm, 0.01f);
+
+    return [entries, mode, band, cell](int index, const Vec3f &pos, const Vec3f &normal) -> int {
+        if (index < 0 || size_t(index) >= entries->size())
+            return -1;
+        const PaletteEntry &e = (*entries)[size_t(index)];
+        if (!e.is_mix())
+            return e.a;
+
+        // Which of the two filaments this point falls on. Both patterns are *ordered*, never random:
+        // the eye blends a regular pattern into a flat colour, and turns a random one into noise.
+        // Auto: bands wherever the surface is steeper than ~45 degrees - consecutive layers alternate
+        // there, which is how a blend prints and reads. On a flat-facing surface a layer is one band
+        // and the only way to interleave is a checkerboard across the surface, which at print scale
+        // reads as a pattern rather than a colour; there the mix falls back to its dominant filament.
+        const bool upright = std::abs(normal.z()) < 0.7f;
+        if (mode == ColorMixMode::Auto && !upright)
+            return e.num * 2 >= e.den ? e.a : e.b;
+        const bool bands = mode == ColorMixMode::ZBands || mode == ColorMixMode::Auto;
+        if (bands) {
+            // One band per print layer. floorf, not a cast, so this stays correct below z = 0.
+            const int slot = int(std::floor(pos.z() / band));
+            const int phase = ((slot % e.den) + e.den) % e.den;
+            return phase < e.num ? e.a : e.b;
+        }
+        // Ordered 4x4 Bayer over the surface, indexed by position so the pattern is stable in space
+        // rather than in triangle order (which would move under any remesh, and read as noise).
+        static const int BAYER[16] = { 0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5 };
+        const int gx = ((int(std::floor(pos.x() / cell)) % 4) + 4) % 4;
+        const int gy = ((int(std::floor(pos.y() / cell)) % 4) + 4) % 4;
+        // A third axis would be ideal, but the two dominant ones are enough for a surface pattern and
+        // keep the cell square on the faces that matter.
+        const float threshold = (float(BAYER[gy * 4 + gx]) + 0.5f) / 16.f;
+        return (float(e.num) / float(e.den)) > threshold ? e.a : e.b;
+    };
+}
+
 ColorQuantizeFn GLGizmoTextureDisplacement::make_palette_quantizer(const std::vector<PaletteEntry> &palette)
 {
     if (palette.empty())
@@ -4382,15 +4408,10 @@ ColorQuantizeFn GLGizmoTextureDisplacement::make_palette_quantizer(const std::ve
                             best_pure   = int(i);
                         }
                     }
-                    // A mix is an interleave that only reads as its colour from a distance; up close it is
-                    // stripes. So it is spent only where it buys a better match than the nearest single
-                    // filament - but "better" was set at ten Delta E, which is not a visible step, it is a
-                    // different colour. Measured over the whole cube that threshold turned 94% of the
-                    // lookups that wanted a mix back into a pure filament, leaving 38%; along a greyscale
-                    // ramp, the shape a height texture actually traces, it cut 80% to 66%. Two Delta E is
-                    // about where a side-by-side difference stops being arguable, which is the right place
-                    // to start paying for stripes.
-                    constexpr float PREFER_PURE_DE = 2.f;
+                    // A mix is an interleave that only reads as its colour from a distance; up close
+                    // it is stripes. Spend it only where it buys a clearly better match than the nearest
+                    // single filament: ten Delta E is a visible step, less is not worth the stripes.
+                    constexpr float PREFER_PURE_DE = 10.f;
                     if (best_pure >= 0 && palette[size_t(best)].is_mix() && best_pure_d - best_d < PREFER_PURE_DE)
                         best = best_pure;
                     (*lut)[(size_t(r) * E + size_t(g)) * E + size_t(b)] = uint8_t(best);
@@ -4490,7 +4511,7 @@ TextureDisplacementPrepareResult GLGizmoTextureDisplacement::prepare_mesh(
             if (params.subdiv_color_edge_mm > 0.f && !palette.empty())
                 color = make_combined_color_sampler(mesh.its, layers, current, make_palette_quantizer(palette));
             // Note the sampler is built on the *quantizer* alone - the refinement follows perceived
-            // colour, never the interleaving that realises a mix - the slicer does that per layer.
+            // colour, never the interleaving that realises a mix (see ColorResolveFn).
             // "Min edge" is a feature-mode control (it is the floor the curvature test refines down
             // to); in plain adaptive mode the target edge length is the only criterion, so the floor
             // must not be allowed to silently override a target the user set below it.
@@ -6048,6 +6069,24 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                                        "of filaments can cover a photo or a gradient. An image of flat colors "
                                        "prints the same either way. Off uses one filament per area."));
                         if (opts.color_mix_enabled) {
+                            slider_label(_L("Mix by"));
+                            const std::string mix_z       = _u8L("Layers");
+                            const std::string mix_xy      = _u8L_CONTEXT("Surface", "Texture Displacement");
+                            const std::string mix_auto    = _u8L("Automatic");
+                            const char       *mix_items[] = { mix_z.c_str(), mix_xy.c_str(), mix_auto.c_str() };
+                            int               mix_mode    = int(opts.color_mix_mode);
+                            ImGui::SetNextItemWidth(-card_pad);
+                            if (scoped_combo("##color_mix_mode", &mix_mode, mix_items, IM_ARRAYSIZE(mix_items))) {
+                                opts.color_mix_mode    = ColorMixMode(mix_mode);
+                                m_preview_params_dirty = true;
+                            }
+                            hover_tip(_u8L("Layers: the two filaments alternate between print layers, which "
+                                           "blends smoothly on upright surfaces but disappears on flat-facing "
+                                           "ones, where a whole layer is a single band.\n"
+                                           "Surface: a fine checkerboard across the surface, which works at "
+                                           "any angle but can read as texture rather than as a blend.\n"
+                                           "Automatic: layers on upright faces; flat-facing faces take the nearer "
+                                           "single filament, since a checkerboard there shows as a pattern."));
                             ImGui::TextDisabled("%s", Slic3r::format(_u8L("%1% printable colors from %2% filaments"),
                                                                      int(cached_palette().size()), int(m_palette_filaments.size())).c_str());
                         }

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp

@@ -81,11 +81,7 @@ public:
     // How many ratios depends on how many filaments there are, so the palette stays bounded: the
     // quantizer's lookup cube costs one DeltaE00 per cell per entry to fill, and with sixteen
     // filaments there are already plenty of colours without mixing any of them.
-    // `max_entries` bounds the whole palette. It is normally the quantizer's own limit, but when the
-    // mixes become filament slots it has to be the paint mask's instead: a mask can name only
-    // EnforcerBlockerType::ExtruderMax states, and every mix now occupies one of them.
-    static std::vector<PaletteEntry> make_palette(const std::vector<ColorRGBA> &filaments, bool mixing,
-                                                  int max_entries);
+    static std::vector<PaletteEntry> make_palette(const std::vector<ColorRGBA> &filaments, bool mixing);
 
     // Maps an image colour to the closest entry of `palette`, perceptually (CIEDE2000 over CIELAB - a
     // plain RGB distance picks visibly wrong filaments, most obviously between a saturated colour and
@@ -99,6 +95,9 @@ public:
 
     // Turns a palette index plus a position into the filament to print there, interleaving the two
     // filaments of a mixed entry per `mode`. `layer_height` sizes the Z bands; `cell_mm` the dither
+    // cells. See ColorResolveFn for why this is separate from the quantizer.
+    static ColorResolveFn make_mix_resolver(const std::vector<PaletteEntry> &palette, ColorMixMode mode,
+                                            float layer_height, float cell_mm);
 
     // Everything the jobs need to colour with, for the current volume: palette, mix mode, layer
     // height, despeckle. Empty when no layer is actually colouring.
@@ -107,20 +106,16 @@ public:
     // The printable palette for the current filaments and mixing setting, rebuilt only when either
     // actually changes - see the definition for why that caching is not optional.
     const std::vector<PaletteEntry> &cached_palette();
-    // Turns every mix in `palette` into a mixed filament slot and rewrites the entry to name that slot
-    // as a plain filament, so nothing downstream has to know a mix is involved: is_mix() goes false and
-    // the resolver simply returns it. The per-layer interleaving then happens in the slicer, where it is
-    // not limited by how fine the mesh is. Entries whose slot could not be created (the paint-state cap)
-    // fall back to the nearer of the two components.
-    void bind_mixes_to_filament_slots(std::vector<PaletteEntry> &palette);
     std::vector<PaletteEntry>  m_palette_cache;
     std::vector<ColorRGBA>     m_palette_filaments;
-    int                        m_palette_cap = 0; // the max_entries m_palette_cache was built with
     bool                       m_palette_mixing = false;
     ColorQuantizeFn            m_palette_quantizer;
 
     // The loaded filaments, clamped to the sixteen mmu_segmentation_facets can address.
     static std::vector<ColorRGBA> filament_palette();
+    // The print's layer height, which sizes ColorMixMode::ZBands. Falls back to 0.2 mm if it cannot be
+    // read - a wrong band size is a cosmetic error, not a reason to refuse to colour anything.
+    static float print_layer_height();
     // The Z band height, in mm. One print layer is the ideal, but the interleave is realised per
     // *facet*: a band thinner than the mesh can resolve does not dither, it beats against the triangle
     // grid and comes out as broad horizontal stripes - and since MMU segmentation reads facet colour,
@@ -128,6 +123,7 @@ public:
     // diagonal and knows nothing about the layer height, so the band is rounded up to a whole number of
     // layers at least two facet rows tall: still exact on the printer, and representable by the mesh
     // that has to carry it. Used by both the bake settings and the preview shader, so the two agree.
+    float        color_band_mm(const ModelVolume &mv);
 
     // The Normal preview's triangles, grouped by the filament they will print in. Colour is per facet
     // and there are at most sixteen filaments, so the mesh is uploaded once with its index buffer

src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.cpp

@@ -53,6 +53,9 @@ void TextureDisplacementBakeJob::process(Ctl &ctl)
         color_request.quantize = GLGizmoTextureDisplacement::make_palette_quantizer(m_input.color.palette);
         if (!m_input.color.palette_pure.empty())
             color_request.quantize_pure = GLGizmoTextureDisplacement::make_palette_quantizer(m_input.color.palette_pure);
+        color_request.resolve  = GLGizmoTextureDisplacement::make_mix_resolver(
+            m_input.color.palette, m_input.color.mix_mode, m_input.color.layer_height,
+            m_input.color.dither_cell_mm);
         color_request.despeckle_passes = m_input.color.despeckle_passes;
         color_request.out_triangle     = &m_triangle_color;
         if (color_request.quantize)

src/slic3r/GUI/Jobs/TextureDisplacementPreviewJob.cpp

@@ -32,6 +32,9 @@ void TextureDisplacementPreviewJob::process(Ctl &ctl)
         color_request.quantize = GLGizmoTextureDisplacement::make_palette_quantizer(m_input.color.palette);
         if (!m_input.color.palette_pure.empty())
             color_request.quantize_pure = GLGizmoTextureDisplacement::make_palette_quantizer(m_input.color.palette_pure);
+        color_request.resolve  = GLGizmoTextureDisplacement::make_mix_resolver(
+            m_input.color.palette, m_input.color.mix_mode, m_input.color.layer_height,
+            m_input.color.dither_cell_mm);
         color_request.despeckle_passes = m_input.color.despeckle_passes;
         color_request.out_triangle     = &m_result.triangle_color;
         if (color_request.quantize)

src/slic3r/GUI/Plater.cpp

@@ -935,7 +935,6 @@ struct Sidebar::priv
     StaticLine*       m_text_mixed_title{nullptr};
     ScalableButton*   m_btn_mixed_add{nullptr};
     ScalableButton*   m_btn_mixed_del{nullptr};
-    ScalableButton*   m_btn_mixed_del_all{nullptr};
     wxScrolledWindow* m_mixed_scroll_area{nullptr};       // independent scrollbar for mixed rows
     wxPanel*          m_panel_mixed_content{nullptr};
     wxBoxSizer*       m_sizer_mixed_filaments{nullptr};   // two-column, mirrors sizer_filaments
@@ -3450,11 +3449,6 @@ Sidebar::Sidebar(Plater *parent)
         });
         title_sizer->Add(p->m_btn_mixed_del, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
 
-        p->m_btn_mixed_del_all = new ScalableButton(p->m_panel_mixed_title, wxID_ANY, "delete_all_filaments");
-        p->m_btn_mixed_del_all->SetToolTip(_L("Remove all mixed filaments"));
-        p->m_btn_mixed_del_all->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { remove_all_mixed_filaments(); });
-        title_sizer->Add(p->m_btn_mixed_del_all, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
-
         p->m_btn_mixed_add = new ScalableButton(p->m_panel_mixed_title, wxID_ANY, "add_filament");
         p->m_btn_mixed_add->SetToolTip(_L("Add mixed filament"));
         p->m_btn_mixed_add->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { add_mixed_filament(); });
@@ -5128,58 +5122,6 @@ static bool create_mixed_filament_from_result(
     return true;
 }
 
-int Sidebar::ensure_mixed_filament(const std::vector<unsigned int> &components, const std::vector<int> &ratios)
-{
-    if (components.size() < 2 || components.size() != ratios.size())
-        return -1;
-    if (p->combos_filament.size() < 2)
-        return -1;
-
-    // Normalise the way create_mixed_filament_from_result() stores them, so the comparison below sees
-    // the same text the config holds rather than two spellings of one blend.
-    int ratio_sum = 0;
-    for (const int r : ratios)
-        ratio_sum += r;
-    if (ratio_sum <= 0)
-        return -1;
-
-    std::string comp_str, ratio_str;
-    {
-        CNumericLocalesSetter c_locale_setter;
-        for (size_t i = 0; i < components.size(); ++i) {
-            if (i > 0) { comp_str += ","; ratio_str += ","; }
-            comp_str += std::to_string(components[i]);
-            char buf[32];
-            std::snprintf(buf, sizeof(buf), "%.4f", float(ratios[i]) / float(ratio_sum));
-            ratio_str += buf;
-        }
-    }
-
-    const auto &project_config = wxGetApp().preset_bundle->project_config;
-    const auto *is_mixed_opt   = project_config.option<ConfigOptionBools>("filament_is_mixed");
-    const auto *comp_opt       = project_config.option<ConfigOptionStrings>("filament_mixed_components");
-    const auto *ratios_opt     = project_config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
-    if (is_mixed_opt != nullptr && comp_opt != nullptr && ratios_opt != nullptr)
-        for (size_t i = 0; i < is_mixed_opt->values.size(); ++i)
-            if (is_mixed_opt->values[i] && i < comp_opt->values.size() && i < ratios_opt->values.size() &&
-                comp_opt->values[i] == comp_str && ratios_opt->values[i] == ratio_str)
-                return int(i);
-
-    if (wxGetApp().preset_bundle->filament_presets.size() >= size_t(EnforcerBlockerType::ExtruderMax))
-        return -1;
-
-    std::vector<std::string> color_strs, names, types;
-    collect_physical_filament_info(color_strs, names, types);
-
-    MixedFilamentResult result;
-    result.components = components;
-    result.ratios     = ratios;
-    const size_t created_at = wxGetApp().preset_bundle->filament_presets.size();
-    if (!create_mixed_filament_from_result(this, result, color_strs))
-        return -1;
-    return int(created_at);
-}
-
 void Sidebar::add_mixed_filament()
 {
     auto* plater = dynamic_cast<Plater*>(GetParent());
@@ -5357,28 +5299,6 @@ void Sidebar::edit_mixed_filament(size_t panel_idx)
     }
 }
 
-void Sidebar::remove_all_mixed_filaments()
-{
-    auto *plater = dynamic_cast<Plater *>(GetParent());
-    if (plater == nullptr)
-        return;
-    const size_t count = plater->mixed_filament_config_indices().size();
-    if (count == 0)
-        return;
-
-    // Worth a confirmation: this drops filament slots the model may be painted with, and anything
-    // painted in one falls back to a plain filament.
-    MessageDialog dlg(this, format_wxstr(_L("Remove all %1% mixed filaments?"), count), _L("Mixed Filament"),
-                      wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION);
-    if (dlg.ShowModal() != wxID_YES)
-        return;
-
-    // Back to front: delete_mixed_filament_at() indexes the list as it stands, so removing from the end
-    // leaves the indices of everything still to go untouched.
-    for (size_t i = count; i-- > 0;)
-        delete_mixed_filament_at(i);
-}
-
 void Sidebar::delete_mixed_filament_at(size_t panel_idx)
 {
     auto* plater = dynamic_cast<Plater*>(GetParent());

src/slic3r/GUI/Plater.hpp

@@ -292,19 +292,8 @@ public:
 
     // Mixed-color filament sidebar section
     void add_mixed_filament();
-    // The filament slot that blends `components` (1-based physical filament indices) in `ratios`
-    // (percentages), creating it when no existing mixed slot already describes that blend. Returns the
-    // 0-based filament index, or -1 when the paint-state cap leaves no room for another one.
-    //
-    // Exists so a feature that needs a blend can ask for one without going through the modal dialog:
-    // the texture displacement gizmo turns each mix in its palette into a slot, which is what moves the
-    // interleaving from its own paint mask to the slicer, where it happens per layer.
-    int ensure_mixed_filament(const std::vector<unsigned int> &components, const std::vector<int> &ratios);
     void edit_mixed_filament(size_t idx);
     void delete_mixed_filament_at(size_t idx);
-    // Drops every mixed filament at once, after confirming. The texture displacement gizmo can create
-    // one slot per colour in its palette, so clearing them one at a time is tedious.
-    void remove_all_mixed_filaments();
     void decompose_filament_color(int filament_idx);
     void recalc_filament_scroll_sizes();
     void update_mixed_filament_list();

src/slic3r/GUI/PublishSettingsDialog.cpp

@@ -14,6 +14,7 @@
 #include "Widgets/DialogButtons.hpp"
 #include "Widgets/StaticLine.hpp"
 #include "Widgets/StateColor.hpp"
+#include "Widgets/SwitchButton.hpp"
 
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/Preset.hpp"
@@ -864,34 +865,25 @@ void PublishSettingsDialog::build_option_model()
     };
 
     // --- Phase 1: printer per-extruder retraction settings (first, mirroring the sidebar's
-    // Printer group), from the printer tab's "Extruder"/"Extruder N" pages. One inner tab per
-    // extruder (e.g. "Left Extruder"/"Right Extruder" via Tab::translate_category), each holding
-    // that extruder's Retraction and Z-Hop rows with per-extruder "#N" values.
+    // Printer group), from the printer tab's "Extruder" page. One inner tab per extruder (named
+    // as on the printer tab's switch, e.g. "Left Extruder"/"Right Extruder" via
+    // Tab::translate_category), each holding that extruder's Retraction and Z-Hop rows with
+    // per-extruder "#N" values.
     {
         size_t g = section_group_for(Section::Printer);
         std::set<std::string> printer_added;
         for (Tab* tab : wxGetApp().tabs_list) {
-            if (tab->m_type != Preset::TYPE_PRINTER)
+            // The page's controls edit the extruder chosen on the printer tab's switch, so its
+            // option list is read once per extruder.
+            auto*       printer_tab = dynamic_cast<TabPrinter*>(tab);
+            const Page* page        = printer_tab ? printer_tab->extruder_page() : nullptr;
+            if (page == nullptr)
                 continue;
-            for (const PageShp& page : tab->m_pages) {
-                if (!page->title().StartsWith("Extruder"))
-                    continue;
-                // The extruder index of this page: its options are appended with the same
-                // "#N" opt_index (opt.second.second), so derive the tab's index from the first
-                // allowlisted option; skip the page when none is found (defensive).
-                int extruder_idx = -1;
-                for (const ConfigOptionsGroupShp& optgroup : page->m_optgroups) {
-                    if (optgroup->title != "Retraction" && optgroup->title != "Z-Hop")
-                        continue;
-                    for (const auto& opt : optgroup->opt_map())
-                        if (extruder_idx < 0)
-                            extruder_idx = opt.second.second;
-                    if (extruder_idx >= 0)
-                        break;
-                }
-                if (extruder_idx < 0)
-                    continue;
-                const wxString page_title = Tab::translate_category(page->title(), tab->m_type);
+            const size_t extruders_count = printer_tab->m_extruders_count;
+            for (size_t extruder_idx = 0; extruder_idx < extruders_count; ++extruder_idx) {
+                const wxString page_title = Tab::translate_category(extruders_count > 1 ? wxString::Format("Extruder %d", int(extruder_idx + 1)) : wxString("Extruder"), tab->m_type);
+                // Retraction and Z-Hop values are stored per variant column, not per extruder.
+                const int variant_index = printer_tab->extruder_variant_index(int(extruder_idx));
                 for (const ConfigOptionsGroupShp& optgroup : page->m_optgroups) {
                     // Allowlist on the untranslated optgroup title; the "Retraction when
                     // switching material" group is intentionally skipped.
@@ -899,17 +891,17 @@ void PublishSettingsDialog::build_option_model()
                         continue;
                     const wxString subcategory = _(optgroup->title);
                     for (const auto& opt : optgroup->opt_map()) {
-                        const std::string& opt_id   = opt.first;
                         const std::string& pure_key = opt.second.first;
                         // Rows are keyed by the full per-extruder "#N" opt_id so each extruder
                         // tab publishes its own value; GetPublishedKeys() emits the checked rows
                         // as-is.
+                        const std::string opt_id = pure_key + "#" + std::to_string(variant_index);
                         if (!printer_added.insert(opt_id).second)
                             continue;
                         wxString label, value, unit;
                         if (!option_text(opt_id, pure_key, label, value, unit))
                             continue;
-                        size_t cat_index = category_index_for(page_title, Section::Printer, g, size_t(extruder_idx));
+                        size_t cat_index = category_index_for(page_title, Section::Printer, g, extruder_idx);
                         size_t sub_index = subcategory_index_for(cat_index, subcategory, optgroup->icon);
                         add_row_ui(opt_id, label, value, unit, cat_index, sub_index);
                     }
@@ -1098,6 +1090,10 @@ void PublishSettingsDialog::build_option_model()
     for (SectionGroup& section : m_sections)
         if (!section.categories.empty())
             section.tabs->SelectItem(0);
+    // Orca: the Printer section shows its extruders on the same switch as the printer tab's Extruder page.
+    for (size_t s = 0; s < m_sections.size(); ++s)
+        if (m_sections[s].kind == Section::Printer && m_sections[s].categories.size() > 1)
+            setup_variant_switch(s);
     if (!m_sections.empty()) {
         m_outer_tabs->SelectItem(0);
         show_outer_page(0);
@@ -1630,6 +1626,8 @@ void PublishSettingsDialog::show_inner_page(size_t section_index, int inner_inde
         section.selected_mixed = -1;
     }
     section.selected_inner = inner_index;
+    if (section.variant_switch != nullptr)
+        section.variant_switch->SetSelection(inner_index); // fires its event, which ignores the shown page
     Category& category     = m_categories[section.categories[inner_index]];
     category.page->Show();
     category.scroll->FitInside();
@@ -1639,6 +1637,32 @@ void PublishSettingsDialog::show_inner_page(size_t section_index, int inner_inde
     section.page_host_sizer->Layout();
 }
 
+void PublishSettingsDialog::setup_variant_switch(size_t section_index)
+{
+    SectionGroup& section = m_sections[section_index];
+    std::vector<wxString> titles;
+    for (size_t category : section.categories)
+        titles.push_back(m_categories[category].title);
+
+    section.variant_switch = new MultiSwitchButton(section.page);
+    section.variant_switch->SetFitToOptions();
+    section.variant_switch->SetOptions(titles);
+    section.variant_switch->SetSelection(section.selected_inner);
+    section.variant_switch->Bind(wxCUSTOMEVT_MULTISWITCH_SELECTION, [this, section_index](wxCommandEvent& evt) {
+        evt.Skip();
+        // The hidden tab strip stays the selection model; its event shows the page.
+        SectionGroup& sec = m_sections[section_index];
+        if (evt.GetInt() != sec.selected_inner)
+            sec.tabs->SelectItem(evt.GetInt());
+    });
+
+    // The switch takes the place of the tab strip, centered like on the printer tab.
+    wxSizer* page_sizer = section.page->GetSizer();
+    page_sizer->Insert(1, section.variant_switch, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(4));
+    section.tabs->Hide();
+    section.page->Layout();
+}
+
 void PublishSettingsDialog::show_mixed_page(size_t section_index, int mixed_index)
 {
     if (section_index >= m_sections.size())
@@ -2184,6 +2208,13 @@ void PublishSettingsDialog::refresh_tab_indicators()
         for (size_t i = 0; i < section.categories.size(); ++i) {
             const bool on = category_has_selection(m_categories[section.categories[i]]);
             section.tabs->SetItemIndicator(static_cast<unsigned int>(i), on);
+            // The switch has no indicator dot; mark its option text instead.
+            if (section.variant_switch != nullptr) {
+                const wxString& title = m_categories[section.categories[i]].title;
+                const wxString  text  = on ? title + wxString(" ") + wxString(wxUniChar(0x2022)) : title;
+                if (section.variant_switch->GetOptionText(static_cast<unsigned int>(i)) != text)
+                    section.variant_switch->SetOptionText(static_cast<unsigned int>(i), text);
+            }
             any = any || on;
         }
         if (section.mixed_tabs != nullptr)
@@ -2248,6 +2279,8 @@ void PublishSettingsDialog::on_dpi_changed(const wxRect& suggested_rect)
         section.tabs->Rescale();
         if (section.mixed_tabs != nullptr)
             section.mixed_tabs->Rescale();
+        if (section.variant_switch != nullptr)
+            section.variant_switch->Rescale();
     }
 
     // Refresh the per-row Color chips at the new DPI (they carry the slot number too).

src/slic3r/GUI/PublishSettingsDialog.hpp

@@ -37,6 +37,7 @@ namespace Slic3r { class DynamicPrintConfig; }
 class TextInput;
 class StaticLine;
 class CheckBox;
+class MultiSwitchButton;
 
 namespace Slic3r { namespace GUI {
 
@@ -195,6 +196,10 @@ private:
         ScalableBitmap icon_bmp;      // tab icon next to the title; rescaled on DPI change
         wxPanel* page{nullptr};
         TabCtrl* tabs{nullptr};
+        // Printer section with several extruders: the extruder switch shown instead of `tabs`, the
+        // same MultiSwitchButton (and option names) as the printer tab's Extruder page. One option
+        // per entry of `categories`, named by its title; `tabs` stays as the hidden selection model.
+        MultiSwitchButton* variant_switch{nullptr};
         // Second tab strip, below the main one, listing only the mixed-color filament slots.
         // Present on the Material section only (null elsewhere).
         TabCtrl* mixed_tabs{nullptr};
@@ -277,6 +282,8 @@ private:
     bool row_is_visible(const Row& row) const;
     void apply_visibility();
     void bind_tab_events();
+    // Replaces a section's inner tab strip with a variant switch (see SectionGroup::variant_switch).
+    void setup_variant_switch(size_t section_index);
 
     TabCtrl* m_outer_tabs{nullptr};
     wxPanel* m_outer_host{nullptr};

src/slic3r/GUI/Tab.cpp

@@ -811,6 +811,12 @@ wxString Tab::translate_category(const wxString& title, Preset::Type preset_type
         }
         return _("Extruder") + title.SubString(8, title.Last());
     }
+    // Orca: one "Extruder" page serves all extruders; name it "Extruders" when there are several.
+    if (preset_type == Preset::TYPE_PRINTER && title == "Extruder") {
+        auto preset = wxGetApp().preset_bundle;
+        if (preset && preset->get_printer_extruder_count() > 1)
+            return _("Extruders");
+    }
     return _(title);
 }
 
@@ -1153,6 +1159,38 @@ std::string Tab::options_list_storage_key(const std::string& opt_key) const
     return (serialized || is_plugin_field) ? opt_key : opt_key + "#0";
 }
 
+// Orca: deep_diff() flags every vector entry at or past the reference vector's length as changed,
+// whatever its value (e.g. the values of an extruder added by raising the extruder count). A vector
+// grows by copying its first entry (ConfigOptionVector::resize), so such an entry only counts as
+// changed when it differs from the reference's first entry, as before Orca's deep_diff() change.
+// The change of the count itself shows on "extruders_count".
+static void drop_unchanged_added_entries(std::vector<std::string> &options, const DynamicPrintConfig &current, const Preset *reference)
+{
+    if (reference == nullptr)
+        return;
+    // deep_diff() lists a key's entries one after another, so serialize each key's vectors once.
+    std::string              serialized_key;
+    std::vector<std::string> cur_values;
+    std::string              ref_first;
+    options.erase(std::remove_if(options.begin(), options.end(), [&](const std::string &opt) {
+        const auto pos = opt.find('#');
+        if (pos == std::string::npos)
+            return false;
+        const std::string key = opt.substr(0, pos);
+        const size_t      idx = size_t(std::atoi(opt.c_str() + pos + 1));
+        auto ref = dynamic_cast<const ConfigOptionVectorBase *>(reference->config.option(key));
+        auto cur = dynamic_cast<const ConfigOptionVectorBase *>(current.option(key));
+        if (ref == nullptr || cur == nullptr || idx < ref->size() || ref->size() == 0 || idx >= cur->size())
+            return false;
+        if (key != serialized_key) {
+            serialized_key = key;
+            cur_values     = cur->vserialize();
+            ref_first      = ref->vserialize().front();
+        }
+        return cur_values[idx] == ref_first;
+    }), options.end());
+}
+
 void Tab::update_all_extruder_options_status()
 {
     if (!m_extruder_switch && !m_variant_combo) {
@@ -1183,6 +1221,8 @@ void Tab::update_all_extruder_options_status()
 
     auto dirty_options = m_presets->current_dirty_options(true);
     auto nonsys_options = m_presets->current_different_from_parent_options(true);
+    if (m_type == Preset::TYPE_PRINTER)
+        update_custom_dirty(dirty_options, nonsys_options);
     auto filter_extruder_options = [](const std::vector<std::string>& options) {
         std::vector<std::string> filtered_options;
         for (const auto& opt : options) {
@@ -1231,7 +1271,7 @@ void Tab::update_extruder_switch_colors()
 
         if (m_active_page) {
             if (m_active_page->title() == "Speed" || m_active_page->title() == "Motion ability" || m_active_page->title() == "Filament" ||
-                m_active_page->title() == "Setting Overrides" || m_active_page->title() == "Multimaterial") {
+                m_active_page->title() == "Setting Overrides" || m_active_page->title() == "Multimaterial" || is_printer_extruder_page(m_active_page)) {
                 for (auto page_ptr : m_pages) {
                     if (page_ptr.get() == m_active_page) {
                         pages_to_check.push_back(page_ptr);
@@ -1262,8 +1302,8 @@ void Tab::update_extruder_switch_colors()
 void Tab::check_extruder_options_status(int index, bool &sys_extruder, bool &modified_extruder, const std::vector<PageShp>& pages_to_check)
 {
     int config_index = index;
+    int extruder_id  = index;
     if (m_type == Preset::TYPE_PRINT || m_type == Preset::TYPE_PRINTER || m_type == Preset::TYPE_MODEL) {
-        int extruder_id;
         NozzleVolumeType nozzle_type;
         parse_extruder_selection(index, extruder_id, nozzle_type);
 
@@ -1296,6 +1336,10 @@ void Tab::check_extruder_options_status(int index, bool &sys_extruder, bool &mod
                 }
 
                 std::string target_opt_key = base_opt_key + "#" + std::to_string(config_index * stride);
+                // Orca: on the printer's Extruder page only per-variant options use the variant column,
+                // the others (nozzle_diameter, extruder_offset, ...) are indexed by the extruder.
+                if (is_printer_extruder_page(page.get()) && printer_options_with_variant_1.count(base_opt_key) == 0)
+                    target_opt_key = base_opt_key + "#" + std::to_string(extruder_id);
 
                 auto status_iter = m_all_extruder_options_status.find(target_opt_key);
                 if (status_iter != m_all_extruder_options_status.end()) {
@@ -1336,18 +1380,6 @@ void TabPrinter::init_options_list()
     Tab::init_options_list();
     if (m_printer_technology == ptFFF)
         m_options_list.emplace("extruders_count", m_opt_status_value);
-    for (size_t i = 1; i < m_extruders_count; ++i) {
-        wxString target_title = wxString::Format("Extruder %d", int(i + 1));
-        for (auto &page : m_pages) {
-            if (page->title() == target_title) {
-                for (auto group : page->m_optgroups) {
-                    for (auto &opt : group->opt_map())
-                        m_options_list.emplace(opt.first, m_opt_status_value);
-                }
-                break;
-            }
-        }
-    }
 }
 
 void TabPrinter::msw_rescale()
@@ -1437,7 +1469,7 @@ void Tab::update_changed_tree_ui()
                     get_sys_and_mod_flags("compatible_printers", sys_page, modified_page);
                 }
             }
-            if (page->title() == "Speed" || page->title() == "Motion ability" || page->title() == "Filament" || page->title() == "Setting Overrides" || page->title() == "Multimaterial") {
+            if (page->title() == "Speed" || page->title() == "Motion ability" || page->title() == "Filament" || page->title() == "Setting Overrides" || page->title() == "Multimaterial" || is_printer_extruder_page(page.get())) {
                 auto options = generate_extruder_options();
                 for (size_t switch_index = 0; switch_index < options.size(); ++switch_index) {
                     std::vector<PageShp> pages_to_check = { page };
@@ -1540,6 +1572,10 @@ void Tab::on_roll_back_value(const bool to_sys /*= true*/)
 
     m_postpone_update_ui = false;
 
+    // Orca: the restored config may have another extruder count than the tab shows.
+    if (auto printer_tab = dynamic_cast<TabPrinter *>(this))
+        printer_tab->sync_extruders_count();
+
     // When all values are rolled, then we have to update whole tab in respect to the reverted values
     update();
     if (m_active_page)
@@ -1877,6 +1913,17 @@ static wxString pad_combo_value_for_config(const DynamicPrintConfig &config)
     return config.opt_bool("pad_enable") ? (config.opt_bool("pad_around_object") ? _("Around object") : _("Below object")) : _("None");
 }
 
+// Rebuilds the variant switch of every tab that has one, e.g. after the extruder count or a nozzle volume type changed.
+static void update_all_extruder_variants(int extruder_idx = -1)
+{
+    for (auto tab : wxGetApp().tabs_list)
+        tab->update_extruder_variants(extruder_idx);
+    if (auto tab = wxGetApp().plate_tab)
+        tab->update_extruder_variants(extruder_idx);
+    for (auto tab : wxGetApp().model_tabs_list)
+        tab->update_extruder_variants(extruder_idx);
+}
+
 void Tab::on_value_change(const std::string& opt_key, const boost::any& value)
 {
     // Orca:
@@ -2319,15 +2366,7 @@ void Tab::on_value_change(const std::string& opt_key, const boost::any& value)
 
     if (opt_key.find("nozzle_volume_type") != std::string::npos) {
         int extruder_idx = std::atoi(opt_key.substr(opt_key.find_last_of('#') + 1).c_str());
-        for (auto tab : wxGetApp().tabs_list) {
-            tab->update_extruder_variants(extruder_idx);
-        }
-        if (auto tab = wxGetApp().plate_tab) {
-            tab->update_extruder_variants(extruder_idx);
-        }
-        for (auto tab : wxGetApp().model_tabs_list) {
-            tab->update_extruder_variants(extruder_idx);
-        }
+        update_all_extruder_variants(extruder_idx);
         if (wxGetApp().app_config->get("auto_calculate_flush") == "all") {
             wxGetApp().plater()->sidebar().auto_calc_flushing_volumes(-1,extruder_idx);
         }
@@ -5685,9 +5724,13 @@ if (is_marlin_flavor)
             size_t extruders_count = size_t(boost::any_cast<int>(v));
             wxTheApp->CallAfter([this, opt_key, value, extruders_count]() {
                 if (opt_key == "extruders_count" || opt_key == "single_extruder_multi_material") {
+                    const size_t old_extruders_count = m_extruders_count;
                     extruders_count_changed(extruders_count);
                     init_options_list(); // m_options_list should be updated before UI updating
                     update_dirty();
+                    // Orca: the variant switches (here, Process in the sidebar, ...) list one option per extruder.
+                    if (m_extruders_count != old_extruders_count)
+                        update_all_extruder_variants();
                     if (opt_key == "single_extruder_multi_material") { // the single_extruder_multimaterial was added to force pages
                         on_value_change(opt_key, value);                      // rebuild - let's make sure the on_value_change is not skipped
 
@@ -5697,6 +5740,7 @@ if (is_marlin_flavor)
 // Orca: we use a different logic here. If SEMM is enabled, we set extruder count to 1.
 #if 1
                             extruders_count_changed(1);
+                            update_all_extruder_variants();
 #else
 
                             std::vector<double> nozzle_diameters =
@@ -5768,14 +5812,13 @@ if (is_marlin_flavor)
         m_pages.insert(m_pages.end() - n_after_single_extruder_MM, page);
     }
 
-    // Orca: build missed extruder pages
-    for (auto extruder_idx = m_extruders_count_old; extruder_idx < m_extruders_count; ++extruder_idx) {
-        const wxString& page_name = (m_extruders_count > 1) ? wxString::Format("Extruder %d", int(extruder_idx + 1)) : wxString::Format("Extruder");
-
-        //# build page
-        //const wxString& page_name = wxString::Format("Extruder %d", int(extruder_idx + 1));
-        auto page = add_options_page(page_name, "custom-gcode_extruder", true); // ORCA: icon only visible on placeholders
-        m_pages.insert(m_pages.begin() + n_before_extruders + extruder_idx, page);
+    // Orca: a single "Extruder" page serves all extruders. Its controls are created once for extruder 0;
+    // switch_excluder() re-targets them to the extruder selected on the variant switch (m_extruder_switch),
+    // which the printer tab shows on this page too.
+    if (extruder_page() == nullptr && m_extruders_count > 0) {
+        const size_t extruder_idx = 0;
+        auto page = add_options_page(L("Extruder"), "custom-gcode_extruder", true); // ORCA: icon only visible on placeholders
+        m_pages.insert(m_pages.begin() + n_before_extruders, page);
 
         auto optgroup = page->new_optgroup(L("Basic information"), L"param_information", -1, true);
             optgroup->append_single_option_line("nozzle_diameter", "printer_extruder_basic_information#nozzle-diameter", extruder_idx);
@@ -5788,8 +5831,10 @@ if (is_marlin_flavor)
             option.opt.full_width = true;
             optgroup->append_single_option_line(option, "printer_extruder_basic_information#extruder-offset-position");
 
-            optgroup->m_on_change = [this, extruder_idx](const t_config_option_key& opt_key, boost::any value)
+            optgroup->m_on_change = [this](const t_config_option_key& opt_key, boost::any value)
             {
+                // The page edits the extruder selected on the variant switch.
+                const size_t extruder_idx = size_t(get_current_active_extruder());
                 bool is_SEMM = m_config->opt_bool("single_extruder_multi_material");
                 if (is_SEMM && m_extruders_count > 1 && boost::starts_with(opt_key, "nozzle_diameter"))
                 {
@@ -5884,22 +5929,22 @@ if (is_marlin_flavor)
             //optgroup->append_line(line);
 #endif
     }
-    // BBS. No extra extruder page for single physical extruder machine
-    // # remove extra pages
-    auto &first_extruder_title = const_cast<wxString &>(m_pages[n_before_extruders]->title());
-    if (m_extruders_count < m_extruders_count_old) {
-        m_pages.erase(	m_pages.begin() + n_before_extruders + m_extruders_count,
-                        m_pages.begin() + n_before_extruders + m_extruders_count_old);
-        if (m_extruders_count == 1)
-            first_extruder_title = wxString::Format("Extruder");
-    } else if (m_extruders_count_old == 1) {
-        first_extruder_title = wxString::Format("Extruder %d", 1);
-    }
-    auto & index = wxGetApp().sidebar().settings_index();
-    for (auto &group : m_pages[n_before_extruders]->m_optgroups) {
-        group->set_config_category_and_type(first_extruder_title, m_type);
-        for (auto &opt : group->opt_map())
-            index.add_key(opt.first + "#0", m_type, group->title, first_extruder_title, group->icon);
+
+    // The page holds only the "#0" controls, so register every extruder's options with the search
+    // index under "Extruder N"; a search hit selects that extruder (TabPrinter::activate_option()).
+    if (Page *page = extruder_page()) {
+        auto &index = wxGetApp().sidebar().settings_index();
+        for (auto &group : page->m_optgroups) {
+            group->set_config_category_and_type(page->title(), m_type);
+            for (auto &opt : group->opt_map()) {
+                if (opt.second.second < 0)
+                    continue;
+                for (size_t i = 0; i < m_extruders_count; ++i) {
+                    const wxString category = m_extruders_count > 1 ? wxString::Format("Extruder %d", int(i + 1)) : wxString("Extruder");
+                    index.add_key(opt.second.first + "#" + std::to_string(i), m_type, group->title, category, group->icon);
+                }
+            }
+        }
     }
 
     Thaw();
@@ -6180,12 +6225,6 @@ void TabPrinter::toggle_options()
         return;
 
     auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
-    auto extruders      = m_config->option<ConfigOptionEnumsGeneric>("extruder_type");
-        auto get_index_for_extruder =
-            [this, &extruders](int extruder_id, int stride = 1) {
-        return m_config->get_index_for_extruder(extruder_id + 1, "printer_extruder_id",
-            ExtruderType(extruders->values[extruder_id]), get_actual_nozzle_volume_type(extruder_id), "printer_extruder_variant", stride);
-    };
 
     //BBS: whether the preset is Bambu Lab printer
     bool is_BBL_printer = false;
@@ -6260,14 +6299,13 @@ void TabPrinter::toggle_options()
         toggle_option("tool_change_on_wipe_tower", !bSEMM && supports_wipe_tower_2 && extruders_count > 1);
         toggle_option("wait_for_temp_on_wipe_tower", !bSEMM && supports_wipe_tower_2 && extruders_count > 1);
     }
-    wxString extruder_number;
-    long val = 1;
-    if ( m_active_page->title().IsSameAs(L("Extruder")) ||
-        (m_active_page->title().StartsWith("Extruder ", &extruder_number) && extruder_number.ToLong(&val) &&
-        val > 0 && (size_t)val <= m_extruders_count))
+    if (m_active_page->title() == L("Extruder") && m_extruders_count > 0)
     {
-        size_t i = size_t(val - 1);
-        int variant_index = get_index_for_extruder(i);
+        // Orca: the single Extruder page edits the extruder selected on the variant switch; its
+        // controls carry field index 0 (i), the values are read for `extruder`.
+        const size_t i        = 0;
+        const size_t extruder = std::min<size_t>(size_t(get_current_active_extruder()), m_extruders_count - 1);
+        const int    variant_index = extruder_variant_index(int(extruder));
         bool have_retract_length = m_config->opt_float("retraction_length", variant_index) > 0;
 
         toggle_option("extruder_printable_area", false, i);          // disable
@@ -6294,7 +6332,7 @@ void TabPrinter::toggle_options()
         vec.resize(0);
         vec = {"retract_lift_above", "retract_lift_below", "retract_lift_enforce"};
         for (auto el : vec)
-          toggle_option(el, retraction && (m_config->opt_float("z_hop", i) > 0), i);
+          toggle_option(el, retraction && (m_config->opt_float("z_hop", variant_index) > 0), i);
 
         // some options only apply when not using firmware retraction
         vec.resize(0);
@@ -6347,7 +6385,7 @@ void TabPrinter::toggle_options()
         toggle_option("long_retractions_when_cut", !use_firmware_retraction && m_config->opt_int("enable_long_retraction_when_cut"), i);
         toggle_line("retraction_distances_when_cut", m_config->opt_bool("long_retractions_when_cut", variant_index), i);
 
-        toggle_option("travel_slope", m_config->opt_enum("z_hop_types", i) != ZHopType::zhtNormal, i);
+        toggle_option("travel_slope", m_config->opt_enum("z_hop_types", variant_index) != ZHopType::zhtNormal, i);
     }
 
     if (m_active_page->title() == L("Motion ability")) {
@@ -6421,12 +6459,16 @@ void TabPrinter::on_value_change(const std::string& opt_key, const boost::any& v
         return;
 
     const int pos = opt_key.find("#");
+    // Orca: fields of the single Extruder page keep index 0 but edit the selected extruder.
+    const int data_idx = pos > 0 ? extruder_page_data_index(opt_key) : -1;
 
     if (pos > 0) {
         std::string temp_str = opt_key;
         boost::erase_head(temp_str, pos + 1);
         int orig_opt_idx = static_cast<size_t>(atoi(temp_str.c_str()));
         int opt_idx = orig_opt_idx >= 0 ? orig_opt_idx : 0;
+        if (data_idx >= 0)
+            opt_idx = data_idx;
 
         std::string opt_key_pure = opt_key;
         boost::erase_tail(opt_key_pure, opt_key_pure.size() - pos);
@@ -6461,7 +6503,12 @@ void TabPrinter::on_value_change(const std::string& opt_key, const boost::any& v
         }
     }
 
-    Tab::on_value_change(opt_key, value);
+    // Orca: report Extruder page changes as "key#<extruder>", as the former "Extruder N" pages did,
+    // so per-extruder handling in Tab::on_value_change() sees the extruder that was edited.
+    if (data_idx >= 0)
+        Tab::on_value_change(opt_key.substr(0, pos) + "#" + std::to_string(get_current_active_extruder()), value);
+    else
+        Tab::on_value_change(opt_key, value);
 }
 
 void TabPrinter::update()
@@ -7393,12 +7440,7 @@ bool Tab::tree_sel_change_delayed(wxCommandEvent& event)
         // update_undo_buttons();
         this->OnActivate();
         m_parent->set_active_tab(this);
-        if (m_variant_sizer) {
-            wxWindow *variant_ctrl = m_extruder_switch ? (wxWindow *) m_extruder_switch : m_variant_combo;
-            m_main_sizer->Show(m_variant_sizer, variant_ctrl->IsThisEnabled() && !m_active_page->m_opt_id_map.empty() && !m_active_page->title().StartsWith("Extruder "));
-            if (m_extruder_sync) m_extruder_sync->Show(variant_ctrl->IsShown());
-            GetParent()->Layout();
-        }
+        update_variant_sizer_visibility();
 
         m_page_view->Thaw();
         return false;
@@ -7409,12 +7451,7 @@ bool Tab::tree_sel_change_delayed(wxCommandEvent& event)
         return false;
 
     m_active_page = page;
-    if (m_variant_sizer) {
-        wxWindow *variant_ctrl = m_extruder_switch ? (wxWindow *) m_extruder_switch : m_variant_combo;
-        m_main_sizer->Show(m_variant_sizer, variant_ctrl->IsThisEnabled() && !m_active_page->m_opt_id_map.empty() && !m_active_page->title().StartsWith("Extruder"));
-        if (m_extruder_sync) m_extruder_sync->Show(variant_ctrl->IsShown());
-        GetParent()->Layout();
-    }
+    update_variant_sizer_visibility();
 
     auto throw_if_canceled = std::function<void()>([this](){
 #ifdef WIN32
@@ -8240,9 +8277,11 @@ void Tab::update_extruder_variants(int extruder_id, bool reload)
         m_actual_nozzle_volumes.resize(extruder_nums, NozzleVolumeType::nvtStandard);
         for (int i = 0; i < extruder_nums; i++) m_actual_nozzle_volumes[i] = (NozzleVolumeType)nozzle_volumes->values[i];
 
-        // Orca: a non-Bambu dual-nozzle printer has two extruders but a single variant column, so
-        // the nozzle switch and sync button have nothing to act on. Only enable with real variants.
-        if (extruder_nums >= 2 && m_preset_bundle->support_different_extruders()) {
+        // Orca: when every extruder uses the same variant (e.g. a non-Bambu dual-nozzle printer), the
+        // switch has no nozzle variants to select and nothing to sync. The printer tab still enables it
+        // to choose the extruder its Extruder and Motion ability pages edit.
+        m_extruder_switch_variants = extruder_nums >= 2 && m_preset_bundle->support_different_extruders();
+        if (m_extruder_switch_variants || (m_type == Preset::TYPE_PRINTER && extruder_nums >= 2)) {
             auto options = generate_extruder_options();
             m_extruder_switch->SetOptions(options);
 
@@ -8281,12 +8320,8 @@ void Tab::update_extruder_variants(int extruder_id, bool reload)
     if (m_type == Preset::TYPE_PRINT) {
         update_pages_with_multi_variant();
     }
-    if (m_variant_sizer) {
-        wxWindow *variant_ctrl = m_extruder_switch ? (wxWindow *) m_extruder_switch : m_variant_combo;
-        m_main_sizer->Show(m_variant_sizer, variant_ctrl->IsThisEnabled() && m_active_page && !m_active_page->m_opt_id_map.empty() && !m_active_page->title().StartsWith("Extruder "));
-        if (m_extruder_sync) m_extruder_sync->Show(variant_ctrl->IsShown());
-        GetParent()->Layout();
-    }
+    update_extruder_switch_colors();
+    update_variant_sizer_visibility();
 }
 
 // The variant switch tags are the narrowest place a volume type is named, so they abbreviate it;
@@ -8361,12 +8396,21 @@ std::vector<wxString> Tab::generate_extruder_options()
         return options;
     }
 
+    // Orca: the printer tab has one tag per extruder, named as its former "Extruder N" pages were.
+    // parse_extruder_selection() counts a hybrid extruder as two tags; that still lines up because
+    // only the last extruder can be hybrid.
+    if (m_type == Preset::TYPE_PRINTER) {
+        for (int i = 0; i < extruder_nums; ++i)
+            options.push_back(translate_category(wxString::Format("Extruder %d", i + 1), m_type));
+        return options;
+    }
+
     std::string pt = m_preset_bundle->printers.get_edited_preset().get_printer_type(m_preset_bundle);
-    // Orca: the main/deputy toolhead names describe a dual-nozzle printer, where extruder 0 is the
-    // left (deputy) and extruder 1 the right (main) nozzle. From three extruders on the tools are
-    // interchangeable, so name them by index instead of repeating one side.
+    // Orca: the main/deputy toolhead names describe a Bambu dual-nozzle printer, where extruder 0 is
+    // the left (deputy) and extruder 1 the right (main) nozzle. Other printers number their tools.
+    const bool toolhead_names = extruder_nums == 2 && m_preset_bundle->is_bbl_vendor();
     for (int i = 0; i < extruder_nums; ++i) {
-        wxString extruder_name = extruder_nums > 2 ? wxString::Format("T%d", i + 1) :
+        wxString extruder_name = !toolhead_names ? wxString::Format("T%d", i + 1) :
                                                      _L(DevPrinterConfigUtil::get_toolhead_display_name(
                                                          pt, (i == 0) ? DEPUTY_EXTRUDER_ID : MAIN_EXTRUDER_ID,
                                                          ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase, true));
@@ -8383,6 +8427,71 @@ std::vector<wxString> Tab::generate_extruder_options()
     return options;
 }
 
+Page *TabPrinter::extruder_page() const
+{
+    for (const PageShp &page : m_pages)
+        if (page->title() == "Extruder")
+            return page.get();
+    return nullptr;
+}
+
+int TabPrinter::extruder_page_data_index(const std::string &field_id) const
+{
+    if (Page *page = extruder_page())
+        for (const auto &group : page->m_optgroups)
+            if (auto it = group->opt_map().find(field_id); it != group->opt_map().end())
+                return it->second.second;
+    return -1;
+}
+
+int TabPrinter::extruder_variant_index(int extruder)
+{
+    const auto *extruders = m_config->option<ConfigOptionEnumsGeneric>("extruder_type");
+    const int   index     = extruder < int(extruders->size()) ?
+                                m_config->get_index_for_extruder(extruder + 1, "printer_extruder_id", ExtruderType(extruders->values[extruder]),
+                                                                 get_actual_nozzle_volume_type(extruder), "printer_extruder_variant") :
+                                -1;
+    return index < 0 ? extruder : index;
+}
+
+void TabPrinter::update_custom_dirty(std::vector<std::string> &dirty_options, std::vector<std::string> &nonsys_options)
+{
+    drop_unchanged_added_entries(dirty_options, *m_config, &m_presets->get_selected_preset());
+    drop_unchanged_added_entries(nonsys_options, *m_config, m_presets->get_selected_preset_parent());
+}
+
+void TabPrinter::sync_extruders_count()
+{
+    if (m_printer_technology != ptFFF)
+        return;
+    const auto *nozzle_diameter = m_config->option<ConfigOptionFloats>("nozzle_diameter");
+    if (nozzle_diameter == nullptr || nozzle_diameter->size() == m_extruders_count)
+        return;
+    extruders_count_changed(nozzle_diameter->size());
+    init_options_list();
+    update_all_extruder_variants();
+}
+
+void TabPrinter::activate_option(const std::string &opt_key, const wxString &category)
+{
+    wxString number;
+    long     n = 0;
+    const bool numbered = category.StartsWith("Extruder ", &number) && number.ToLong(&n);
+    if (extruder_page() == nullptr || (!numbered && category != "Extruder")) {
+        Tab::activate_option(opt_key, category);
+        return;
+    }
+
+    // Selecting fires the switch's event, which re-targets the page (switch_excluder()).
+    const int extruder_idx = (n >= 1 && n <= long(m_extruders_count)) ? int(n - 1) : 0;
+    if (m_extruder_switch && m_extruder_switch->IsThisEnabled() && extruder_idx != get_current_active_extruder())
+        m_extruder_switch->SetSelection(calculate_selection_index_for_extruder(extruder_idx, get_actual_nozzle_volume_type(extruder_idx)));
+
+    // The page's controls are created for index 0.
+    const auto pos = opt_key.find('#');
+    Tab::activate_option(pos == std::string::npos ? opt_key : opt_key.substr(0, pos) + "#0", "Extruder");
+}
+
 NozzleVolumeType Tab::get_actual_nozzle_volume_type(int extruder_id)
 {
     int extruder_count = m_preset_bundle->get_printer_extruder_count();
@@ -8459,18 +8568,44 @@ bool Tab::get_extruder_sync_enable_state(int extruder_id)
     return false;
 }
 
+bool Tab::variant_switch_active() const
+{
+    if (m_extruder_switch)
+        return m_extruder_switch->IsThisEnabled();
+    return m_variant_combo && m_variant_combo->IsThisEnabled();
+}
+
+void Tab::update_variant_sizer_visibility()
+{
+    if (!m_variant_sizer)
+        return;
+    const bool show = variant_switch_active() && m_active_page && !m_active_page->m_opt_id_map.empty();
+    m_main_sizer->Show(m_variant_sizer, show);
+    if (m_extruder_sync) {
+        m_extruder_sync->Show(show);
+        // Orca: copying between extruders is offered only between nozzle variants, and not on the Extruder page.
+        m_extruder_sync->Enable(m_extruder_switch_variants && !is_printer_extruder_page(m_active_page) &&
+                                get_extruder_sync_enable_state(get_current_active_extruder()));
+    }
+    GetParent()->Layout();
+}
+
 void Tab::switch_excluder(int extruder_id, bool reload)
 {
     Preset & printer_preset = m_preset_bundle->printers.get_edited_preset();
     auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
     auto extruders      = printer_preset.config.option<ConfigOptionEnumsGeneric>("extruder_type");
 
+    // Orca: the printer tab re-targets its pages to the extruder selected on the switch. Resolved before
+    // the range check below, which keeps the extruder_type read in get_index_for_extruder in range.
+    if (m_type == Preset::TYPE_PRINTER && extruder_id == -1)
+        extruder_id = get_current_active_extruder();
     if (!m_variant_combo && (extruder_id >= (int)nozzle_volumes->size() || extruder_id >= (int)extruders->size()))
         extruder_id = 0;
     if (m_extruder_switch) {
         int current_extruder = get_current_active_extruder();
         bool sync_enable = get_extruder_sync_enable_state(current_extruder);
-        m_extruder_sync->Enable(m_extruder_switch->IsThisEnabled() && sync_enable);
+        m_extruder_sync->Enable(m_extruder_switch_variants && sync_enable && !is_printer_extruder_page(m_active_page));
         m_extruder_sync->Show();
         if (m_type != Preset::TYPE_PRINTER) {
             if (extruder_id == -1)
@@ -8497,24 +8632,26 @@ void Tab::switch_excluder(int extruder_id, bool reload)
         return;
     if (m_extruder_switch) m_extruder_switch->SetClientData(reinterpret_cast<void*>(static_cast<std::uintptr_t>(index)));
     if (m_variant_combo) m_variant_combo->SetClientData(reinterpret_cast<void *>(static_cast<std::uintptr_t>(index)));
-    wxWindow *variant_ctrl = m_extruder_switch ? (wxWindow *) m_extruder_switch : m_variant_combo;
     for (auto page : m_pages) {
         bool is_extruder = false;
+        int  page_index  = index;
         if (m_type == Preset::TYPE_PRINTER) {
-            if (page->title().StartsWith("Extruder")) {
-                int extruder_id2 = std::atoi(page->title().Mid(9).ToUTF8()) - 1;
-                if (extruder_id >= 0 && extruder_id2 != extruder_id)
-                    continue;
-                if (extruder_id2 > 0)
-                    index = get_index_for_extruder(extruder_id2);
+            if (page->title() == "Extruder")
                 is_extruder = true;
-            } else if (page->title().StartsWith("Motion ability")) {
-                index = get_index_for_extruder(extruder_id == -1 ? 0 : extruder_id, 2);
-            }
+            else if (page->title().StartsWith("Motion ability"))
+                page_index = get_index_for_extruder(extruder_id == -1 ? 0 : extruder_id, 2);
         }
         page->m_opt_id_map.clear();
         for (auto group : page->m_optgroups) {
             for (auto &opt : group->opt_map()) {
+                if (is_extruder && opt.second.second >= 0) {
+                    // Per-variant options use the variant column, the others (nozzle_diameter,
+                    // extruder_offset, ...) are sized by the extruder count and use the extruder.
+                    const int idx = printer_options_with_variant_1.count(opt.second.first) > 0 ? page_index : extruder_id;
+                    const_cast<int &>(opt.second.second) = idx;
+                    page->m_opt_id_map.insert({opt.second.first + "#" + std::to_string(idx), opt.first});
+                    continue;
+                }
                 auto iter = std::find(printer_extruder_options.begin(), printer_extruder_options.end(), opt.second.first);
                 if (iter != printer_extruder_options.end()) {
                     page->m_opt_id_map.insert({opt.first, opt.first});
@@ -8522,9 +8659,9 @@ void Tab::switch_excluder(int extruder_id, bool reload)
                 }
 
                 if (opt.second.second >= 0) {
-                    const_cast<int &>(opt.second.second) = index;
-                    page->m_opt_id_map.insert({opt.second.first + "#" + std::to_string(index), opt.first});
-                    group->draw_multi_extruder = !is_extruder && variant_ctrl->IsThisEnabled();
+                    const_cast<int &>(opt.second.second) = page_index;
+                    page->m_opt_id_map.insert({opt.second.first + "#" + std::to_string(page_index), opt.first});
+                    group->draw_multi_extruder = variant_switch_active();
                 }
             }
         }

src/slic3r/GUI/Tab.hpp

@@ -331,6 +331,10 @@ public:
     MultiSwitchButton *  m_variant_combo   = nullptr;
     ScalableButton *m_extruder_sync   = nullptr;
 	wxPanel *       m_extruder_sync_box  = nullptr;
+    // Orca: whether m_extruder_switch switches nozzle variants (it then offers sync between them).
+    // The printer tab also enables the switch for printers without variants, to choose the extruder
+    // its Extruder and Motion ability pages edit.
+    bool            m_extruder_switch_variants = false;
     std::vector<NozzleVolumeType> m_actual_nozzle_volumes;
 
 public:
@@ -387,6 +391,13 @@ public:
     void        update_changed_tree_ui();
 	void		update_undo_buttons();
     void        update_extruder_switch_colors();
+    // Whether the variant switch (m_extruder_switch / m_variant_combo) is enabled: on the printer tab for
+    // any multi-extruder printer, on the other tabs when it switches nozzle variants.
+    bool        variant_switch_active() const;
+    // Orca: whether `page` is the printer tab's single "Extruder" page, which edits the extruder selected on the switch.
+    bool        is_printer_extruder_page(const Page* page) const { return m_type == Preset::TYPE_PRINTER && page && page->title() == "Extruder"; }
+    // Shows the variant switch row on pages with options that follow it.
+    void        update_variant_sizer_visibility();
     void        update_all_extruder_options_status();
     void        check_extruder_options_status(int index, bool &sys_extruder, bool &modified_extruder, const std::vector<PageShp>& pages_to_check);
 
@@ -444,7 +455,7 @@ public:
 	virtual void    on_value_change(const std::string& opt_key, const boost::any& value);
 
     void            update_wiping_button_visibility();
-	void			activate_option(const std::string& opt_key, const wxString& category);
+	virtual void	activate_option(const std::string& opt_key, const wxString& category);
     void			apply_searcher();
 	void			cache_config_diff(const std::vector<std::string>& selected_options, const DynamicPrintConfig* config = nullptr);
 	void			apply_config_from_cache();
@@ -710,6 +721,25 @@ public:
 	void		cache_extruder_cnt(const DynamicPrintConfig* config = nullptr);
 	bool		apply_extruder_cnt_from_cache();
 	void		refresh_printer_agent_dropdown() const;
+
+	// Orca: a single "Extruder" page for all extruders. Its controls are created once (index 0) and
+	// switch_excluder() re-targets them to the extruder selected on m_extruder_switch.
+	Page*		extruder_page() const;
+	// Config index an "Extruder" page field (e.g. "retraction_length#0") currently edits, -1 if not on that page.
+	int			extruder_page_data_index(const std::string& field_id) const;
+	// Config index of an extruder's per-variant options (Retraction, Z-Hop, ...): its variant column
+	// for the nozzle selected on the switch, or the extruder index on a printer without variants.
+	int			extruder_variant_index(int extruder);
+	// After the config was restored (roll back): follow its extruder count, if it differs.
+	void		sync_extruders_count();
+	// Search jump to "Extruder N" / "key#N": selects extruder N on the switch, then activates the
+	// page's own field on the "Extruder" page.
+	void		activate_option(const std::string& opt_key, const wxString& category) override;
+
+protected:
+	// Orca: values of extruders added by raising the extruder count have no saved / system value to
+	// revert to; the change is shown on "extruders_count", not on each of their parameters.
+	void		update_custom_dirty(std::vector<std::string> &dirty_options, std::vector<std::string> &nonsys_options) override;
 };
 
 class TabSLAMaterial : public Tab

src/slic3r/Utils/BBLNetworkPlugin.cpp

@@ -596,7 +596,8 @@ PrintParams_Legacy BBLNetworkPlugin::as_legacy(PrintParams& param)
 }
 
 // Every PrintParams field except the four the 02.08.01 series added
-// (task_timelapse_use_internal, extruder_cali_manual_mode, svc_context, slicer_uid).
+// (task_timelapse_use_internal, extruder_cali_manual_mode, svc_context, slicer_uid) and the
+// queue_plate_id 02.08.02 appended.
 PrintParams_0203 BBLNetworkPlugin::as_0203(PrintParams& param)
 {
     PrintParams_0203 p;

src/slic3r/Utils/bambu_networking.hpp

@@ -336,6 +336,7 @@ struct PrintParams {
     bool            try_emmc_print;
     std::string     svc_context;
     std::string     slicer_uid;
+    std::string     queue_plate_id;
 };
 
 struct TaskQueryParams
@@ -412,7 +413,7 @@ enum class NetworkAbi {
     Unsupported, // no generation in this build can call it - never dispatch through it
     Legacy,      // 01.10.01: PrintParams_Legacy; send_message/send_message_to_printer take no flag
     V0203,       // 02.03.00: PrintParams_0203; bind takes no dev_model
-    Current,     // 02.08.01: the layouts and signatures this build declares directly
+    Current,     // 02.08.04: the layouts and signatures this build declares directly
 };
 
 struct NetworkLibraryVersion {
@@ -425,10 +426,12 @@ struct NetworkLibraryVersion {
 };
 
 // Every row names the generation that can call it, so a series can never be offered without a
-// host-side ABI for it. Series with no generation - 02.01.01, 02.00.02 and older - must stay out;
-// is_supported_network_version() is the gate that keeps them from loading.
+// host-side ABI for it. Series with no generation - 02.08.01 (whose PrintParams lacks the
+// queue_plate_id that 02.08.02 appended, and whose malformed bind table macOS 27 refuses to
+// load), 02.01.01, 02.00.02 and older - must stay out; is_supported_network_version() is the
+// gate that keeps them from loading.
 static const NetworkLibraryVersion AVAILABLE_NETWORK_VERSIONS[] = {
-    {"02.08.01", "02.08.01", nullptr, true, nullptr, NetworkAbi::Current},
+    {"02.08.04", "02.08.04", nullptr, true, nullptr, NetworkAbi::Current},
     {"02.03.00", "02.03.00", nullptr, false,
      "An older plug-in series. Features that need newer plug-in support, such as print-failure "
      "snapshots in the device error dialog, are unavailable.", NetworkAbi::V0203},

src/slic3r/plugin/host/PluginHostUi.cpp

@@ -28,6 +28,7 @@
 #include <wx/app.h>
 #include <wx/defs.h>
 #include <wx/thread.h>
+#include <wx/timer.h>
 #include <wx/toplevel.h>
 #include <wx/event.h>
 #include <wx/progdlg.h>
@@ -415,6 +416,44 @@ struct UiDockPanelHandle
     int id{0};
 };
 
+// Polls until the plater is shown on screen, then runs the callback with it (null when the app
+// is closing instead) and deletes itself. A plugin loaded at startup opens its panes from
+// on_load, before the main window exists, and a pane added before that window is laid out is
+// sized against the unsized frame and keeps that width (AuiMgr::track_docked_size).
+class PlaterShownWaiter : public wxTimer
+{
+public:
+    explicit PlaterShownWaiter(std::function<void(GUI::Plater*)> fn) : m_fn(std::move(fn)) {}
+
+    // True once the callback ran.
+    bool try_run()
+    {
+        const bool   closing = GUI::wxGetApp().is_closing();
+        GUI::Plater* plater  = closing ? nullptr : GUI::wxGetApp().plater();
+        if (!closing && (plater == nullptr || !plater->IsShownOnScreen()))
+            return false;
+        Stop();
+        m_fn(plater);
+        // Off the timer callback's stack: wxGTK's timeout callback still reads the timer after Notify().
+        GUI::wxGetApp().CallAfter([this]() { delete this; });
+        return true;
+    }
+
+    void Notify() override { try_run(); }
+
+private:
+    std::function<void(GUI::Plater*)> m_fn;
+};
+
+void run_when_plater_shown(std::function<void(GUI::Plater*)> fn)
+{
+    GUI::wxGetApp().CallAfter([fn = std::move(fn)]() mutable {
+        auto* waiter = new PlaterShownWaiter(std::move(fn));
+        if (!waiter->try_run())
+            waiter->Start(100);
+    });
+}
+
 py::object ui_create_dock_panel(const std::string& html, const std::string& title, int width, int height,
                                 py::object on_message, py::object on_close, const std::string& dock)
 {
@@ -434,14 +473,13 @@ py::object ui_create_dock_panel(const std::string& html, const std::string& titl
     const int new_id = UiRegistry::instance().reserve_id();
     UiRegistry::instance().bind(new_id, nullptr, plugin_key);
 
-    GUI::wxGetApp().CallAfter([new_id, plugin_key, html, title, dock, w, h,
-                               msg_adapter = std::move(msg_adapter),
-                               close_holder = std::move(close_holder)]() mutable {
+    run_when_plater_shown([new_id, plugin_key, html, title, dock, w, h,
+                           msg_adapter = std::move(msg_adapter),
+                           close_holder = std::move(close_holder)](GUI::Plater* plater) mutable {
         if (!UiRegistry::instance().is_open(new_id))
             return;
 
-        GUI::Plater* plater = GUI::wxGetApp().plater();
-        if (plater == nullptr || GUI::wxGetApp().is_closing()) {
+        if (plater == nullptr) {
             UiRegistry::instance().remove(new_id);
             return;
         }

tests/libslic3r/test_config.cpp

@@ -538,6 +538,110 @@ SCENARIO("update_diff_values_to_child_config keeps a child's values on variants
     }
 }
 
+SCENARIO("update_non_diff_values_to_base_config keeps a project's changed values on variants it does not list",
+         "[Config][Variant]") {
+    std::set<std::string> no_keys;
+    auto variants = [](std::initializer_list<std::string> names) { return new Slic3r::ConfigOptionStrings(names); };
+
+    GIVEN("A filament base with three variants") {
+        Slic3r::DynamicPrintConfig base;
+        base.set_key_value("filament_extruder_variant",
+            variants({"Direct Drive Standard", "Bowden Standard", "Direct Drive High Flow"}));
+        base.set_deserialize_strict("nozzle_temperature", "220,220,220");
+
+        WHEN("the project was saved when the base had only its first variant") {
+            Slic3r::DynamicPrintConfig project;
+            project.set_key_value("filament_extruder_variant", variants({"Direct Drive Standard"}));
+            project.set_deserialize_strict("nozzle_temperature", "199");
+
+            AND_WHEN("the project lists the value as changed") {
+                project.update_non_diff_values_to_base_config(base, project.keys(), {"nozzle_temperature"}, "", "filament_extruder_variant",
+                                                              Slic3r::filament_options_with_variant, no_keys);
+                THEN("the project's value applies to every variant") {
+                    REQUIRE(project.opt_serialize("nozzle_temperature") == "199,199,199");
+                }
+            }
+            AND_WHEN("the project does not list the value as changed") {
+                project.update_non_diff_values_to_base_config(base, project.keys(), {}, "", "filament_extruder_variant",
+                                                              Slic3r::filament_options_with_variant, no_keys);
+                THEN("the base's values replace it") {
+                    REQUIRE(project.opt_serialize("nozzle_temperature") == "220,220,220");
+                }
+            }
+        }
+        WHEN("the project lists every variant, in another order") {
+            Slic3r::DynamicPrintConfig project;
+            project.set_key_value("filament_extruder_variant",
+                variants({"Bowden Standard", "Direct Drive High Flow", "Direct Drive Standard"}));
+            project.set_deserialize_strict("nozzle_temperature", "190,205,199");
+            project.update_non_diff_values_to_base_config(base, project.keys(), {"nozzle_temperature"}, "", "filament_extruder_variant",
+                                                          Slic3r::filament_options_with_variant, no_keys);
+            THEN("each variant keeps its own value") {
+                REQUIRE(project.opt_serialize("nozzle_temperature") == "199,190,205");
+            }
+        }
+        WHEN("the project lists no variants") {
+            Slic3r::DynamicPrintConfig project;
+            project.set_deserialize_strict("nozzle_temperature", "199");
+            project.update_non_diff_values_to_base_config(base, project.keys(), {"nozzle_temperature"}, "", "filament_extruder_variant",
+                                                          Slic3r::filament_options_with_variant, no_keys);
+            THEN("the project's value applies to every variant") {
+                REQUIRE(project.opt_serialize("nozzle_temperature") == "199,199,199");
+            }
+        }
+    }
+
+    GIVEN("A two-extruder printer base with two variants per extruder") {
+        Slic3r::DynamicPrintConfig base;
+        base.set_key_value("printer_extruder_variant",
+            variants({"Direct Drive Standard", "Direct Drive High Flow", "Direct Drive Standard", "Direct Drive High Flow"}));
+        base.set_key_value("printer_extruder_id", new Slic3r::ConfigOptionInts({1, 1, 2, 2}));
+        base.set_deserialize_strict("retraction_length", "0.8,0.8,0.8,0.8");
+
+        WHEN("the project lists only the Standard variant of each extruder") {
+            Slic3r::DynamicPrintConfig project;
+            project.set_key_value("printer_extruder_variant", variants({"Direct Drive Standard", "Direct Drive Standard"}));
+            project.set_key_value("printer_extruder_id", new Slic3r::ConfigOptionInts({1, 2}));
+            project.set_deserialize_strict("retraction_length", "1.1,2.2");
+            project.update_non_diff_values_to_base_config(base, project.keys(), {"retraction_length"}, "printer_extruder_id", "printer_extruder_variant",
+                                                          Slic3r::printer_options_with_variant_1,
+                                                          Slic3r::printer_options_with_variant_2);
+            THEN("each extruder's High Flow variant takes that extruder's value") {
+                REQUIRE(project.opt_serialize("retraction_length") == "1.1,1.1,2.2,2.2");
+            }
+        }
+        WHEN("the project lists only the Standard variant of each extruder, and the variant lists as changed") {
+            Slic3r::DynamicPrintConfig project;
+            project.set_key_value("printer_extruder_variant", variants({"Direct Drive Standard", "Direct Drive Standard"}));
+            project.set_key_value("printer_extruder_id", new Slic3r::ConfigOptionInts({1, 2}));
+            project.set_deserialize_strict("machine_max_speed_x", "300,100,400,150");
+            base.set_deserialize_strict("machine_max_speed_x", "500,200,500,200,500,200,500,200");
+            project.update_non_diff_values_to_base_config(base, project.keys(),
+                                                          {"machine_max_speed_x", "printer_extruder_id", "printer_extruder_variant"},
+                                                          "printer_extruder_id", "printer_extruder_variant",
+                                                          Slic3r::printer_options_with_variant_1,
+                                                          Slic3r::printer_options_with_variant_2);
+            THEN("the variant lists are the base's") {
+                REQUIRE(project.opt_serialize("printer_extruder_variant") == base.opt_serialize("printer_extruder_variant"));
+                REQUIRE(project.opt_serialize("printer_extruder_id") == "1,1,2,2");
+            }
+            THEN("each extruder's High Flow variant takes that extruder's pair of limits") {
+                REQUIRE(project.opt_serialize("machine_max_speed_x") == "300,100,300,100,400,150,400,150");
+            }
+        }
+        WHEN("the project lists no variants") {
+            Slic3r::DynamicPrintConfig project;
+            project.set_deserialize_strict("retraction_length", "1.1");
+            project.update_non_diff_values_to_base_config(base, project.keys(), {"retraction_length"}, "printer_extruder_id", "printer_extruder_variant",
+                                                          Slic3r::printer_options_with_variant_1,
+                                                          Slic3r::printer_options_with_variant_2);
+            THEN("only the first extruder's variants take the project's value") {
+                REQUIRE(project.opt_serialize("retraction_length") == "1.1,1.1,0.8,0.8");
+            }
+        }
+    }
+}
+
 // SCENARIO("DynamicPrintConfig JSON serialization", "[Config]") {
 //     WHEN("DynamicPrintConfig is serialized and deserialized") {
 // 	auto now = std::chrono::high_resolution_clock::now();

tests/libslic3r/test_config_variant_expansion.cpp

@@ -799,3 +799,67 @@ TEST_CASE("A per-variant filament option read with a single value gives it to ev
     config.load_from_ini_string("pressure_advance = 0.021", ForwardCompatibilitySubstitutionRule::Disable);
     REQUIRE(config.option<ConfigOptionFloats>("pressure_advance")->values == std::vector<double>({0.021, 0.021, 0.021}));
 }
+
+// Machine limits (printer_options_with_variant_2) hold a (normal, silent) pair per printer variant, so the
+// printer Tab's Motion ability page can edit each extruder's own limits.
+TEST_CASE("set_num_extruders gives every printer variant its own pair of machine limits", "[Config]")
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    auto speed_x = [&config]() { return config.option<ConfigOptionFloats>("machine_max_speed_x")->values; };
+
+    SECTION("a new extruder's pair is padded with the first value, like the other variant keys") {
+        config.option<ConfigOptionFloats>("machine_max_speed_x")->values = {500., 200.};
+        config.set_num_extruders(3);
+        REQUIRE(config.option<ConfigOptionStrings>("printer_extruder_variant")->size() == 3);
+        REQUIRE(speed_x() == std::vector<double>({500., 200., 500., 500., 500., 500.}));
+    }
+
+    SECTION("per-extruder pairs are kept, and removing an extruder removes its pair") {
+        config.option<ConfigOptionFloats>("machine_max_speed_x")->values = {500., 200., 400., 150., 300., 100.};
+        config.set_num_extruders(3);
+        REQUIRE(speed_x() == std::vector<double>({500., 200., 400., 150., 300., 100.}));
+        config.set_num_extruders(2);
+        REQUIRE(speed_x() == std::vector<double>({500., 200., 400., 150.}));
+    }
+
+    SECTION("a printer with nozzle variants gets a pair per variant") {
+        // 2 extruders x 2 variants each = 4 variants
+        config.option<ConfigOptionStrings>("extruder_variant_list", true)->values = {"Direct Drive Standard,Direct Drive High Flow",
+                                                                                     "Direct Drive Standard,Direct Drive High Flow"};
+        const std::vector<double> per_variant = {500., 200., 510., 210., 520., 220., 530., 230.};
+        config.option<ConfigOptionFloats>("machine_max_speed_x")->values = per_variant;
+        config.set_num_extruders(2);
+        REQUIRE(speed_x() == per_variant);
+
+        config.option<ConfigOptionFloats>("machine_max_speed_x")->values = {500., 200.};
+        config.set_num_extruders(2);
+        REQUIRE(speed_x() == std::vector<double>({500., 200., 500., 500., 500., 500., 500., 500.}));
+    }
+}
+
+// The device drying options hold several values per filament, as many as each filament preset gives.
+TEST_CASE("The device drying options are rebuilt as each filament's values in slot order", "[Config]")
+{
+    DynamicPrintConfig two_values, one_value, no_value;
+    two_values.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations", true)->values = {"1", "0"};
+    two_values.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature", true)->values     = {45., 45., 55., 55.};
+    one_value.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations", true)->values = {"1"};
+    one_value.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature", true)->values      = {65., 65., 75., 75.};
+
+    // values a project stored for three other filaments
+    DynamicPrintConfig config;
+    config.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations", true)->values = {"0", "0", "0"};
+    config.option<ConfigOptionFloats>("filament_dev_chamber_drying_time", true)->values         = {12., 8., 12.};
+
+    set_filament_dev_options(config, {&two_values, &one_value, &two_values});
+    REQUIRE(config.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations")->values ==
+            std::vector<std::string>({"1", "0", "1", "1", "0"}));
+    REQUIRE(config.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature")->values ==
+            std::vector<double>({45., 45., 55., 55., 65., 65., 75., 75., 45., 45., 55., 55.}));
+    // an option no filament defines keeps the stored values
+    REQUIRE(config.option<ConfigOptionFloats>("filament_dev_chamber_drying_time")->values == std::vector<double>({12., 8., 12.}));
+
+    // a filament without the option takes the option's default
+    set_filament_dev_options(config, {&two_values, &no_value});
+    REQUIRE(config.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations")->values == std::vector<std::string>({"1", "0", ""}));
+}

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -6228,8 +6228,9 @@ TEST_CASE("A per-variant project value maps onto its base preset's variant layou
                                                                    base_finder(&base, calls));
     CHECK(config.option<ConfigOptionStrings>("print_extruder_variant")->values ==
           std::vector<std::string>{"Direct Drive Standard", "Direct Drive High Flow"});
-    // The listed key keeps the project's Standard value and takes High Flow from the base.
-    check_double_vector(config.option<ConfigOptionFloats>("outer_wall_speed")->values, {100., 300.});
+    // The listed key keeps the project's Standard value, and High Flow, which the project does not
+    // list, takes it too, as a user preset's value does.
+    check_double_vector(config.option<ConfigOptionFloats>("outer_wall_speed")->values, {100., 100.});
     check_double_vector(config.option<ConfigOptionFloats>("inner_wall_speed")->values, {250., 350.});
 }
 

tests/slic3rutils/test_network_versions.cpp

@@ -78,31 +78,34 @@ TEST_CASE("Series and managed classification", "[NetworkVersions]")
 
 TEST_CASE_METHOD(PluginFolderFixture, "Managed builds fold into the series; customs are surfaced", "[NetworkVersions]")
 {
-    add_plugin("02.08.01.55");          // managed, same series -> folded into the 02.08.01 row
+    add_plugin("02.08.04.60");          // managed, same series -> folded into the 02.08.04 row
     add_plugin("02.09.00.10");          // managed, unknown series -> not listed
+    add_plugin("02.08.01.55");          // managed, series this build no longer has an ABI for -> not listed
     add_plugin("02.03.00.62");          // managed, older whitelisted series -> folded into 02.03.00
     add_plugin("02.01.01.52");          // managed, series with no ABI in this build -> not listed
-    add_plugin("02.08.01_custom");      // custom, whitelisted series -> listed under it
-    add_plugin("02.08.01.52-dev");      // custom (dash-suffixed), whitelisted series -> listed
+    add_plugin("02.08.04_custom");      // custom, whitelisted series -> listed under it
+    add_plugin("02.08.04.52-dev");      // custom (dash-suffixed), whitelisted series -> listed
 
     auto versions = get_all_available_versions();
 
     // The specific managed build never gets its own row - the series represents it.
-    REQUIRE(count_version(versions, "02.08.01.55") == 0);
-    REQUIRE(count_version(versions, "02.08.01")    == 1);
+    REQUIRE(count_version(versions, "02.08.04.60") == 0);
+    REQUIRE(count_version(versions, "02.08.04")    == 1);
     REQUIRE(count_version(versions, "02.09.00.10") == 0);
+    REQUIRE(count_version(versions, "02.08.01.55") == 0);
+    REQUIRE(count_version(versions, "02.08.01")    == 0);
     REQUIRE(count_version(versions, "02.03.00.62") == 0);
     REQUIRE(count_version(versions, "02.03.00")    == 1);
     REQUIRE(count_version(versions, "02.01.01.52") == 0);
     // Custom-named builds are distinct files kept under their own name.
-    REQUIRE(count_version(versions, "02.08.01_custom")  == 1);
-    REQUIRE(count_version(versions, "02.08.01.52-dev")  == 1);
+    REQUIRE(count_version(versions, "02.08.04_custom")  == 1);
+    REQUIRE(count_version(versions, "02.08.04.52-dev")  == 1);
 
     // Newest series first, its customs nested under it (suffix sort: "" < ".52-dev" < "_custom"),
     // then older series, legacy last.
-    REQUIRE(versions[0].version == "02.08.01");
-    REQUIRE(versions[1].version == "02.08.01.52-dev");
-    REQUIRE(versions[2].version == "02.08.01_custom");
+    REQUIRE(versions[0].version == "02.08.04");
+    REQUIRE(versions[1].version == "02.08.04.52-dev");
+    REQUIRE(versions[2].version == "02.08.04_custom");
     REQUIRE(versions[3].version == "02.03.00");
     REQUIRE(versions.back().version == BAMBU_NETWORK_AGENT_VERSION_LEGACY);
 
@@ -111,9 +114,9 @@ TEST_CASE_METHOD(PluginFolderFixture, "Managed builds fold into the series; cust
     REQUIRE_FALSE(versions[3].is_latest);
 
     // Customs sort/render nested under their series (non-empty suffix, base = the series).
-    REQUIRE(versions[1].base_version == "02.08.01");
+    REQUIRE(versions[1].base_version == "02.08.04");
     REQUIRE_FALSE(versions[1].suffix.empty());
-    REQUIRE(versions[2].base_version == "02.08.01");
+    REQUIRE(versions[2].base_version == "02.08.04");
     REQUIRE_FALSE(versions[2].suffix.empty());
 
     // "(Latest)" is the series row, never a nested custom build.
@@ -123,20 +126,20 @@ TEST_CASE_METHOD(PluginFolderFixture, "Managed builds fold into the series; cust
     REQUIRE_FALSE(versions[2].is_latest);
 
     // The stored default that drives download and update-check decisions is now the series.
-    REQUIRE(std::string(get_latest_network_version()) == "02.08.01");
+    REQUIRE(std::string(get_latest_network_version()) == "02.08.04");
 }
 
 TEST_CASE_METHOD(PluginFolderFixture, "Only the loaded series is marked installed", "[NetworkVersions]")
 {
-    add_plugin("02.08.01.55");
-    add_plugin("02.08.01_custom");
+    add_plugin("02.08.04.60");
+    add_plugin("02.08.04_custom");
 
-    // The loaded plug-in reports its full build (02.08.01.55); the series row is what gets marked.
+    // The loaded plug-in reports its full build (02.08.04.60); the series row is what gets marked.
     {
-        auto versions = get_all_available_versions("02.08.01.55");
+        auto versions = get_all_available_versions("02.08.04.60");
         int marked = 0;
         for (const auto& info : versions)
-            if (info.is_loaded) { ++marked; REQUIRE(info.version == "02.08.01"); }
+            if (info.is_loaded) { ++marked; REQUIRE(info.version == "02.08.04"); }
         REQUIRE(marked == 1);
     }
 
@@ -152,10 +155,10 @@ TEST_CASE_METHOD(PluginFolderFixture, "Only the loaded series is marked installe
 
     // A loaded custom build matches its own row, never the bare series.
     {
-        auto versions = get_all_available_versions("02.08.01_custom");
+        auto versions = get_all_available_versions("02.08.04_custom");
         int marked = 0;
         for (const auto& info : versions)
-            if (info.is_loaded) { ++marked; REQUIRE(info.version == "02.08.01_custom"); }
+            if (info.is_loaded) { ++marked; REQUIRE(info.version == "02.08.04_custom"); }
         REQUIRE(marked == 1);
     }
 
@@ -167,11 +170,11 @@ TEST_CASE_METHOD(PluginFolderFixture, "Only the loaded series is marked installe
 TEST_CASE("Only whitelisted series pass the load gate", "[NetworkVersions]")
 {
     // Each whitelisted series, its builds, and custom-named builds of that series.
-    REQUIRE(is_supported_network_version("02.08.01"));
-    REQUIRE(is_supported_network_version("02.08.01.52"));
-    REQUIRE(is_supported_network_version("02.08.01.55"));
-    REQUIRE(is_supported_network_version("02.08.01_custom"));
-    REQUIRE(is_supported_network_version("02.08.01.52-dev"));
+    REQUIRE(is_supported_network_version("02.08.04"));
+    REQUIRE(is_supported_network_version("02.08.04.52"));
+    REQUIRE(is_supported_network_version("02.08.04.60"));
+    REQUIRE(is_supported_network_version("02.08.04_custom"));
+    REQUIRE(is_supported_network_version("02.08.04.52-dev"));
     REQUIRE(is_supported_network_version("02.03.00"));
     REQUIRE(is_supported_network_version("02.03.00.62"));
     REQUIRE(is_supported_network_version("02.03.00.70"));
@@ -179,6 +182,9 @@ TEST_CASE("Only whitelisted series pass the load gate", "[NetworkVersions]")
     REQUIRE(is_supported_network_version(BAMBU_NETWORK_AGENT_VERSION_LEGACY));
 
     // Series whitelisted by previous Orca releases that no generation here can call.
+    REQUIRE_FALSE(is_supported_network_version("02.08.01"));
+    REQUIRE_FALSE(is_supported_network_version("02.08.01.55"));
+    REQUIRE_FALSE(is_supported_network_version("02.08.01_custom"));
     REQUIRE_FALSE(is_supported_network_version("02.01.01.52"));
     REQUIRE_FALSE(is_supported_network_version("02.00.02.50"));
 
@@ -198,9 +204,9 @@ TEST_CASE("Each version resolves to the ABI generation that can call it", "[Netw
 {
     // The generation is keyed on the series, so every build of a series - including the
     // custom-named ones - resolves to the same one.
-    CHECK(network_plugin_abi("02.08.01")        == NetworkAbi::Current);
-    CHECK(network_plugin_abi("02.08.01.55")     == NetworkAbi::Current);
-    CHECK(network_plugin_abi("02.08.01.52-dev") == NetworkAbi::Current);
+    CHECK(network_plugin_abi("02.08.04")        == NetworkAbi::Current);
+    CHECK(network_plugin_abi("02.08.04.60")     == NetworkAbi::Current);
+    CHECK(network_plugin_abi("02.08.04.52-dev") == NetworkAbi::Current);
     CHECK(network_plugin_abi("02.03.00")        == NetworkAbi::V0203);
     CHECK(network_plugin_abi("02.03.00.62")     == NetworkAbi::V0203);
     CHECK(network_plugin_abi("02.03.00_custom") == NetworkAbi::V0203);
@@ -208,6 +214,7 @@ TEST_CASE("Each version resolves to the ABI generation that can call it", "[Netw
 
     // Anything the load gate rejects must dispatch through nothing at all, rather than
     // defaulting to a layout it does not share.
+    CHECK(network_plugin_abi("02.08.01.55") == NetworkAbi::Unsupported);
     CHECK(network_plugin_abi("02.01.01.52") == NetworkAbi::Unsupported);
     CHECK(network_plugin_abi("02.00.02.50") == NetworkAbi::Unsupported);
     CHECK(network_plugin_abi("02.09.00.10") == NetworkAbi::Unsupported);
@@ -234,7 +241,7 @@ TEST_CASE_METHOD(PluginFolderFixture, "Legacy series never adopts discovered bui
     // With nothing else on disk, the series holds "(Latest)" even though its library is
     // not installed.
     for (const auto& info : versions) {
-        if (info.version == "02.08.01") {
+        if (info.version == "02.08.04") {
             REQUIRE(info.is_latest);
             REQUIRE_FALSE(info.is_loaded);
         }