diff --git a/src/PrusaSlicer.cpp b/src/PrusaSlicer.cpp
index 891554c76..12058c3f6 100644
--- a/src/PrusaSlicer.cpp
+++ b/src/PrusaSlicer.cpp
@@ -565,10 +565,6 @@ int CLI::run(int argc, char **argv)
                 gui->mainframe->load_config(m_extra_config);
         });
         int result = wxEntry(argc, argv);
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-        //FIXME this is a workaround for the PrusaSlicer 2.1 release.
-		_3DScene::destroy();
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
         return result;
 #else /* SLIC3R_GUI */
         // No GUI support. Just print out a help.
diff --git a/src/libslic3r/Technologies.hpp b/src/libslic3r/Technologies.hpp
index 255afc631..a648bb244 100644
--- a/src/libslic3r/Technologies.hpp
+++ b/src/libslic3r/Technologies.hpp
@@ -53,13 +53,9 @@
 // Enable rendering of objects colored by facets' slope
 #define ENABLE_SLOPE_RENDERING (1 && ENABLE_2_3_0_ALPHA1)
 
-// Moves GLCanvas3DManager from being a static member of _3DScene to be a normal member of GUI_App
-#define ENABLE_NON_STATIC_CANVAS_MANAGER (1 && ENABLE_2_3_0_ALPHA1)
-
 // Enable G-Code viewer
 #define ENABLE_GCODE_VIEWER (1 && ENABLE_2_3_0_ALPHA1)
 #define ENABLE_GCODE_VIEWER_DEBUG_OUTPUT (0 && ENABLE_GCODE_VIEWER)
 #define ENABLE_GCODE_VIEWER_STATISTICS (0 && ENABLE_GCODE_VIEWER)
 
-
 #endif // _prusaslicer_technologies_h_
diff --git a/src/slic3r/GUI/3DScene.cpp b/src/slic3r/GUI/3DScene.cpp
index cac0910e2..ca2f0389d 100644
--- a/src/slic3r/GUI/3DScene.cpp
+++ b/src/slic3r/GUI/3DScene.cpp
@@ -1853,10 +1853,6 @@ void _3DScene::point3_to_verts(const Vec3crd& point, double width, double height
     thick_point_to_verts(point, width, height, volume);
 }
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-GUI::GLCanvas3DManager _3DScene::s_canvas_mgr;
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
 GLModel::GLModel()
     : m_filename("")
 {
@@ -2147,41 +2143,4 @@ bool GLBed::on_init_from_file(const std::string& filename)
     return true;
 }
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-std::string _3DScene::get_gl_info(bool format_as_html, bool extensions)
-{
-    return Slic3r::GUI::GLCanvas3DManager::get_gl_info().to_string(format_as_html, extensions);
-}
-
-bool _3DScene::add_canvas(wxGLCanvas* canvas, GUI::Bed3D& bed, GUI::Camera& camera, GUI::GLToolbar& view_toolbar)
-{
-    return s_canvas_mgr.add(canvas, bed, camera, view_toolbar);
-}
-
-bool _3DScene::remove_canvas(wxGLCanvas* canvas)
-{
-    return s_canvas_mgr.remove(canvas);
-}
-
-void _3DScene::remove_all_canvases()
-{
-    s_canvas_mgr.remove_all();
-}
-
-bool _3DScene::init(wxGLCanvas* canvas)
-{
-    return s_canvas_mgr.init(canvas);
-}
-
-void _3DScene::destroy()
-{
-    s_canvas_mgr.destroy();
-}
-
-GUI::GLCanvas3D* _3DScene::get_canvas(wxGLCanvas* canvas)
-{
-    return s_canvas_mgr.get_canvas(canvas);
-}
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
 } // namespace Slic3r
diff --git a/src/slic3r/GUI/3DScene.hpp b/src/slic3r/GUI/3DScene.hpp
index 70d6fb016..07c5cd53e 100644
--- a/src/slic3r/GUI/3DScene.hpp
+++ b/src/slic3r/GUI/3DScene.hpp
@@ -7,9 +7,6 @@
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Model.hpp"
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-#include "slic3r/GUI/GLCanvas3DManager.hpp"
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #include <functional>
 
@@ -668,30 +665,8 @@ protected:
     bool on_init_from_file(const std::string& filename) override;
 };
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 struct _3DScene
-#else
-class _3DScene
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 {
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    static GUI::GLCanvas3DManager s_canvas_mgr;
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-public:
-    static std::string get_gl_info(bool format_as_html, bool extensions);
-
-    static bool add_canvas(wxGLCanvas* canvas, GUI::Bed3D& bed, GUI::Camera& camera, GUI::GLToolbar& view_toolbar);
-    static bool remove_canvas(wxGLCanvas* canvas);
-    static void remove_all_canvases();
-
-    static bool init(wxGLCanvas* canvas);
-    static void destroy();
-
-    static GUI::GLCanvas3D* get_canvas(wxGLCanvas* canvas);
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
     static void thick_lines_to_verts(const Lines& lines, const std::vector<double>& widths, const std::vector<double>& heights, bool closed, double top_z, GLVolume& volume);
     static void thick_lines_to_verts(const Lines3& lines, const std::vector<double>& widths, const std::vector<double>& heights, bool closed, GLVolume& volume);
 	static void extrusionentity_to_verts(const Polyline &polyline, float width, float height, float print_z, GLVolume& volume);
diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp
index 875e4fd52..403730d85 100644
--- a/src/slic3r/GUI/GLCanvas3D.cpp
+++ b/src/slic3r/GUI/GLCanvas3D.cpp
@@ -19,9 +19,7 @@
 #include "slic3r/GUI/PresetBundle.hpp"
 #include "slic3r/GUI/Tab.hpp"
 #include "slic3r/GUI/GUI_Preview.hpp"
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "slic3r/GUI/GLCanvas3DManager.hpp"
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "slic3r/GUI/3DBed.hpp"
 #include "slic3r/GUI/Camera.hpp"
 
@@ -364,13 +362,7 @@ Rect GLCanvas3D::LayersEditing::get_bar_rect_viewport(const GLCanvas3D& canvas)
     const Size& cnv_size = canvas.get_canvas_size();
     float half_w = 0.5f * (float)cnv_size.get_width();
     float half_h = 0.5f * (float)cnv_size.get_height();
-
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)canvas.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
-
     return Rect((half_w - thickness_bar_width(canvas)) * inv_zoom, half_h * inv_zoom, half_w * inv_zoom, -half_h * inv_zoom);
 }
 
@@ -868,11 +860,7 @@ void GLCanvas3D::WarningTexture::render(const GLCanvas3D& canvas) const
     if ((m_id > 0) && (m_original_width > 0) && (m_original_height > 0) && (m_width > 0) && (m_height > 0))
     {
         const Size& cnv_size = canvas.get_canvas_size();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-        float inv_zoom = (float)canvas.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         float left = (-0.5f * (float)m_original_width) * inv_zoom;
         float top = (-0.5f * (float)cnv_size.get_height() + (float)m_original_height + 2.0f) * inv_zoom;
         float right = left + (float)m_original_width * inv_zoom;
@@ -1240,11 +1228,7 @@ void GLCanvas3D::LegendTexture::render(const GLCanvas3D& canvas) const
     if ((m_id > 0) && (m_original_width > 0) && (m_original_height > 0) && (m_width > 0) && (m_height > 0))
     {
         const Size& cnv_size = canvas.get_canvas_size();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-        float inv_zoom = (float)canvas.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         float left = (-0.5f * (float)cnv_size.get_width()) * inv_zoom;
         float top = (0.5f * (float)cnv_size.get_height()) * inv_zoom;
         float right = left + (float)m_original_width * inv_zoom;
@@ -1271,11 +1255,7 @@ void GLCanvas3D::Labels::render(const std::vector<const ModelInstance*>& sorted_
     if (!m_enabled || !is_shown())
         return;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const Camera& camera = wxGetApp().plater()->get_camera();
-#else
-    const Camera& camera = m_canvas.get_camera();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     const Model* model = m_canvas.get_model();
     if (model == nullptr)
         return;
@@ -1545,22 +1525,13 @@ wxDEFINE_EVENT(EVT_GLCANVAS_RELOAD_FROM_DISK, SimpleEvent);
 
 const double GLCanvas3D::DefaultCameraZoomToBoxMarginFactor = 1.25;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas)
-#else
-GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar)
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     : m_canvas(canvas)
     , m_context(nullptr)
 #if ENABLE_RETINA_GL
     , m_retina_helper(nullptr)
 #endif
     , m_in_render(false)
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    , m_bed(bed)
-    , m_camera(camera)
-    , m_view_toolbar(view_toolbar)
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
     , m_main_toolbar(GLToolbar::Normal, "Top")
     , m_undoredo_toolbar(GLToolbar::Normal, "Top")
     , m_collapse_toolbar(GLToolbar::Normal, "Top")
@@ -1599,10 +1570,6 @@ GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLToolbar
         m_timer.SetOwner(m_canvas);
 #if ENABLE_RETINA_GL
         m_retina_helper.reset(new RetinaHelper(canvas));
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-        // set default view_toolbar icons size equal to GLGizmosManager::Default_Icons_Size
-        m_view_toolbar.set_icons_size(GLGizmosManager::Default_Icons_Size);
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
 #endif // ENABLE_RETINA_GL
     }
 
@@ -1724,7 +1691,6 @@ void GLCanvas3D::reset_volumes()
     if (!m_initialized)
         return;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (m_volumes.empty())
         return;
 
@@ -1735,18 +1701,6 @@ void GLCanvas3D::reset_volumes()
     m_dirty = true;
 
     _set_warning_texture(WarningTexture::ObjectOutside, false);
-#else
-    _set_current();
-
-    if (!m_volumes.empty())
-    {
-        m_selection.clear();
-        m_volumes.clear();
-        m_dirty = true;
-    }
-
-    _set_warning_texture(WarningTexture::ObjectOutside, false);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
 int GLCanvas3D::check_volumes_outside_state() const
@@ -1835,11 +1789,7 @@ void GLCanvas3D::set_model(Model* model)
 void GLCanvas3D::bed_shape_changed()
 {
     refresh_camera_scene_box();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGetApp().plater()->get_camera().requires_zoom_to_bed = true;
-#else
-    m_camera.requires_zoom_to_bed = true;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     m_dirty = true;
 }
 
@@ -1848,12 +1798,10 @@ void GLCanvas3D::set_color_by(const std::string& value)
     m_color_by = value;
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 void GLCanvas3D::refresh_camera_scene_box()
 {
     wxGetApp().plater()->get_camera().set_scene_box(scene_bounding_box());
 }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 BoundingBoxf3 GLCanvas3D::volumes_bounding_box() const
 {
@@ -1869,12 +1817,7 @@ BoundingBoxf3 GLCanvas3D::volumes_bounding_box() const
 BoundingBoxf3 GLCanvas3D::scene_bounding_box() const
 {
     BoundingBoxf3 bb = volumes_bounding_box();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bb.merge(wxGetApp().plater()->get_bed().get_bounding_box(true));
-#else
-    bb.merge(m_bed.get_bounding_box(true));
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
-
     if (m_config != nullptr)
     {
         double h = m_config->opt_float("max_print_height");
@@ -2000,11 +1943,7 @@ void GLCanvas3D::allow_multisample(bool allow)
 
 void GLCanvas3D::zoom_to_bed()
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     _zoom_to_box(wxGetApp().plater()->get_bed().get_bounding_box(false));
-#else
-    _zoom_to_box(m_bed.get_bounding_box(false));
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
 void GLCanvas3D::zoom_to_volumes()
@@ -2022,11 +1961,7 @@ void GLCanvas3D::zoom_to_selection()
 
 void GLCanvas3D::select_view(const std::string& direction)
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGetApp().plater()->get_camera().select_view(direction);
-#else
-    m_camera.select_view(direction);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     if (m_canvas != nullptr)
         m_canvas->Refresh();
 }
@@ -2054,26 +1989,17 @@ void GLCanvas3D::render()
         return;
 
     // ensures this canvas is current and initialized
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (!_is_shown_on_screen() || !_set_current() || !wxGetApp().init_opengl())
         return;
 
     if (!is_initialized() && !init())
         return;
-#else
-    if (! _is_shown_on_screen() || !_set_current() || !_3DScene::init(m_canvas))
-        return;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_RENDER_STATISTICS
     auto start_time = std::chrono::high_resolution_clock::now();
 #endif // ENABLE_RENDER_STATISTICS
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (wxGetApp().plater()->get_bed().get_shape().empty())
-#else
-    if (m_bed.get_shape().empty())
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     {
         // this happens at startup when no data is still saved under <>\AppData\Roaming\Slic3rPE
         post_event(SimpleEvent(EVT_GLCANVAS_UPDATE_BED_SHAPE));
@@ -2085,7 +2011,6 @@ void GLCanvas3D::render()
     // to preview, this was called before canvas had its final size. It reported zero width
     // and the viewport was set incorrectly, leading to tripping glAsserts further down
     // the road (in apply_projection). That's why the minimum size is forced to 10.
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     Camera& camera = wxGetApp().plater()->get_camera();
     camera.apply_viewport(0, 0, std::max(10u, (unsigned int)cnv_size.get_width()), std::max(10u, (unsigned int)cnv_size.get_height()));
 
@@ -2098,19 +2023,6 @@ void GLCanvas3D::render()
 
     camera.apply_view_matrix();
     camera.apply_projection(_max_bounding_box(true, true));
-#else
-    m_camera.apply_viewport(0, 0, std::max(10u, (unsigned int)cnv_size.get_width()), std::max(10u, (unsigned int)cnv_size.get_height()));
-
-    if (m_camera.requires_zoom_to_bed)
-    {
-        zoom_to_bed();
-        _resize((unsigned int)cnv_size.get_width(), (unsigned int)cnv_size.get_height());
-        m_camera.requires_zoom_to_bed = false;
-    }
-
-    m_camera.apply_view_matrix();
-    m_camera.apply_projection(_max_bounding_box(true, true));
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     GLfloat position_cam[4] = { 1.0f, 0.0f, 1.0f, 0.0f };
     glsafe(::glLightfv(GL_LIGHT1, GL_POSITION, position_cam));
@@ -2144,11 +2056,7 @@ void GLCanvas3D::render()
 #endif // ENABLE_GCODE_VIEWER
     _render_sla_slices();
     _render_selection();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     _render_bed(!camera.is_looking_downward(), true);
-#else
-    _render_bed(!m_camera.is_looking_downward(), true);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_RENDER_SELECTION_CENTER
     _render_selection_center();
@@ -2223,11 +2131,7 @@ void GLCanvas3D::render()
 	        tooltip = m_collapse_toolbar.get_tooltip();
 
 	    if (tooltip.empty())
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
             tooltip = wxGetApp().plater()->get_view_toolbar().get_tooltip();
-#else
-            tooltip = m_view_toolbar.get_tooltip();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     }
 
     set_tooltip(tooltip);
@@ -2275,13 +2179,8 @@ void GLCanvas3D::render_thumbnail(ThumbnailData& thumbnail_data, unsigned int w,
 {
     switch (GLCanvas3DManager::get_framebuffers_type())
     {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     case GLCanvas3DManager::EFramebufferType::Arb: { _render_thumbnail_framebuffer(thumbnail_data, w, h, printable_only, parts_only, show_bed, transparent_background); break; }
     case GLCanvas3DManager::EFramebufferType::Ext: { _render_thumbnail_framebuffer_ext(thumbnail_data, w, h, printable_only, parts_only, show_bed, transparent_background); break; }
-#else
-    case GLCanvas3DManager::FB_Arb: { _render_thumbnail_framebuffer(thumbnail_data, w, h, printable_only, parts_only, show_bed, transparent_background); break; }
-    case GLCanvas3DManager::FB_Ext: { _render_thumbnail_framebuffer_ext(thumbnail_data, w, h, printable_only, parts_only, show_bed, transparent_background); break; }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     default: { _render_thumbnail_legacy(thumbnail_data, w, h, printable_only, parts_only, show_bed, transparent_background); break; }
     }
 }
@@ -2421,15 +2320,10 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re
     if ((m_canvas == nullptr) || (m_config == nullptr) || (m_model == nullptr))
         return;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (!m_initialized)
         return;
     
     _set_current();
-#else
-    if (m_initialized)
-        _set_current();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     struct ModelVolumeState {
         ModelVolumeState(const GLVolume* volume) :
@@ -3061,13 +2955,8 @@ void GLCanvas3D::on_idle(wxIdleEvent& evt)
     m_dirty |= m_main_toolbar.update_items_state();
     m_dirty |= m_undoredo_toolbar.update_items_state();
     m_dirty |= m_collapse_toolbar.update_items_state();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     m_dirty |= wxGetApp().plater()->get_view_toolbar().update_items_state();
     bool mouse3d_controller_applied = wxGetApp().plater()->get_mouse3d_controller().apply(wxGetApp().plater()->get_camera());
-#else
-    m_dirty |= m_view_toolbar.update_items_state();
-    bool mouse3d_controller_applied = wxGetApp().plater()->get_mouse3d_controller().apply(m_camera);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     m_dirty |= mouse3d_controller_applied;
 
     if (!m_dirty)
@@ -3231,11 +3120,7 @@ void GLCanvas3D::on_char(wxKeyEvent& evt)
         case 'I':
         case 'i': { _update_camera_zoom(1.0); break; }
         case 'K':
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         case 'k': { wxGetApp().plater()->get_camera().select_next_type(); m_dirty = true; break; }
-#else
-        case 'k': { m_camera.select_next_type(); m_dirty = true; break; }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 #if ENABLE_GCODE_VIEWER
         case 'L':
         case 'l': {
@@ -3374,11 +3259,7 @@ void GLCanvas3D::on_key(wxKeyEvent& evt)
             Vec3d displacement;
             if (camera_space)
             {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                 Eigen::Matrix<double, 3, 3, Eigen::DontAlign> inv_view_3x3 = wxGetApp().plater()->get_camera().get_view_matrix().inverse().matrix().block(0, 0, 3, 3);
-#else
-                Eigen::Matrix<double, 3, 3, Eigen::DontAlign> inv_view_3x3 = m_camera.get_view_matrix().inverse().matrix().block(0, 0, 3, 3);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
                 displacement = multiplier * (inv_view_3x3 * direction);
                 displacement(2) = 0.0;
             }
@@ -3721,11 +3602,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
         return;
     }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (wxGetApp().plater()->get_view_toolbar().on_mouse(evt, *this))
-#else
-    if (m_view_toolbar.on_mouse(evt, *this))
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     {
         if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
             mouse_up_cleanup();
@@ -3889,12 +3766,8 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
             // we do not want to translate objects if the user just clicked on an object while pressing shift to remove it from the selection and then drag
             if (m_selection.contains_volume(get_first_hover_volume_idx()))
             {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                 const Camera& camera = wxGetApp().plater()->get_camera();
                 if (std::abs(camera.get_dir_forward()(2)) < EPSILON)
-#else
-                if (std::abs(m_camera.get_dir_forward()(2)) < EPSILON)
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
                 {
                     // side view -> move selected volumes orthogonally to camera view direction
                     Linef3 ray = mouse_ray(pos);
@@ -3907,13 +3780,8 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                     // vector from the starting position to the found intersection
                     Vec3d inters_vec = inters - m_mouse.drag.start_position_3D;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                     Vec3d camera_right = camera.get_dir_right();
                     Vec3d camera_up = camera.get_dir_up();
-#else
-                    Vec3d camera_right = m_camera.get_dir_right();
-                    Vec3d camera_up = m_camera.get_dir_up();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
                     // finds projection of the vector along the camera axes
                     double projection_x = inters_vec.dot(camera_right);
@@ -3963,25 +3831,16 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                 const Vec3d rot = (Vec3d(pos.x(), pos.y(), 0.) - m_mouse.drag.start_position_3D) * (PI * TRACKBALLSIZE / 180.);
                 if (wxGetApp().app_config->get("use_free_camera") == "1")
                     // Virtual track ball (similar to the 3DConnexion mouse).
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                     wxGetApp().plater()->get_camera().rotate_local_around_target(Vec3d(rot.y(), rot.x(), 0.));
-#else
-                    m_camera.rotate_local_around_target(Vec3d(rot.y(), rot.x(), 0.));
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
                 else
                 {
                     // Forces camera right vector to be parallel to XY plane in case it has been misaligned using the 3D mouse free rotation.
                     // It is cheaper to call this function right away instead of testing wxGetApp().plater()->get_mouse3d_controller().connected(),
                     // which checks an atomics (flushes CPU caches).
                     // See GH issue #3816.
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                     Camera& camera = wxGetApp().plater()->get_camera();
                     camera.recover_from_free_camera();
                     camera.rotate_on_sphere(rot.x(), rot.y(), wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA);
-#else
-                    m_camera.recover_from_free_camera();
-                    m_camera.rotate_on_sphere(rot.x(), rot.y(), wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
                 }
 
                 m_dirty = true;
@@ -3997,23 +3856,15 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                 float z = 0.0f;
                 const Vec3d& cur_pos = _mouse_to_3d(pos, &z);
                 Vec3d orig = _mouse_to_3d(m_mouse.drag.start_position_2D, &z);
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                 Camera& camera = wxGetApp().plater()->get_camera();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER                
                 if (wxGetApp().app_config->get("use_free_camera") != "1")
                     // Forces camera right vector to be parallel to XY plane in case it has been misaligned using the 3D mouse free rotation.
                     // It is cheaper to call this function right away instead of testing wxGetApp().plater()->get_mouse3d_controller().connected(),
                     // which checks an atomics (flushes CPU caches).
                     // See GH issue #3816.
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
                     camera.recover_from_free_camera();
 
                 camera.set_target(camera.get_target() + orig - cur_pos);
-#else
-                    m_camera.recover_from_free_camera();
-
-                m_camera.set_target(m_camera.get_target() + orig - cur_pos);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER                
                 m_dirty = true;
             }
 
@@ -4468,15 +4319,11 @@ void GLCanvas3D::update_ui_from_settings()
     if (new_scaling != orig_scaling) {
         BOOST_LOG_TRIVIAL(debug) << "GLCanvas3D: Scaling factor: " << new_scaling;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         Camera& camera = wxGetApp().plater()->get_camera();
         camera.set_zoom(camera.get_zoom() * new_scaling / orig_scaling);
-#else
-        m_camera.set_zoom(m_camera.get_zoom() * new_scaling / orig_scaling);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         _refresh_if_shown_on_screen();
     }
-#endif
+#endif // ENABLE_RETINA_GL
 }
 
 
@@ -4508,11 +4355,7 @@ Linef3 GLCanvas3D::mouse_ray(const Point& mouse_pos)
 
 double GLCanvas3D::get_size_proportional_to_max_bed_size(double factor) const
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     return factor * wxGetApp().plater()->get_bed().get_bounding_box(false).max_size();
-#else
-    return factor * m_bed.get_bounding_box(false).max_size();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
 void GLCanvas3D::set_cursor(ECursorType type)
@@ -4575,11 +4418,7 @@ bool GLCanvas3D::_render_undo_redo_stack(const bool is_undo, float pos_x) const
 
     ImGuiWrapper* imgui = wxGetApp().imgui();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const float x = pos_x * (float)wxGetApp().plater()->get_camera().get_zoom() + 0.5f * (float)get_canvas_size().get_width();
-#else
-    const float x = pos_x * (float)get_camera().get_zoom() + 0.5f * (float)get_canvas_size().get_width();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     imgui->set_next_window_pos(x, m_undoredo_toolbar.get_height(), ImGuiCond_Always, 0.5f, 0.0f);
     std::string title = is_undo ? L("Undo History") : L("Redo History");
     imgui->begin(_(title), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
@@ -4620,11 +4459,7 @@ bool GLCanvas3D::_render_search_list(float pos_x) const
     bool action_taken = false;
     ImGuiWrapper* imgui = wxGetApp().imgui();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const float x = pos_x * (float)wxGetApp().plater()->get_camera().get_zoom() + 0.5f * (float)get_canvas_size().get_width();
-#else
-    const float x = pos_x * (float)get_camera().get_zoom() + 0.5f * (float)get_canvas_size().get_width();
-#endif
     imgui->set_next_window_pos(x, m_main_toolbar.get_height(), ImGuiCond_Always, 0.5f, 0.0f);
     std::string title = L("Search");
     imgui->begin(_(title), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
@@ -4635,7 +4470,7 @@ bool GLCanvas3D::_render_search_list(float pos_x) const
     float em = static_cast<float>(wxGetApp().em_unit());
 #if ENABLE_RETINA_GL
 	em *= m_retina_helper->get_scale_factor();
-#endif
+#endif // ENABLE_RETINA_GL
 
     Sidebar& sidebar = wxGetApp().sidebar();
 
@@ -4737,11 +4572,7 @@ void GLCanvas3D::_render_thumbnail_internal(ThumbnailData& thumbnail_data, bool
         // extends the near and far z of the frustrum to avoid the bed being clipped
 
         // box in eye space
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         BoundingBoxf3 t_bed_box = wxGetApp().plater()->get_bed().get_bounding_box(true).transformed(camera.get_view_matrix());
-#else
-        BoundingBoxf3 t_bed_box = m_bed.get_bounding_box(true).transformed(camera.get_view_matrix());
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         near_z = -t_bed_box.max(2);
         far_z = -t_bed_box.min(2);
     }
@@ -5018,11 +4849,7 @@ void GLCanvas3D::_render_thumbnail_legacy(ThumbnailData& thumbnail_data, unsigne
 #endif // ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
 
     // restore the default framebuffer size to avoid flickering on the 3D scene
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGetApp().plater()->get_camera().apply_viewport(0, 0, cnv_size.get_width(), cnv_size.get_height());
-#else
-    m_camera.apply_viewport(0, 0, cnv_size.get_width(), cnv_size.get_height());
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
 bool GLCanvas3D::_init_toolbars()
@@ -5473,11 +5300,7 @@ BoundingBoxf3 GLCanvas3D::_max_bounding_box(bool include_gizmos, bool include_be
         bb.merge(BoundingBoxf3(sel_bb_center - extend_by, sel_bb_center + extend_by));
     }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bb.merge(wxGetApp().plater()->get_bed().get_bounding_box(include_bed_model));
-#else
-    bb.merge(m_bed.get_bounding_box(include_bed_model));
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_GCODE_VIEWER
     if (!m_main_toolbar.is_enabled())
@@ -5489,21 +5312,13 @@ BoundingBoxf3 GLCanvas3D::_max_bounding_box(bool include_gizmos, bool include_be
 
 void GLCanvas3D::_zoom_to_box(const BoundingBoxf3& box, double margin_factor)
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGetApp().plater()->get_camera().zoom_to_box(box, margin_factor);
-#else
-    m_camera.zoom_to_box(box, margin_factor);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     m_dirty = true;
 }
 
 void GLCanvas3D::_update_camera_zoom(double zoom)
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGetApp().plater()->get_camera().update_zoom(zoom);
-#else
-    m_camera.update_zoom(zoom);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     m_dirty = true;
 }
 
@@ -5699,11 +5514,7 @@ void GLCanvas3D::_render_bed(bool bottom, bool show_axes) const
             (m_gizmos.get_current_type() != GLGizmosManager::FdmSupports
           && m_gizmos.get_current_type() != GLGizmosManager::SlaSupports);
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGetApp().plater()->get_bed().render(const_cast<GLCanvas3D&>(*this), bottom, scale_factor, show_axes, show_texture);
-#else
-    m_bed.render(const_cast<GLCanvas3D&>(*this), theta, scale_factor, show_axes);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
 void GLCanvas3D::_render_objects() const
@@ -5722,11 +5533,7 @@ void GLCanvas3D::_render_objects() const
 
         if (m_config != nullptr)
         {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
             const BoundingBoxf3& bed_bb = wxGetApp().plater()->get_bed().get_bounding_box(false);
-#else
-            const BoundingBoxf3& bed_bb = m_bed.get_bounding_box(false);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
             m_volumes.set_print_box((float)bed_bb.min(0), (float)bed_bb.min(1), 0.0f, (float)bed_bb.max(0), (float)bed_bb.max(1), (float)m_config->opt_float("max_print_height"));
             m_volumes.check_outside_state(m_config, nullptr);
         }
@@ -5742,37 +5549,20 @@ void GLCanvas3D::_render_objects() const
     m_shader.start_using();
     if (m_picking_enabled && !m_gizmos.is_dragging() && m_layers_editing.is_enabled() && (m_layers_editing.last_object_id != -1) && (m_layers_editing.object_max_z() > 0.0f)) {
         int object_id = m_layers_editing.last_object_id;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         m_volumes.render(GLVolumeCollection::Opaque, false, wxGetApp().plater()->get_camera().get_view_matrix(), [object_id](const GLVolume& volume) {
             // Which volume to paint without the layer height profile shader?
             return volume.is_active && (volume.is_modifier || volume.composite_id.object_id != object_id);
             });
-#else
-        m_volumes.render(GLVolumeCollection::Opaque, false, m_camera.get_view_matrix(), [object_id](const GLVolume& volume) {
-            // Which volume to paint without the layer height profile shader?
-            return volume.is_active && (volume.is_modifier || volume.composite_id.object_id != object_id);
-        });
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         // Let LayersEditing handle rendering of the active object using the layer height profile shader.
         m_layers_editing.render_volumes(*this, this->m_volumes);
     } else {
         // do not cull backfaces to show broken geometry, if any
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         m_volumes.render(GLVolumeCollection::Opaque, m_picking_enabled, wxGetApp().plater()->get_camera().get_view_matrix(), [this](const GLVolume& volume) {
             return (m_render_sla_auxiliaries || volume.composite_id.volume_id >= 0);
             });
-#else
-        m_volumes.render(GLVolumeCollection::Opaque, m_picking_enabled, m_camera.get_view_matrix(), [this](const GLVolume& volume) {
-            return (m_render_sla_auxiliaries || volume.composite_id.volume_id >= 0);
-        });
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     m_volumes.render(GLVolumeCollection::Transparent, false, wxGetApp().plater()->get_camera().get_view_matrix());
-#else
-    m_volumes.render(GLVolumeCollection::Transparent, false, m_camera.get_view_matrix());
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     m_shader.stop_using();
 
     m_camera_clipping_plane = ClippingPlane::ClipsNothing();
@@ -5790,7 +5580,7 @@ void GLCanvas3D::_render_selection() const
     float scale_factor = 1.0;
 #if ENABLE_RETINA_GL
     scale_factor = m_retina_helper->get_scale_factor();
-#endif
+#endif // ENABLE_RETINA_GL
 
     if (!m_gizmos.is_running())
         m_selection.render(scale_factor);
@@ -5809,16 +5599,10 @@ void GLCanvas3D::_render_overlays() const
     glsafe(::glPushMatrix());
     glsafe(::glLoadIdentity());
     // ensure that the textures are renderered inside the frustrum
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const Camera& camera = wxGetApp().plater()->get_camera();
     glsafe(::glTranslated(0.0, 0.0, -(camera.get_near_z() + 0.005)));
     // ensure that the overlay fits the frustrum near z plane
     double gui_scale = camera.get_gui_scale();
-#else
-    glsafe(::glTranslated(0.0, 0.0, -(m_camera.get_near_z() + 0.005)));
-    // ensure that the overlay fits the frustrum near z plane
-    double gui_scale = m_camera.get_gui_scale();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     glsafe(::glScaled(gui_scale, gui_scale, 1.0));
 
     _render_gizmos_overlay();
@@ -5892,11 +5676,7 @@ void GLCanvas3D::_render_volumes_for_picking() const
     glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
     glsafe(::glEnableClientState(GL_NORMAL_ARRAY));
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const Transform3d& view_matrix = wxGetApp().plater()->get_camera().get_view_matrix();
-#else
-    const Transform3d& view_matrix = m_camera.get_view_matrix();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     for (size_t type = 0; type < 2; ++ type) {
 	    GLVolumeWithIdAndZList to_render = volumes_to_render(m_volumes.volumes, (type == 0) ? GLVolumeCollection::Opaque : GLVolumeCollection::Transparent, view_matrix);
 	    for (const GLVolumeWithIdAndZ& volume : to_render)
@@ -5945,11 +5725,7 @@ void GLCanvas3D::_render_main_toolbar() const
         return;
 
     Size cnv_size = get_canvas_size();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)m_camera.get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     float top = 0.5f * (float)cnv_size.get_height() * inv_zoom;
     float left = -0.5f * (m_main_toolbar.get_width() + m_undoredo_toolbar.get_width()) * inv_zoom;
@@ -5964,11 +5740,7 @@ void GLCanvas3D::_render_undoredo_toolbar() const
         return;
 
     Size cnv_size = get_canvas_size();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)m_camera.get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     float top = 0.5f * (float)cnv_size.get_height() * inv_zoom;
     float left = (m_main_toolbar.get_width() - 0.5f * (m_main_toolbar.get_width() + m_undoredo_toolbar.get_width())) * inv_zoom;
@@ -5982,11 +5754,7 @@ void GLCanvas3D::_render_collapse_toolbar() const
         return;
 
     Size cnv_size = get_canvas_size();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)m_camera.get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     float band = m_layers_editing.is_enabled() ? (wxGetApp().imgui()->get_style_scaling() * LayersEditing::THICKNESS_BAR_WIDTH) : 0.0;
 
@@ -5999,50 +5767,27 @@ void GLCanvas3D::_render_collapse_toolbar() const
 
 void GLCanvas3D::_render_view_toolbar() const
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     GLToolbar& view_toolbar = wxGetApp().plater()->get_view_toolbar();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_RETINA_GL
 //     m_view_toolbar.set_scale(m_retina_helper->get_scale_factor());
     const float scale = m_retina_helper->get_scale_factor() * wxGetApp().toolbar_icon_scale();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     view_toolbar.set_scale(scale); //! #ys_FIXME_experiment
-#else
-    m_view_toolbar.set_scale(scale); //! #ys_FIXME_experiment
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 #else
 //     m_view_toolbar.set_scale(m_canvas->GetContentScaleFactor());
 //     m_view_toolbar.set_scale(wxGetApp().em_unit()*0.1f);
     const float size = int(GLGizmosManager::Default_Icons_Size * wxGetApp().toolbar_icon_scale());
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     view_toolbar.set_icons_size(size); //! #ys_FIXME_experiment
-#else
-    m_view_toolbar.set_icons_size(size); //! #ys_FIXME_experiment
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 #endif // ENABLE_RETINA_GL
 
     Size cnv_size = get_canvas_size();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)m_camera.get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     // places the toolbar on the bottom-left corner of the 3d scene
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float top = (-0.5f * (float)cnv_size.get_height() + view_toolbar.get_height()) * inv_zoom;
-#else
-    float top = (-0.5f * (float)cnv_size.get_height() + m_view_toolbar.get_height()) * inv_zoom;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float left = -0.5f * (float)cnv_size.get_width() * inv_zoom;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     view_toolbar.set_position(top, left);
     view_toolbar.render(*this);
-#else
-    m_view_toolbar.set_position(top, left);
-    m_view_toolbar.render(*this);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
 #if ENABLE_SHOW_CAMERA_TARGET
@@ -6321,16 +6066,10 @@ Vec3d GLCanvas3D::_mouse_to_3d(const Point& mouse_pos, float* z)
     if (m_canvas == nullptr)
         return Vec3d(DBL_MAX, DBL_MAX, DBL_MAX);
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const Camera& camera = wxGetApp().plater()->get_camera();
     const std::array<int, 4>& viewport = camera.get_viewport();
     const Transform3d& modelview_matrix = camera.get_view_matrix();
     const Transform3d& projection_matrix = camera.get_projection_matrix();
-#else
-    const std::array<int, 4>& viewport = m_camera.get_viewport();
-    const Transform3d& modelview_matrix = m_camera.get_view_matrix();
-    const Transform3d& projection_matrix = m_camera.get_projection_matrix();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     GLint y = viewport[3] - (GLint)mouse_pos(1);
     GLfloat mouse_z;
diff --git a/src/slic3r/GUI/GLCanvas3D.hpp b/src/slic3r/GUI/GLCanvas3D.hpp
index be10e79a1..ed034bd28 100644
--- a/src/slic3r/GUI/GLCanvas3D.hpp
+++ b/src/slic3r/GUI/GLCanvas3D.hpp
@@ -16,9 +16,6 @@
 #include "GUI_ObjectLayers.hpp"
 #include "GLSelectionRectangle.hpp"
 #include "MeshUtils.hpp"
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-#include "Camera.hpp"
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
 #if ENABLE_GCODE_VIEWER
 #include "libslic3r/GCode/GCodeProcessor.hpp"
 #include "GCodeViewer.hpp"
@@ -35,9 +32,7 @@ class wxMouseEvent;
 class wxTimerEvent;
 class wxPaintEvent;
 class wxGLCanvas;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 class wxGLContext;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 // Support for Retina OpenGL on Mac OS
 #define ENABLE_RETINA_GL __APPLE__
@@ -453,11 +448,6 @@ private:
 #endif // !ENABLE_GCODE_VIEWER
     WarningTexture m_warning_texture;
     wxTimer m_timer;
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    Bed3D& m_bed;
-    Camera& m_camera;
-    GLToolbar& m_view_toolbar;
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
     LayersEditing m_layers_editing;
     Shader m_shader;
     Mouse m_mouse;
@@ -532,16 +522,10 @@ private:
 #endif // ENABLE_SLOPE_RENDERING
 
 public:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     explicit GLCanvas3D(wxGLCanvas* canvas);
-#else
-    GLCanvas3D(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     ~GLCanvas3D();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bool is_initialized() const { return m_initialized; }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     void set_context(wxGLContext* context) { m_context = context; }
 
@@ -593,13 +577,7 @@ public:
 
     void set_color_by(const std::string& value);
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     void refresh_camera_scene_box();
-#else
-    void refresh_camera_scene_box() { m_camera.set_scene_box(scene_bounding_box()); }
-    const Camera& get_camera() const { return m_camera; }
-    Camera& get_camera() { return m_camera; }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     const Shader& get_shader() const { return m_shader; }
 
     BoundingBoxf3 volumes_bounding_box() const;
@@ -719,10 +697,6 @@ public:
 
     void update_ui_from_settings();
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    float get_view_toolbar_height() const { return m_view_toolbar.get_height(); }
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
     int get_move_volume_id() const { return m_mouse.drag.move_volume_idx; }
     int get_first_hover_volume_idx() const { return m_hover_volume_idxs.empty() ? -1 : m_hover_volume_idxs.front(); }
     void set_selected_extruder(int extruder) { m_selected_extruder = extruder;}
diff --git a/src/slic3r/GUI/GLCanvas3DManager.cpp b/src/slic3r/GUI/GLCanvas3DManager.cpp
index d4522bb07..83f429c5e 100644
--- a/src/slic3r/GUI/GLCanvas3DManager.cpp
+++ b/src/slic3r/GUI/GLCanvas3DManager.cpp
@@ -8,9 +8,7 @@
 
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include <boost/log/trivial.hpp>
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 #include <wx/glcanvas.h>
 #include <wx/timer.h>
 #include <wx/msgdlg.h>
@@ -33,19 +31,6 @@
 namespace Slic3r {
 namespace GUI {
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-GLCanvas3DManager::GLInfo::GLInfo()
-    : m_detected(false)
-    , m_version("")
-    , m_glsl_version("")
-    , m_vendor("")
-    , m_renderer("")
-    , m_max_tex_size(0)
-    , m_max_anisotropy(0.0f)
-{
-}
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
 const std::string& GLCanvas3DManager::GLInfo::get_version() const
 {
     if (!m_detected)
@@ -205,13 +190,8 @@ std::string GLCanvas3DManager::GLInfo::to_string(bool format_as_html, bool exten
 
 GLCanvas3DManager::GLInfo GLCanvas3DManager::s_gl_info;
 bool GLCanvas3DManager::s_compressed_textures_supported = false;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 GLCanvas3DManager::EMultisampleState GLCanvas3DManager::s_multisample = GLCanvas3DManager::EMultisampleState::Unknown;
 GLCanvas3DManager::EFramebufferType GLCanvas3DManager::s_framebuffers_type = GLCanvas3DManager::EFramebufferType::Unknown;
-#else
-GLCanvas3DManager::EMultisampleState GLCanvas3DManager::s_multisample = GLCanvas3DManager::MS_Unknown;
-GLCanvas3DManager::EFramebufferType GLCanvas3DManager::s_framebuffers_type = GLCanvas3DManager::FB_None;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_HACK_CLOSING_ON_OSX_10_9_5
 #ifdef __APPLE__ 
@@ -220,17 +200,8 @@ GLCanvas3DManager::OSInfo GLCanvas3DManager::s_os_info;
 #endif // __APPLE__ 
 #endif // ENABLE_HACK_CLOSING_ON_OSX_10_9_5
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-GLCanvas3DManager::GLCanvas3DManager()
-    : m_context(nullptr)
-    , m_gl_initialized(false)
-{
-}
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
 GLCanvas3DManager::~GLCanvas3DManager()
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #if ENABLE_HACK_CLOSING_ON_OSX_10_9_5
 #ifdef __APPLE__ 
     // This is an ugly hack needed to solve the crash happening when closing the application on OSX 10.9.5 with newer wxWidgets
@@ -248,116 +219,29 @@ GLCanvas3DManager::~GLCanvas3DManager()
     }
 #endif //__APPLE__
 #endif // ENABLE_HACK_CLOSING_ON_OSX_10_9_5
-#else
-    this->destroy();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-bool GLCanvas3DManager::add(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar)
-{
-    if (canvas == nullptr)
-        return false;
-
-    if (do_get_canvas(canvas) != m_canvases.end())
-        return false;
-
-    GLCanvas3D* canvas3D = new GLCanvas3D(canvas, bed, camera, view_toolbar);
-    if (canvas3D == nullptr)
-        return false;
-
-    canvas3D->bind_event_handlers();
-
-    if (m_context == nullptr)
-    {
-        m_context = new wxGLContext(canvas);
-        if (m_context == nullptr)
-            return false;
-
-#if ENABLE_HACK_CLOSING_ON_OSX_10_9_5
-#ifdef __APPLE__ 
-        // Part of hack to remove crash when closing the application on OSX 10.9.5 when building against newer wxWidgets
-        s_os_info.major = wxPlatformInfo::Get().GetOSMajorVersion();
-        s_os_info.minor = wxPlatformInfo::Get().GetOSMinorVersion();
-        s_os_info.micro = wxPlatformInfo::Get().GetOSMicroVersion();
-#endif //__APPLE__
-#endif // ENABLE_HACK_CLOSING_ON_OSX_10_9_5
-    }
-
-    canvas3D->set_context(m_context);
-
-    m_canvases.insert(CanvasesMap::value_type(canvas, canvas3D));
-
-    return true;
-}
-
-bool GLCanvas3DManager::remove(wxGLCanvas* canvas)
-{
-    CanvasesMap::iterator it = do_get_canvas(canvas);
-    if (it == m_canvases.end())
-        return false;
-
-    it->second->unbind_event_handlers();
-    delete it->second;
-    m_canvases.erase(it);
-
-    return true;
-}
-
-void GLCanvas3DManager::remove_all()
-{
-    for (CanvasesMap::value_type& item : m_canvases)
-    {
-        item.second->unbind_event_handlers();
-        delete item.second;
-    }
-    m_canvases.clear();
-}
-
-size_t GLCanvas3DManager::count() const
-{
-    return m_canvases.size();
-}
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 bool GLCanvas3DManager::init_gl()
-#else
-void GLCanvas3DManager::init_gl()
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 {
     if (!m_gl_initialized)
     {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         if (glewInit() != GLEW_OK)
         {
             BOOST_LOG_TRIVIAL(error) << "Unable to init glew library";
             return false;
         }
-#else
-        glewInit();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         m_gl_initialized = true;
         if (GLEW_EXT_texture_compression_s3tc)
             s_compressed_textures_supported = true;
         else
             s_compressed_textures_supported = false;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         if (GLEW_ARB_framebuffer_object)
             s_framebuffers_type = EFramebufferType::Arb;
         else if (GLEW_EXT_framebuffer_object)
             s_framebuffers_type = EFramebufferType::Ext;
         else
             s_framebuffers_type = EFramebufferType::Unknown;
-#else
-        if (GLEW_ARB_framebuffer_object)
-            s_framebuffers_type = FB_Arb;
-        else if (GLEW_EXT_framebuffer_object)
-            s_framebuffers_type = FB_Ext;
-        else
-            s_framebuffers_type = FB_None;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
         if (! s_gl_info.is_version_greater_or_equal_to(2, 0)) {
         	// Complain about the OpenGL version.
@@ -374,12 +258,9 @@ void GLCanvas3DManager::init_gl()
         }
     }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     return true;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 wxGLContext* GLCanvas3DManager::init_glcontext(wxGLCanvas& canvas)
 {
     if (m_context == nullptr)
@@ -397,48 +278,8 @@ wxGLContext* GLCanvas3DManager::init_glcontext(wxGLCanvas& canvas)
     }
     return m_context;
 }
-#else
-bool GLCanvas3DManager::init(wxGLCanvas* canvas)
-{
-    CanvasesMap::const_iterator it = do_get_canvas(canvas);
-    if (it != m_canvases.end())
-        return (it->second != nullptr) ? init(*it->second) : false;
-    else
-        return false;
-}
 
-void GLCanvas3DManager::destroy()
-{
-    if (m_context != nullptr)
-    {
-#if ENABLE_HACK_CLOSING_ON_OSX_10_9_5
-#ifdef __APPLE__ 
-        // this is an ugly hack needed to solve the crash happening when closing the application on OSX 10.9.5
-        // the crash is inside wxGLContext destructor
-        if (s_os_info.major == 10 && s_os_info.minor == 9 && s_os_info.micro == 5)
-            return;
-#endif //__APPLE__
-#endif // ENABLE_HACK_CLOSING_ON_OSX_10_9_5
-
-        delete m_context;
-        m_context = nullptr;
-    }
-}
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-GLCanvas3D* GLCanvas3DManager::get_canvas(wxGLCanvas* canvas)
-{
-    CanvasesMap::const_iterator it = do_get_canvas(canvas);
-    return (it != m_canvases.end()) ? it->second : nullptr;
-}
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 wxGLCanvas* GLCanvas3DManager::create_wxglcanvas(wxWindow& parent)
-#else
-wxGLCanvas* GLCanvas3DManager::create_wxglcanvas(wxWindow *parent)
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 {
     int attribList[] = { 
     	WX_GL_RGBA,
@@ -456,11 +297,7 @@ wxGLCanvas* GLCanvas3DManager::create_wxglcanvas(wxWindow *parent)
     	0
     };
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (s_multisample == EMultisampleState::Unknown)
-#else
-    if (s_multisample == MS_Unknown)
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     {
         detect_multisample(attribList);
 //        // debug output
@@ -470,42 +307,14 @@ wxGLCanvas* GLCanvas3DManager::create_wxglcanvas(wxWindow *parent)
     if (! can_multisample())
         attribList[12] = 0;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     return new wxGLCanvas(&parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS);
-#else
-    return new wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 }
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-GLCanvas3DManager::CanvasesMap::iterator GLCanvas3DManager::do_get_canvas(wxGLCanvas* canvas)
-{
-    return (canvas == nullptr) ? m_canvases.end() : m_canvases.find(canvas);
-}
-
-GLCanvas3DManager::CanvasesMap::const_iterator GLCanvas3DManager::do_get_canvas(wxGLCanvas* canvas) const
-{
-    return (canvas == nullptr) ? m_canvases.end() : m_canvases.find(canvas);
-}
-
-bool GLCanvas3DManager::init(GLCanvas3D& canvas)
-{
-    if (!m_gl_initialized)
-        init_gl();
-
-    return canvas.init();
-}
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
 void GLCanvas3DManager::detect_multisample(int* attribList)
 {
     int wxVersion = wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + wxRELEASE_NUMBER;
     bool enable_multisample = wxVersion >= 30003;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     s_multisample = (enable_multisample && wxGLCanvas::IsDisplaySupported(attribList)) ? EMultisampleState::Enabled : EMultisampleState::Disabled;
-#else
-    s_multisample = (enable_multisample && wxGLCanvas::IsDisplaySupported(attribList)) ? MS_Enabled : MS_Disabled;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     // Alternative method: it was working on previous version of wxWidgets but not with the latest, at least on Windows
     // s_multisample = enable_multisample && wxGLCanvas::IsExtensionSupported("WGL_ARB_multisample");
 }
diff --git a/src/slic3r/GUI/GLCanvas3DManager.hpp b/src/slic3r/GUI/GLCanvas3DManager.hpp
index 428ccd96a..51d4a49b1 100644
--- a/src/slic3r/GUI/GLCanvas3DManager.hpp
+++ b/src/slic3r/GUI/GLCanvas3DManager.hpp
@@ -23,34 +23,19 @@ class PrintObject;
 namespace GUI {
 
 class GLCanvas3D;
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-class Bed3D;
-class GLToolbar;
-struct Camera;
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
 
 class GLCanvas3DManager
 {
 public:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     enum class EFramebufferType : unsigned char
     {
         Unknown,
         Arb,
         Ext
     };
-#else
-    enum EFramebufferType : unsigned char
-    {
-        FB_None,
-        FB_Arb,
-        FB_Ext
-    };
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     class GLInfo
     {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         mutable bool m_detected{ false };
         mutable int m_max_tex_size{ 0 };
         mutable float m_max_anisotropy{ 0.0f };
@@ -59,24 +44,9 @@ public:
         mutable std::string m_glsl_version;
         mutable std::string m_vendor;
         mutable std::string m_renderer;
-#else
-        mutable bool m_detected;
-
-        mutable std::string m_version;
-        mutable std::string m_glsl_version;
-        mutable std::string m_vendor;
-        mutable std::string m_renderer;
-
-        mutable int m_max_tex_size;
-        mutable float m_max_anisotropy;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     public:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         GLInfo() = default;
-#else
-        GLInfo();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
         const std::string& get_version() const;
         const std::string& get_glsl_version() const;
@@ -107,32 +77,15 @@ public:
 #endif // ENABLE_HACK_CLOSING_ON_OSX_10_9_5
 
 private:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     enum class EMultisampleState : unsigned char
     {
         Unknown,
         Enabled,
         Disabled
     };
-#else
-    enum EMultisampleState : unsigned char
-    {
-        MS_Unknown,
-        MS_Enabled,
-        MS_Disabled
-    };
 
-    typedef std::map<wxGLCanvas*, GLCanvas3D*> CanvasesMap;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bool m_gl_initialized{ false };
     wxGLContext* m_context{ nullptr };
-#else
-    wxGLContext* m_context;
-    bool m_gl_initialized;
-    CanvasesMap m_canvases;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     static GLInfo s_gl_info;
 #if ENABLE_HACK_CLOSING_ON_OSX_10_9_5
 #ifdef __APPLE__ 
@@ -145,63 +98,21 @@ private:
     static EFramebufferType s_framebuffers_type;
 
 public:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     GLCanvas3DManager() = default;
-#else
-    GLCanvas3DManager();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     ~GLCanvas3DManager();
 
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    bool add(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar);
-    bool remove(wxGLCanvas* canvas);
-    void remove_all();
-
-    size_t count() const;
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bool init_gl();
-#else
-    void init_gl();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     wxGLContext* init_glcontext(wxGLCanvas& canvas);
-#else
-    bool init(wxGLCanvas* canvas);
-    void destroy();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
-
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    GLCanvas3D* get_canvas(wxGLCanvas* canvas);
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
 
     static bool are_compressed_textures_supported() { return s_compressed_textures_supported; }
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     static bool can_multisample() { return s_multisample == EMultisampleState::Enabled; }
     static bool are_framebuffers_supported() { return (s_framebuffers_type != EFramebufferType::Unknown); }
-#else
-    static bool can_multisample() { return s_multisample == MS_Enabled; }
-    static bool are_framebuffers_supported() { return (s_framebuffers_type != FB_None); }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     static EFramebufferType get_framebuffers_type() { return s_framebuffers_type; }
-
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     static wxGLCanvas* create_wxglcanvas(wxWindow& parent);
-#else
-    static wxGLCanvas* create_wxglcanvas(wxWindow *parent);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
-
     static const GLInfo& get_gl_info() { return s_gl_info; }
 
 private:
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    CanvasesMap::iterator do_get_canvas(wxGLCanvas* canvas);
-    CanvasesMap::const_iterator do_get_canvas(wxGLCanvas* canvas) const;
-
-    bool init(GLCanvas3D& canvas);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     static void detect_multisample(int* attribList);
 };
 
diff --git a/src/slic3r/GUI/GLSelectionRectangle.cpp b/src/slic3r/GUI/GLSelectionRectangle.cpp
index eacf7a153..d1d2b89f1 100644
--- a/src/slic3r/GUI/GLSelectionRectangle.cpp
+++ b/src/slic3r/GUI/GLSelectionRectangle.cpp
@@ -2,9 +2,7 @@
 #include "Camera.hpp"
 #include "3DScene.hpp"
 #include "GLCanvas3D.hpp"
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "GUI_App.hpp"
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #include <GL/glew.h>
 
@@ -38,11 +36,7 @@ namespace GUI {
 
         m_state = Off;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         const Camera& camera = wxGetApp().plater()->get_camera();
-#else
-        const Camera& camera = canvas.get_camera();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         const std::array<int, 4>& viewport = camera.get_viewport();
         const Transform3d& modelview_matrix = camera.get_view_matrix();
         const Transform3d& projection_matrix = camera.get_projection_matrix();
@@ -75,11 +69,7 @@ namespace GUI {
         if (!is_dragging())
             return;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
         const Camera& camera = wxGetApp().plater()->get_camera();
-#else
-        const Camera& camera = canvas.get_camera();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         float inv_zoom = (float)camera.get_inv_zoom();
 
         Size cnv_size = canvas.get_canvas_size();
diff --git a/src/slic3r/GUI/GLTexture.cpp b/src/slic3r/GUI/GLTexture.cpp
index 545b066bb..7daa89cc7 100644
--- a/src/slic3r/GUI/GLTexture.cpp
+++ b/src/slic3r/GUI/GLTexture.cpp
@@ -2,9 +2,7 @@
 #include "GLTexture.hpp"
 
 #include "3DScene.hpp"
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "GLCanvas3DManager.hpp"
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #include <GL/glew.h>
 
diff --git a/src/slic3r/GUI/GLToolbar.cpp b/src/slic3r/GUI/GLToolbar.cpp
index 0bd087814..0d437958c 100644
--- a/src/slic3r/GUI/GLToolbar.cpp
+++ b/src/slic3r/GUI/GLToolbar.cpp
@@ -3,14 +3,9 @@
 
 #include "GLToolbar.hpp"
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "slic3r/GUI/GLCanvas3D.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Camera.hpp"
-#else
-#include "../../slic3r/GUI/GLCanvas3D.hpp"
-#include "../../slic3r/GUI/Camera.hpp"
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #include <wx/event.h>
 #include <wx/bitmap.h>
@@ -729,11 +724,7 @@ std::string GLToolbar::update_hover_state_horizontal(const Vec2d& mouse_pos, GLC
 {
     // NB: mouse_pos is already scaled appropriately
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float factor = m_layout.scale * inv_zoom;
 
     Size cnv_size = parent.get_canvas_size();
@@ -874,11 +865,7 @@ std::string GLToolbar::update_hover_state_vertical(const Vec2d& mouse_pos, GLCan
 {
     // NB: mouse_pos is already scaled appropriately
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float factor = m_layout.scale * inv_zoom;
 
     Size cnv_size = parent.get_canvas_size();
@@ -1027,11 +1014,7 @@ int GLToolbar::contains_mouse_horizontal(const Vec2d& mouse_pos, const GLCanvas3
 {
     // NB: mouse_pos is already scaled appropriately
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float factor = m_layout.scale * inv_zoom;
 
     Size cnv_size = parent.get_canvas_size();
@@ -1104,11 +1087,7 @@ int GLToolbar::contains_mouse_vertical(const Vec2d& mouse_pos, const GLCanvas3D&
 {
     // NB: mouse_pos is already scaled appropriately
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float factor = m_layout.scale * inv_zoom;
 
     Size cnv_size = parent.get_canvas_size();
@@ -1260,11 +1239,7 @@ void GLToolbar::render_horizontal(const GLCanvas3D& parent) const
     int tex_width = m_icons_texture.get_width();
     int tex_height = m_icons_texture.get_height();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float factor = inv_zoom * m_layout.scale;
 
     float scaled_icons_size = m_layout.icons_size * factor;
@@ -1312,11 +1287,7 @@ void GLToolbar::render_vertical(const GLCanvas3D& parent) const
     int tex_width = m_icons_texture.get_width();
     int tex_height = m_icons_texture.get_height();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float inv_zoom = (float)parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     float factor = inv_zoom * m_layout.scale;
 
     float scaled_icons_size = m_layout.icons_size * factor;
diff --git a/src/slic3r/GUI/GUI_App.cpp b/src/slic3r/GUI/GUI_App.cpp
index 4f92906a5..3ea1cb0e0 100644
--- a/src/slic3r/GUI/GUI_App.cpp
+++ b/src/slic3r/GUI/GUI_App.cpp
@@ -283,7 +283,6 @@ GUI_App::~GUI_App()
         delete preset_updater;
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 std::string GUI_App::get_gl_info(bool format_as_html, bool extensions)
 {
     return GLCanvas3DManager::get_gl_info().to_string(format_as_html, extensions);
@@ -298,7 +297,6 @@ bool GUI_App::init_opengl()
 {
     return m_canvas_mgr.init_gl();
 }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 void GUI_App::init_app_config()
 {
diff --git a/src/slic3r/GUI/GUI_App.hpp b/src/slic3r/GUI/GUI_App.hpp
index b2fcef48b..6a9711689 100644
--- a/src/slic3r/GUI/GUI_App.hpp
+++ b/src/slic3r/GUI/GUI_App.hpp
@@ -7,9 +7,7 @@
 #include "MainFrame.hpp"
 #include "ImGuiWrapper.hpp"
 #include "ConfigWizard.hpp"
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "GLCanvas3DManager.hpp"
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #include <wx/app.h>
 #include <wx/colour.h>
@@ -100,9 +98,7 @@ class GUI_App : public wxApp
     // Best translation language, provided by Windows or OSX, owned by wxWidgets.
     const wxLanguageInfo		 *m_language_info_best   = nullptr;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     GLCanvas3DManager m_canvas_mgr;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     std::unique_ptr<RemovableDriveManager> m_removable_drive_manager;
 
@@ -117,11 +113,9 @@ public:
     GUI_App();
     ~GUI_App() override;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     static std::string get_gl_info(bool format_as_html, bool extensions);
     wxGLContext* init_glcontext(wxGLCanvas& canvas);
     bool init_opengl();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     static unsigned get_colour_approx_luma(const wxColour &colour);
     static bool     dark_mode();
diff --git a/src/slic3r/GUI/GUI_Preview.cpp b/src/slic3r/GUI/GUI_Preview.cpp
index b4cbe4461..ec919eaad 100644
--- a/src/slic3r/GUI/GUI_Preview.cpp
+++ b/src/slic3r/GUI/GUI_Preview.cpp
@@ -27,51 +27,27 @@
 namespace Slic3r {
 namespace GUI {
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 View3D::View3D(wxWindow* parent, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process)
     : m_canvas_widget(nullptr)
     , m_canvas(nullptr)
 {
     init(parent, model, config, process);
 }
-#else
-View3D::View3D(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process)
-    : m_canvas_widget(nullptr)
-    , m_canvas(nullptr)
-{
-    init(parent, bed, camera, view_toolbar, model, config, process);
-}
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 View3D::~View3D()
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (m_canvas != nullptr)
         delete m_canvas;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     if (m_canvas_widget != nullptr)
-    {
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-        _3DScene::remove_canvas(m_canvas_widget);
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
         delete m_canvas_widget;
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-        m_canvas = nullptr;
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
-    }
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 bool View3D::init(wxWindow* parent, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process)
-#else
-bool View3D::init(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process)
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 {
     if (!Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 /* disable wxTAB_TRAVERSAL */))
         return false;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     m_canvas_widget = GLCanvas3DManager::create_wxglcanvas(*this);
     if (m_canvas_widget == nullptr)
         return false;
@@ -79,11 +55,6 @@ bool View3D::init(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_
     m_canvas = new GLCanvas3D(m_canvas_widget);
     m_canvas->set_context(wxGetApp().init_glcontext(*m_canvas_widget));
     m_canvas->bind_event_handlers();
-#else
-    m_canvas_widget = GLCanvas3DManager::create_wxglcanvas(this);
-    _3DScene::add_canvas(m_canvas_widget, bed, camera, view_toolbar);
-    m_canvas = _3DScene::get_canvas(this->m_canvas_widget);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     m_canvas->allow_multisample(GLCanvas3DManager::can_multisample());
     // XXX: If have OpenGL
@@ -199,27 +170,15 @@ void View3D::render()
         m_canvas->set_as_dirty();
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #if ENABLE_GCODE_VIEWER
 Preview::Preview(
-    wxWindow* parent, Model* model, DynamicPrintConfig* config,
-    BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, GCodeProcessor::Result* gcode_result, std::function<void()> schedule_background_process_func)
+    wxWindow * parent, Model * model, DynamicPrintConfig * config,
+    BackgroundSlicingProcess * process, GCodePreviewData * gcode_preview_data, GCodeProcessor::Result * gcode_result, std::function<void()> schedule_background_process_func)
 #else
 Preview::Preview(
     wxWindow* parent, Model* model, DynamicPrintConfig* config,
     BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, std::function<void()> schedule_background_process_func)
 #endif // ENABLE_GCODE_VIEWER
-#else
-#if ENABLE_GCODE_VIEWER
-Preview::Preview(
-    wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config,
-    BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, GCodeProcessor::Result* gcode_result, std::function<void()> schedule_background_process_func)
-#else
-Preview::Preview(
-    wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config,
-    BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, std::function<void()> schedule_background_process_func)
-#endif // ENABLE_GCODE_VIEWER
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     : m_canvas_widget(nullptr)
     , m_canvas(nullptr)
     , m_double_slider_sizer(nullptr)
@@ -254,11 +213,7 @@ Preview::Preview(
     , m_volumes_cleanup_required(false)
 #endif // __linux__
 {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (init(parent, model))
-#else
-    if (init(parent, bed, camera, view_toolbar, model))
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     {
 #if !ENABLE_GCODE_VIEWER
         show_hide_ui_elements("none");
@@ -267,16 +222,11 @@ Preview::Preview(
     }
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 bool Preview::init(wxWindow* parent, Model* model)
-#else
-bool Preview::init(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model)
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 {
     if (!Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 /* disable wxTAB_TRAVERSAL */))
         return false;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     m_canvas_widget = GLCanvas3DManager::create_wxglcanvas(*this);
     if (m_canvas_widget == nullptr)
         return false;
@@ -284,11 +234,6 @@ bool Preview::init(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view
     m_canvas = new GLCanvas3D(m_canvas_widget);
     m_canvas->set_context(wxGetApp().init_glcontext(*m_canvas_widget));
     m_canvas->bind_event_handlers();
-#else
-    m_canvas_widget = GLCanvas3DManager::create_wxglcanvas(this);
-    _3DScene::add_canvas(m_canvas_widget, bed, camera, view_toolbar);
-    m_canvas = _3DScene::get_canvas(this->m_canvas_widget);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     m_canvas->allow_multisample(GLCanvas3DManager::can_multisample());
     m_canvas->set_config(m_config);
     m_canvas->set_model(model);
@@ -435,19 +380,11 @@ Preview::~Preview()
 {
     unbind_event_handlers();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     if (m_canvas != nullptr)
         delete m_canvas;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     if (m_canvas_widget != nullptr)
-    {
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-        _3DScene::remove_canvas(m_canvas_widget);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         delete m_canvas_widget;
-        m_canvas = nullptr;
-    }
 }
 
 void Preview::set_as_dirty()
diff --git a/src/slic3r/GUI/GUI_Preview.hpp b/src/slic3r/GUI/GUI_Preview.hpp
index a7db054bc..90943de00 100644
--- a/src/slic3r/GUI/GUI_Preview.hpp
+++ b/src/slic3r/GUI/GUI_Preview.hpp
@@ -37,9 +37,7 @@ class GLCanvas3D;
 class GLToolbar;
 class Bed3D;
 struct Camera;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 class Plater;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 class View3D : public wxPanel
 {
@@ -47,11 +45,7 @@ class View3D : public wxPanel
     GLCanvas3D* m_canvas;
 
 public:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     View3D(wxWindow* parent, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process);
-#else
-    View3D(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     virtual ~View3D();
 
     wxGLCanvas* get_wxglcanvas() { return m_canvas_widget; }
@@ -79,11 +73,7 @@ public:
     void render();
 
 private:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bool init(wxWindow* parent, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process);
-#else
-    bool init(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 };
 
 class Preview : public wxPanel
@@ -133,23 +123,13 @@ class Preview : public wxPanel
     DoubleSlider::Control*       m_slider {nullptr};
 
 public:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #if ENABLE_GCODE_VIEWER
-    Preview(wxWindow* parent, Model* model, DynamicPrintConfig* config,
-        BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, GCodeProcessor::Result* gcode_result, std::function<void()> schedule_background_process = []() {});
+Preview(wxWindow * parent, Model * model, DynamicPrintConfig * config,
+    BackgroundSlicingProcess * process, GCodePreviewData * gcode_preview_data, GCodeProcessor::Result * gcode_result, std::function<void()> schedule_background_process = []() {});
 #else
-    Preview(wxWindow* parent, Model* model, DynamicPrintConfig* config,
+Preview(wxWindow* parent, Model* model, DynamicPrintConfig* config,
         BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, std::function<void()> schedule_background_process = []() {});
 #endif // ENABLE_GCODE_VIEWER
-#else
-#if ENABLE_GCODE_VIEWER
-    Preview(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config,
-        BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, GCodeProcessor::Result* gcode_result, std::function<void()> schedule_background_process = []() {});
-#else
-    Preview(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model, DynamicPrintConfig* config,
-        BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, std::function<void()> schedule_background_process = []() {});
-#endif // ENABLE_GCODE_VIEWER
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     virtual ~Preview();
 
     wxGLCanvas* get_wxglcanvas() { return m_canvas_widget; }
@@ -180,11 +160,7 @@ public:
 #endif // ENABLE_GCODE_VIEWER
 
 private:
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     bool init(wxWindow* parent, Model* model);
-#else
-    bool init(wxWindow* parent, Bed3D& bed, Camera& camera, GLToolbar& view_toolbar, Model* model);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     void bind_event_handlers();
     void unbind_event_handlers();
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp b/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
index d2f668dab..b248db1c6 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
@@ -220,11 +220,7 @@ bool GLGizmoHollow::unproject_on_mesh(const Vec2d& mouse_pos, std::pair<Vec3f, V
     if (! m_c->raycaster()->raycaster())
         return false;
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const Camera& camera = wxGetApp().plater()->get_camera();
-#else
-    const Camera& camera = m_parent.get_camera();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     const Selection& selection = m_parent.get_selection();
     const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin());
     Geometry::Transformation trafo = volume->get_instance_transformation();
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
index 685e49d36..5f09a3daf 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
@@ -2,9 +2,7 @@
 #include "GLGizmosManager.hpp"
 #include "slic3r/GUI/GLCanvas3D.hpp"
 #include "slic3r/GUI/3DScene.hpp"
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "slic3r/GUI/Camera.hpp"
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/GUI_ObjectManipulation.hpp"
 #include "slic3r/GUI/PresetBundle.hpp"
@@ -1076,13 +1074,8 @@ void GLGizmosManager::do_render_overlay() const
 
     float cnv_w = (float)m_parent.get_canvas_size().get_width();
     float cnv_h = (float)m_parent.get_canvas_size().get_height();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     float zoom = (float)wxGetApp().plater()->get_camera().get_zoom();
     float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
-#else
-    float zoom = (float)m_parent.get_camera().get_zoom();
-    float inv_zoom = (float)m_parent.get_camera().get_inv_zoom();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     float height = get_scaled_total_height();
     float width = get_scaled_total_width();
@@ -1133,11 +1126,7 @@ void GLGizmosManager::do_render_overlay() const
 
         GLTexture::render_sub_texture(icons_texture_id, zoomed_top_x, zoomed_top_x + zoomed_icons_size, zoomed_top_y - zoomed_icons_size, zoomed_top_y, { { u_left, v_bottom }, { u_right, v_bottom }, { u_right, v_top }, { u_left, v_top } });
         if (idx == m_current) {
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
             float toolbar_top = cnv_h - wxGetApp().plater()->get_view_toolbar().get_height();
-#else
-            float toolbar_top = cnv_h - m_parent.get_view_toolbar_height();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
             gizmo->render_input_window(width, 0.5f * cnv_h - zoomed_top_y * zoom, toolbar_top);
         }
         zoomed_top_y -= zoomed_stride_y;
diff --git a/src/slic3r/GUI/MainFrame.cpp b/src/slic3r/GUI/MainFrame.cpp
index d3bd2720e..dd39f86d1 100644
--- a/src/slic3r/GUI/MainFrame.cpp
+++ b/src/slic3r/GUI/MainFrame.cpp
@@ -212,7 +212,6 @@ void MainFrame::shutdown()
     if (m_plater)
     	m_plater->stop_jobs();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     // Unbinding of wxWidgets event handling in canvases needs to be done here because on MAC,
     // when closing the application using Command+Q, a mouse event is triggered after this lambda is completed,
     // causing a crash
@@ -221,7 +220,6 @@ void MainFrame::shutdown()
     // Cleanup of canvases' volumes needs to be done here or a crash may happen on some Linux Debian flavours
     // see: https://github.com/prusa3d/PrusaSlicer/issues/3964
     if (m_plater) m_plater->reset_canvas_volumes();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     // Weird things happen as the Paint messages are floating around the windows being destructed.
     // Avoid the Paint messages by hiding the main window.
@@ -244,9 +242,6 @@ void MainFrame::shutdown()
     wxGetApp().app_config->save();
 //         if (m_plater)
 //             m_plater->print = undef;
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    _3DScene::remove_all_canvases();
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
 //         Slic3r::GUI::deregister_on_request_update_callback();
 
     // set to null tabs and a plater
diff --git a/src/slic3r/GUI/Plater.cpp b/src/slic3r/GUI/Plater.cpp
index a9e82b8e8..7d6497731 100644
--- a/src/slic3r/GUI/Plater.cpp
+++ b/src/slic3r/GUI/Plater.cpp
@@ -77,11 +77,9 @@
 #include "RemovableDriveManager.hpp"
 #include "InstanceCheck.hpp"
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 #ifdef __APPLE__
 #include "Gizmos/GLGizmosManager.hpp"
 #endif // __APPLE__
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #include <wx/glcanvas.h>    // Needs to be last because reasons :-/
 #include "WipeTowerDialog.hpp"
@@ -1635,10 +1633,8 @@ struct Plater::priv
 
     void set_current_canvas_as_dirty();
     GLCanvas3D* get_current_canvas3D();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     void unbind_canvas_event_handlers();
     void reset_canvas_volumes();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     bool init_view_toolbar();
 #if ENABLE_GCODE_VIEWER
@@ -1870,7 +1866,6 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
     sla_print.set_status_callback(statuscb);
     this->q->Bind(EVT_SLICING_UPDATE, &priv::on_slicing_update, this);
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     view3D = new View3D(q, &model, config, &background_process);
 #if ENABLE_GCODE_VIEWER
     preview = new Preview(q, &model, config, &background_process, &gcode_preview_data, &gcode_result, [this]() { schedule_background_process(); });
@@ -1882,14 +1877,6 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
     // set default view_toolbar icons size equal to GLGizmosManager::Default_Icons_Size
     view_toolbar.set_icons_size(GLGizmosManager::Default_Icons_Size);
 #endif // __APPLE__
-#else
-    view3D = new View3D(q, bed, camera, view_toolbar, &model, config, &background_process);
-#if ENABLE_GCODE_VIEWER
-    preview = new Preview(q, bed, camera, view_toolbar, &model, config, &background_process, &gcode_preview_data, &gcode_result, [this]() { schedule_background_process(); });
-#else
-    preview = new Preview(q, bed, camera, view_toolbar, &model, config, &background_process, &gcode_preview_data, [this]() { schedule_background_process(); });
-#endif // ENABLE_GCODE_VIEWER
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     panels.push_back(view3D);
     panels.push_back(preview);
@@ -1990,10 +1977,6 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
 
     // Drop target:
     q->SetDropTarget(new PlaterDropTarget(q));   // if my understanding is right, wxWindow takes the owenership
-
-#if !ENABLE_NON_STATIC_CANVAS_MANAGER
-    update_ui_from_settings();
-#endif // !ENABLE_NON_STATIC_CANVAS_MANAGER
     q->Layout();
 
     set_current_panel(view3D);
@@ -3801,7 +3784,6 @@ GLCanvas3D* Plater::priv::get_current_canvas3D()
     return (current_panel == view3D) ? view3D->get_canvas3d() : ((current_panel == preview) ? preview->get_canvas3d() : nullptr);
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 void Plater::priv::unbind_canvas_event_handlers()
 {
     if (view3D != nullptr)
@@ -3819,7 +3801,6 @@ void Plater::priv::reset_canvas_volumes()
     if (preview != nullptr)
         preview->get_canvas3d()->reset_volumes();
 }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 bool Plater::priv::init_view_toolbar()
 {
@@ -5270,7 +5251,6 @@ void Plater::set_current_canvas_as_dirty()
     p->set_current_canvas_as_dirty();
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 void Plater::unbind_canvas_event_handlers()
 {
     p->unbind_canvas_event_handlers();
@@ -5280,7 +5260,6 @@ void Plater::reset_canvas_volumes()
 {
     p->reset_canvas_volumes();
 }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 PrinterTechnology Plater::printer_technology() const
 {
@@ -5438,7 +5417,6 @@ Camera& Plater::get_camera()
     return p->camera;
 }
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 const Bed3D& Plater::get_bed() const
 {
     return p->bed;
@@ -5458,7 +5436,6 @@ GLToolbar& Plater::get_view_toolbar()
 {
     return p->view_toolbar;
 }
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_GCODE_VIEWER
 void Plater::update_preview_bottom_toolbar()
diff --git a/src/slic3r/GUI/Plater.hpp b/src/slic3r/GUI/Plater.hpp
index 7e0283935..7a08c04ef 100644
--- a/src/slic3r/GUI/Plater.hpp
+++ b/src/slic3r/GUI/Plater.hpp
@@ -45,10 +45,8 @@ class ObjectList;
 class GLCanvas3D;
 class Mouse3DController;
 struct Camera;
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
 class Bed3D;
 class GLToolbar;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 using t_optgroups = std::vector <std::shared_ptr<ConfigOptionsGroup>>;
 
@@ -280,10 +278,8 @@ public:
     void find_new_position(const ModelInstancePtrs  &instances, coord_t min_d);
 
     void set_current_canvas_as_dirty();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     void unbind_canvas_event_handlers();
     void reset_canvas_volumes();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     PrinterTechnology   printer_technology() const;
     const DynamicPrintConfig * config() const;
@@ -316,13 +312,11 @@ public:
     const Camera& get_camera() const;
     Camera& get_camera();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const Bed3D& get_bed() const;
     Bed3D& get_bed();
 
     const GLToolbar& get_view_toolbar() const;
     GLToolbar& get_view_toolbar();
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
 #if ENABLE_GCODE_VIEWER
     void update_preview_bottom_toolbar();
diff --git a/src/slic3r/GUI/Selection.cpp b/src/slic3r/GUI/Selection.cpp
index b07463857..87f8b60ed 100644
--- a/src/slic3r/GUI/Selection.cpp
+++ b/src/slic3r/GUI/Selection.cpp
@@ -440,11 +440,9 @@ void Selection::clear()
     update_type();
     this->set_bounding_boxes_dirty();
 
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     // this happens while the application is closing
     if (wxGetApp().obj_manipul() == nullptr)
         return;
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
 
     // resets the cache in the sidebar
     wxGetApp().obj_manipul()->reset_cache();
diff --git a/src/slic3r/GUI/SysInfoDialog.cpp b/src/slic3r/GUI/SysInfoDialog.cpp
index f26fe7033..9e7d1bad6 100644
--- a/src/slic3r/GUI/SysInfoDialog.cpp
+++ b/src/slic3r/GUI/SysInfoDialog.cpp
@@ -145,11 +145,7 @@ SysInfoDialog::SysInfoDialog()
             "</font>"
             "</body>"
             "</html>", bgr_clr_str, text_clr_str, text_clr_str,
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
             get_mem_info(true) + "<br>" + wxGetApp().get_gl_info(true, true));
-#else
-            get_mem_info(true) + "<br>" + _3DScene::get_gl_info(true, true));
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
         m_opengl_info_html->SetPage(text);
         main_sizer->Add(m_opengl_info_html, 1, wxEXPAND | wxBOTTOM, 15);
     }
@@ -202,11 +198,7 @@ void SysInfoDialog::on_dpi_changed(const wxRect &suggested_rect)
 void SysInfoDialog::onCopyToClipboard(wxEvent &)
 {
     wxTheClipboard->Open();
-#if ENABLE_NON_STATIC_CANVAS_MANAGER
     const auto text = get_main_info(false) + "\n" + wxGetApp().get_gl_info(false, true);
-#else
-    const auto text = get_main_info(false)+"\n"+_3DScene::get_gl_info(false, true);
-#endif // ENABLE_NON_STATIC_CANVAS_MANAGER
     wxTheClipboard->SetData(new wxTextDataObject(text));
     wxTheClipboard->Close();
 }