diff --git a/deps/OpenVDB/OpenVDB.cmake b/deps/OpenVDB/OpenVDB.cmake
index d83cb5b074..f581f6f34e 100644
--- a/deps/OpenVDB/OpenVDB.cmake
+++ b/deps/OpenVDB/OpenVDB.cmake
@@ -6,6 +6,13 @@ else()
     set(_build_static ON)
 endif()
 
+set (_openvdb_vdbprint ON)
+if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
+    # Build fails on raspberry pi due to missing link directive to latomic
+    # Let's hope it will be fixed soon.
+    set (_openvdb_vdbprint OFF)
+endif ()
+
 prusaslicer_add_cmake_project(OpenVDB
     # 8.2 patched
     URL https://github.com/tamasmeszaros/openvdb/archive/a68fd58d0e2b85f01adeb8b13d7555183ab10aa5.zip
@@ -19,7 +26,7 @@ prusaslicer_add_cmake_project(OpenVDB
         -DOPENVDB_CORE_STATIC=${_build_static}
         -DOPENVDB_ENABLE_RPATH:BOOL=OFF
         -DTBB_STATIC=${_build_static}
-        -DOPENVDB_BUILD_VDB_PRINT=ON
+        -DOPENVDB_BUILD_VDB_PRINT=${_openvdb_vdbprint}
         -DDISABLE_DEPENDENCY_VERSION_CHECKS=ON # Centos6 has old zlib
 )
 
diff --git a/src/libslic3r/Arrange.cpp b/src/libslic3r/Arrange.cpp
index 8124b23e3e..8227ea4ad6 100644
--- a/src/libslic3r/Arrange.cpp
+++ b/src/libslic3r/Arrange.cpp
@@ -581,11 +581,6 @@ static void process_arrangeable(const ArrangePolygon &arrpoly,
     const Vec2crd &offs     = arrpoly.translation;
     double         rotation = arrpoly.rotation;
 
-    // This fixes:
-    // https://github.com/prusa3d/PrusaSlicer/issues/2209
-    if (p.points.size() < 3)
-        return;
-
     outp.emplace_back(std::move(p));
     outp.back().rotation(rotation);
     outp.back().translation({offs.x(), offs.y()});
diff --git a/src/libslic3r/Format/SL1.cpp b/src/libslic3r/Format/SL1.cpp
index df10ce0465..2f324accda 100644
--- a/src/libslic3r/Format/SL1.cpp
+++ b/src/libslic3r/Format/SL1.cpp
@@ -503,21 +503,19 @@ static void write_thumbnail(Zipper &zipper, const ThumbnailData &data)
     }
 }
 
-void SL1Archive::export_print(const std::string     fname,
+void SL1Archive::export_print(Zipper               &zipper,
                               const SLAPrint       &print,
                               const ThumbnailsList &thumbnails,
                               const std::string    &prjname)
 {
-    Zipper zipper{fname};
-
     std::string project =
         prjname.empty() ?
             boost::filesystem::path(zipper.get_filename()).stem().string() :
             prjname;
-    
+
     ConfMap iniconf, slicerconf;
     fill_iniconf(iniconf, print);
-    
+
     iniconf["jobDir"] = project;
 
     fill_slicerconf(slicerconf, print);
@@ -527,13 +525,13 @@ void SL1Archive::export_print(const std::string     fname,
         zipper << to_ini(iniconf);
         zipper.add_entry("prusaslicer.ini");
         zipper << to_ini(slicerconf);
-        
+
         size_t i = 0;
         for (const sla::EncodedRaster &rst : m_layers) {
 
             std::string imgname = project + string_printf("%.5d", i++) + "." +
                                   rst.extension();
-            
+
             zipper.add_entry(imgname.c_str(), rst.data(), rst.size());
         }
 
@@ -549,4 +547,14 @@ void SL1Archive::export_print(const std::string     fname,
     }
 }
 
+void SL1Archive::export_print(const std::string     fname,
+                              const SLAPrint       &print,
+                              const ThumbnailsList &thumbnails,
+                              const std::string    &prjname)
+{
+    Zipper zipper{fname, Zipper::FAST_COMPRESSION};
+
+    export_print(zipper, print, thumbnails, prjname);
+}
+
 } // namespace Slic3r
diff --git a/src/libslic3r/Format/SL1.hpp b/src/libslic3r/Format/SL1.hpp
index 493550db4b..0a662cc1e0 100644
--- a/src/libslic3r/Format/SL1.hpp
+++ b/src/libslic3r/Format/SL1.hpp
@@ -22,8 +22,13 @@ protected:
     SLAPrinterConfig & cfg() { return m_cfg; }
     const SLAPrinterConfig & cfg() const { return m_cfg; }
 
+    void export_print(Zipper &,
+                      const SLAPrint       &print,
+                      const ThumbnailsList &thumbnails,
+                      const std::string    &projectname);
+
 public:
-    
+
     SL1Archive() = default;
     explicit SL1Archive(const SLAPrinterConfig &cfg): m_cfg(cfg) {}
     explicit SL1Archive(SLAPrinterConfig &&cfg): m_cfg(std::move(cfg)) {}
diff --git a/src/libslic3r/Format/SL1_SVG.cpp b/src/libslic3r/Format/SL1_SVG.cpp
index 372348283a..d138a72ba8 100644
--- a/src/libslic3r/Format/SL1_SVG.cpp
+++ b/src/libslic3r/Format/SL1_SVG.cpp
@@ -224,4 +224,14 @@ sla::RasterEncoder SL1_SVGArchive::get_encoder() const
     return nullptr;
 }
 
+void SL1_SVGArchive::export_print(const std::string     fname,
+                                  const SLAPrint       &print,
+                                  const ThumbnailsList &thumbnails,
+                                  const std::string    &projectname)
+{
+    Zipper zipper{fname, Zipper::TIGHT_COMPRESSION};
+
+    SL1Archive::export_print(zipper, print, thumbnails, projectname);
+}
+
 } // namespace Slic3r
diff --git a/src/libslic3r/Format/SL1_SVG.hpp b/src/libslic3r/Format/SL1_SVG.hpp
index a3afbcdfff..a764f1a4c0 100644
--- a/src/libslic3r/Format/SL1_SVG.hpp
+++ b/src/libslic3r/Format/SL1_SVG.hpp
@@ -14,6 +14,11 @@ protected:
 
 public:
 
+    void export_print(const std::string     fname,
+                      const SLAPrint       &print,
+                      const ThumbnailsList &thumbnails,
+                      const std::string    &projectname = "") override;
+
     using SL1Archive::SL1Archive;
 };
 
diff --git a/src/libslic3r/Model.hpp b/src/libslic3r/Model.hpp
index 387ffce88e..d2609c6709 100644
--- a/src/libslic3r/Model.hpp
+++ b/src/libslic3r/Model.hpp
@@ -816,8 +816,7 @@ private:
     }
     // Providing a new mesh, therefore this volume will get a new unique ID assigned.
     ModelVolume(ModelObject *object, const ModelVolume &other, TriangleMesh &&mesh) :
-        name(other.name), source(other.source), m_mesh(new TriangleMesh(std::move(mesh))), 
-        config(other.config), m_type(other.m_type), object(object), m_transformation(other.m_transformation),
+        name(other.name), source(other.source), config(other.config), object(object), m_mesh(new TriangleMesh(std::move(mesh))), m_type(other.m_type), m_transformation(other.m_transformation),
         text_configuration(other.text_configuration)
     {
 		assert(this->id().valid()); 
@@ -833,7 +832,7 @@ private:
         assert(this->config.id() == other.config.id());
         this->set_material_id(other.material_id());
         this->config.set_new_unique_id();
-        if (mesh.facets_count() > 1)
+        if (m_mesh->facets_count() > 1)
             calculate_convex_hull();
 		assert(this->config.id().valid()); 
         assert(this->config.id() != other.config.id()); 
diff --git a/src/libslic3r/Technologies.hpp b/src/libslic3r/Technologies.hpp
index 59352e7ef0..0cd9b8b6e4 100644
--- a/src/libslic3r/Technologies.hpp
+++ b/src/libslic3r/Technologies.hpp
@@ -89,6 +89,8 @@
 #define ENABLE_PROCESS_G2_G3_LINES (1 && ENABLE_2_5_0_ALPHA1)
 // Enable fix of used filament data exported to gcode file
 #define ENABLE_USED_FILAMENT_POST_PROCESS (1 && ENABLE_2_5_0_ALPHA1)
+// Enable gizmo grabbers to share common models
+#define ENABLE_GIZMO_GRABBER_REFACTOR (1 && ENABLE_2_5_0_ALPHA1)
 
 
 #endif // _prusaslicer_technologies_h_
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp b/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
index 55e8cd1626..456357948e 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
@@ -18,10 +18,19 @@ const float GLGizmoBase::Grabber::SizeFactor = 0.05f;
 const float GLGizmoBase::Grabber::MinHalfSize = 1.5f;
 const float GLGizmoBase::Grabber::DraggingScaleFactor = 1.25f;
 
-void GLGizmoBase::Grabber::render(bool hover, float size)
-{
-    render(size, hover ? complementary(color) : color, false);
-}
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+GLModel GLGizmoBase::Grabber::s_cube;
+GLModel GLGizmoBase::Grabber::s_cone;
+
+GLGizmoBase::Grabber::~Grabber()
+{
+    if (s_cube.is_initialized())
+        s_cube.reset();
+
+    if (s_cone.is_initialized())
+        s_cone.reset();
+}
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 
 float GLGizmoBase::Grabber::get_half_size(float size) const
 {
@@ -41,29 +50,64 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
         return;
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
-    if (!m_cube.is_initialized()) {
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    if (!s_cube.is_initialized()) {
+#else
+    if (!m_cube.is_initialized()) {
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
         // This cannot be done in constructor, OpenGL is not yet
         // initialized at that point (on Linux at least).
-        indexed_triangle_set its = its_make_cube(1., 1., 1.);
+        indexed_triangle_set its = its_make_cube(1.0, 1.0, 1.0);
         its_translate(its, -0.5f * Vec3f::Ones());
-#if ENABLE_LEGACY_OPENGL_REMOVAL
-        m_cube.init_from(its);
-#else
-        m_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } });
+#if ENABLE_LEGACY_OPENGL_REMOVAL
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+        s_cube.init_from(its);
+#else
+        m_cube.init_from(its);
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
+#else
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+        s_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } });
+#else
+        m_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } });
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
     }
 
-    const float fullsize = 2.0f * (dragging ? get_dragging_half_size(size) : get_half_size(size));
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    if (!s_cone.is_initialized())
+        s_cone.init_from(its_make_cone(0.375, 1.5, double(PI) / 18.0));
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
+
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    const float half_size = dragging ? get_dragging_half_size(size) : get_half_size(size);
+#else
+    const float fullsize = 2.0f * (dragging ? get_dragging_half_size(size) : get_half_size(size));
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 
-#if ENABLE_LEGACY_OPENGL_REMOVAL
-    m_cube.set_color(render_color);
-#else
-    m_cube.set_color(-1, render_color);
+#if ENABLE_LEGACY_OPENGL_REMOVAL
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    s_cube.set_color(render_color);
+    s_cone.set_color(render_color);
+#else
+    m_cube.set_color(render_color);
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
+#else
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    s_cube.set_color(-1, render_color);
+    s_cone.set_color(-1, render_color);
+#else
+    m_cube.set_color(-1, render_color);
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, 2.0 * half_size * Vec3d::Ones());
+#else
+    const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
     const Transform3d& projection_matrix = camera.get_projection_matrix();
  
     shader->set_uniform("view_model_matrix", view_model_matrix);
@@ -75,9 +119,86 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
     glsafe(::glRotated(Geometry::rad2deg(angles.z()), 0.0, 0.0, 1.0));
     glsafe(::glRotated(Geometry::rad2deg(angles.y()), 0.0, 1.0, 0.0));
     glsafe(::glRotated(Geometry::rad2deg(angles.x()), 1.0, 0.0, 0.0));
-    glsafe(::glScaled(fullsize, fullsize, fullsize));
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    glsafe(::glScaled(2.0 * half_size, 2.0 * half_size, 2.0 * half_size));
+#else
+    glsafe(::glScaled(fullsize, fullsize, fullsize));
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
-    m_cube.render();
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    s_cube.render();
+
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) {
+        shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitX(), Vec3d(0.0, 0.5 * double(PI), 0.0)));
+        s_cone.render();
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegX)) != 0) {
+        shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitX(), Vec3d(0.0, -0.5 * double(PI), 0.0)));
+        s_cone.render();
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosY)) != 0) {
+        shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitY(), Vec3d(-0.5 * double(PI), 0.0, 0.0)));
+        s_cone.render();
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegY)) != 0) {
+        shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitY(), Vec3d(0.5 * double(PI), 0.0, 0.0)));
+        s_cone.render();
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosZ)) != 0) {
+        shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitZ()));
+        s_cone.render();
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegZ)) != 0) {
+        shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitZ(), Vec3d(double(PI), 0.0, 0.0)));
+        s_cone.render();
+    }
+#else
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) {
+        glsafe(::glPushMatrix());
+        glsafe(::glTranslated(1.0, 0.0, 0.0));
+        glsafe(::glRotated(0.5 * Geometry::rad2deg(double(PI)), 0.0, 1.0, 0.0));
+        s_cone.render();
+        glsafe(::glPopMatrix());
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegX)) != 0) {
+        glsafe(::glPushMatrix());
+        glsafe(::glTranslated(-1.0, 0.0, 0.0));
+        glsafe(::glRotated(-0.5 * Geometry::rad2deg(double(PI)), 0.0, 1.0, 0.0));
+        s_cone.render();
+        glsafe(::glPopMatrix());
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosY)) != 0) {
+        glsafe(::glPushMatrix());
+        glsafe(::glTranslated(0.0, 1.0, 0.0));
+        glsafe(::glRotated(-0.5 * Geometry::rad2deg(double(PI)), 1.0, 0.0, 0.0));
+        s_cone.render();
+        glsafe(::glPopMatrix());
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegY)) != 0) {
+        glsafe(::glPushMatrix());
+        glsafe(::glTranslated(0.0, -1.0, 0.0));
+        glsafe(::glRotated(0.5 * Geometry::rad2deg(double(PI)), 1.0, 0.0, 0.0));
+        s_cone.render();
+        glsafe(::glPopMatrix());
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosZ)) != 0) {
+        glsafe(::glPushMatrix());
+        glsafe(::glTranslated(0.0, 0.0, 1.0));
+        s_cone.render();
+        glsafe(::glPopMatrix());
+    }
+    if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegZ)) != 0) {
+        glsafe(::glPushMatrix());
+        glsafe(::glTranslated(0.0, 0.0, -1.0));
+        glsafe(::glRotated(Geometry::rad2deg(double(PI)), 1.0, 0.0, 0.0));
+        s_cone.render();
+        glsafe(::glPopMatrix());
+    }
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
+#else
+    m_cube.render();
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
     glsafe(::glPopMatrix());
 #endif // !ENABLE_GL_SHADERS_ATTRIBUTES
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp b/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
index b4276e16b7..6196c7a73c 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
@@ -38,6 +38,19 @@ public:
     // (254 is choosen to leave some space for forward compatibility)
     static const unsigned int BASE_ID = 255 * 255 * 254;
 
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    enum class EGrabberExtension
+    {
+        None = 0,
+        PosX = 1 << 0,
+        NegX = 1 << 1,
+        PosY = 1 << 2,
+        NegY = 1 << 3,
+        PosZ = 1 << 4,
+        NegZ = 1 << 5,
+    };
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
+
     // Represents NO key(button on keyboard) value
     static const int NO_SHORTCUT_KEY_VALUE = 0;
 
@@ -56,10 +69,16 @@ protected:
         Transform3d matrix{ Transform3d::Identity() };
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
         ColorRGBA color{ ColorRGBA::WHITE() };
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+        EGrabberExtension extensions{ EGrabberExtension::None };
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 
         Grabber() = default;
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+        ~Grabber();
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
 
-        void render(bool hover, float size);
+        void render(bool hover, float size) { render(size, hover ? complementary(color) : color, false); }
         void render_for_picking(float size) { render(size, color, true); }
 
         float get_half_size(float size) const;
@@ -68,7 +87,12 @@ protected:
     private:
         void render(float size, const ColorRGBA& render_color, bool picking);
 
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+        static GLModel s_cube;
+        static GLModel s_cone;
+#else
         GLModel m_cube;
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
     };
 
 public:
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp b/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
index 5a14ae651c..1a081328ed 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
@@ -54,15 +54,25 @@ bool GLGizmoMove3D::on_mouse(const wxMouseEvent &mouse_event) {
 }
 
 void GLGizmoMove3D::data_changed() {
-    m_grabbers[2].enabled = !m_parent.get_selection().is_wipe_tower();
+    const Selection& selection = m_parent.get_selection();
+    bool is_wipe_tower = selection.is_wipe_tower();
+    m_grabbers[2].enabled = !is_wipe_tower;
 }
 
 bool GLGizmoMove3D::on_init()
 {
     for (int i = 0; i < 3; ++i) {
         m_grabbers.push_back(Grabber());
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+        m_grabbers.back().extensions = GLGizmoBase::EGrabberExtension::PosZ;
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
     }
 
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    m_grabbers[0].angles = { 0.0, 0.5 * double(PI), 0.0 };
+    m_grabbers[1].angles = { -0.5 * double(PI), 0.0, 0.0 };
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
+
     m_shortcut_key = WXK_CONTROL_M;
 
     return true;
@@ -133,8 +143,10 @@ void GLGizmoMove3D::on_dragging(const UpdateData& data)
 
 void GLGizmoMove3D::on_render()
 {
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     if (!m_cone.is_initialized())
         m_cone.init_from(its_make_cone(1.0, 1.0, double(PI) / 18.0));
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 
     glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
     glsafe(::glEnable(GL_DEPTH_TEST));
@@ -268,6 +280,7 @@ void GLGizmoMove3D::on_render()
         // draw grabbers
 #if ENABLE_WORLD_COORDINATE
         render_grabbers(m_bounding_box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
         for (unsigned int i = 0; i < 3; ++i) {
             if (m_grabbers[i].enabled)
 #if ENABLE_GL_SHADERS_ATTRIBUTES
@@ -276,12 +289,15 @@ void GLGizmoMove3D::on_render()
                 render_grabber_extension((Axis)i, m_bounding_box, false);
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
         }
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #else
         render_grabbers(box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
         for (unsigned int i = 0; i < 3; ++i) {
             if (m_grabbers[i].enabled)
                 render_grabber_extension((Axis)i, box, false);
         }
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_WORLD_COORDINATE
     }
     else {
@@ -328,6 +344,7 @@ void GLGizmoMove3D::on_render()
             m_grabbers[m_hover_id].render(true, mean_size);
             shader->stop_using();
         }
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
 #if ENABLE_WORLD_COORDINATE
 #if ENABLE_GL_SHADERS_ATTRIBUTES
         render_grabber_extension((Axis)m_hover_id, base_matrix, m_bounding_box, false);
@@ -337,6 +354,7 @@ void GLGizmoMove3D::on_render()
 #else
         render_grabber_extension((Axis)m_hover_id, box, false);
 #endif // ENABLE_WORLD_COORDINATE
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
     }
 
 #if ENABLE_WORLD_COORDINATE
@@ -362,21 +380,27 @@ void GLGizmoMove3D::on_render_for_picking()
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
     render_grabbers_for_picking(m_bounding_box);
 #if ENABLE_GL_SHADERS_ATTRIBUTES
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(X, base_matrix, m_bounding_box, true);
     render_grabber_extension(Y, base_matrix, m_bounding_box, true);
     render_grabber_extension(Z, base_matrix, m_bounding_box, true);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #else
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(X, m_bounding_box, true);
     render_grabber_extension(Y, m_bounding_box, true);
     render_grabber_extension(Z, m_bounding_box, true);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
     glsafe(::glPopMatrix());
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 #else
     const BoundingBoxf3& box = m_parent.get_selection().get_bounding_box();
     render_grabbers_for_picking(box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(X, box, true);
     render_grabber_extension(Y, box, true);
     render_grabber_extension(Z, box, true);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_WORLD_COORDINATE
 }
 
@@ -406,6 +430,7 @@ double GLGizmoMove3D::calc_projection(const UpdateData& data) const
     return projection;
 }
 
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
 #if ENABLE_WORLD_COORDINATE && ENABLE_GL_SHADERS_ATTRIBUTES
 void GLGizmoMove3D::render_grabber_extension(Axis axis, const Transform3d& base_matrix, const BoundingBoxf3& box, bool picking)
 #else
@@ -469,6 +494,7 @@ void GLGizmoMove3D::render_grabber_extension(Axis axis, const BoundingBoxf3& box
 #endif // !ENABLE_LEGACY_OPENGL_REMOVAL
         shader->stop_using();
 }
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 
 #if ENABLE_WORLD_COORDINATE
 #if ENABLE_GL_SHADERS_ATTRIBUTES
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp b/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp
index aefecc9367..199618f3d1 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp
@@ -25,7 +25,9 @@ class GLGizmoMove3D : public GLGizmoBase
     Vec3d m_starting_box_center{ Vec3d::Zero() };
     Vec3d m_starting_box_bottom_center{ Vec3d::Zero() };
 
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     GLModel m_cone;
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #if ENABLE_LEGACY_OPENGL_REMOVAL
     struct GrabberConnection
     {
@@ -75,11 +77,13 @@ private:
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
     void calc_selection_box_and_center();
 #endif // ENABLE_WORLD_COORDINATE
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
 #if ENABLE_WORLD_COORDINATE && ENABLE_GL_SHADERS_ATTRIBUTES
     void render_grabber_extension(Axis axis, const Transform3d& base_matrix, const BoundingBoxf3& box, bool picking);
 #else
     void render_grabber_extension(Axis axis, const BoundingBoxf3& box, bool picking);
 #endif // ENABLE_WORLD_COORDINATE && ENABLE_GL_SHADERS_ATTRIBUTES
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 };
 
 
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp b/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
index 16e0f23b16..61608c6ad0 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
@@ -94,6 +94,9 @@ void GLGizmoRotate::disable_grabber() { m_grabbers[0].enabled = false; }
 bool GLGizmoRotate::on_init()
 {
     m_grabbers.push_back(Grabber());
+#if ENABLE_GIZMO_GRABBER_REFACTOR
+    m_grabbers.back().extensions = (GLGizmoBase::EGrabberExtension)(int(GLGizmoBase::EGrabberExtension::PosY) | int(GLGizmoBase::EGrabberExtension::NegY));
+#endif // ENABLE_GIZMO_GRABBER_REFACTOR
     return true;
 }
 
@@ -149,15 +152,17 @@ void GLGizmoRotate::on_render()
     if (!m_grabbers.front().enabled)
         return;
 
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     if (!m_cone.is_initialized())
         m_cone.init_from(its_make_cone(1.0, 1.0, double(PI) / 12.0));
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 
     const Selection& selection = m_parent.get_selection();
 #if !ENABLE_WORLD_COORDINATE
     const BoundingBoxf3& box = selection.get_bounding_box();
 #endif // !ENABLE_WORLD_COORDINATE
 
-    if (m_hover_id != 0 && !m_grabbers[0].dragging) {
+    if (m_hover_id != 0 && !m_grabbers.front().dragging) {
 #if ENABLE_WORLD_COORDINATE
         init_data_from_selection(selection);
 #else
@@ -233,10 +238,14 @@ void GLGizmoRotate::on_render()
 
 #if ENABLE_WORLD_COORDINATE
     render_grabber(m_bounding_box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(m_bounding_box, false);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #else
     render_grabber(box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(box, false);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_WORLD_COORDINATE
 
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
@@ -259,11 +268,15 @@ void GLGizmoRotate::on_render_for_picking()
 
 #if ENABLE_WORLD_COORDINATE
     render_grabbers_for_picking(m_bounding_box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(m_bounding_box, true);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #else
     const BoundingBoxf3& box = selection.get_bounding_box();
     render_grabbers_for_picking(box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     render_grabber_extension(box, true);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #endif // ENABLE_WORLD_COORDINATE
 
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
@@ -632,6 +645,7 @@ void GLGizmoRotate::render_grabber(const BoundingBoxf3& box)
     render_grabbers(box);
 }
 
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
 void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool picking)
 {
     const float mean_size = float((box.size().x() + box.size().y() + box.size().z()) / 3.0);
@@ -706,6 +720,7 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
 #endif // !ENABLE_LEGACY_OPENGL_REMOVAL
         shader->stop_using();
 }
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
 Transform3d GLGizmoRotate::local_transform(const Selection& selection) const
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp b/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp
index 7f8c867e92..7ab7631496 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp
@@ -29,17 +29,19 @@ private:
     Axis m_axis;
     double m_angle{ 0.0 };
     Vec3d m_center{ Vec3d::Zero() };
-    float m_radius{ 0.0 };
-    float m_snap_coarse_in_radius{ 0.0 };
-    float m_snap_coarse_out_radius{ 0.0 };
-    float m_snap_fine_in_radius{ 0.0 };
-    float m_snap_fine_out_radius{ 0.0 };
+    float m_radius{ 0.0f };
+    float m_snap_coarse_in_radius{ 0.0f };
+    float m_snap_coarse_out_radius{ 0.0f };
+    float m_snap_fine_in_radius{ 0.0f };
+    float m_snap_fine_out_radius{ 0.0f };
 #if ENABLE_WORLD_COORDINATE
     BoundingBoxf3 m_bounding_box;
     Transform3d m_orient_matrix{ Transform3d::Identity() };
 #endif // ENABLE_WORLD_COORDINATE
 
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     GLModel m_cone;
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 #if ENABLE_LEGACY_OPENGL_REMOVAL
     GLModel m_circle;
     GLModel m_scale;
@@ -59,6 +61,7 @@ private:
 
     ColorRGBA m_drag_color;
     ColorRGBA m_highlight_color;
+
 public:
     GLGizmoRotate(GLCanvas3D& parent, Axis axis);
     virtual ~GLGizmoRotate() = default;
@@ -110,7 +113,9 @@ private:
     void render_angle() const;
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
     void render_grabber(const BoundingBoxf3& box);
+#if !ENABLE_GIZMO_GRABBER_REFACTOR
     void render_grabber_extension(const BoundingBoxf3& box, bool picking);
+#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     Transform3d local_transform(const Selection& selection) const;
diff --git a/src/slic3r/GUI/Jobs/SLAImportDialog.hpp b/src/slic3r/GUI/Jobs/SLAImportDialog.hpp
index 7dbecff2ae..15cab9ed1b 100644
--- a/src/slic3r/GUI/Jobs/SLAImportDialog.hpp
+++ b/src/slic3r/GUI/Jobs/SLAImportDialog.hpp
@@ -54,6 +54,7 @@ public:
             inp_choices.size(), inp_choices.data(), wxCB_READONLY | wxCB_DROPDOWN);
 
         szchoices->Add(m_import_dropdown);
+        szchoices->AddStretchSpacer(1);
         szchoices->Add(new wxStaticText(this, wxID_ANY, _L("Quality") + ": "), 0, wxALIGN_CENTER | wxALL, 5);
 
         static const std::vector<wxString> qual_choices = {
@@ -65,7 +66,7 @@ public:
         m_quality_dropdown = new wxComboBox(
             this, wxID_ANY, qual_choices[0], wxDefaultPosition, wxDefaultSize,
             qual_choices.size(), qual_choices.data(), wxCB_READONLY | wxCB_DROPDOWN);
-        szchoices->Add(m_quality_dropdown);
+        szchoices->Add(m_quality_dropdown, 1);
 
         m_import_dropdown->Bind(wxEVT_COMBOBOX, [this](wxCommandEvent &) {
             if (get_selection() == Sel::profileOnly)
@@ -73,14 +74,20 @@ public:
             else m_quality_dropdown->Enable();
         });
 
-        szvert->Add(szchoices, 0, wxALL, 5);
-        szvert->AddStretchSpacer(1);
+        szvert->Add(szchoices, 1, wxEXPAND | wxALL, 5);
         auto szbtn = new wxBoxSizer(wxHORIZONTAL);
-        szbtn->Add(new wxButton{this, wxID_CANCEL});
+        szbtn->Add(new wxButton{this, wxID_CANCEL}, 0, wxRIGHT, 5);
         szbtn->Add(new wxButton{this, wxID_OK});
         szvert->Add(szbtn, 0, wxALIGN_RIGHT | wxALL, 5);
 
         SetSizerAndFit(szvert);
+        wxGetApp().UpdateDlgDarkUI(this);
+    }
+
+    int ShowModal() override
+    {
+        CenterOnParent();
+        return wxDialog::ShowModal();
     }
 
     Sel get_selection() const override
diff --git a/src/slic3r/GUI/Jobs/SLAImportJob.cpp b/src/slic3r/GUI/Jobs/SLAImportJob.cpp
index 96702d158f..b7dc64d525 100644
--- a/src/slic3r/GUI/Jobs/SLAImportJob.cpp
+++ b/src/slic3r/GUI/Jobs/SLAImportJob.cpp
@@ -139,6 +139,7 @@ void SLAImportJob::finalize(bool canceled, std::exception_ptr &eptr)
         config += std::move(p->profile);
 
         wxGetApp().preset_bundle->load_config_model(name, std::move(config));
+        p->plater->check_selected_presets_visibility(ptSLA);
         wxGetApp().load_current_presets();
     }
 
diff --git a/src/slic3r/GUI/MainFrame.cpp b/src/slic3r/GUI/MainFrame.cpp
index ec4d012b24..af285e46e2 100644
--- a/src/slic3r/GUI/MainFrame.cpp
+++ b/src/slic3r/GUI/MainFrame.cpp
@@ -1821,6 +1821,8 @@ bool MainFrame::load_config_file(const std::string &path)
         show_error(this, ex.what());
         return false;
     }
+
+    m_plater->check_selected_presets_visibility(ptFFF);
     wxGetApp().load_current_presets();
     return true;
 }
diff --git a/src/slic3r/GUI/Plater.cpp b/src/slic3r/GUI/Plater.cpp
index f74e8a96b2..26d898ce28 100644
--- a/src/slic3r/GUI/Plater.cpp
+++ b/src/slic3r/GUI/Plater.cpp
@@ -2344,6 +2344,52 @@ std::string Plater::priv::get_config(const std::string &key) const
     return wxGetApp().app_config->get(key);
 }
 
+// After loading of the presets from project, check if they are visible.
+// Set them to visible if they are not.
+void Plater::check_selected_presets_visibility(PrinterTechnology loaded_printer_technology)
+{
+    auto update_selected_preset_visibility = [](PresetCollection& presets, std::vector<std::string>& names) {
+        if (!presets.get_selected_preset().is_visible) {
+            assert(presets.get_selected_preset().name == presets.get_edited_preset().name);
+            presets.get_selected_preset().is_visible = true;
+            presets.get_edited_preset().is_visible = true;
+            names.emplace_back(presets.get_selected_preset().name);
+        }
+    };
+
+    std::vector<std::string> names;
+    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+    if (loaded_printer_technology == ptFFF) {
+        update_selected_preset_visibility(preset_bundle->prints, names);
+        for (const std::string& filament : preset_bundle->filament_presets) {
+            Preset* preset = preset_bundle->filaments.find_preset(filament);
+            if (preset && !preset->is_visible) {
+                preset->is_visible = true;
+                names.emplace_back(preset->name);
+                if (preset->name == preset_bundle->filaments.get_edited_preset().name)
+                    preset_bundle->filaments.get_selected_preset().is_visible = true;
+            }
+        }
+    }
+    else {
+        update_selected_preset_visibility(preset_bundle->sla_prints, names);
+        update_selected_preset_visibility(preset_bundle->sla_materials, names);
+    }
+    update_selected_preset_visibility(preset_bundle->printers, names);
+
+    preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
+
+    // show notification about temporarily installed presets
+    if (!names.empty()) {
+        std::string notif_text = into_u8(_L_PLURAL("The preset below was temporarily installed on the active instance of PrusaSlicer",
+            "The presets below were temporarily installed on the active instance of PrusaSlicer", names.size())) + ":";
+        for (std::string& name : names)
+            notif_text += "\n - " + name;
+        get_notification_manager()->push_notification(NotificationType::CustomNotification,
+            NotificationManager::NotificationLevel::PrintInfoNotificationLevel, notif_text);
+    }
+}
+
 std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_files, bool load_model, bool load_config, bool imperial_units/* = false*/)
 {
     if (input_files.empty()) { return std::vector<size_t>(); }
@@ -2443,50 +2489,7 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
                         Preset::normalize(config);
                         PresetBundle* preset_bundle = wxGetApp().preset_bundle;
                         preset_bundle->load_config_model(filename.string(), std::move(config));
-                        {
-                            // After loading of the presets from project, check if they are visible.
-                            // Set them to visible if they are not.
-
-                            auto update_selected_preset_visibility = [](PresetCollection& presets, std::vector<std::string>& names) {
-                                if (!presets.get_selected_preset().is_visible) {
-                                    assert(presets.get_selected_preset().name == presets.get_edited_preset().name);
-                                    presets.get_selected_preset().is_visible = true;
-                                    presets.get_edited_preset().is_visible = true;
-                                    names.emplace_back(presets.get_selected_preset().name);
-                                }
-                            };
-
-                            std::vector<std::string> names;
-                            if (loaded_printer_technology == ptFFF) {
-                                update_selected_preset_visibility(preset_bundle->prints, names);
-                                for (const std::string& filament : preset_bundle->filament_presets) {
-                                    Preset* preset = preset_bundle->filaments.find_preset(filament);
-                                    if (preset && !preset->is_visible) {
-                                        preset->is_visible = true;
-                                        names.emplace_back(preset->name);
-                                        if (preset->name == preset_bundle->filaments.get_edited_preset().name)
-                                            preset_bundle->filaments.get_selected_preset().is_visible = true;
-                                    }
-                                }
-                            }
-                            else {
-                                update_selected_preset_visibility(preset_bundle->sla_prints, names);
-                                update_selected_preset_visibility(preset_bundle->sla_materials, names);
-                            }
-                            update_selected_preset_visibility(preset_bundle->printers, names);
-
-                            preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
-
-                            // show notification about temporarily installed presets
-                            if (!names.empty()) {
-                                std::string notif_text = into_u8(_L_PLURAL("The preset below was temporarily installed on the active instance of PrusaSlicer",
-                                                                           "The presets below were temporarily installed on the active instance of PrusaSlicer", names.size())) + ":";
-                                for (std::string& name : names)
-                                    notif_text += "\n - " + name;
-                                notification_manager->push_notification(NotificationType::CustomNotification,
-                                    NotificationManager::NotificationLevel::PrintInfoNotificationLevel, notif_text);
-                            }
-                        }
+                        q->check_selected_presets_visibility(loaded_printer_technology);
 
                         if (loaded_printer_technology == ptFFF)
                             CustomGCode::update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z, &preset_bundle->project_config);
diff --git a/src/slic3r/GUI/Plater.hpp b/src/slic3r/GUI/Plater.hpp
index da74c93338..729ae5487f 100644
--- a/src/slic3r/GUI/Plater.hpp
+++ b/src/slic3r/GUI/Plater.hpp
@@ -175,6 +175,7 @@ public:
     std::vector<size_t> load_files(const std::vector<std::string>& input_files, bool load_model = true, bool load_config = true, bool imperial_units = false);
     // to be called on drag and drop
     bool load_files(const wxArrayString& filenames);
+    void check_selected_presets_visibility(PrinterTechnology loaded_printer_technology);
 
     const wxString& get_last_loaded_gcode() const { return m_last_loaded_gcode; }