Merge branch 'main' into feature/filament_id

src/libslic3r/AppConfig.cpp

@@ -280,6 +280,9 @@ void AppConfig::set_defaults()
         set(SETTING_OPENGL_FPS_CAP, std::to_string(fps_cap));
     }
 
+    // The getter already defaults, parses and clamps; write back what it resolves to.
+    set(SETTING_PLUGIN_PAGES_VISIBLE_COUNT, std::to_string(get_plugin_pages_visible_count()));
+
     if (get(SETTING_OPENGL_SHOW_FPS_OVERLAY).empty())
         set_bool(SETTING_OPENGL_SHOW_FPS_OVERLAY, false);
 
@@ -853,6 +856,10 @@ std::string AppConfig::load()
                         local_machine.dev_ip = p["dev_ip"].get<std::string>();
                     if (p.contains("printer_type"))
                         local_machine.printer_type = p["printer_type"].get<std::string>();
+                    if (p.contains("printer_agent_id"))
+                        local_machine.printer_agent_id = p["printer_agent_id"].get<std::string>();
+                    if (p.contains("access_code"))
+                        local_machine.access_code = p["access_code"].get<std::string>();
                     m_local_machines[local_machine.dev_id] = local_machine;
                 }
             } else {
@@ -1065,6 +1072,8 @@ void AppConfig::save()
         m_json["dev_name"]         = local_machine.second.dev_name;
         m_json["dev_ip"]           = local_machine.second.dev_ip;
         m_json["printer_type"]     = local_machine.second.printer_type;
+        m_json["printer_agent_id"] = local_machine.second.printer_agent_id;
+        m_json["access_code"]      = local_machine.second.access_code;
 
         j["local_machines"][local_machine.first] = m_json;
     }
@@ -1630,6 +1639,22 @@ void AppConfig::set_network_plugin_version(const std::string& version)
     set(SETTING_NETWORK_PLUGIN_VERSION, version);
 }
 
+int AppConfig::get_plugin_pages_visible_count() const
+{
+    std::string value = get(SETTING_PLUGIN_PAGES_VISIBLE_COUNT);
+    if (value.empty())
+        return PLUGIN_PAGES_VISIBLE_COUNT_DEFAULT;
+
+    int visible_count = PLUGIN_PAGES_VISIBLE_COUNT_DEFAULT;
+    try {
+        visible_count = std::stoi(value);
+    }
+    catch (...) {
+        return PLUGIN_PAGES_VISIBLE_COUNT_DEFAULT;
+    }
+    return std::clamp(visible_count, PLUGIN_PAGES_VISIBLE_COUNT_MIN, PLUGIN_PAGES_VISIBLE_COUNT_MAX);
+}
+
 std::vector<std::string> AppConfig::get_skipped_network_versions() const
 {
     std::vector<std::string> result;

src/libslic3r/AppConfig.hpp

@@ -41,6 +41,11 @@ using namespace nlohmann;
 #define SETTING_OPENGL_PHONG_SSAO "opengl_phong_ssao"
 #define SETTING_OPENGL_PHONG_SMOOTH_NORMALS "opengl_phong_smooth_normals"
 
+#define SETTING_PLUGIN_PAGES_VISIBLE_COUNT "plugin_pages_visible_count"
+#define PLUGIN_PAGES_VISIBLE_COUNT_MIN 1
+#define PLUGIN_PAGES_VISIBLE_COUNT_DEFAULT 5
+#define PLUGIN_PAGES_VISIBLE_COUNT_MAX 10
+
 #if defined(_WIN32) || defined(_WIN64)
 #define BAMBU_NETWORK_AGENT_VERSION_LEGACY "01.10.01.09"
 #else
@@ -61,10 +66,19 @@ struct BBLocalMachine
     std::string dev_ip;
     std::string dev_id; /* serial number */
     std::string printer_type; /* model_id */
+    std::string printer_agent_id; /* id of the IPrinterAgent that discovered/bound this device, e.g. "bbl"; empty for entries persisted before this field existed */
+    // Access code, scoped to printer_agent_id above - so a code saved while bound under one
+    // printer agent isn't treated as valid for a different, independent agent talking to the
+    // same physical dev_id. Empty for entries persisted before this field existed; those fall
+    // back to the legacy flat "access_code"/"user_access_code" AppConfig sections (BBL-only,
+    // since BBL was the only agent when they were saved) - see
+    // get_access_code_with_legacy_fallback() in DevManager.cpp.
+    std::string access_code;
 
     bool operator==(const BBLocalMachine& other) const
     {
-        return dev_name == other.dev_name && dev_ip == other.dev_ip && dev_id == other.dev_id && printer_type == other.printer_type;
+        return dev_name == other.dev_name && dev_ip == other.dev_ip && dev_id == other.dev_id && printer_type == other.printer_type &&
+               printer_agent_id == other.printer_agent_id && access_code == other.access_code;
     }
     bool operator!=(const BBLocalMachine& other) const { return !operator==(other); }
 };
@@ -374,6 +388,10 @@ public:
     std::string get_network_plugin_version() const;
     void set_network_plugin_version(const std::string& version);
 
+    // Number of plugin pages shown as fixed tabs before the rest are collapsed into a
+    // dropdown on the last tab.
+    int get_plugin_pages_visible_count() const;
+
     std::vector<std::string> get_skipped_network_versions() const;
     void add_skipped_network_version(const std::string& version);
     bool is_network_version_skipped(const std::string& version) const;

src/libslic3r/BoundingBox.cpp

@@ -8,6 +8,8 @@
 namespace Slic3r {
 
 template BoundingBoxBase<Point, Points>::BoundingBoxBase(const Points &points);
+template void BoundingBoxBase<Point, Points>::construct<0, BoundingBox, Points::const_iterator>(BoundingBox&, Points::const_iterator, Points::const_iterator);
+template void BoundingBoxBase<Point, Points>::construct<1, BoundingBox, Points::const_iterator>(BoundingBox&, Points::const_iterator, Points::const_iterator);
 template BoundingBoxBase<Vec2d>::BoundingBoxBase(const std::vector<Vec2d> &points);
 
 template BoundingBox3Base<Vec3d>::BoundingBox3Base(const std::vector<Vec3d> &points);

src/libslic3r/CMakeLists.txt

@@ -149,6 +149,8 @@ set(lisbslic3r_sources
     Fill/FillConcentric.hpp
     Fill/FillConcentricInternal.cpp
     Fill/FillConcentricInternal.hpp
+    Fill/FillCornerSmoothing.cpp
+    Fill/FillCornerSmoothing.hpp
     Fill/Fill.cpp
     Fill/FillCrossHatch.cpp
     Fill/FillCrossHatch.hpp
@@ -346,6 +348,8 @@ set(lisbslic3r_sources
     Polyline.hpp
     PresetBundle.cpp
     PresetBundle.hpp
+    PresetCacheFormat.cpp
+    PresetCacheFormat.hpp
     Preset.cpp
     Preset.hpp
     PrincipalComponents2D.cpp

src/libslic3r/Config.hpp

@@ -28,6 +28,9 @@
 
 #include <cereal/access.hpp>
 #include <cereal/types/base_class.hpp>
+// The serialize() members below archive ConfigOption hierarchies through
+// cereal::base_class, whose registration machinery lives in polymorphic.hpp.
+#include <cereal/types/polymorphic.hpp>
 
 namespace Slic3r {
     struct FloatOrPercent
@@ -2982,6 +2985,8 @@ public:
     const double &      opt_float(const t_config_option_key &opt_key, unsigned int idx) const;
     double &            opt_float_nullable(const t_config_option_key &opt_key, unsigned int idx) { return this->option<ConfigOptionFloatsNullable>(opt_key)->get_at(idx); }
     const double &      opt_float_nullable(const t_config_option_key &opt_key, unsigned int idx) const { return dynamic_cast<const ConfigOptionFloatsNullable *>(this->option(opt_key))->get_at(idx); }
+    FloatOrPercent &    opt_float_or_percent_nullable(const t_config_option_key &opt_key, unsigned int idx) { return this->option<ConfigOptionFloatsOrPercentsNullable>(opt_key)->get_at(idx); }
+    const FloatOrPercent & opt_float_or_percent_nullable(const t_config_option_key &opt_key, unsigned int idx) const { return dynamic_cast<const ConfigOptionFloatsOrPercentsNullable *>(this->option(opt_key))->get_at(idx); }
 
     int&                opt_int(const t_config_option_key &opt_key)                             { return this->option<ConfigOptionInt>(opt_key)->value; }
     int                 opt_int(const t_config_option_key &opt_key) const                       { return dynamic_cast<const ConfigOptionInt*>(this->option(opt_key))->value; }

src/libslic3r/Fill/Fill.cpp

@@ -970,9 +970,9 @@ std::vector<SurfaceFill> group_fills(const Layer &layer, LockRegionParam &lock_p
                                                                    region_config.sparse_infill_rotate_template.value);
                     params.fixed_angle = !region_config.sparse_infill_rotate_template.value.empty();
 
-                    // Orca: special case; apply smoothing factor only for Hilbert Curve sparse infill.
-                    // FillHilbertCurve::generate clamps and validates the value itself.
-                    if (params.pattern == ipHilbertCurve)
+                    // Orca: the smoothing factor only applies to the sparse infill patterns that
+                    // implement it. The fills clamp and validate the value themselves.
+                    if (is_smoothable_infill_pattern(params.pattern, params.multiline))
                         params.smooth_factor = 0.01 * region_config.sparse_infill_smooth_factor.value;
                 } else {
                     const bool top_layer_direction_set    = surface.is_top() && region_config.top_layer_direction.value >= 0.;

src/libslic3r/Fill/Fill3DHoneycomb.cpp

@@ -2,6 +2,7 @@
 #include "../ShortestPath.hpp"
 #include "../Surface.hpp"
 #include "FillBase.hpp"
+#include "FillCornerSmoothing.hpp"
 #include "Fill3DHoneycomb.hpp"
 
 namespace Slic3r {
@@ -271,6 +272,9 @@ void Fill3DHoneycomb::_fill_surface_single(
     for (Polyline &pl : polylines){
       pl.translate(bb.min);
       pl.simplify(5 * spacing); // simplify to 5x line width
+      // Orca: round the corners of the octahedral wave. The layers where the wave degenerates to a
+      // straight line have no corner to round.
+      smooth_polyline_corners(pl, params.smooth_factor, scaled<double>(params.resolution));
     }
 
     // Apply multiline offset if needed

src/libslic3r/Fill/FillConcentric.cpp

@@ -5,6 +5,7 @@
 #include "Arachne/WallToolPaths.hpp"
 
 #include "FillConcentric.hpp"
+#include "FillCornerSmoothing.hpp"
 #include <libslic3r/ShortestPath.hpp>
 
 namespace Slic3r {
@@ -32,12 +33,32 @@ void FillConcentric::_fill_surface_single(
 
     Polygons loops = to_polygons(contracted);
 
-    ExPolygons last { std::move(contracted) };
+    ExPolygons last { contracted };
     while (! last.empty()) {
         last = offset2_ex(last, -(distance + min_spacing/2), +min_spacing/2);
         append(loops, to_polygons(last));
     }
 
+    // Orca: round the corners of the loops. Unlike the other patterns these are never clipped to the
+    // fill region - they are its offsets - so a corner may only be rounded where the curve replacing it
+    // stays inside. Rounding cuts toward the inside of the turn, which around a hole, at a concave
+    // feature or across a thin region is outside the fill and would put the extrusion over a wall.
+    // The reach is capped at half the distance between two loops as well: a loop is as long as the
+    // object, and a corner cut by half of its side would swallow the neighbouring loops.
+    auto corner_stays_inside = [&contracted](const Vec2d &from, const Vec2d &to) {
+        // The straight chord between the ends of the curve is the deepest the curve can cut.
+        for (const double t : { 0.25, 0.5, 0.75 }) {
+            const Vec2d  sample = from + t * (to - from);
+            const Point  point(coord_t(sample.x()), coord_t(sample.y()));
+            if (std::none_of(contracted.begin(), contracted.end(),
+                             [&point](const ExPolygon &region) { return region.contains(point); }))
+                return false;
+        }
+        return true;
+    };
+    smooth_polygons_corners(loops, params.smooth_factor, scaled<double>(params.resolution), 0.5 * distance,
+                            corner_stays_inside);
+
     // generate paths from the outermost to the innermost, to avoid
     // adhesion problems of the first central tiny loops
     loops = union_pt_chained_outside_in(loops);

src/libslic3r/Fill/FillCornerSmoothing.cpp

@@ -0,0 +1,226 @@
+#include <array>
+
+#include "FillCornerSmoothing.hpp"
+
+namespace Slic3r {
+
+// Turns sharper than this are left untouched: both ends of the curve replacing such a corner nearly
+// coincide, so the corner would be rounded into a degenerate loop instead of a hairpin.
+static constexpr const double min_smoothed_turn_cosine = -0.9;
+
+// The control points are expressed in the (incoming, outgoing) basis of the corner, which is not
+// orthonormal for turns other than a right angle.
+using QuinticBezier = std::array<Vec2d, 6>;
+
+static bool is_bezier_flat(const QuinticBezier &curve, const Vec2d &incoming, const Vec2d &outgoing, const double deviation)
+{
+    // A Bezier curve stays inside the convex hull of its control points. Therefore, keeping every
+    // control point within a deviation-wide strip around the endpoint chord conservatively bounds the
+    // flattening error. The cross product is the perpendicular distance scaled by the chord length;
+    // comparing squared values avoids a square root.
+    auto         in_plane        = [&incoming, &outgoing](const Vec2d &c) { return c.x() * incoming + c.y() * outgoing; };
+    const Vec2d  chord           = in_plane(curve.back() - curve.front());
+    const double chord_length_sq = chord.squaredNorm();
+    const double max_cross_sq    = deviation * deviation * chord_length_sq;
+
+    for (size_t i = 1; i + 1 < curve.size(); ++i) {
+        const Vec2d  offset = in_plane(curve[i] - curve.front());
+        const double cross  = chord.x() * offset.y() - chord.y() * offset.x();
+        if (cross * cross > max_cross_sq)
+            return false;
+    }
+    return true;
+}
+
+static void subdivide_bezier(const QuinticBezier &curve, QuinticBezier &left, QuinticBezier &right)
+{
+    // Split the curve at t = 0.5 using de Casteljau's algorithm. Each averaging level contributes one
+    // control point to the left half and one to the right half; the latter is filled backwards to keep
+    // both resulting control polygons in their original parameter direction.
+    QuinticBezier subdivision = curve;
+    left.front() = subdivision.front();
+    right.back() = subdivision.back();
+    for (size_t level = 1; level < curve.size(); ++level) {
+        for (size_t i = 0; i + level < curve.size(); ++i)
+            subdivision[i] = 0.5 * (subdivision[i] + subdivision[i + 1]);
+        left[level] = subdivision.front();
+        right[curve.size() - level - 1] = subdivision[curve.size() - level - 1];
+    }
+}
+
+static void flatten_bezier(
+    const QuinticBezier &curve, const Vec2d &incoming, const Vec2d &outgoing, const double deviation, std::vector<Vec2d> &output)
+{
+    // Subdivide to at least depth 1 so a rounded corner cannot collapse to a single diagonal chord.
+    // A uniform subdivision depth keeps samples at equal parameter intervals t = k / 2^depth,
+    // avoiding abrupt segment-length jumps at adaptive-depth boundaries.
+    static constexpr size_t max_depth = 16;
+
+    std::vector<QuinticBezier> subcurves(2);
+    subdivide_bezier(curve, subcurves[0], subcurves[1]);
+
+    for (size_t depth = 1; depth < max_depth; ++depth) {
+        bool all_flat = true;
+        for (const QuinticBezier &c : subcurves)
+            if (!is_bezier_flat(c, incoming, outgoing, deviation)) {
+                all_flat = false;
+                break;
+            }
+        if (all_flat)
+            break;
+        std::vector<QuinticBezier> finer(subcurves.size() * 2);
+        for (size_t i = 0; i < subcurves.size(); ++i)
+            subdivide_bezier(subcurves[i], finer[i * 2], finer[i * 2 + 1]);
+        subcurves = std::move(finer);
+    }
+
+    // The curve start is deliberately omitted so it can be shared with the straight leg feeding into it.
+    output.clear();
+    output.reserve(subcurves.size());
+    for (const QuinticBezier &c : subcurves)
+        output.emplace_back(c.back());
+}
+
+const std::vector<Vec2d>& CornerSmoother::curve_coefficients(
+    const double corner_distance, const Vec2d &incoming, const Vec2d &outgoing)
+{
+    const double cosine = incoming.dot(outgoing);
+    // Corners of the same size and turn angle are congruent, so they flatten identically. An infill
+    // path walks over the very same corner over and over again, the Hilbert curve over a single one.
+    if (m_has_cached_coefficients && corner_distance == m_cached_distance && cosine == m_cached_cosine)
+        return m_cached_coefficients;
+
+    // One canonical corner running from -corner_distance along the incoming leg to corner_distance
+    // along the outgoing one. At each end, the first three control points are collinear and equally
+    // spaced: the tangent follows the adjoining straight leg and the second derivative is zero. The
+    // endpoint curvature is therefore zero, giving G2 joins to both legs.
+    const double        d = corner_distance;
+    const QuinticBezier corner_curve {{
+        {-d, 0.}, {-0.7 * d, 0.}, {-0.4 * d, 0.}, {0., 0.4 * d}, {0., 0.7 * d}, {0., d}
+    }};
+    // Retain a finite positive tolerance if the smoother was set up with an invalid one.
+    const double deviation = m_tolerance > 0. && std::isfinite(m_tolerance) ? m_tolerance : EPSILON;
+    flatten_bezier(corner_curve, incoming, outgoing, deviation, m_cached_coefficients);
+
+    m_cached_distance         = corner_distance;
+    m_cached_cosine           = cosine;
+    m_has_cached_coefficients = true;
+    return m_cached_coefficients;
+}
+
+void CornerSmoother::round_corner(const Vec2d &previous, const Vec2d &corner, const Vec2d &next)
+{
+    m_corner_points.clear();
+
+    const Vec2d  incoming_leg = corner - previous;
+    const Vec2d  outgoing_leg = next - corner;
+    const double incoming_length = incoming_leg.norm();
+    const double outgoing_length = outgoing_leg.norm();
+    if (incoming_length < EPSILON || outgoing_length < EPSILON) {
+        m_corner_points.emplace_back(corner);
+        return;
+    }
+
+    const Vec2d  incoming = incoming_leg / incoming_length;
+    const Vec2d  outgoing = outgoing_leg / outgoing_length;
+    const double cross    = incoming.x() * outgoing.y() - incoming.y() * outgoing.x();
+    // A collinear vertex is no corner at all, and a hairpin cannot be rounded, see above.
+    if (std::abs(cross) < EPSILON || incoming.dot(outgoing) < min_smoothed_turn_cosine) {
+        m_corner_points.emplace_back(corner);
+        return;
+    }
+
+    // Consuming at most half of the shorter leg keeps the curves of two adjacent corners apart.
+    double corner_distance = m_corner_distance_ratio * std::min(incoming_length, outgoing_length);
+    if (m_max_corner_distance > 0.)
+        corner_distance = std::min(corner_distance, m_max_corner_distance);
+
+    const Vec2d curve_start = corner - corner_distance * incoming;
+    const Vec2d curve_end   = corner + corner_distance * outgoing;
+    if (m_corner_filter && !m_corner_filter(curve_start, curve_end)) {
+        m_corner_points.emplace_back(corner);
+        return;
+    }
+
+    const std::vector<Vec2d> &coefficients = curve_coefficients(corner_distance, incoming, outgoing);
+    m_corner_points.reserve(coefficients.size() + 1);
+    m_corner_points.emplace_back(curve_start);
+    for (const Vec2d &coefficient : coefficients)
+        m_corner_points.emplace_back(corner + coefficient.x() * incoming + coefficient.y() * outgoing);
+}
+
+// Rounds the corners of a scaled point sequence. A polygon closes implicitly, so all of its vertices
+// are corners; a polyline is an open path that keeps both of its ends, even where they coincide - a
+// path returning to where it started retraces its way back and is not a loop.
+static Points smooth_corners(const Points &points, const bool polygon, CornerSmoother &smoother)
+{
+    // A polygon has no free ends, so its first vertex is a corner like any other. Rounding it takes
+    // feeding the smoother the last vertex first, whose own output point is then dropped again.
+    size_t skip = polygon ? 1 : 0;
+
+    Points smoothed;
+    smoothed.reserve(2 * points.size());
+    auto emit = [&smoothed, &skip](const Vec2d &point) {
+        if (skip > 0) {
+            --skip;
+            return;
+        }
+        smoothed.emplace_back(coord_t(std::floor(point.x() + 0.5)), coord_t(std::floor(point.y() + 0.5)));
+    };
+
+    if (polygon)
+        smoother.push(points.back().cast<double>(), emit);
+    for (const Point &point : points)
+        smoother.push(point.cast<double>(), emit);
+    if (polygon)
+        // Wrap the first vertex around, so that the last one is a corner as well.
+        smoother.push(points.front().cast<double>(), emit);
+    smoother.flush(emit);
+
+    if (polygon)
+        // The flushed point is the wrapped first vertex, which a polygon does not store.
+        smoothed.pop_back();
+    return smoothed;
+}
+
+void smooth_polyline_corners(Polyline &polyline, const double smooth_factor, const double tolerance,
+                             const double max_corner_distance, const CornerFilter &corner_filter)
+{
+    CornerSmoother smoother(smooth_factor, tolerance, max_corner_distance, corner_filter);
+    if (!smoother.enabled() || polyline.size() < 3)
+        return;
+
+    polyline.points = smooth_corners(polyline.points, false, smoother);
+    // Rounding back to the integer grid may collapse neighbouring samples of a curve.
+    polyline.remove_duplicate_points();
+}
+
+void smooth_polylines_corners(Polylines &polylines, const double smooth_factor, const double tolerance,
+                              const double max_corner_distance, const CornerFilter &corner_filter)
+{
+    if (sanitize_smooth_factor(smooth_factor) == 0.)
+        return;
+    for (Polyline &polyline : polylines)
+        smooth_polyline_corners(polyline, smooth_factor, tolerance, max_corner_distance, corner_filter);
+}
+
+void smooth_polygons_corners(Polygons &polygons, const double smooth_factor, const double tolerance,
+                             const double max_corner_distance, const CornerFilter &corner_filter)
+{
+    CornerSmoother smoother(smooth_factor, tolerance, max_corner_distance, corner_filter);
+    if (!smoother.enabled())
+        return;
+
+    for (Polygon &polygon : polygons) {
+        if (polygon.size() < 3)
+            continue;
+        polygon.points = smooth_corners(polygon.points, true, smoother);
+        polygon.remove_duplicate_points();
+        // The curves of the first and of the last corner may have met on the segment they share. A
+        // polygon closes implicitly, so it must not repeat its first vertex at the end.
+        if (polygon.points.size() > 1 && polygon.points.front() == polygon.points.back())
+            polygon.points.pop_back();
+    }
+}
+
+} // namespace Slic3r

src/libslic3r/Fill/FillCornerSmoothing.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <vector>
+
+#include "../libslic3r.h"
+#include "../Point.hpp"
+#include "../Polygon.hpp"
+#include "../Polyline.hpp"
+
+namespace Slic3r {
+
+// Orca: NaN or infinite factors disable the smoothing, everything else is clamped to <0, 1>.
+inline double sanitize_smooth_factor(double smooth_factor)
+{
+    return std::isfinite(smooth_factor) ? std::clamp(smooth_factor, 0., 1.) : 0.;
+}
+
+// Decides whether a corner may be replaced by the curve that leaves the path at `from` and rejoins it
+// at `to`, both in the coordinate system of the pushed points. Rounding cuts toward the inside of the
+// turn, so a path that is not clipped to the fill region afterwards needs this to stay inside it.
+using CornerFilter = std::function<bool(const Vec2d &from, const Vec2d &to)>;
+
+// Orca: Replaces the sharp vertices of an infill path with curves that join the adjoining straight
+// legs with a continuous curvature, so the toolhead does not have to stop in every corner.
+// Points are pushed one by one, because the plane path fills produce their path on the fly, and
+// every point of the smoothed path is handed over to the caller supplied emit callback.
+// Fully smoothed adjacent corners meet at the midpoint of the segment they share, so the emitted
+// points may collapse onto each other once rounded to the integer grid of the caller. Dropping such
+// duplicates is left to the caller, which is the only one knowing that grid.
+class CornerSmoother
+{
+public:
+    // tolerance is the maximum chordal deviation of the flattened curves, in the units of the pushed
+    // points. max_corner_distance caps how far a curve may reach along a leg, in the same units; it
+    // bounds how far a rounded corner moves away from the original path, which matters where the legs
+    // are much longer than the spacing of the pattern. Zero leaves the reach uncapped.
+    CornerSmoother(double smooth_factor, double tolerance, double max_corner_distance = 0.,
+                   CornerFilter corner_filter = {})
+        : m_corner_distance_ratio(0.5 * sanitize_smooth_factor(smooth_factor)), m_tolerance(tolerance),
+          m_max_corner_distance(max_corner_distance), m_corner_filter(std::move(corner_filter))
+    {}
+
+    bool enabled() const { return m_corner_distance_ratio > 0.; }
+
+    template<typename Emit> void push(const Vec2d &point, Emit &emit)
+    {
+        if (m_pending == 0) {
+            emit(point);
+            m_previous = point;
+        } else if (m_pending > 1) {
+            round_corner(m_previous, m_corner, point);
+            for (const Vec2d &corner_point : m_corner_points)
+                emit(corner_point);
+            m_previous = m_corner;
+        }
+        m_corner  = point;
+        m_pending = std::min(m_pending + 1, 2);
+    }
+
+    // Emits the last point of the path and prepares the smoother for a new one.
+    template<typename Emit> void flush(Emit &emit)
+    {
+        if (m_pending > 1)
+            emit(m_corner);
+        m_pending = 0;
+    }
+
+private:
+    // Fills m_corner_points with the points replacing the corner vertex.
+    void round_corner(const Vec2d &previous, const Vec2d &corner, const Vec2d &next);
+    // Flattens the canonical corner curve of the given size and turn into coordinates of the
+    // (incoming, outgoing) basis of the corner. Cached, as an infill path repeats the same corner.
+    const std::vector<Vec2d>& curve_coefficients(double corner_distance, const Vec2d &incoming, const Vec2d &outgoing);
+
+    // Fraction of the shorter adjoining segment consumed on each side of a corner. Half of a segment
+    // is the maximum, otherwise the curves of two adjacent corners would overlap.
+    const double       m_corner_distance_ratio;
+    const double       m_tolerance;
+    const double       m_max_corner_distance;
+    const CornerFilter m_corner_filter;
+    std::vector<Vec2d> m_corner_points;
+    // Cached flattening of the last corner, valid for corners of the same size and turn angle.
+    std::vector<Vec2d> m_cached_coefficients;
+    double             m_cached_distance { 0. };
+    double             m_cached_cosine { 0. };
+    bool               m_has_cached_coefficients { false };
+
+    Vec2d m_previous { Vec2d::Zero() };
+    Vec2d m_corner { Vec2d::Zero() };
+    // Number of points held back: none, the first point of a path, or a corner candidate.
+    int   m_pending { 0 };
+};
+
+// Rounds the corners of already scaled paths in place. Paths of less than three points are left alone.
+// Both ends of a polyline are kept where they are, even when they coincide: such a path retraces its
+// way back and joining its ends would turn it into a loop. See CornerSmoother for max_corner_distance.
+void smooth_polyline_corners(Polyline &polyline, double smooth_factor, double tolerance,
+                             double max_corner_distance = 0., const CornerFilter &corner_filter = {});
+void smooth_polylines_corners(Polylines &polylines, double smooth_factor, double tolerance,
+                              double max_corner_distance = 0., const CornerFilter &corner_filter = {});
+// Polygons close implicitly, so every one of their vertices is a corner.
+void smooth_polygons_corners(Polygons &polygons, double smooth_factor, double tolerance,
+                             double max_corner_distance = 0., const CornerFilter &corner_filter = {});
+
+} // namespace Slic3r

src/libslic3r/Fill/FillCrossHatch.cpp

@@ -3,6 +3,7 @@
 #include "../Surface.hpp"
 #include <cmath>
 #include "FillBase.hpp"
+#include "FillCornerSmoothing.hpp"
 #include "FillCrossHatch.hpp"
 
 namespace Slic3r {
@@ -205,6 +206,9 @@ void FillCrossHatch ::_fill_surface_single(
     // shift the pattern to the actual space
     for (Polyline &pl : polylines) { pl.translate(bb.min); }
 
+    // Orca: round the corners of the transition layers. The repeat layers are straight lines and stay as they are.
+    smooth_polylines_corners(polylines, params.smooth_factor, scaled<double>(params.resolution));
+
     // Apply multiline offset if needed
     multiline_fill(polylines, params, spacing);
 

src/libslic3r/Fill/FillHoneycomb.cpp

@@ -2,6 +2,7 @@
 #include "../ShortestPath.hpp"
 #include "../Surface.hpp"
 
+#include "FillCornerSmoothing.hpp"
 #include "FillHoneycomb.hpp"
 
 namespace Slic3r {
@@ -70,6 +71,9 @@ void FillHoneycomb::_fill_surface_single(
             }
             p.rotate(-direction.first, m.hex_center);
             p.simplify(5 * spacing); // simplify to 5x line width
+            // Orca: round the corners of the honeycomb cells. Done before the clipping, so that the
+            // curves are cut by the region boundary just like the sharp path would be.
+            smooth_polyline_corners(p, params.smooth_factor, scaled<double>(params.resolution));
             all_polylines.push_back(p);
         }
     }

src/libslic3r/Fill/FillLightning.cpp

@@ -2,6 +2,7 @@
 #include "../Print.hpp"
 #include "../ShortestPath.hpp"
 #include "FillBase.hpp"
+#include "FillCornerSmoothing.hpp"
 #include "FillLightning.hpp"
 #include "Lightning/Generator.hpp"
 
@@ -17,6 +18,19 @@ void Filler::_fill_surface_single(
     const Layer &layer      = generator->getTreesForLayer(this->layer_id);
     Polylines    fill_lines = layer.convertToLines(to_polygons(expolygon), scaled<coord_t>(0.5 * this->spacing - this->overlap));
 
+    // Orca: round the turns of the branches. Hairpins are left sharp, as they cannot be rounded, and
+    // the reach is capped: cutting a corner moves the branch, and a branch is as long as the object
+    // rather than as long as one cell of a pattern, so half of a leg would merge it with its neighbour
+    // instead of rounding the turn between them. Half the distance between two branches keeps them
+    // apart. With more than one line per infill wall the branches are printed as outlines drawn around
+    // them, and the outlines of branches that run into each other merge into a single one; moving a
+    // branch by more than a fraction of its printed width breaks such an outline up into separate
+    // loops, so that width bounds the reach as well.
+    const double branch_width   = scaled<double>(this->spacing) * params.multiline;
+    const double branch_spacing = branch_width / std::max(double(params.density), EPSILON);
+    const double max_reach      = 0.5 * (params.multiline > 1 ? branch_width : branch_spacing);
+    smooth_polylines_corners(fill_lines, params.smooth_factor, scaled<double>(params.resolution), max_reach);
+
     // Apply multiline offset if needed
     multiline_fill(fill_lines, params, spacing);
 

src/libslic3r/Fill/FillPlanePath.cpp

@@ -2,6 +2,7 @@
 #include "../ShortestPath.hpp"
 #include "../Surface.hpp"
 
+#include "FillCornerSmoothing.hpp"
 #include "FillPlanePath.hpp"
 
 namespace Slic3r {
@@ -288,145 +289,60 @@ static void generate_hilbert_curve(coord_t min_x, coord_t min_y, coord_t max_x,
     }
 }
 
-using QuinticBezier = std::array<Vec2d, 6>;
-
-static bool is_bezier_flat(const QuinticBezier &curve, const double deviation)
-{
-    // A Bezier curve stays inside the convex hull of its control points. Therefore, keeping every
-    // control point within a deviation-wide strip around the endpoint chord conservatively bounds the
-    // flattening error. The cross product is the perpendicular distance scaled by the chord length;
-    // comparing squared values avoids a square root.
-    const Vec2d  chord           = curve.back() - curve.front();
-    const double chord_length_sq = chord.squaredNorm();
-    const double max_cross_sq    = deviation * deviation * chord_length_sq;
-
-    for (size_t i = 1; i + 1 < curve.size(); ++i) {
-        const Vec2d  offset = curve[i] - curve.front();
-        const double cross  = chord.x() * offset.y() - chord.y() * offset.x();
-        if (cross * cross > max_cross_sq)
-            return false;
-    }
-    return true;
-}
-
-static void subdivide_bezier(const QuinticBezier &curve, QuinticBezier &left, QuinticBezier &right)
-{
-    // Split the curve at t = 0.5 using de Casteljau's algorithm. Each averaging level contributes one
-    // control point to the left half and one to the right half; the latter is filled backwards to keep
-    // both resulting control polygons in their original parameter direction.
-    QuinticBezier subdivision = curve;
-    left.front() = subdivision.front();
-    right.back() = subdivision.back();
-    for (size_t level = 1; level < curve.size(); ++level) {
-        for (size_t i = 0; i + level < curve.size(); ++i)
-            subdivision[i] = 0.5 * (subdivision[i] + subdivision[i + 1]);
-        left[level] = subdivision.front();
-        right[curve.size() - level - 1] = subdivision[curve.size() - level - 1];
-    }
-}
-
-static void flatten_bezier(const QuinticBezier &curve, const double deviation, std::vector<Vec2d> &output)
-{
-    // Subdivide to at least depth 1 so a rounded corner cannot collapse to a single diagonal chord.
-    // A uniform subdivision depth keeps samples at equal parameter intervals t = k / 2^depth,
-    // avoiding abrupt segment-length jumps at adaptive-depth boundaries.
-    static constexpr size_t max_depth = 16;
-
-    std::vector<QuinticBezier> subcurves(2);
-    subdivide_bezier(curve, subcurves[0], subcurves[1]);
-
-    for (size_t depth = 1; depth < max_depth; ++depth) {
-        bool all_flat = true;
-        for (const QuinticBezier &c : subcurves)
-            if (!is_bezier_flat(c, deviation)) {
-                all_flat = false;
-                break;
-            }
-        if (all_flat)
-            break;
-        std::vector<QuinticBezier> finer(subcurves.size() * 2);
-        for (size_t i = 0; i < subcurves.size(); ++i)
-            subdivide_bezier(subcurves[i], finer[i * 2], finer[i * 2 + 1]);
-        subcurves = std::move(finer);
-    }
-
-    // The curve start is deliberately omitted so consecutive curve pieces can share it without duplication.
-    output.reserve(output.size() + subcurves.size());
-    for (const QuinticBezier &c : subcurves)
-        output.emplace_back(c.back());
-}
-
+// Rounds the corners of the generated path on its way to the infill output.
 template<typename Output>
-static void generate_smooth_hilbert_curve(
-    coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y, const double resolution,
-    const double corner_distance, Output &output)
+class SmoothingPolylineOutput
 {
-    // A Hilbert curve is defined on a square grid whose side is a power of two. As in the unsmoothed
-    // generator, expand the larger requested dimension to the next valid Hilbert grid size. The output
-    // clipper or the later region intersection removes the padded part of the traversal.
-    size_t sz = 2;
-    const size_t sz0 = std::max(max_x + 1 - min_x, max_y + 1 - min_y);
-    while (sz < sz0)
-        sz <<= 1;
+public:
+    SmoothingPolylineOutput(Output &output, const double smooth_factor, const double tolerance)
+        : m_output(output), m_smoother(smooth_factor, tolerance) {}
 
-    const size_t point_count = sz * sz;
-    output.reserve(point_count);
+    void reserve(size_t n) { m_output.reserve(n); }
+    void add_point(const Vec2d &pt) { auto emit = emitter(); m_smoother.push(pt, emit); }
+    // The smoother holds back the last point of the path until it knows there is no corner left to round.
+    void finish() { auto emit = emitter(); m_smoother.flush(emit); }
 
-    // The caller normalizes resolution to the unit Hilbert grid; retain a finite positive tolerance
-    // if this helper is invoked with an invalid resolution.
-    const double deviation = resolution > 0. && std::isfinite(resolution) ? resolution : EPSILON;
-    // Construct one canonical 90-degree corner from (-corner_distance, 0) to (0, corner_distance).
-    // At each end, the first three control points are collinear and equally spaced: the tangent follows
-    // the adjoining straight leg and the second derivative is zero. The endpoint curvature is therefore
-    // zero, giving G2 joins to both legs. Every Hilbert turn is an oriented copy of this curve, so flatten
-    // it only once to the requested chordal-deviation tolerance.
-    const QuinticBezier corner_curve {{
-        {-corner_distance, 0.}, {-0.7 * corner_distance, 0.}, {-0.4 * corner_distance, 0.},
-        {0., 0.4 * corner_distance}, {0., 0.7 * corner_distance}, {0., corner_distance}
-    }};
-    std::vector<Vec2d> curve_coefficients;
-    flatten_bezier(corner_curve, deviation, curve_coefficients);
-
-    auto translated_point = [min_x, min_y](size_t idx) {
-        Point p = hilbert_n_to_xy(idx);
-        return Point(p.x() + min_x, p.y() + min_y);
-    };
-    auto to_vec2d = [](const Point &p) { return Vec2d(double(p.x()), double(p.y())); };
-    bool has_last_output = false;
-    Vec2d last_output;
-    // Fully smoothed adjacent corners may meet at the same segment midpoint. Suppress such duplicates
-    // to avoid emitting zero-length extrusion segments.
-    auto add_point = [&output, &has_last_output, &last_output](const Vec2d &point) {
-        if (!has_last_output || point.x() != last_output.x() || point.y() != last_output.y()) {
-            output.add_point(point);
-            last_output     = point;
-            has_last_output = true;
-        }
-    };
-
-    Vec2d previous = to_vec2d(translated_point(0));
-    Vec2d corner   = to_vec2d(translated_point(1));
-    add_point(previous);
-    // Replace each non-collinear Hilbert vertex by the canonical curve expressed in the local basis of
-    // its incoming and outgoing unit vectors. Collinear vertices remain part of the straight polyline.
-    for (size_t i = 1; i + 1 < point_count; ++i) {
-        const Vec2d next     = to_vec2d(translated_point(i + 1));
-        const Vec2d incoming = (corner - previous).normalized();
-        const Vec2d outgoing = (next - corner).normalized();
-        const double cross   = incoming.x() * outgoing.y() - incoming.y() * outgoing.x();
-
-        if (std::abs(cross) < EPSILON) {
-            add_point(corner);
-        } else {
-            add_point(corner - corner_distance * incoming);
-            for (const Vec2d &coefficient : curve_coefficients)
-                add_point(corner + coefficient.x() * incoming + coefficient.y() * outgoing);
-        }
-
-        previous = corner;
-        corner   = next;
+private:
+    // The curves of two adjacent corners meet at the midpoint of the segment they share, where they
+    // may round to the very same output point. Drop those, they would be zero length extrusions.
+    auto emitter()
+    {
+        return [this](const Vec2d &pt) {
+            const Point snapped = m_output.scaled(pt);
+            if (m_has_last_snapped && snapped == m_last_snapped)
+                return;
+            m_last_snapped     = snapped;
+            m_has_last_snapped = true;
+            m_output.add_point(pt);
+        };
     }
-    add_point(corner);
+
+    Output        &m_output;
+    CornerSmoother m_smoother;
+    Point          m_last_snapped { Point::Zero() };
+    bool           m_has_last_snapped { false };
+};
+
+// Runs the path generator against the concrete output type, optionally through the corner smoother.
+// The outputs do not share a virtual add_point(), so the type has to be resolved here.
+template<typename GenerateFn>
+static void generate_path(InfillPolylineOutput &output, const FillParams &params, const double resolution, GenerateFn generate)
+{
+    const double smooth_factor = sanitize_smooth_factor(params.smooth_factor);
+    auto run = [smooth_factor, resolution, &generate](auto &out) {
+        if (smooth_factor == 0.) {
+            generate(out);
+        } else {
+            SmoothingPolylineOutput<std::remove_reference_t<decltype(out)>> smoothing(out, smooth_factor, resolution);
+            generate(smoothing);
+            smoothing.finish();
+        }
+    };
+
+    if (output.clips())
+        run(static_cast<InfillPolylineClipper&>(output));
+    else
+        run(output);
 }
 
 void FillHilbertCurve::generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y, const double /* resolution */, InfillPolylineOutput &output)
@@ -440,19 +356,8 @@ void FillHilbertCurve::generate(coord_t min_x, coord_t min_y, coord_t max_x, coo
 void FillHilbertCurve::generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y, const double resolution,
     const FillParams &params, InfillPolylineOutput &output)
 {
-    const double smooth_factor = std::isfinite(params.smooth_factor) ?
-        std::clamp(params.smooth_factor, 0., 1.) : 0.;
-    if (smooth_factor == 0.) {
-        this->generate(min_x, min_y, max_x, max_y, resolution, output);
-        return;
-    }
-
-    const double corner_distance = 0.5 * smooth_factor;
-    if (output.clips())
-        generate_smooth_hilbert_curve(
-            min_x, min_y, max_x, max_y, resolution, corner_distance, static_cast<InfillPolylineClipper&>(output));
-    else
-        generate_smooth_hilbert_curve(min_x, min_y, max_x, max_y, resolution, corner_distance, output);
+    generate_path(output, params, resolution,
+        [min_x, min_y, max_x, max_y](auto &out) { generate_hilbert_curve(min_x, min_y, max_x, max_y, out); });
 }
 
 template<typename Output>
@@ -495,4 +400,11 @@ void FillOctagramSpiral::generate(coord_t min_x, coord_t min_y, coord_t max_x, c
         generate_octagram_spiral(min_x, min_y, max_x, max_y, output);
 }
 
+void FillOctagramSpiral::generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y, const double resolution,
+    const FillParams &params, InfillPolylineOutput &output)
+{
+    generate_path(output, params, resolution,
+        [min_x, min_y, max_x, max_y](auto &out) { generate_octagram_spiral(min_x, min_y, max_x, max_y, out); });
+}
+
 } // namespace Slic3r

src/libslic3r/Fill/FillPlanePath.hpp

@@ -21,10 +21,10 @@ public:
     void            add_point(const Vec2d& pt) { m_out.emplace_back(this->scaled(pt)); }
     Points&& result() { return std::move(m_out); }
     virtual bool    clips() const { return false; }
-
-protected:
+    // The output grid the generated points are snapped to.
     const Point     scaled(const Vec2d& fpt) const { return { coord_t(floor(fpt.x() * m_scale_out + 0.5)), coord_t(floor(fpt.y() * m_scale_out + 0.5)) }; }
 
+protected:
     // Output polyline.
     Points          m_out;
 
@@ -93,6 +93,8 @@ public:
 protected:
     bool centered() const override { return true; }
     void generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y, const double resolution, InfillPolylineOutput &output) override;
+    void generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y, const double resolution,
+                              const FillParams &params, InfillPolylineOutput &output) override;
 };
 
 } // namespace Slic3r

src/libslic3r/Fill/FillRectilinear.cpp

@@ -18,6 +18,7 @@
 #include "../ShortestPath.hpp"
 #include "../VariableWidth.hpp"
 
+#include "FillCornerSmoothing.hpp"
 #include "FillRectilinear.hpp"
 
 // #define SLIC3R_DEBUG
@@ -3364,6 +3365,10 @@ bool FillRectilinear::fill_surface_trapezoidal(
         for (Polyline &pl : polylines)
             pl.translate(rotate_vector.second);
 
+    // Orca: round the corners of the trapezoids. The straight base lines of the triangular family
+    // have no corner to round.
+    smooth_polylines_corners(polylines, params.smooth_factor, scaled<double>(params.resolution));
+
     // Apply multiline fill
     multiline_fill(polylines, params, spacing);
 

src/libslic3r/GCode.cpp

@@ -6726,6 +6726,7 @@ void GCode::append_full_config(const Print &print, std::string &str)
         "farthest_point_timelapse"sv,
         "compatible_printers"sv,
         "compatible_prints"sv,
+        "filament_colour_type"sv,
         "print_host"sv,
         "print_host_webui"sv,
         "printhost_apikey"sv,

src/libslic3r/GCode/ExtrusionProcessor.hpp

@@ -19,6 +19,7 @@
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <functional>
 #include <limits>
 #include <numeric>
 #include <unordered_map>
@@ -39,7 +40,11 @@ std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&
                                                               const AABBTreeLines::LinesDistancer<L>& unscaled_prev_layer,
                                                               float                                   flow_width,
                                                               float                                   max_line_length = -1.0f,
-                                                              float                                   min_distance    = -1.0f)
+                                                              float                                   min_distance    = -1.0f,
+                                                              // Maps an overhang distance onto the speed it will be printed at. Interior sampling
+                                                              // needs it to tell which of the points it could add would change the G-code, and is
+                                                              // skipped without it.
+                                                              const std::function<float(float)>&      distance_to_speed = {})
 {
     bool   looped     = input_points.front() == input_points.back();
     std::function<size_t(size_t,size_t)> get_prev_index = [](size_t idx, size_t count) {
@@ -120,6 +125,107 @@ std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&
         points.push_back(next_point);
     }
 
+    // ORCA: Interior sampling
+    // The passes below infer the support under a span from its endpoints alone, so an interior that is supported
+    // differently from both ends is invisible to them: the outer perimeter of an overhang whose ends are caged by
+    // full height walls reads as supported along its whole length. Probe the interior, keep the samples the
+    // endpoint interpolation fails to predict, and bisect either side of each one, so a span that is only partly
+    // unsupported gets points where its support actually changes instead of one reading spread across all of it.
+    if (PREV_LAYER_BOUNDARY_OFFSET && ADD_INTERSECTIONS && min_distance > 0 && distance_to_speed) {
+        // Probe at least this densely before treating matching samples as evidence that a span is uniform. The
+        // segmentation pass below only splits lines of 2mm or more, and every pass here drops points closer
+        // together than min_spacing, so finer discovery would not produce a more precise speed transition.
+        const double max_probe_spacing = std::max(2., 4. * min_spacing);
+        // A backstop for that length test, which on a non-finite length would never be met.
+        constexpr int max_bisection_depth = 10;
+        // Whether two readings are interchangeable. A segment is printed at the lower of the speeds its ends
+        // read, so a sample that agrees on speed with what is already known cannot change the G-code, whatever
+        // its distance says. The distances themselves are far too coarse a stand-in for this: the speed sections
+        // interpolate, so readings a small fraction of min_distance apart can still be tens of mm/s apart.
+        // The tolerance matches the one GCode.cpp applies when it decides a path has a variable speed at all.
+        auto same_speed = [&distance_to_speed](float a, float b) {
+            return std::abs(distance_to_speed(a) - distance_to_speed(b)) <= 1.f;
+        };
+        // Whether the first reading is printed slower than the second, once they are known to differ.
+        auto prints_slower = [&distance_to_speed](float a, float b) { return distance_to_speed(a) < distance_to_speed(b); };
+
+        // Part of a segment still to bisect: its positions along the segment and bisections left.
+        struct Subspan { double t0, t1; int depth; };
+
+        std::vector<ExtendedPoint<L::Dim>>    sampled_points; // Populated lazily, on the first insertion
+        std::vector<std::pair<double, float>> interior;       // Samples of one segment, keyed by position along it
+        std::vector<Subspan>                  pending;
+
+        for (size_t point_idx = 0; point_idx + 1 < points.size(); ++point_idx) {
+            const ExtendedPoint<L::Dim>& curr     = points[point_idx];
+            const ExtendedPoint<L::Dim>& next     = points[point_idx + 1];
+            const Vec                    step     = next.position - curr.position;
+            const double                 line_len = step.norm();
+
+            interior.clear();
+            if (line_len >= max_probe_spacing)
+                pending.push_back({0., 1., max_bisection_depth});
+
+            while (!pending.empty()) {
+                const Subspan subspan = pending.back();
+                pending.pop_back();
+                if (subspan.depth <= 0 || (subspan.t1 - subspan.t0) * line_len < max_probe_spacing)
+                    continue;
+
+                const double t = 0.5 * (subspan.t0 + subspan.t1);
+                auto [distance, nearest_line, x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(
+                    (curr.position + t * step).template cast<AABBScalar>());
+                const float sampled = float(distance + boundary_offset);
+
+                interior.emplace_back(t, sampled);
+                pending.push_back({subspan.t0, t, subspan.depth - 1});
+                pending.push_back({t, subspan.t1, subspan.depth - 1});
+            }
+
+            if (!interior.empty()) {
+                std::sort(interior.begin(), interior.end(),
+                          [](const std::pair<double, float>& l, const std::pair<double, float>& r) { return l.first < r.first; });
+                // Coarse probing keeps every sample it took until this pass can see which ones bracket a speed
+                // transition. Matching samples cannot be discarded during discovery: one may be the last
+                // supported point before a narrow unsupported pocket found by a later probe.
+                size_t kept = 0;
+                for (size_t i = 0; i < interior.size(); ++i) {
+                    const float sample    = interior[i].second;
+                    const bool  at_start  = kept == 0;                     // Nothing kept yet, so the segment's own start precedes it
+                    const bool  at_end    = i + 1 == interior.size();      // And nothing follows the last sample but the segment's end
+                    const float before    = at_start ? curr.distance : interior[kept - 1].second;
+                    const float after     = at_end ? next.distance : interior[i + 1].second;
+                    // A sample is worth a point in the path only where it prints at a different speed from the
+                    // readings either side of it. Differing from one of the segment's own ends is not enough on
+                    // its own where the sample is the faster of the two: the segmentation pass below already
+                    // ends the slowdown an end reads, at a distance taken from how far out that end is rather
+                    // than from wherever bisection happened to stop, and a point here would leave the span
+                    // beside the end too short for that pass to run at all. Support an end cannot account for,
+                    // where the interior is the slower reading, is exactly what this pass is here to find.
+                    const bool worth_before = !same_speed(sample, before) && (!at_start || prints_slower(sample, before));
+                    const bool worth_after  = !same_speed(sample, after) && (!at_end || prints_slower(sample, after));
+                    if (worth_before || worth_after)
+                        interior[kept++] = interior[i];
+                }
+                interior.resize(kept);
+            }
+
+            if (!interior.empty() && sampled_points.empty()) {
+                sampled_points.reserve(points.size() + 8);
+                sampled_points.assign(points.begin(), points.begin() + point_idx + 1);
+            }
+            if (!sampled_points.empty()) {
+                // Only a sub-span of max_probe_spacing or more is ever bisected, so these sit at least
+                // 2 * min_spacing apart, and need none of the filtering the passes either side of this one do.
+                for (const auto& [t, distance] : interior)
+                    sampled_points.push_back({curr.position + t * step, distance});
+                sampled_points.push_back(next);
+            }
+        }
+        if (!sampled_points.empty())
+            points = std::move(sampled_points);
+    }
+
     // Segmentation handling
     if (PREV_LAYER_BOUNDARY_OFFSET && ADD_INTERSECTIONS) {
         std::vector<ExtendedPoint<L::Dim>> new_points;
@@ -362,9 +468,28 @@ public:
             smallest_distance_with_lower_speed=-1.f;
 
         // Orca: Pass to the point properties estimator the smallest ovehang distance that triggers a slowdown (smallest_distance_with_lower_speed)
+        auto calculate_speed = [&speed_sections, &original_speed](float distance) {
+            float final_speed;
+            if (distance <= speed_sections.front().first) {
+                final_speed = original_speed;
+            } else if (distance >= speed_sections.back().first) {
+                final_speed = speed_sections.back().second;
+            } else {
+                size_t section_idx = 0;
+                while (distance > speed_sections[section_idx + 1].first) {
+                    section_idx++;
+                }
+                float t = (distance - speed_sections[section_idx].first) /
+                          (speed_sections[section_idx + 1].first - speed_sections[section_idx].first);
+                t           = std::clamp(t, 0.0f, 1.0f);
+                final_speed = (1.0f - t) * speed_sections[section_idx].second + t * speed_sections[section_idx + 1].second;
+            }
+            return round(final_speed);
+        };
+
         std::vector<ExtendedPoint<3>> extended_points =
             estimate_points_properties<true, true, true, true>(path.polyline.points, prev_layer_boundaries[current_object], path.width, -1,
-                                                               smallest_distance_with_lower_speed);
+                                                               smallest_distance_with_lower_speed, calculate_speed);
         const auto width_inv = 1.0f / path.width;
         std::vector<ProcessedPoint> processed_points;
         processed_points.reserve(extended_points.size());
@@ -423,25 +548,6 @@ public:
                 }
             }	
 
-            auto calculate_speed = [&speed_sections, &original_speed](float distance) {
-                float final_speed;
-                if (distance <= speed_sections.front().first) {
-                    final_speed = original_speed;
-                } else if (distance >= speed_sections.back().first) {
-                    final_speed = speed_sections.back().second;
-                } else {
-                    size_t section_idx = 0;
-                    while (distance > speed_sections[section_idx + 1].first) {
-                        section_idx++;
-                    }
-                    float t = (distance - speed_sections[section_idx].first) /
-                              (speed_sections[section_idx + 1].first - speed_sections[section_idx].first);
-                    t           = std::clamp(t, 0.0f, 1.0f);
-                    final_speed = (1.0f - t) * speed_sections[section_idx].second + t * speed_sections[section_idx + 1].second;
-                }
-                return round(final_speed);
-            };
-            
             float extrusion_speed = std::min(calculate_speed(curr.distance), calculate_speed(next.distance));
             // ORCA: Clamp resulting speed to lowest of calculated speed based on the overhang values and the current speed
             // Fixes bug where resulting overhang speed is higher than the current speed due to (for example) volumetric flow limits.

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -298,6 +298,7 @@ void GCodeProcessor::TimeMachine::State::reset()
     //BBS
     enter_direction = { 0.0f, 0.0f, 0.0f };
     exit_direction = { 0.0f, 0.0f, 0.0f };
+    jd_unit_vec = { 0.0f, 0.0f, 0.0f, 0.0f };
 }
 
 void GCodeProcessor::TimeMachine::CustomGCodeTime::reset()
@@ -5036,6 +5037,10 @@ void GCodeProcessor::process_G1(const std::array<std::optional<double>, 4>& axes
         if (!is_extrusion_only_move(delta_pos))
             curr.enter_direction = curr.enter_direction / norm;
         curr.exit_direction = curr.enter_direction;
+        curr.jd_unit_vec = Vec4f(static_cast<float>(delta_pos[X]),
+                                 static_cast<float>(delta_pos[Y]),
+                                 static_cast<float>(delta_pos[Z]),
+                                 static_cast<float>(delta_pos[E])).normalized();
 
         TimeBlock block;
         block.move_type = type;
@@ -5118,22 +5123,32 @@ void GCodeProcessor::process_G1(const std::array<std::optional<double>, 4>& axes
 
         block.acceleration = acceleration;
 
-        // calculates block exit feedrate
-        curr.safe_feedrate = block.feedrate_profile.cruise;
+        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
+        const bool has_prev_move = !blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD;
 
-        for (unsigned char a = X; a <= E; ++a) {
-            float axis_max_jerk = get_axis_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
-            if (curr.abs_axis_feedrate[a] > axis_max_jerk)
-                curr.safe_feedrate = std::min(curr.safe_feedrate, axis_max_jerk);
+        // Orca: junction deviation where the firmware uses it (Klipper always, Marlin 2 with M205 J).
+        // Negative leaves the classic jerk path below unchanged.
+        const float vmax_junction_jd = calc_vmax_junction_deviation(block, prev, curr, has_prev_move,
+                                                                    static_cast<PrintEstimatedStatistics::ETimeMode>(i));
+        const bool use_junction_deviation = vmax_junction_jd >= 0.0f;
+
+        // calculates block exit feedrate. Junction deviation has no per axis jerk floor, so a move is
+        // free to start from rest.
+        curr.safe_feedrate = use_junction_deviation ? 0.0f : block.feedrate_profile.cruise;
+
+        if (!use_junction_deviation) {
+            for (unsigned char a = X; a <= E; ++a) {
+                float axis_max_jerk = get_axis_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
+                if (curr.abs_axis_feedrate[a] > axis_max_jerk)
+                    curr.safe_feedrate = std::min(curr.safe_feedrate, axis_max_jerk);
+            }
         }
 
         block.feedrate_profile.exit = curr.safe_feedrate;
 
-        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
-
         // calculates block entry feedrate
-        float vmax_junction = curr.safe_feedrate;
-        if (!blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD) {
+        float vmax_junction = use_junction_deviation ? vmax_junction_jd : curr.safe_feedrate;
+        if (!use_junction_deviation && has_prev_move) {
             bool prev_speed_larger = prev.feedrate > block.feedrate_profile.cruise;
             float smaller_speed_factor = prev_speed_larger ? (block.feedrate_profile.cruise / prev.feedrate) : (prev.feedrate / block.feedrate_profile.cruise);
             // Pick the smaller of the nominal speeds. Higher speed shall not be achieved at the junction during coasting.
@@ -5400,6 +5415,10 @@ void GCodeProcessor::process_VG1(const GCodeReader::GCodeLine& line)
         if (!is_extrusion_only_move(delta_pos))
             curr.enter_direction = curr.enter_direction / norm;
         curr.exit_direction = curr.enter_direction;
+        curr.jd_unit_vec = Vec4f(static_cast<float>(delta_pos[X]),
+                                 static_cast<float>(delta_pos[Y]),
+                                 static_cast<float>(delta_pos[Z]),
+                                 static_cast<float>(delta_pos[E])).normalized();
 
         TimeBlock block;
         block.move_type = type;
@@ -5480,22 +5499,32 @@ void GCodeProcessor::process_VG1(const GCodeReader::GCodeLine& line)
 
         block.acceleration = acceleration;
 
-        // calculates block exit feedrate
-        curr.safe_feedrate = block.feedrate_profile.cruise;
+        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
+        const bool has_prev_move = !blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD;
 
-        for (unsigned char a = X; a <= E; ++a) {
-            float axis_max_jerk = get_axis_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
-            if (curr.abs_axis_feedrate[a] > axis_max_jerk)
-                curr.safe_feedrate = std::min(curr.safe_feedrate, axis_max_jerk);
+        // Orca: junction deviation where the firmware uses it (Klipper always, Marlin 2 with M205 J).
+        // Negative leaves the classic jerk path below unchanged.
+        const float vmax_junction_jd = calc_vmax_junction_deviation(block, prev, curr, has_prev_move,
+                                                                    static_cast<PrintEstimatedStatistics::ETimeMode>(i));
+        const bool use_junction_deviation = vmax_junction_jd >= 0.0f;
+
+        // calculates block exit feedrate. Junction deviation has no per axis jerk floor, so a move is
+        // free to start from rest.
+        curr.safe_feedrate = use_junction_deviation ? 0.0f : block.feedrate_profile.cruise;
+
+        if (!use_junction_deviation) {
+            for (unsigned char a = X; a <= E; ++a) {
+                float axis_max_jerk = get_axis_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
+                if (curr.abs_axis_feedrate[a] > axis_max_jerk)
+                    curr.safe_feedrate = std::min(curr.safe_feedrate, axis_max_jerk);
+            }
         }
 
         block.feedrate_profile.exit = curr.safe_feedrate;
 
-        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
-
         // calculates block entry feedrate
-        float vmax_junction = curr.safe_feedrate;
-        if (!blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD) {
+        float vmax_junction = use_junction_deviation ? vmax_junction_jd : curr.safe_feedrate;
+        if (!use_junction_deviation && has_prev_move) {
             bool prev_speed_larger = prev.feedrate > block.feedrate_profile.cruise;
             float smaller_speed_factor = prev_speed_larger ? (block.feedrate_profile.cruise / prev.feedrate) : (prev.feedrate / block.feedrate_profile.cruise);
             // Pick the smaller of the nominal speeds. Higher speed shall not be achieved at the junction during coasting.
@@ -7168,6 +7197,91 @@ float GCodeProcessor::get_axis_max_jerk_with_jd(PrintEstimatedStatistics::ETimeM
     return get_axis_max_jerk_with_jd(mode, axis, get_acceleration(mode));
 }
 
+float GCodeProcessor::get_junction_deviation(PrintEstimatedStatistics::ETimeMode mode, float acceleration) const
+{
+    const size_t id = static_cast<size_t>(mode);
+
+    // Klipper has no classic jerk: jd = scv^2 * (sqrt(2) - 1) / max_accel
+    // (toolhead.py::_calc_junction_deviation). Passing the block acceleration back in makes it cancel
+    // in calc_vmax_junction_deviation(), leaving the identity v == scv at a 90 degree corner.
+    if (m_flavor == gcfKlipper) {
+        // machine_max_jerk_x holds the square corner velocity; process_SET_VELOCITY_LIMIT() writes it.
+        const float scv = get_option_value(m_time_processor.machine_limits.machine_max_jerk_x, id);
+        if (scv <= 0.0f || acceleration <= 0.0f)
+            return 0.0f;
+        return sqr(scv) * (std::sqrt(2.0f) - 1.0f) / acceleration;
+    }
+
+    // Marlin 2 plans with junction deviation only when M205 J > 0; classic jerk leaves it at 0.
+    if (m_flavor == gcfMarlinFirmware)
+        return get_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, id);
+
+    return 0.0f;
+}
+
+float GCodeProcessor::calc_junction_acceleration(const TimeBlock& block, const Vec4f& junction_unit_vec,
+                                                 PrintEstimatedStatistics::ETimeMode mode) const
+{
+    float junction_acceleration = block.acceleration;
+    for (unsigned char a = X; a <= E; ++a) {
+        if (junction_unit_vec[a] == 0.0f)
+            continue;
+        const float axis_max_acceleration = get_axis_max_acceleration(mode, static_cast<Axis>(a), m_machine_config_idx);
+        if (axis_max_acceleration > 0.0f)
+            junction_acceleration = std::min(junction_acceleration, std::abs(axis_max_acceleration / junction_unit_vec[a]));
+    }
+    return junction_acceleration;
+}
+
+// Ported from PrusaSlicer (src/libslic3r/GCode/GCodeProcessor.cpp).
+float GCodeProcessor::calc_vmax_junction_deviation(const TimeBlock& block, const TimeMachine::State& prev,
+                                                   const TimeMachine::State& curr, bool has_prev_move,
+                                                   PrintEstimatedStatistics::ETimeMode mode) const
+{
+    const float junction_deviation = get_junction_deviation(mode, block.acceleration);
+    if (junction_deviation <= 0.0f)
+        return -1.0f; // classic jerk machine, the caller keeps its own computation
+    if (!has_prev_move)
+        return 0.0f;  // starts from rest, the planner raises this on the reverse pass
+
+    // -1 for a straight continuation, +1 for a full reversal. Half angle identity, no acos()/sin().
+    // Both vectors are unit length over XYZE, so this really is a cosine: scaling by 1 / distance
+    // instead, as PrusaSlicer does, leaves an E term that makes extruding corners look straighter
+    // than they are. Marlin normalizes over XYZE for any extruding move (planner.cpp, esteps > 0)
+    // and Klipper keeps E out of the cosine entirely (toolhead.py::Move.calc_junction); both agree
+    // that the corner is planned by its geometry, and normalizing matches them to within 1e-5.
+    float junction_cos_theta = (-prev.jd_unit_vec).dot(curr.jd_unit_vec);
+    if (junction_cos_theta > 0.999999f)
+        return 0.0f; // the path doubles back, the machine has to stop
+    junction_cos_theta = std::max(junction_cos_theta, -0.999999f); // guards the division below
+
+    const float sin_theta_d2 = std::sqrt(0.5f * (1.0f - junction_cos_theta)); // always positive
+    const Vec4f junction_vec = curr.jd_unit_vec - prev.jd_unit_vec;
+    const float junction_vec_norm = junction_vec.norm();
+    const Vec4f junction_unit_vec = (junction_vec_norm > 0.0f) ? Vec4f(junction_vec / junction_vec_norm)
+                                                               : Vec4f(0.0f, 0.0f, 0.0f, 0.0f);
+    const float junction_acceleration = calc_junction_acceleration(block, junction_unit_vec, mode);
+
+    float vmax_junction_sqr = (junction_acceleration * junction_deviation * sin_theta_d2) / (1.0f - sin_theta_d2);
+
+    // Marlin's JD_HANDLE_SMALL_SEGMENTS: a short move through a shallow corner is treated as an arc and
+    // capped by the centripetal acceleration it needs. Klipper has no equivalent.
+    if (m_flavor != gcfKlipper && block.distance < 1.0f && junction_cos_theta < -0.7071067812f) {
+        // Fast acos(-t), max. error +-0.033rad. MinMax polynomial by W. Randolph Franklin:
+        // https://wrf.ecse.rpi.edu/Research/Short_Notes/arcsin/onlyelem.html
+        const float neg = junction_cos_theta < 0.0f ? -1.0f : 1.0f;
+        const float t = neg * junction_cos_theta;
+        const float asinx = 0.032843707f + t * (-1.451838349f + t * (29.66153956f + t * (-131.1123477f +
+                            t * (262.8130562f + t * (-242.7199627f + t * (84.31466202f))))));
+        const float junction_theta = float(0.5 * M_PI) + neg * asinx; // acos(-t), bottoms out at 0.033
+        vmax_junction_sqr = std::min(vmax_junction_sqr, (block.distance * junction_acceleration) / junction_theta);
+    }
+
+    // Never faster than either of the two moves the junction joins.
+    vmax_junction_sqr = std::min(vmax_junction_sqr, std::min(sqr(block.feedrate_profile.cruise), sqr(prev.feedrate)));
+    return std::sqrt(vmax_junction_sqr);
+}
+
 float GCodeProcessor::get_axis_max_jerk(PrintEstimatedStatistics::ETimeMode mode, Axis axis) const
 {
     const size_t id = static_cast<size_t>(mode);

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -637,6 +637,9 @@ class Print;
                 //For line move, there are same. For arc move, there are different.
                 Vec3f enter_direction;
                 Vec3f exit_direction;
+                // Orca: move direction over all four axes, unit length. Used by
+                // calc_vmax_junction_deviation(); see there for why E is normalized in.
+                Vec4f jd_unit_vec;
 
                 void reset();
             };
@@ -1488,6 +1491,16 @@ class Print;
         float get_axis_max_acceleration(PrintEstimatedStatistics::ETimeMode mode, Axis axis, int machine_idx) const;
         float get_axis_max_jerk_with_jd(PrintEstimatedStatistics::ETimeMode mode, Axis axis, float acceleration) const;
         float get_axis_max_jerk_with_jd(PrintEstimatedStatistics::ETimeMode mode, Axis axis) const;
+        // Orca: junction deviation for a block at the given acceleration, 0 for a classic jerk machine.
+        float get_junction_deviation(PrintEstimatedStatistics::ETimeMode mode, float acceleration) const;
+        // Orca: acceleration along the junction direction, clamped by the per axis limits.
+        float calc_junction_acceleration(const TimeBlock& block, const Vec4f& junction_unit_vec,
+                                         PrintEstimatedStatistics::ETimeMode mode) const;
+        // Orca: entry speed from the junction deviation model, which limits a corner by its angle alone
+        // and is therefore isotropic, unlike per axis jerk. Negative means classic jerk applies instead.
+        float calc_vmax_junction_deviation(const TimeBlock& block, const TimeMachine::State& prev,
+                                           const TimeMachine::State& curr, bool has_prev_move,
+                                           PrintEstimatedStatistics::ETimeMode mode) const;
         float get_axis_max_jerk(PrintEstimatedStatistics::ETimeMode mode, Axis axis) const;
         Vec3f get_xyz_max_jerk(PrintEstimatedStatistics::ETimeMode mode) const;
         float get_retract_acceleration(PrintEstimatedStatistics::ETimeMode mode) const;

src/libslic3r/Model.cpp

@@ -3243,9 +3243,9 @@ double Model::findMaxSpeed(const ModelObject* object) {
         if (objectKey == "outer_wall_speed")
             externalPerimeterSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
         if (objectKey == "small_perimeter_speed")
-            smallPerimeterSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
+            smallPerimeterSpeedObj = object->config.get().opt_float_or_percent_nullable(objectKey, 0).get_abs_value(externalPerimeterSpeedObj);
         if (objectKey == "small_support_perimeter_speed")
-            smallSupportPerimeterSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
+            smallSupportPerimeterSpeedObj = object->config.get().opt_float_or_percent_nullable(objectKey, 0).get_abs_value(supportSpeedObj);
     }
     objMaxSpeed = std::max(perimeterSpeedObj, std::max(externalPerimeterSpeedObj, std::max(infillSpeedObj, std::max(solidInfillSpeedObj, std::max(topSolidInfillSpeedObj, std::max(supportSpeedObj, std::max(smallPerimeterSpeedObj, std::max(smallSupportPerimeterSpeedObj, objMaxSpeed))))))));
     if (objMaxSpeed <= 0) objMaxSpeed = 250.;

src/libslic3r/Preset.cpp

@@ -147,6 +147,9 @@ Semver get_version_from_json(std::string file_path)
         return Semver();
         //throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file_path, err.what()));
     }
+    catch(...) {
+        return Semver();
+    }
 }
 
 //BBS: add a function to load the key-values from xxx.json
@@ -261,18 +264,28 @@ void extend_default_config_length(DynamicPrintConfig& config, const bool set_nil
         }
     };
 
+    // The four variant sets are immutable after static init and probed for every
+    // key of every preset loaded; one merged map makes that a single lookup.
+    // emplace keeps the first insertion, preserving the first-set-wins priority
+    // of the else-if chain this replaces.
+    static const std::unordered_map<std::string, int> variant_class = [] {
+        std::unordered_map<std::string, int> m;
+        for (const std::string& k : print_options_with_variant)     m.emplace(k, 0);
+        for (const std::string& k : filament_options_with_variant)  m.emplace(k, 1);
+        for (const std::string& k : printer_options_with_variant_1) m.emplace(k, 2);
+        for (const std::string& k : printer_options_with_variant_2) m.emplace(k, 3);
+        return m;
+    }();
+
     for(auto& key :config.keys()){
-        if(auto iter = print_options_with_variant.find(key); iter != print_options_with_variant.end()){
-            replace_nil_and_resize(key, process_variant_length);
-        }
-        else if(auto iter = filament_options_with_variant.find(key); iter != filament_options_with_variant.end()){
-            replace_nil_and_resize(key, filament_variant_length);
-        }
-        else if(auto iter = printer_options_with_variant_1.find(key); iter != printer_options_with_variant_1.end()){
-            replace_nil_and_resize(key, machine_variant_length);
-        }
-        else if(auto iter = printer_options_with_variant_2.find(key); iter != printer_options_with_variant_2.end()){
-            replace_nil_and_resize(key, machine_variant_length * 2);
+        auto iter = variant_class.find(key);
+        if (iter == variant_class.end())
+            continue;
+        switch (iter->second) {
+        case 0: replace_nil_and_resize(key, process_variant_length); break;
+        case 1: replace_nil_and_resize(key, filament_variant_length); break;
+        case 2: replace_nil_and_resize(key, machine_variant_length); break;
+        case 3: replace_nil_and_resize(key, machine_variant_length * 2); break;
         }
     }
 }

src/libslic3r/Preset.hpp

@@ -148,6 +148,10 @@ public:
         PrinterVariant() {}
         PrinterVariant(const std::string &name) : name(name) {}
         std::string                 name;
+
+        // All fields, declaration order — keep in sync; bump CACHE_VERSION on change.
+        template<class Archive>
+        void serialize(Archive& ar) { ar(name); }                       // PrinterVariant
     };
 
     struct PrinterModel {
@@ -156,7 +160,7 @@ public:
         std::string                 name;
         //BBS: this is internal id for the printer. Currently only used for searching in database
         std::string                 model_id;
-        PrinterTechnology           technology;
+        PrinterTechnology           technology = ptFFF;
         std::string                 family;
         std::vector<PrinterVariant> variants;
         std::vector<std::string>	default_materials;
@@ -179,6 +183,17 @@ public:
         }
 
         const PrinterVariant* variant(const std::string &name) const { return const_cast<PrinterModel*>(this)->variant(name); }
+
+        // All fields, declaration order — keep in sync; bump CACHE_VERSION on change.
+        template<class Archive>
+        void serialize(Archive& ar)                                     // PrinterModel
+        {
+            ar(id, name, model_id, technology, family, variants, default_materials,
+               not_support_bed_types, bed_model, bed_texture, image_bed_type,
+               bottom_texture_end_name, use_double_extruder_default_texture,
+               bottom_texture_rect, bottom_texture_rect_longer, middle_texture_rect,
+               hotend_model);
+        }
     };
     std::vector<PrinterModel>          models;
 
@@ -190,6 +205,14 @@ public:
 
     bool 		valid() const { return ! name.empty() && ! id.empty() && config_version.valid(); }
 
+    // All fields, declaration order — keep in sync; bump CACHE_VERSION on change.
+    template<class Archive>
+    void serialize(Archive& ar)                                         // VendorProfile
+    {
+        ar(name, id, config_version, config_update_url, changelog_url,
+           models, default_filaments, default_sla_materials);
+    }
+
     // Load VendorProfile from an ini file.
     // If `load_all` is false, only the header with basic info (name, version, URLs) is loaded.
     static VendorProfile from_ini(const boost::filesystem::path &path, bool load_all=true);
@@ -444,10 +467,10 @@ public:
     Preset(Type type, const std::string &name, bool is_default = false) : type(type), is_default(is_default), name(name) {}
 
 protected:
-    Preset() = default;
-
     friend class        PresetCollection;
     friend class        PresetBundle;
+
+    Preset() = default;
 };
 
 bool is_compatible_with_print  (const PresetWithVendorProfile &preset, const PresetWithVendorProfile &active_print, const PresetWithVendorProfile &active_printer);

src/libslic3r/PresetBundle.hpp

@@ -2,10 +2,12 @@
 #define slic3r_PresetBundle_hpp_
 
 #include "Preset.hpp"
+#include "PresetCacheFormat.hpp"
 #include "AppConfig.hpp"
 #include "enum_bitmask.hpp"
 
 #include <memory>
+#include <set>
 #include <shared_mutex>
 #include <unordered_map>
 #include <optional>
@@ -170,6 +172,31 @@ struct PresetBundleMetadata
 class PresetBundle
 {
 public:
+    // ---- Per-vendor preset cache --------------------------------------------
+    // One cache file per vendor (plus the Orca filament library), stamped with
+    // the vendor's own profile version rather than a directory scan. The bytes
+    // on disk are VendorCacheFile's business (PresetCacheFormat.hpp); what
+    // lives here is how a cache's contents install into a bundle.
+
+    // The cache is not something a caller loads from: a vendor is loaded with
+    // load_vendor_configs_from_json, which comes from the cache whenever one covers
+    // it. What is public here is what the cache's own tests drive directly.
+
+    // Load a per-vendor cache into this bundle by installing its entries, with
+    // base_bundle's filament library as the inheritance base. Rejects (returns
+    // false, with this bundle left clean) unless VendorCacheFile::load accepts
+    // the file — see its contract for the version and identity checks — and
+    // every entry installs. Options this build no longer defines are dropped,
+    // not fatal — the payload names its own keys.
+    bool load_vendor_cache(const std::string& cache_path, const std::string& expected_vendor_name,
+                          const Semver& expected_vendor_version, const PresetBundle* base_bundle = nullptr);
+
+    // Enable writing a per-vendor cache after a JSON parse (off by default). Cache
+    // content is pure parse output, so the guard is policy, not correctness: only
+    // the deliberate generators (load_system_presets_from_json, the cache build
+    // tool) write files, not every incidental load a dialog performs.
+    void set_generate_vendor_caches(bool enable) { m_generate_vendor_caches = enable; }
+
     static DynamicPrintConfig construct_full_config(Preset                         &in_printer_preset,
                                                     Preset                         &in_print_preset,
                                                     const DynamicPrintConfig       &project_config,
@@ -444,8 +471,12 @@ public:
     /*std::pair<PresetsConfigSubstitutions, size_t> load_configbundle(
         const std::string &path, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule);*/
     //Orca: load config bundle from json, pass the base bundle to support cross vendor inheritance
+    // Orca: `dir` is where the vendor is looked for — its own directory, whether or
+    // not the profile JSONs are still there. A whole-vendor load comes from the
+    // vendor's preset cache whenever one covers the profile on disk, and is parsed
+    // from the JSONs in `dir` only when none does. Nothing here reads resources.
     std::pair<PresetsConfigSubstitutions, size_t> load_vendor_configs_from_json(
-        const std::string &path, const std::string &vendor_name, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle = nullptr);
+        const std::string &dir, const std::string &vendor_name, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle = nullptr);
 
     // Export a config bundle file containing all the presets and the names of the active presets.
     //void                        export_configbundle(const std::string &path, bool export_system_settings = false, bool export_physical_printers = false);
@@ -517,11 +548,49 @@ public:
     // Orca: for validation only.
     bool has_errors(bool check_duplicate_filament_subtypes = false) const;
 
+    // Errors the last load recorded. What the cache's error accounting promises —
+    // a cache-served vendor reports what its parse would — is pinned against this.
+    int error_count() const { return m_errors; }
+
     // Orca: for validation only. Flag any system preset whose inherits / compatible_printers /
     // compatible_prints references a deleted (unknown) or renamed (old) preset name.
     bool check_preset_references() const;
 
+    // Merge one vendor's presets with the other vendor's presets, report duplicates.
+    // Public so per-vendor-cache consumers (e.g. the setup wizard) can assemble a
+    // bundle out of several per-vendor caches loaded into separate PresetBundle instances.
+    std::vector<std::string>    merge_presets(PresetBundle &&other);
+
 private:
+    // Load one vendor from the preset cache installed in `dir`, judged against
+    // the vendor profile there. False, with this bundle left clean, when there
+    // is no usable cache and the vendor has to be parsed. This is how
+    // load_vendor_configs_from_json reads a cache.
+    bool load_vendor_cache(const boost::filesystem::path& dir, const std::string& vendor_name, const PresetBundle* base_bundle);
+
+    // Load one source-form preset entry into this bundle: resolve `inherits`,
+    // flatten, validate and register the preset. Returns the reason loading
+    // failed, empty on success. See the definition for the sharing contract
+    // between the JSON parse and the cache load.
+    // retain_configs, when non-null, names the only presets registered into
+    // config_maps (a full config copy each). The cache load passes the names its
+    // entries inherit — the only ones ever looked up again; the JSON parse
+    // retains all, not knowing what later subfiles inherit.
+    std::string load_vendor_preset(const CachedPreset& entry,
+        const std::string& path, const std::string& vendor_name,
+        const PresetBundle* base_bundle,
+        LoadConfigBundleAttributes flags,
+        ConfigSubstitutionContext& substitution_context, PresetsConfigSubstitutions& substitutions,
+        std::map<std::string, DynamicPrintConfig>& config_maps, std::map<std::string, std::string>& filament_id_maps,
+        PresetCollection* presets_collection, size_t& count, bool is_from_lib,
+        const std::set<std::string>* retain_configs = nullptr);
+
+    // Clear every collection's m_printer_hold_alias, which reset() leaves alone.
+    void clear_printer_hold_aliases();
+
+    // Whether to (re)write a per-vendor cache after a JSON parse.
+    bool m_generate_vendor_caches { false };
+
     // Orca: validation only - flag any printer with two or more compatible
     // filament presets sharing one filament_id (ambiguous AMS subtype match).
     bool check_duplicate_filament_subtypes() const;
@@ -529,8 +598,6 @@ private:
     //std::pair<PresetsConfigSubstitutions, std::string> load_system_presets(ForwardCompatibilitySubstitutionRule compatibility_rule);
     //BBS: add json related logic
     std::pair<PresetsConfigSubstitutions, std::string> load_system_presets_from_json(ForwardCompatibilitySubstitutionRule compatibility_rule);
-    // Merge one vendor's presets with the other vendor's presets, report duplicates.
-    std::vector<std::string>    merge_presets(PresetBundle &&other);
     // Update the multicolor information for filaments.
     void update_filament_multi_color();
     // Update renamed_from and alias maps of system profiles.

src/libslic3r/PresetCacheFormat.cpp

@@ -0,0 +1,588 @@
+#include "libslic3r/PresetCacheFormat.hpp"
+
+#include <algorithm>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <utility>
+
+#include <boost/crc.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/iostreams/device/array.hpp>
+#include <boost/iostreams/stream.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <cereal/types/map.hpp>
+#include <cereal/types/set.hpp>
+
+#include "libslic3r/Utils.hpp"
+
+namespace Slic3r {
+
+CacheDictionary::CacheDictionary()
+{
+    // ENUM_UNNAMED is index 0 and always the empty name.
+    m_enum_values.emplace_back();
+}
+
+// The ints an enum option holds — one for a coEnum, the whole vector for coEnums.
+static std::vector<int> enum_ints(const ConfigOptionDef& def, const ConfigOption* opt)
+{
+    if (def.type == coEnum)
+        return { opt->getInt() };
+    return static_cast<const ConfigOptionInts*>(opt)->values;
+}
+
+// The name this build gives one of those ints, empty where it has none — a
+// nullable option's nil, or a definition carrying no enum_keys_map. Enums are
+// written by name so a build that reorders an enum's values still reads it right.
+static std::string enum_name_of(const ConfigOptionDef& def, int value)
+{
+    if (def.enum_keys_map != nullptr)
+        for (const auto& kvp : *def.enum_keys_map)
+            if (kvp.second == value)
+                return kvp.first;
+    return {};
+}
+
+void CacheDictionary::collect(const DynamicPrintConfig& config)
+{
+    for (auto it = config.cbegin(); it != config.cend(); ++ it) {
+        const ConfigOptionDef* def = print_config_def.get(it->first);
+        if (def == nullptr)
+            continue;   // save_config does not write it either
+        if (m_key_index.try_emplace(it->first, uint16_t(m_keys.size())).second) {
+            m_keys.push_back(it->first);
+            m_types.push_back(uint16_t(def->type));
+        }
+        if (def->type != coEnum && def->type != coEnums)
+            continue;
+        for (int value : enum_ints(*def, it->second.get())) {
+            std::string name = enum_name_of(*def, value);
+            if (! name.empty() && m_enum_index.try_emplace(name, uint16_t(m_enum_values.size())).second)
+                m_enum_values.push_back(std::move(name));
+        }
+    }
+}
+
+uint16_t CacheDictionary::key_index(const t_config_option_key& key) const
+{
+    auto it = m_key_index.find(key);
+    if (it == m_key_index.end())
+        throw std::runtime_error("preset cache: option " + key + " was never collected into the dictionary");
+    return it->second;
+}
+
+uint16_t CacheDictionary::enum_index(const std::string& name) const
+{
+    if (name.empty())
+        return ENUM_UNNAMED;
+    auto it = m_enum_index.find(name);
+    return it == m_enum_index.end() ? ENUM_UNNAMED : it->second;
+}
+
+void CacheDictionary::save(cereal::BinaryOutputArchive& ar) const
+{
+    // Checked here rather than left to the caller: an index that wrapped would
+    // be written silently, and nothing downstream could tell.
+    if (m_keys.size() > MAX_ENTRIES || m_enum_values.size() > MAX_ENTRIES)
+        throw std::runtime_error("preset cache: the option dictionary outgrew the uint16 it is indexed with");
+    ar(m_keys, m_types, m_enum_values);
+}
+
+void CacheDictionary::load(cereal::BinaryInputArchive& ar)
+{
+    ar(m_keys, m_types, m_enum_values);
+    if (m_keys.size() != m_types.size())
+        throw std::runtime_error("preset cache: dictionary key and type tables differ in length");
+    if (m_keys.size() > MAX_ENTRIES || m_enum_values.size() > MAX_ENTRIES)
+        throw std::runtime_error("preset cache: dictionary is larger than the uint16 it is indexed with");
+    if (m_enum_values.empty() || ! m_enum_values.front().empty())
+        throw std::runtime_error("preset cache: dictionary is missing its unnamed-enum slot");
+    // Resolved once per file: every option read after this is a vector index.
+    m_defs.resize(m_keys.size());
+    for (size_t i = 0; i < m_keys.size(); ++ i) {
+        const ConfigOptionDef* def = print_config_def.get(m_keys[i]);
+        m_defs[i] = (def != nullptr && uint16_t(def->type) == m_types[i]) ? def : nullptr;
+    }
+}
+
+// ---- one config -----------------------------------------------------------
+
+static void save_enum_option(cereal::BinaryOutputArchive& ar, const ConfigOptionDef& def,
+                             const ConfigOption* opt, const CacheDictionary& dict)
+{
+    const std::vector<int> values = enum_ints(def, opt);
+    ar(uint32_t(values.size()));
+    for (int value : values) {
+        const uint16_t idx = dict.enum_index(enum_name_of(def, value));
+        ar(idx);
+        if (idx == CacheDictionary::ENUM_UNNAMED)
+            ar(int32_t(value));
+    }
+}
+
+// `config` may be null, in which case the option is read and dropped.
+static void load_enum_option(cereal::BinaryInputArchive& ar, ConfigOptionType type,
+                             const ConfigOptionDef* def, DynamicPrintConfig* config,
+                             const CacheDictionary& dict)
+{
+    uint32_t cnt = 0;
+    ar(cnt);
+    if (type == coEnum && cnt != 1)
+        throw std::runtime_error("preset cache: a scalar enum carrying more than one value");
+    // Every element is read whatever happens, so the stream stays in sync and
+    // whatever follows this option still loads.
+    bool usable = def != nullptr && config != nullptr;
+    std::vector<int> values;
+    values.reserve(cnt);
+    for (uint32_t i = 0; i < cnt; ++ i) {
+        uint16_t idx = 0;
+        ar(idx);
+        if (! dict.valid_enum_index(idx))
+            throw std::runtime_error("preset cache: enum value index past the end of the dictionary");
+        if (idx == CacheDictionary::ENUM_UNNAMED) {
+            // An int the writer could not name — a nil, or an option whose
+            // definition carried no enum_keys_map. It travels verbatim.
+            int32_t raw = 0;
+            ar(raw);
+            values.push_back(int(raw));
+            continue;
+        }
+        if (! usable)
+            continue;             // the index above was this element's whole payload
+        if (def->enum_keys_map == nullptr) {
+            usable = false;       // this build no longer maps this option's names
+            continue;
+        }
+        const auto it = def->enum_keys_map->find(dict.enum_name_at(idx));
+        if (it == def->enum_keys_map->end()) {
+            usable = false;       // a value this build dropped: the option goes with it
+            continue;
+        }
+        values.push_back(it->second);
+    }
+    if (! usable)
+        return;
+    if (type == coEnum) {
+        config->set_key_value(def->opt_key, new ConfigOptionEnumGeneric(def->enum_keys_map, values.front()));
+    } else {
+        auto* opt = def->nullable ? static_cast<ConfigOptionInts*>(new ConfigOptionEnumsGenericNullable(def->enum_keys_map))
+                                  : static_cast<ConfigOptionInts*>(new ConfigOptionEnumsGeneric(def->enum_keys_map));
+        opt->values = std::move(values);
+        config->set_key_value(def->opt_key, opt);
+    }
+}
+
+void save_config(cereal::BinaryOutputArchive& ar, const DynamicPrintConfig& config, const CacheDictionary& dict)
+{
+    struct Written { uint16_t idx; const ConfigOptionDef* def; const ConfigOption* opt; };
+    std::vector<Written> written;
+    written.reserve(config.size());
+    for (auto it = config.cbegin(); it != config.cend(); ++ it)
+        if (const ConfigOptionDef* def = print_config_def.get(it->first))
+            written.push_back({ dict.key_index(it->first), def, it->second.get() });
+
+    ar(uint32_t(written.size()));
+    for (const Written& w : written) {
+        ar(w.idx);
+        if (w.def->type == coEnum || w.def->type == coEnums)
+            save_enum_option(ar, *w.def, w.opt, dict);
+        else
+            w.def->save_option_to_archive(ar, w.opt);
+    }
+}
+
+// `config` null means: read everything, keep nothing.
+static void read_config(cereal::BinaryInputArchive& ar, DynamicPrintConfig* config, const CacheDictionary& dict)
+{
+    uint32_t cnt = 0;
+    ar(cnt);
+    if (config != nullptr)
+        config->clear();
+    // Reused across the loop: constructing a ConfigOptionDef per dropped option
+    // would allocate its strings and vectors for nothing.
+    ConfigOptionDef scratch;
+    for (uint32_t i = 0; i < cnt; ++ i) {
+        uint16_t idx = 0;
+        ar(idx);
+        if (! dict.valid_key_index(idx))
+            throw std::runtime_error("preset cache: option index past the end of the dictionary");
+        const ConfigOptionType type = dict.type_at(idx);
+        const ConfigOptionDef* def  = dict.def_at(idx);
+        if (type == coEnum || type == coEnums) {
+            load_enum_option(ar, type, def, config, dict);
+        } else if (def != nullptr && config != nullptr) {
+            config->set_key_value(def->opt_key, def->load_option_from_archive(ar));
+        } else {
+            // Read by the type the writer recorded, then drop: the same outcome
+            // a JSON profile gets for an option this build no longer has.
+            scratch.type = type;
+            std::unique_ptr<ConfigOption> discard(scratch.load_option_from_archive(ar));
+        }
+    }
+}
+
+void load_config(cereal::BinaryInputArchive& ar, DynamicPrintConfig& config, const CacheDictionary& dict)
+{
+    read_config(ar, &config, dict);
+}
+
+void skip_config(cereal::BinaryInputArchive& ar, const CacheDictionary& dict)
+{
+    read_config(ar, nullptr, dict);
+}
+
+// ---- The per-vendor cache file (<vendor>.opc) -----------------------------
+
+namespace {
+
+#pragma pack(push, 1)
+struct CacheFileHeader {
+    uint32_t magic;
+    uint32_t version;
+    uint64_t data_size;
+    uint32_t crc32;
+};
+#pragma pack(pop)
+static_assert(sizeof(CacheFileHeader) == 20, "CacheFileHeader must be 20 bytes");
+
+constexpr uint32_t CACHE_MAGIC   = 0x4F52435A; // "ORCZ"
+// Bump when the wire format changes in a way the payload cannot describe
+// itself out of: reordering, removing or retyping a field of a hand-written
+// serialize() (VendorProfile and its nested types, CachedPreset via
+// save_entries below), or a change to the cache's own layout or the
+// meaning of its stamps. Option-schema drift is NOT such a change — the
+// dictionary handles it, which is why this no longer moves every release.
+constexpr uint32_t CACHE_VERSION = 1;
+
+// A stamp-string read that refuses an absurd length before allocating anything.
+// The stamps are read from files named from the outside (peek_version is
+// pointed at whatever <vendor>.opc a directory holds), so the length word may
+// be arbitrary bytes — and a resize to a garbage 64-bit length does not fail as
+// a catchable bad_alloc here, it takes the app down through the out-of-memory
+// handler. A vendor name or profile version is a short token; anything longer
+// is not a cache this build wrote.
+std::string read_bounded_string(cereal::BinaryInputArchive& ar)
+{
+    constexpr uint64_t MAX_STAMP_LEN = 1024;
+    cereal::size_type len = 0;
+    ar(cereal::make_size_tag(len));
+    if (uint64_t(len) > MAX_STAMP_LEN)
+        throw std::runtime_error("preset cache: string length out of bounds");
+    std::string s(size_t(len), '\0');
+    ar(cereal::binary_data(s.data(), size_t(len)));
+    return s;
+}
+
+// The prologue every cache reader starts with: the format version, then the
+// vendor's identity. Returns the vendor version stamped on a body this build can
+// read, empty on anything else — which is the same answer as "not this vendor".
+std::string read_cache_stamps(cereal::BinaryInputArchive& ar, const std::string& expected_vendor_name)
+{
+    // The version is judged before anything variable-length is read: on a body
+    // that is not a per-vendor cache of this version, the bytes where a string
+    // length would sit may be arbitrary framing.
+    uint32_t cache_version = 0;
+    ar(cache_version);
+    if (cache_version != CACHE_VERSION)
+        return {};
+    const std::string vendor_name    = read_bounded_string(ar);
+    const std::string vendor_version = read_bounded_string(ar);
+    if (vendor_name != expected_vendor_name)
+        return {};
+    return vendor_version;
+}
+
+// A cache stays usable as long as it was built from a vendor profile at least
+// as new as the one now on disk. Profiles whose version is invalid cannot be
+// judged this way and are never served from cache; where no profile sits
+// beside the cache at all, nothing can be newer than it — that state is passed
+// as Semver::inf(), which no real profile can carry (an invalid version could
+// not say it apart from "profile there but unjudgeable", and zero would
+// collide with a genuine "0.0.0"). This is the serve rule; the install rule
+// (cache_covers in PresetBundle.cpp) deliberately reads an unjudgeable profile
+// the other way, so the two are not one function.
+bool cache_covers_version(const std::string& cached, const Semver& on_disk)
+{
+    if (on_disk == Semver::inf())
+        return true;    // before parsing `cached`: nothing exists that the stamp must cover
+    if (! on_disk.valid())
+        return false;
+    const auto cached_ver = Semver::parse(cached);
+    return cached_ver && *cached_ver >= on_disk;
+}
+
+// CachedPreset on the wire: all fields, declaration order, in one place.
+// `config` writes, reads or skips the config sitting in the middle of that
+// order — the three things a reader can want to do with it — so save, load and
+// the name peek below cannot drift apart. Keep in sync with the struct in
+// PresetCacheFormat.hpp and bump CACHE_VERSION on change. Written here rather
+// than as a serialize() member because the config needs the file's dictionary,
+// which cereal cannot thread through one.
+template<class Archive, class Entry, class ConfigFn>
+void visit_entry(Archive& ar, Entry& e, ConfigFn&& config)
+{
+    ar(e.name, e.sub_path);
+    config();
+    ar(e.inherits, e.description, e.instantiation, e.setting_id, e.filament_id, e.renamed_from);
+}
+
+// The count comes from a file that has already passed magic and CRC, but a
+// reserve is a promise to allocate: cap it and let push_back grow the rest.
+constexpr uint32_t MAX_RESERVED_ENTRIES = 4096;
+
+void save_entries(cereal::BinaryOutputArchive& ar,
+                  const std::vector<CachedPreset>& entries,
+                  const CacheDictionary& dict)
+{
+    ar(uint32_t(entries.size()));
+    for (const CachedPreset& e : entries)
+        visit_entry(ar, e, [&] { save_config(ar, e.config_src, dict); });
+}
+
+void load_entries(cereal::BinaryInputArchive& ar,
+                  std::vector<CachedPreset>& entries,
+                  const CacheDictionary& dict)
+{
+    uint32_t cnt = 0;
+    ar(cnt);
+    entries.clear();
+    entries.reserve(std::min(cnt, MAX_RESERVED_ENTRIES));
+    for (uint32_t i = 0; i < cnt; ++ i) {
+        CachedPreset e;
+        visit_entry(ar, e, [&] { load_config(ar, e.config_src, dict); });
+        entries.push_back(std::move(e));
+    }
+}
+
+// Read a raw cache body: verify magic, size, CRC.
+bool read_cache_blob(const std::string& path, std::string& out_blob)
+{
+    try {
+        boost::nowide::ifstream ifs(path, std::ios::binary);
+        if (!ifs.is_open())
+            return false;
+        CacheFileHeader fhdr;
+        if (!ifs.read(reinterpret_cast<char*>(&fhdr), sizeof(fhdr)))
+            return false;
+        if (fhdr.magic != CACHE_MAGIC)
+            return false;
+        // data_size is 8 bytes from a file nothing has authenticated yet, and
+        // it is about to size an allocation. The body is the whole of the file
+        // behind the header — anything else is not a cache this build wrote.
+        ifs.seekg(0, std::ios::end);
+        const std::streamoff file_size = ifs.tellg();
+        if (file_size < std::streamoff(sizeof(fhdr)) ||
+            fhdr.data_size == 0 ||
+            fhdr.data_size != uint64_t(file_size) - sizeof(fhdr))
+            return false;
+        ifs.seekg(sizeof(fhdr), std::ios::beg);
+        out_blob.assign(fhdr.data_size, '\0');
+        if (!ifs.read(&out_blob[0], static_cast<std::streamsize>(fhdr.data_size)))
+            return false;
+        boost::crc_32_type crc;
+        crc.process_bytes(out_blob.data(), out_blob.size());
+        if (crc.checksum() != fhdr.crc32) {
+            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: CRC mismatch: " << path;
+            return false;
+        }
+        return true;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: read failed (" << path << "): " << e.what();
+        return false;
+    }
+}
+
+// Write a cache body behind the standard 20-byte file header. False when the
+// file could not be opened or written whole.
+bool write_cache_blob(const std::string& path, const std::string& blob)
+{
+    boost::crc_32_type crc;
+    crc.process_bytes(blob.data(), blob.size());
+    // Written beside the target and moved into place, as AppConfig::save does:
+    // a cache is truncated and rewritten in full, so a write that dies partway
+    // would otherwise leave a header claiming more body than the file holds.
+    // The PID suffix also keeps two instances writing the same vendor from
+    // interleaving.
+    const std::string tmp_path = path + "." + std::to_string(get_current_pid()) + ".tmp";
+    try {
+        boost::filesystem::create_directories(boost::filesystem::path(path).parent_path());
+        {
+            boost::nowide::ofstream ofs(tmp_path, std::ios::binary | std::ios::trunc);
+            if (!ofs.is_open()) {
+                BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: cannot open for writing: " << tmp_path;
+                return false;
+            }
+            CacheFileHeader fhdr;
+            fhdr.magic     = CACHE_MAGIC;
+            fhdr.version   = CACHE_VERSION;
+            fhdr.data_size = static_cast<uint64_t>(blob.size());
+            fhdr.crc32     = crc.checksum();
+            ofs.write(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
+            ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
+            ofs.close();   // flush; close() raises failbit on error
+            if (! ofs.good()) {
+                BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << tmp_path << ")";
+                boost::system::error_code ec;
+                boost::filesystem::remove(tmp_path, ec);
+                return false;
+            }
+        }
+        if (const std::error_code ec = rename_file(tmp_path, path)) {
+            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: could not move " << tmp_path << " into place: " << ec.message();
+            boost::system::error_code rm;
+            boost::filesystem::remove(tmp_path, rm);
+            return false;
+        }
+        return true;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << e.what();
+        boost::system::error_code ec;
+        boost::filesystem::remove(tmp_path, ec);
+        return false;
+    }
+}
+
+} // anonymous namespace
+
+// static
+bool VendorCacheFile::save(const std::string& path, const std::string& vendor_name,
+                           const std::string& vendor_version, const VendorCacheData& data)
+{
+    try {
+        // Collected before anything is written: the dictionary sits ahead of the
+        // entries so a reader resolves it once and then indexes.
+        CacheDictionary dict;
+        for (const std::vector<CachedPreset>* entries : { &data.process_entries, &data.filament_entries, &data.machine_entries })
+            for (const CachedPreset& e : *entries)
+                dict.collect(e.config_src);
+
+        std::ostringstream body(std::ios::binary);
+        {
+            cereal::BinaryOutputArchive ar(body);
+            ar(CACHE_VERSION);
+            ar(vendor_name, vendor_version);
+            dict.save(ar);
+            ar(data.vendors);
+            save_entries(ar, data.process_entries, dict);
+            save_entries(ar, data.filament_entries, dict);
+            save_entries(ar, data.machine_entries, dict);
+            ar(data.parse_errors);
+        }
+        return write_cache_blob(path, body.str());
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: failed to save vendor cache " << path << ": " << e.what();
+        return false;
+    }
+}
+
+// static
+bool VendorCacheFile::load(const std::string& path, const std::string& expected_vendor_name,
+                           const Semver& expected_vendor_version, VendorCacheData& data)
+{
+    std::string blob;
+    if (! read_cache_blob(path, blob))
+        return false;
+    try {
+        // Read in place: an istringstream would copy the blob once more just to
+        // stream over it.
+        boost::iostreams::stream<boost::iostreams::array_source> body(blob.data(), blob.size());
+        cereal::BinaryInputArchive ar(body);
+        const std::string vendor_version = read_cache_stamps(ar, expected_vendor_name);
+        if (vendor_version.empty() || ! cache_covers_version(vendor_version, expected_vendor_version))
+            return false;
+        CacheDictionary dict;
+        dict.load(ar);
+        ar(data.vendors);
+        load_entries(ar, data.process_entries, dict);
+        load_entries(ar, data.filament_entries, dict);
+        load_entries(ar, data.machine_entries, dict);
+        ar(data.parse_errors);
+        if (data.vendors.find(expected_vendor_name) == data.vendors.end())
+            throw std::runtime_error("vendor cache does not carry its own vendor profile");
+        return true;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: rejecting vendor cache " << path << ": " << e.what();
+        return false;
+    }
+}
+
+// static
+std::string VendorCacheFile::peek_version(const std::string& path, const std::string& expected_vendor_name)
+{
+    try {
+        boost::nowide::ifstream ifs(path, std::ios::binary);
+        CacheFileHeader fhdr;
+        if (! ifs.read(reinterpret_cast<char*>(&fhdr), sizeof(fhdr)) || fhdr.magic != CACHE_MAGIC)
+            return {};
+        // Only the head of the body is read, and its CRC left unverified: the
+        // stamps sit at the front, and this answers "what version is this?"
+        // without paying for tens of megabytes. Callers that need to know the
+        // file is whole use usable_version instead.
+        std::string head(static_cast<size_t>(std::min<uint64_t>(fhdr.data_size, 1024)), '\0');
+        if (! ifs.read(&head[0], static_cast<std::streamsize>(head.size())))
+            return {};
+        std::istringstream body(head, std::ios::binary);
+        cereal::BinaryInputArchive ar(body);
+        return read_cache_stamps(ar, expected_vendor_name);
+    } catch (const std::exception&) {
+        return {};
+    }
+}
+
+// static
+Semver VendorCacheFile::usable_version(const std::string& path, const std::string& expected_vendor_name)
+{
+    std::string blob;
+    if (! read_cache_blob(path, blob))
+        return Semver::invalid();
+    try {
+        boost::iostreams::stream<boost::iostreams::array_source> body(blob.data(), blob.size());
+        cereal::BinaryInputArchive ar(body);
+        const auto ver = Semver::parse(read_cache_stamps(ar, expected_vendor_name));
+        return ver ? *ver : Semver::invalid();
+    } catch (const std::exception&) {
+        return Semver::invalid();
+    }
+}
+
+// static
+bool VendorCacheFile::carries_preset(const std::string& path, const std::string& vendor_name,
+                                     Preset::Type type, const std::string& preset_name)
+{
+    std::string blob;
+    if (! read_cache_blob(path, blob))
+        return false;
+    try {
+        boost::iostreams::stream<boost::iostreams::array_source> body(blob.data(), blob.size());
+        cereal::BinaryInputArchive ar(body);
+        if (read_cache_stamps(ar, vendor_name).empty())
+            return false;
+        CacheDictionary dict;
+        dict.load(ar);
+        VendorMap vendors;
+        ar(vendors);
+        // Reused: every entry overwrites it, and only its name is ever looked at.
+        CachedPreset entry;
+        // Written in this order by save. The list that could carry the preset
+        // is the last one worth reading.
+        for (Preset::Type kind : { Preset::TYPE_PRINT, Preset::TYPE_FILAMENT, Preset::TYPE_PRINTER }) {
+            uint32_t cnt = 0;
+            ar(cnt);
+            for (uint32_t i = 0; i < cnt; ++ i) {
+                visit_entry(ar, entry, [&] { skip_config(ar, dict); });
+                if (kind == type && entry.name == preset_name)
+                    return true;
+            }
+            if (kind == type)
+                return false;
+        }
+        return false;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: could not read preset names from " << path << ": " << e.what();
+        return false;
+    }
+}
+
+} // namespace Slic3r

src/libslic3r/PresetCacheFormat.hpp

@@ -0,0 +1,192 @@
+#ifndef slic3r_PresetCacheFormat_hpp_
+#define slic3r_PresetCacheFormat_hpp_
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <cereal/archives/binary.hpp>
+#include <cereal/types/string.hpp>
+#include <cereal/types/vector.hpp>
+
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Preset.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Semver.hpp"
+
+namespace Slic3r {
+
+// How the preset cache writes a DynamicPrintConfig.
+//
+// Not through the global cereal hooks in PrintConfig.hpp: those key an option by
+// its serialization_key_ordinal, which ConfigDef::add assigns by declaration
+// order at static-init time. Inserting one option into the middle of
+// PrintConfig.cpp shifts every later ordinal, and the lookup on the way back in
+// then SUCCEEDS on the wrong option — where the two share a type, and hundreds
+// of coFloat/coBool/coInt options do, the bytes deserialize cleanly into the
+// wrong key. Silently wrong print settings, no error. Those hooks are also the
+// undo/redo wire format, where the process cannot change underneath them, so
+// they stay as they are and the cache keys by name instead.
+//
+// Names are not repeated per preset. Each cache file carries one dictionary of
+// the distinct opt_keys it uses, the type each was written as, and the distinct
+// enum value names; an option on the wire is then a uint16 index into it plus
+// its value. The dictionary is resolved to this build's option definitions once
+// per file, after which reading an option is a vector index.
+class CacheDictionary
+{
+public:
+    CacheDictionary();
+
+    // Index reserved in the enum table for an int the writing build could not
+    // name — a nullable option's nil, or a definition carrying no
+    // enum_keys_map. The raw int32 follows it on the wire and is loaded
+    // verbatim, so those values survive too.
+    static constexpr uint16_t ENUM_UNNAMED = 0;
+
+    // ---- writing ----
+
+    // Record every key and enum value `config` uses. Call for every config that
+    // will be written, before writing the dictionary.
+    void collect(const DynamicPrintConfig& config);
+
+    uint16_t key_index(const t_config_option_key& key) const;
+    // ENUM_UNNAMED for an empty name or one that was never collected.
+    uint16_t enum_index(const std::string& name) const;
+
+    // ---- reading ----
+
+    // The definition an index resolves to in THIS build, or nullptr where the
+    // key is unknown here or is now defined with a different type. A nullptr
+    // entry's value is still read — using type_at(idx), the type the writer
+    // recorded — and then dropped, which is what a JSON profile gets for an
+    // option this build no longer has.
+    const ConfigOptionDef* def_at(uint16_t idx) const { return m_defs[idx]; }
+    ConfigOptionType       type_at(uint16_t idx) const { return ConfigOptionType(m_types[idx]); }
+    const std::string&     enum_name_at(uint16_t idx) const { return m_enum_values[idx]; }
+    // m_defs, not m_keys: only load() sizes it, so this is false for every index
+    // on a dictionary that was collected rather than read.
+    bool valid_key_index(uint16_t idx) const { return size_t(idx) < m_defs.size(); }
+    bool valid_enum_index(uint16_t idx) const { return size_t(idx) < m_enum_values.size(); }
+
+    // The layout these two agree on is covered by CACHE_VERSION (PresetCacheFormat.cpp);
+    // bump it when they change.
+    // Throws when either table outgrew the uint16 the wire format indexes it
+    // with. Both are bounded by the option count (912 at the time of writing), so
+    // that is a build-time failure in CI, not a runtime one.
+    void save(cereal::BinaryOutputArchive& ar) const;
+    // Throws on a dictionary that cannot be indexed as written.
+    void load(cereal::BinaryInputArchive& ar);
+
+private:
+    // Indices are uint16, so a table may hold at most this many entries.
+    static constexpr size_t MAX_ENTRIES = 0xFFFF;
+
+    std::vector<std::string> m_keys;
+    // ConfigOptionType, as written. Sixteen bits, not eight: coVectorType is
+    // 0x4000, so every vector type — coFloats, coEnums, coStrings — is above
+    // 255, and a byte would fold each one onto its scalar counterpart.
+    std::vector<uint16_t>    m_types;
+    std::vector<std::string> m_enum_values;  // [ENUM_UNNAMED] is always empty
+
+    // Writing.
+    std::unordered_map<std::string, uint16_t> m_key_index;
+    std::unordered_map<std::string, uint16_t> m_enum_index;
+    // Reading, resolved once by load().
+    std::vector<const ConfigOptionDef*> m_defs;
+};
+
+// One config, keyed through `dict`. Options print_config_def does not know are
+// not written: nothing could give them a type on the way back in.
+void save_config(cereal::BinaryOutputArchive& ar, const DynamicPrintConfig& config, const CacheDictionary& dict);
+// Throws only on a payload that cannot be indexed; an option this build cannot
+// place is dropped, not fatal.
+void load_config(cereal::BinaryInputArchive& ar, DynamicPrintConfig& config, const CacheDictionary& dict);
+// Consume one config without building it, for a reader that only wants what
+// comes after.
+void skip_config(cereal::BinaryInputArchive& ar, const CacheDictionary& dict);
+
+// One preset as its JSON subfile states it: the config diff, the name of the
+// preset it inherits, and the parse metadata — everything the parse phase of
+// load_vendor_configs_from_json extracts and nothing it derives. Inheritance
+// is resolved when the entry is installed, against whatever filament library
+// is loaded then, so a cache carries no other vendor's values and no other
+// vendor's update can make it stale.
+// Written and read by visit_entry in PresetCacheFormat.cpp, which lists every
+// field below in this order — once, for the save, the load and the name peek alike.
+struct CachedPreset
+{
+    std::string              name;
+    std::string              sub_path;       // path under the vendor's directory
+    DynamicPrintConfig       config_src;     // the preset's own diff, nothing inherited
+    std::string              inherits;
+    std::string              description;
+    std::string              instantiation;  // "true"/"false" as stated; anything else was already counted as a parse error
+    std::string              setting_id;
+    std::string              filament_id;
+    std::vector<std::string> renamed_from;
+};
+
+// What one per-vendor cache file carries besides its stamps: the vendor profile
+// map, the presets in source form, and how many errors their parse counted.
+struct VendorCacheData
+{
+    VendorMap                 vendors;
+    std::vector<CachedPreset> process_entries;
+    std::vector<CachedPreset> filament_entries;
+    std::vector<CachedPreset> machine_entries;
+    uint64_t                  parse_errors = 0;
+};
+
+// A per-vendor preset cache file (<vendor>.opc): a 20-byte header (magic, format
+// version, body size, CRC) framing one cereal body — stamps (format version,
+// vendor name, vendor profile version), the option dictionary, then the
+// VendorCacheData. Everything about those bytes lives here; when a vendor is
+// served from its cache, and how entries install into a bundle, is
+// PresetBundle's business.
+class VendorCacheFile
+{
+public:
+    // Save one vendor (vendor_name at vendor_version). False when the file
+    // could not be written whole.
+    static bool save(const std::string& path, const std::string& vendor_name,
+                     const std::string& vendor_version, const VendorCacheData& data);
+
+    // Read a whole cache into `data`. False — with `data` in an unspecified
+    // state — unless the file is a cache this build wrote, its CRC holds, it
+    // names this vendor, it was built from a vendor profile at least as new as
+    // `expected_vendor_version`, and it carries its own vendor profile. An
+    // invalid expected version (a profile whose version
+    // cannot be judged) is never served from cache; Semver::inf() (no profile
+    // beside the cache at all) accepts whatever is cached.
+    static bool load(const std::string& path, const std::string& expected_vendor_name,
+                     const Semver& expected_vendor_version, VendorCacheData& data);
+
+    // Read the profile version a cache was stamped with, without deserializing
+    // its presets. Empty if the file is unreadable, not a cache this build
+    // understands, or not this vendor's. This is how an installed vendor's
+    // version is known when only its cache is installed.
+    static std::string peek_version(const std::string& path, const std::string& expected_vendor_name);
+
+    // The profile version an installed cache can actually be served at, or an
+    // invalid Semver when the file is not a cache this build can read. Unlike
+    // peek_version this verifies the body's CRC, at the cost of reading the
+    // whole file: where the cache is the vendor's whole installation, "a file
+    // is there" is not enough to call it installed, and a vendor wrongly
+    // believed installed is never repaired.
+    static Semver usable_version(const std::string& path, const std::string& expected_vendor_name);
+
+    // Whether a cache carries a preset of `type` under `preset_name`, without
+    // installing any of them. False when the file is not a cache this build can
+    // read. The three kinds are written in one stream, so reaching the machines
+    // means reading past the processes and filaments — their configs are consumed
+    // and dropped rather than built. This is how a build that ships caches instead
+    // of preset JSONs answers "which vendor carries this preset?".
+    static bool carries_preset(const std::string& path, const std::string& vendor_name,
+                               Preset::Type type, const std::string& preset_name);
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_PresetCacheFormat_hpp_

src/libslic3r/Print.cpp

@@ -5827,7 +5827,7 @@ BoundingBoxf3 PrintInstance::get_bounding_box() const {
 
 Polygon PrintInstance::get_convex_hull_2d() {
     Polygon poly = print_object->model_object()->convex_hull_2d(model_instance->get_matrix());
-    poly.douglas_peucker(0.1);
+    poly.douglas_peucker(scale_(0.1));
     return poly;
 }
 

src/libslic3r/PrintConfig.cpp

@@ -3469,9 +3469,8 @@ void PrintConfigDef::init_fff_params()
     def = this->add("sparse_infill_smooth_factor", coPercent);
     def->label = L("Sparse infill smooth factor");
     def->category = L("Strength");
-    def->tooltip = L("Controls how strongly sparse infill corners are rounded. 0% keeps the original right-angle path, "
-                     "while 100% produces the largest possible curves between adjacent infill lines. "
-                     "Currently applies only to the Hilbert Curve.");
+    def->tooltip = L("Controls how strongly sparse infill corners are rounded. 0% keeps the original sharp path, "
+                     "while 100% produces the largest possible curves between adjacent infill lines.");
     def->sidetext = "%";
     def->min = 0;
     def->max = 100;
@@ -10426,6 +10425,16 @@ int DynamicPrintConfig::update_values_from_multi_to_multi_2(const std::vector<st
 
 }
 
+void set_variant_override(ConfigOptionVectorBase &target, const ConfigOptionVectorBase &source,
+                          const std::vector<int> &variant_index, int stride)
+{
+    // A single-value object or region override applies to every nozzle variant.
+    std::vector<int> indices = variant_index;
+    if (source.size() == 1 && !source.is_nil(0))
+        std::fill(indices.begin(), indices.end(), 0);
+    target.set_to_index(&source, indices, stride);
+}
+
 
 //used for object/region config
 //use the smallest of multiple to single
@@ -11503,7 +11512,7 @@ void update_static_print_config_from_dynamic(ConfigBase& config, const DynamicPr
                 else {
                     ConfigOptionVectorBase* opt_vec_src = static_cast<ConfigOptionVectorBase*>(opt_src);
                     const ConfigOptionVectorBase* opt_vec_dest = static_cast<const ConfigOptionVectorBase*>(opt_dest);
-                    opt_vec_src->set_to_index(opt_vec_dest, variant_index, stride);
+                    set_variant_override(*opt_vec_src, *opt_vec_dest, variant_index, stride);
                 }
             }
         }

src/libslic3r/PrintConfig.hpp

@@ -146,6 +146,29 @@ inline bool is_separable_infill_pattern(InfillPattern pattern)
     }
 }
 
+// Orca: Infill patterns that round their corners by the "sparse_infill_smooth_factor" option.
+// Grid, Triangles and Tri-hexagon only do so in their trapezoidal form, which is generated with more
+// than one line per infill wall; a single line makes them plain crossing lines with nothing to round.
+inline bool is_smoothable_infill_pattern(InfillPattern pattern, int multiline = 1)
+{
+    switch (pattern) {
+    case ipHilbertCurve:
+    case ipOctagramSpiral:
+    case ipLightning:
+    case ipHoneycomb:
+    case ip3DHoneycomb:
+    case ipConcentric:
+    case ipCrossHatch:
+        return true;
+    case ipGrid:
+    case ipTriangles:
+    case ipStars:
+        return multiline > 1;
+    default:
+        return false;
+    }
+}
+
 enum class IroningType {
     NoIroning,
     TopSurfaces,
@@ -842,6 +865,9 @@ extern std::set<std::string> printer_options_with_variant_1;
 extern std::set<std::string> printer_options_with_variant_2;
 extern std::set<std::string> empty_options;
 
+void set_variant_override(ConfigOptionVectorBase &target, const ConfigOptionVectorBase &source,
+                          const std::vector<int> &variant_index, int stride = 1);
+
 extern std::set<std::string> filament_dev_options;
 
 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);
@@ -2394,6 +2420,55 @@ static void set_flush_volumes_matrix(std::vector<T> &out_matrix, const std::vect
     }
 }
 
+template<class T>
+static bool has_zero_flush_volume_for_used_filaments(const std::vector<T> &fv_matrix,
+                                                      const std::vector<T> &flush_multipliers,
+                                                      const std::vector<int> &used_filaments)
+{
+    if (used_filaments.size() < 2 || flush_multipliers.empty())
+        return false;
+
+    if (fv_matrix.size() % flush_multipliers.size() != 0)
+        return false;
+
+    const size_t matrix_len = fv_matrix.size() / flush_multipliers.size();
+    const size_t row_len    = size_t(std::sqrt(double(matrix_len)));
+    if (row_len < 2 || row_len * row_len != matrix_len)
+        return false;
+
+    std::vector<int> filtered_filaments;
+    filtered_filaments.reserve(used_filaments.size());
+    for (int filament_id : used_filaments) {
+        if (filament_id <= 0 || filament_id > int(row_len))
+            continue;
+        if (std::find(filtered_filaments.begin(), filtered_filaments.end(), filament_id) == filtered_filaments.end())
+            filtered_filaments.push_back(filament_id);
+    }
+    if (filtered_filaments.size() < 2)
+        return false;
+
+    for (T multiplier : flush_multipliers) {
+        if (multiplier == 0)
+            return true;
+    }
+
+    for (size_t nozzle_idx = 0; nozzle_idx < flush_multipliers.size(); nozzle_idx++) {
+        const size_t block_offset = nozzle_idx * matrix_len;
+        for (int from_id : filtered_filaments) {
+            for (int to_id : filtered_filaments) {
+                if (from_id == to_id)
+                    continue;
+
+                const size_t matrix_idx = block_offset + size_t(from_id - 1) * row_len + size_t(to_id - 1);
+                if (matrix_idx < fv_matrix.size() && fv_matrix[matrix_idx] == 0)
+                    return true;
+            }
+        }
+    }
+
+    return false;
+}
+
 size_t get_extruder_index(const GCodeConfig& config, unsigned int filament_id);
 
 } // namespace Slic3r
@@ -2413,7 +2488,8 @@ namespace cereal {
             archive(serialization_key_ordinal);
             assert(serialization_key_ordinal > 0);
             auto it = Slic3r::print_config_def.by_serialization_key_ordinal.find(serialization_key_ordinal);
-            assert(it != Slic3r::print_config_def.by_serialization_key_ordinal.end());
+            if (it == Slic3r::print_config_def.by_serialization_key_ordinal.end())
+                throw std::runtime_error("VendorCache: unknown serialization_key_ordinal " + std::to_string(serialization_key_ordinal) + " - cache is stale");
             config.set_key_value(it->second->opt_key, it->second->load_option_from_archive(archive));
         }
     }

src/libslic3r/PrintObject.cpp

@@ -3812,7 +3812,7 @@ static void apply_to_print_region_config(PrintRegionConfig &out, const DynamicPr
                         else {
                             ConfigOptionVectorBase* opt_vec_src = static_cast<ConfigOptionVectorBase*>(my_opt);
                             const ConfigOptionVectorBase* opt_vec_dest = static_cast<const ConfigOptionVectorBase*>(it->second.get());
-                            opt_vec_src->set_to_index(opt_vec_dest, variant_index, 1);
+                            set_variant_override(*opt_vec_src, *opt_vec_dest, variant_index);
                         }
                     }
                 }

src/libslic3r/Semver.hpp

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

src/libslic3r/Utils.hpp

@@ -3,6 +3,7 @@
 
 #include <iomanip>
 #include <locale>
+#include <set>
 #include <utility>
 #include <functional>
 #include <type_traits>
@@ -18,6 +19,7 @@
 #include <openssl/md5.h>
 
 #include "libslic3r.h"
+#include "Semver.hpp"
 
 //define CLI errors
 
@@ -722,11 +724,42 @@ void copy_directory_recursively(const boost::filesystem::path& source,
                                 std::function<bool(const std::string)> filter = nullptr,
                                 bool merge_mode                               = false);
 
-// Install vendor bundles from resources directory to data directory
-// bundle_names: vector of vendor bundle names (without .json extension)
-// resource_subdir: subdirectory under resources_dir() (default: "profiles")
-// data_subdir: subdirectory under data_dir() (default: "system")
-// Returns: true if all bundles installed successfully, false otherwise
+// ---- Vendor installation on disk ------------------------------------------
+// How a vendor bundle is installed from resources into data_dir()/system: as
+// its profile and preset JSONs or, in a build that ships preset caches, as its
+// .opc preset cache alone. Loading what is installed is PresetBundle's business;
+// the cache file format itself is VendorCacheFile's (PresetCacheFormat.hpp).
+
+// True if `vendor` is installed in data_dir()/system. A build that ships preset
+// caches installs the cache alone, so it — not the profile — marks a vendor
+// installed; a cache this build cannot read marks nothing.
+bool is_vendor_installed(const std::string& vendor);
+
+// The version the installed vendor would be loaded at: its cache's stamp while
+// that covers the profile beside it, the profile's own version once it does not.
+// Invalid Semver if neither form is installed.
+Semver installed_vendor_version(const std::string& vendor);
+
+// Remove every form `vendor` can be installed as from data_dir()/system: its
+// profile, its preset cache, and its preset directory.
+void remove_installed_vendor(const std::string& vendor);
+
+// The vendors `dir` holds, sorted: one is named by its profile or, in a build that
+// ships preset caches instead of the raw profile JSONs, by its cache alone.
+std::set<std::string> vendor_names_in(const boost::filesystem::path& dir);
+
+// The version a build ships `vendor` at: whichever of its preset cache and its
+// profile is newer, that being the one installing lays down. Invalid Semver if the
+// build ships neither.
+Semver resource_vendor_version(const std::string& vendor);
+
+// Install vendors from the resources directory into the data directory, each as
+// its preset cache or as its profile and preset JSONs — whichever of the two the
+// build ships at the newer version. Anything the previous install of that vendor
+// left behind goes, so only the form just installed is there to be loaded.
+// bundle_names: vendor names, without extension.
+// Every bundle that can be installed is, whatever the others do. Returns false
+// if any named bundle could not be installed.
 bool install_vendor_bundles_from_resources(const std::vector<std::string>& bundle_names,
                                            const std::string& resource_subdir = "profiles",
                                            const std::string& data_subdir     = "system");

src/libslic3r/utils.cpp

@@ -17,6 +17,10 @@
 #include "Platform.hpp"
 #include "Time.hpp"
 #include "libslic3r.h"
+// For the vendor-installation helpers: the vendor profile version
+// (get_version_from_json) and the preset cache stamp (VendorCacheFile).
+#include "Preset.hpp"
+#include "PresetCacheFormat.hpp"
 
 #ifdef __APPLE__
 #include "MacUtils.hpp"
@@ -1724,6 +1728,85 @@ void copy_directory_recursively(const boost::filesystem::path& source,
     return;
 }
 
+// ---- Vendor installation on disk ------------------------------------------
+
+// Whether a cache stamped `cache_ver` still speaks for a vendor whose profile on
+// disk claims `profile_ver`: it does unless the profile has moved ahead of it. A
+// profile that is missing or carries no judgeable version cannot be ahead of
+// anything. The one rule behind both "which form gets installed" and "which form
+// is installed"; they must not drift apart. Deliberately NOT the serve rule
+// (VendorCacheFile::load), which refuses an unjudgeable profile instead.
+static bool cache_covers(const Semver& cache_ver, const Semver& profile_ver)
+{
+    return cache_ver.valid() && (! profile_ver.valid() || cache_ver >= profile_ver);
+}
+
+bool is_vendor_installed(const std::string& vendor)
+{
+    const boost::filesystem::path dir = boost::filesystem::path(data_dir()) / PRESET_SYSTEM_DIR;
+    // A cache is the whole of a cache-only installation, so a file this build
+    // cannot serve the vendor from is not an installation. Left counted as one,
+    // the updater would never lay a working copy down.
+    return boost::filesystem::exists(dir / (vendor + ".json"))
+        || VendorCacheFile::usable_version((dir / (vendor + ".opc")).string(), vendor).valid();
+}
+
+Semver installed_vendor_version(const std::string& vendor)
+{
+    const boost::filesystem::path dir  = boost::filesystem::path(data_dir()) / PRESET_SYSTEM_DIR;
+    const boost::filesystem::path json = dir / (vendor + ".json");
+    // Guarded: get_version_from_json logs an error and throws-and-catches its way
+    // to an invalid version on a file that is not there, and a cache-only vendor
+    // never has one.
+    const Semver from_json  = boost::filesystem::exists(json) ? get_version_from_json(json.string()) : Semver();
+    const Semver from_cache = VendorCacheFile::usable_version((dir / (vendor + ".opc")).string(), vendor);
+    // Whichever form a load would serve.
+    return cache_covers(from_cache, from_json) ? from_cache : from_json;
+}
+
+void remove_installed_vendor(const std::string& vendor)
+{
+    const boost::filesystem::path dir = boost::filesystem::path(data_dir()) / PRESET_SYSTEM_DIR;
+    boost::filesystem::remove(dir / (vendor + ".json"));
+    boost::filesystem::remove(dir / (vendor + ".opc"));
+    if (boost::filesystem::exists(dir / vendor))
+        boost::filesystem::remove_all(dir / vendor);
+}
+
+std::set<std::string> vendor_names_in(const boost::filesystem::path& dir)
+{
+    std::set<std::string> names;
+    for (auto& dir_entry : boost::filesystem::directory_iterator(dir)) {
+        const auto& path = dir_entry.path();
+        if (Slic3r::is_json_file(path.string()) || path.extension() == ".opc")
+            names.insert(path.stem().string());
+    }
+    return names;
+}
+
+// A vendor's preset cache is the whole of its installation: it carries the presets,
+// the vendor profile and the version they were built at, so where one ships nothing
+// else needs copying. Unless the profile beside it claims a newer version — a cache
+// generated before that profile was bumped is out of date, and a cache that cannot
+// be read is no installation at all — and the vendor is installed the way it was
+// before caches existed, as its profile and the preset JSONs it points at. Returns
+// the version the cache is stamped with, invalid when it is not the form to install.
+static Semver installable_cache_version(const boost::filesystem::path& dir, const std::string& vendor)
+{
+    const auto cache_ver = Semver::parse(VendorCacheFile::peek_version((dir / (vendor + ".opc")).string(), vendor));
+    if (! cache_ver)
+        return Semver::invalid();
+    const Semver profile_ver = get_version_from_json((dir / (vendor + ".json")).string());
+    return cache_covers(*cache_ver, profile_ver) ? *cache_ver : Semver::invalid();
+}
+
+Semver resource_vendor_version(const std::string& vendor)
+{
+    const boost::filesystem::path dir = boost::filesystem::path(resources_dir()) / "profiles";
+    const Semver ver = installable_cache_version(dir, vendor);
+    return ver.valid() ? ver : get_version_from_json((dir / (vendor + ".json")).string());
+}
+
 bool install_vendor_bundles_from_resources(
     const std::vector<std::string>& bundle_names,
     const std::string& resource_subdir,
@@ -1736,37 +1819,82 @@ bool install_vendor_bundles_from_resources(
 
     BOOST_LOG_TRIVIAL(info) << "Installing " << bundle_names.size() << " bundles from resources...";
 
+    // One vendor that cannot be installed is one vendor missing, not a reason to
+    // leave the rest uninstalled. The caller is told, and every bundle that can
+    // be laid down is.
+    bool all_installed = true;
+
     for (const auto &bundle : bundle_names) {
         try {
+            if (bundle.empty()) {
+                BOOST_LOG_TRIVIAL(warning) << "Refusing to install a bundle with no name";
+                all_installed = false;
+                continue;
+            }
+
             // Install the JSON file
             auto path_in_rsrc = (rsrc_path / bundle).replace_extension(".json");
             auto path_in_vendors = (vendor_path / bundle).replace_extension(".json");
+            auto cache_in_rsrc = (rsrc_path / bundle).replace_extension(".opc");
+            auto cache_in_vendors = (vendor_path / bundle).replace_extension(".opc");
 
-            if (!fs::exists(path_in_rsrc)) {
+            // Either form of the vendor will do: a build may ship it as a cache alone.
+            if (!fs::exists(path_in_rsrc) && !fs::exists(cache_in_rsrc)) {
                 BOOST_LOG_TRIVIAL(warning) << "Bundle not found in resources: " << bundle;
-                return false;
+                all_installed = false;
+                continue;
             }
 
             // Create target directory if needed
             if (!fs::exists(vendor_path))
                 fs::create_directories(vendor_path);
 
-            // Copy JSON file
             std::string error_message;
-            CopyFileResult cfr = copy_file(path_in_rsrc.string(), path_in_vendors.string(), error_message, false);
-            if (cfr != CopyFileResult::SUCCESS) {
-                BOOST_LOG_TRIVIAL(error) << "Failed to copy " << bundle << ".json: " << error_message;
-                return false;
+            bool installed_cache = false;
+            if (installable_cache_version(rsrc_path, bundle).valid()) {
+                installed_cache = copy_file(cache_in_rsrc.string(), cache_in_vendors.string(), error_message, false) == CopyFileResult::SUCCESS;
+                if (! installed_cache) {
+                    BOOST_LOG_TRIVIAL(warning) << "Failed to copy " << bundle << ".opc: " << error_message;
+                } else if (! VendorCacheFile::usable_version(cache_in_vendors.string(), bundle).valid()) {
+                    // The copy is what will be loaded, so it — not the kilobyte
+                    // peek that chose this form — decides whether the profile
+                    // beside it can go.
+                    BOOST_LOG_TRIVIAL(warning) << "Installed cache for " << bundle << " cannot be read; installing its profile instead";
+                    boost::system::error_code ec;
+                    fs::remove(cache_in_vendors, ec);
+                    installed_cache = false;
+                }
+            }
+
+            if (! installed_cache) {
+                CopyFileResult cfr = copy_file(path_in_rsrc.string(), path_in_vendors.string(), error_message, false);
+                if (cfr != CopyFileResult::SUCCESS) {
+                    BOOST_LOG_TRIVIAL(error) << "Failed to copy " << bundle << ".json: " << error_message;
+                    all_installed = false;
+                    continue;
+                }
+                // Only now: an earlier install's cache would shadow this profile,
+                // but removing it before the profile lands would leave neither.
+                boost::system::error_code ec;
+                fs::remove(cache_in_vendors, ec);
+            } else {
+                // Left in place, an earlier install's profile would shadow the cache.
+                boost::system::error_code ec;
+                fs::remove(path_in_vendors, ec);
+                if (ec)
+                    BOOST_LOG_TRIVIAL(warning) << "Could not remove the superseded profile " << path_in_vendors.string() << ": " << ec.message();
             }
 
             // Copy the vendor directory (if it exists)
             auto dir_in_rsrc = rsrc_path / bundle;
             auto dir_in_vendors = vendor_path / bundle;
 
-            if (fs::exists(dir_in_rsrc) && fs::is_directory(dir_in_rsrc)) {
-                // Remove existing directory
-                if (fs::exists(dir_in_vendors))
-                    fs::remove_all(dir_in_vendors);
+            // Whatever is installed came from an earlier version of this vendor and
+            // would be parsed in place of the one being installed now.
+            if (fs::exists(dir_in_vendors))
+                fs::remove_all(dir_in_vendors);
+
+            if (! installed_cache && fs::exists(dir_in_rsrc) && fs::is_directory(dir_in_rsrc)) {
                 fs::create_directories(dir_in_vendors);
 
                 // Copy with file filter (same as PresetUpdater::install_bundles_rsrc)
@@ -1787,11 +1915,11 @@ bool install_vendor_bundles_from_resources(
 
         } catch (const std::exception& e) {
             BOOST_LOG_TRIVIAL(error) << "Exception installing bundle " << bundle << ": " << e.what();
-            return false;
+            all_installed = false;
         }
     }
 
-    return true;
+    return all_installed;
 }
 
 void save_string_file(const boost::filesystem::path& p, const std::string& str)