diff --git a/src/libslic3r/AABBMesh.cpp b/src/libslic3r/AABBMesh.cpp
index 9b57558557..feec61ba03 100644
--- a/src/libslic3r/AABBMesh.cpp
+++ b/src/libslic3r/AABBMesh.cpp
@@ -3,12 +3,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "AABBMesh.hpp"
-#include <libslic3r/Execution/ExecutionTBB.hpp>
 
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/TriangleMesh.hpp>
+#include <igl/Hit.h>
+#include <algorithm>
 
-#include <numeric>
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
 
 #ifdef SLIC3R_HOLE_RAYCASTER
 #include <libslic3r/SLA/Hollowing.hpp>
diff --git a/src/libslic3r/AABBMesh.hpp b/src/libslic3r/AABBMesh.hpp
index bb04aad2cb..2392013623 100644
--- a/src/libslic3r/AABBMesh.hpp
+++ b/src/libslic3r/AABBMesh.hpp
@@ -5,11 +5,14 @@
 #ifndef PRUSASLICER_AABBMESH_H
 #define PRUSASLICER_AABBMESH_H
 
-#include <memory>
-#include <vector>
-
 #include <libslic3r/Point.hpp>
 #include <libslic3r/TriangleMesh.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <memory>
+#include <vector>
+#include <cmath>
+#include <limits>
 
 // There is an implementation of a hole-aware raycaster that was eventually
 // not used in production version. It is now hidden under following define
diff --git a/src/libslic3r/Algorithm/RegionExpansion.cpp b/src/libslic3r/Algorithm/RegionExpansion.cpp
index 1f59a36e41..89bfa4905b 100644
--- a/src/libslic3r/Algorithm/RegionExpansion.cpp
+++ b/src/libslic3r/Algorithm/RegionExpansion.cpp
@@ -8,8 +8,19 @@
 #include <libslic3r/ClipperZUtils.hpp>
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Utils.hpp>
-
+#include <assert.h>
+#include <clipper/clipper_z.hpp>
 #include <numeric>
+#include <cmath>
+#include <iterator>
+#include <utility>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 namespace Algorithm {
diff --git a/src/libslic3r/Algorithm/RegionExpansion.hpp b/src/libslic3r/Algorithm/RegionExpansion.hpp
index 62e32526aa..0c99459c69 100644
--- a/src/libslic3r/Algorithm/RegionExpansion.hpp
+++ b/src/libslic3r/Algorithm/RegionExpansion.hpp
@@ -5,10 +5,13 @@
 #ifndef SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 #define SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 
-#include <cstdint>
 #include <libslic3r/Point.hpp>
 #include <libslic3r/Polygon.hpp>
 #include <libslic3r/ExPolygon.hpp>
+#include <stddef.h>
+#include <cstdint>
+#include <algorithm>
+#include <vector>
 
 namespace Slic3r {
 namespace Algorithm {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp
index f1031f4083..5ade0c9207 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp
@@ -1,8 +1,6 @@
 //Copyright (c) 2022 Ultimaker B.V.
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
-#include <cassert>
-
 #include "BeadingStrategy.hpp"
 #include "libslic3r/Point.hpp"
 
diff --git a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp
index aa645f3c80..18fd501254 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp
@@ -4,7 +4,10 @@
 #ifndef BEADING_STRATEGY_H
 #define BEADING_STRATEGY_H
 
+#include <math.h>
 #include <memory>
+#include <string>
+#include <vector>
 
 #include "libslic3r/libslic3r.h"
 
diff --git a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp
index 853facb213..fd0f0d9b39 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp
@@ -3,13 +3,16 @@
 
 #include "BeadingStrategyFactory.hpp"
 
+#include <boost/log/trivial.hpp>
+#include <memory>
+#include <utility>
+
 #include "LimitedBeadingStrategy.hpp"
 #include "WideningBeadingStrategy.hpp"
 #include "DistributedBeadingStrategy.hpp"
 #include "RedistributeBeadingStrategy.hpp"
 #include "OuterWallInsetBeadingStrategy.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne {
 
diff --git a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp
index a586906f45..9d04d636ed 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp
@@ -4,8 +4,11 @@
 #ifndef BEADING_STRATEGY_FACTORY_H
 #define BEADING_STRATEGY_FACTORY_H
 
+#include <math.h>
+
 #include "BeadingStrategy.hpp"
 #include "../../Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp b/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp
index c8a84c4011..60d0d86144 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp
@@ -1,7 +1,12 @@
 // Copyright (c) 2022 Ultimaker B.V.
 // CuraEngine is released under the terms of the AGPLv3 or higher.
+#include <assert.h>
 #include <numeric>
+#include <algorithm>
+#include <vector>
+
 #include "DistributedBeadingStrategy.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.hpp b/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.hpp
index 4d651732d4..991d5028b7 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.hpp
@@ -5,6 +5,7 @@
 #define DISTRIBUTED_BEADING_STRATEGY_H
 
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp b/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp
index 4249851fd2..4903cb0a73 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp
@@ -1,11 +1,14 @@
 //Copyright (c) 2022 Ultimaker B.V.
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
-#include <cassert>
 #include <boost/log/trivial.hpp>
+#include <stddef.h>
+#include <cassert>
+#include <utility>
 
 #include "LimitedBeadingStrategy.hpp"
 #include "libslic3r/Point.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp b/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp
index 33292bc09f..166057f03e 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp
@@ -4,7 +4,10 @@
 #ifndef LIMITED_BEADING_STRATEGY_H
 #define LIMITED_BEADING_STRATEGY_H
 
+#include <string>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp b/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp
index 1406f7daa8..ac9edb1dba 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp
@@ -4,6 +4,9 @@
 #include "OuterWallInsetBeadingStrategy.hpp"
 
 #include <algorithm>
+#include <utility>
+
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.hpp b/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.hpp
index 45a700b02e..f0b4622df3 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.hpp
@@ -4,7 +4,10 @@
 #ifndef OUTER_WALL_INSET_BEADING_STRATEGY_H
 #define OUTER_WALL_INSET_BEADING_STRATEGY_H
 
+#include <string>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp b/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp
index 2b4dda0272..7307781840 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp
@@ -5,6 +5,9 @@
 
 #include <algorithm>
 #include <numeric>
+#include <utility>
+
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.hpp b/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.hpp
index f0fefe2389..701aa63041 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.hpp
@@ -4,7 +4,10 @@
 #ifndef REDISTRIBUTE_DISTRIBUTED_BEADING_STRATEGY_H
 #define REDISTRIBUTE_DISTRIBUTED_BEADING_STRATEGY_H
 
+#include <string>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp b/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp
index 5345c49269..4c6dbb2706 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp
@@ -3,6 +3,11 @@
 
 #include "WideningBeadingStrategy.hpp"
 
+#include <algorithm>
+#include <utility>
+
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
+
 namespace Slic3r::Arachne
 {
 
diff --git a/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.hpp b/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.hpp
index 3e799b9af7..225aeed88b 100644
--- a/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.hpp
+++ b/src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.hpp
@@ -4,7 +4,11 @@
 #ifndef WIDENING_BEADING_STRATEGY_H
 #define WIDENING_BEADING_STRATEGY_H
 
+#include <string>
+#include <vector>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/PerimeterOrder.cpp b/src/libslic3r/Arachne/PerimeterOrder.cpp
index dd2404122c..dcc2a3fcbb 100644
--- a/src/libslic3r/Arachne/PerimeterOrder.cpp
+++ b/src/libslic3r/Arachne/PerimeterOrder.cpp
@@ -1,5 +1,10 @@
 #include <stack>
+#include <algorithm>
+#include <cmath>
+
 #include "PerimeterOrder.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Arachne::PerimeterOrder {
 
diff --git a/src/libslic3r/Arachne/PerimeterOrder.hpp b/src/libslic3r/Arachne/PerimeterOrder.hpp
index 5db83727f9..27e896fc3d 100644
--- a/src/libslic3r/Arachne/PerimeterOrder.hpp
+++ b/src/libslic3r/Arachne/PerimeterOrder.hpp
@@ -1,7 +1,13 @@
 #ifndef slic3r_GCode_PerimeterOrder_hpp_
 #define slic3r_GCode_PerimeterOrder_hpp_
 
+#include <stddef.h>
+#include <limits>
+#include <vector>
+
 #include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r::Arachne::PerimeterOrder {
 
diff --git a/src/libslic3r/Arachne/SkeletalTrapezoidation.cpp b/src/libslic3r/Arachne/SkeletalTrapezoidation.cpp
index ca33d5dee2..3a2c5f507e 100644
--- a/src/libslic3r/Arachne/SkeletalTrapezoidation.cpp
+++ b/src/libslic3r/Arachne/SkeletalTrapezoidation.cpp
@@ -3,20 +3,23 @@
 
 #include "SkeletalTrapezoidation.hpp"
 
-#include <stack>
-#include <functional>
-#include <sstream>
-#include <queue>
 #include <boost/log/trivial.hpp>
-
-#include "utils/linearAlg2D.hpp"
-#include "libslic3r/Utils.hpp"
-#include "libslic3r/SVG.hpp"
-#include "libslic3r/Geometry/VoronoiVisualUtils.hpp"
-#include "libslic3r/Geometry/VoronoiUtilsCgal.hpp"
-#include "libslic3r/EdgeGrid.hpp"
+#include <assert.h>
+#include <stdlib.h>
+#include <boost/polygon/polygon.hpp>
+#include <queue>
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <utility>
 
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
+#include "ankerl/unordered_dense.h"
+#include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
 
 #define SKELETAL_TRAPEZOIDATION_BEAD_SEARCH_MAX 1000 //A limit to how long it'll keep searching for adjacent beads. Increasing will re-use beadings more often (saving performance), but search longer for beading (costing performance).
 
diff --git a/src/libslic3r/Arachne/SkeletalTrapezoidation.hpp b/src/libslic3r/Arachne/SkeletalTrapezoidation.hpp
index a728d7b03d..4610b1b9df 100644
--- a/src/libslic3r/Arachne/SkeletalTrapezoidation.hpp
+++ b/src/libslic3r/Arachne/SkeletalTrapezoidation.hpp
@@ -5,11 +5,11 @@
 #define SKELETAL_TRAPEZOIDATION_H
 
 #include <boost/polygon/voronoi.hpp>
-
+#include <ankerl/unordered_dense.h>
 #include <memory> // smart pointers
 #include <utility> // pair
-
-#include <ankerl/unordered_dense.h>
+#include <list>
+#include <vector>
 
 #include "utils/HalfEdgeGraph.hpp"
 #include "utils/PolygonsSegmentIndex.hpp"
@@ -20,6 +20,10 @@
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 #include "SkeletalTrapezoidationGraph.hpp"
 #include "../Geometry/Voronoi.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 //#define ARACHNE_DEBUG
 //#define ARACHNE_DEBUG_VORONOI
diff --git a/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp b/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp
index 97932c5abb..1ecb8bd96d 100644
--- a/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp
+++ b/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp
@@ -4,11 +4,16 @@
 #include "SkeletalTrapezoidationGraph.hpp"
 
 #include <ankerl/unordered_dense.h>
-
 #include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <algorithm>
+#include <iostream>
 
-#include "utils/linearAlg2D.hpp"
 #include "../Line.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp b/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp
index ffd1edb55b..5baac24acc 100644
--- a/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp
+++ b/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp
@@ -5,14 +5,19 @@
 #define SKELETAL_TRAPEZOIDATION_GRAPH_H
 
 #include <optional>
+#include <utility>
 
 #include "utils/HalfEdgeGraph.hpp"
 #include "SkeletalTrapezoidationEdge.hpp"
 #include "SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Arachne/utils/HalfEdge.hpp"
+#include "libslic3r/Arachne/utils/HalfEdgeNode.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r
 {
 class Line;
+class Point;
 };
 
 namespace Slic3r::Arachne
diff --git a/src/libslic3r/Arachne/WallToolPaths.cpp b/src/libslic3r/Arachne/WallToolPaths.cpp
index 6c18d5cb9f..59c56be077 100644
--- a/src/libslic3r/Arachne/WallToolPaths.cpp
+++ b/src/libslic3r/Arachne/WallToolPaths.cpp
@@ -1,21 +1,29 @@
 // Copyright (c) 2022 Ultimaker B.V.
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 
+#include <assert.h>
+#include <math.h>
+#include <stdint.h>
 #include <algorithm> //For std::partition_copy and std::min_element.
+#include <limits>
+#include <memory>
 
 #include "WallToolPaths.hpp"
-
 #include "SkeletalTrapezoidation.hpp"
 #include "utils/linearAlg2D.hpp"
 #include "utils/SparseLineGrid.hpp"
-#include "libslic3r/EdgeGrid.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "utils/PolylineStitcher.hpp"
-#include "libslic3r/SVG.hpp"
-#include "libslic3r/Utils.hpp"
 #include "libslic3r/ClipperUtils.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 //#define ARACHNE_STITCH_PATCH_DEBUG
 
diff --git a/src/libslic3r/Arachne/WallToolPaths.hpp b/src/libslic3r/Arachne/WallToolPaths.hpp
index bdc8593cab..cceb6191ad 100644
--- a/src/libslic3r/Arachne/WallToolPaths.hpp
+++ b/src/libslic3r/Arachne/WallToolPaths.hpp
@@ -4,14 +4,22 @@
 #ifndef CURAENGINE_WALLTOOLPATHS_H
 #define CURAENGINE_WALLTOOLPATHS_H
 
-#include <memory>
-
 #include <ankerl/unordered_dense.h>
+#include <stddef.h>
+#include <memory>
+#include <utility>
+#include <vector>
 
 #include "BeadingStrategy/BeadingStrategyFactory.hpp"
 #include "utils/ExtrusionLine.hpp"
 #include "../Polygon.hpp"
 #include "../PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+
+namespace boost {
+template <class T> struct hash;
+}  // namespace boost
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/utils/ExtrusionLine.cpp b/src/libslic3r/Arachne/utils/ExtrusionLine.cpp
index 7626b2b4b3..77fa1f6577 100644
--- a/src/libslic3r/Arachne/utils/ExtrusionLine.cpp
+++ b/src/libslic3r/Arachne/utils/ExtrusionLine.cpp
@@ -1,11 +1,22 @@
 //Copyright (c) 2020 Ultimaker B.V.
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
+#include <stdlib.h>
 #include <algorithm>
+#include <cmath>
 
 #include "ExtrusionLine.hpp"
-#include "linearAlg2D.hpp"
 #include "../../PerimeterGenerator.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+
+namespace Slic3r {
+class Flow;
+}  // namespace Slic3r
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/utils/ExtrusionLine.hpp b/src/libslic3r/Arachne/utils/ExtrusionLine.hpp
index f3469bfe01..7f00bcdfc6 100644
--- a/src/libslic3r/Arachne/utils/ExtrusionLine.hpp
+++ b/src/libslic3r/Arachne/utils/ExtrusionLine.hpp
@@ -5,16 +5,26 @@
 #ifndef UTILS_EXTRUSION_LINE_H
 #define UTILS_EXTRUSION_LINE_H
 
+#include <clipper/clipper_z.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <utility>
+#include <vector>
+
 #include "ExtrusionJunction.hpp"
 #include "../../Polyline.hpp"
 #include "../../Polygon.hpp"
 #include "../../BoundingBox.hpp"
 #include "../../ExtrusionEntity.hpp"
 #include "../../Flow.hpp"
-#include <clipper/clipper_z.hpp>
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 struct ThickPolyline;
+class Flow;
 }
 
 namespace Slic3r::Arachne
diff --git a/src/libslic3r/Arachne/utils/PolylineStitcher.cpp b/src/libslic3r/Arachne/utils/PolylineStitcher.cpp
index 89ec929540..0abf63ac10 100644
--- a/src/libslic3r/Arachne/utils/PolylineStitcher.cpp
+++ b/src/libslic3r/Arachne/utils/PolylineStitcher.cpp
@@ -2,7 +2,16 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "PolylineStitcher.hpp"
+
 #include "ExtrusionLine.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Polygon.hpp"
+
+namespace Slic3r {
+namespace Arachne {
+struct ExtrusionJunction;
+}  // namespace Arachne
+}  // namespace Slic3r
 
 namespace Slic3r::Arachne {
 
diff --git a/src/libslic3r/Arachne/utils/PolylineStitcher.hpp b/src/libslic3r/Arachne/utils/PolylineStitcher.hpp
index 113761ce15..ad05a7799d 100644
--- a/src/libslic3r/Arachne/utils/PolylineStitcher.hpp
+++ b/src/libslic3r/Arachne/utils/PolylineStitcher.hpp
@@ -4,10 +4,18 @@
 #ifndef UTILS_POLYLINE_STITCHER_H
 #define UTILS_POLYLINE_STITCHER_H
 
+#include <stddef.h>
+#include <stdint.h>
+#include <cassert>
+#include <functional>
+#include <limits>
+#include <vector>
+
 #include "SparsePointGrid.hpp"
 #include "PolygonsPointIndex.hpp"
 #include "../../Polygon.hpp"
-#include <cassert>
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {
diff --git a/src/libslic3r/Arachne/utils/SquareGrid.cpp b/src/libslic3r/Arachne/utils/SquareGrid.cpp
index 856eb5968b..1af9910426 100644
--- a/src/libslic3r/Arachne/utils/SquareGrid.cpp
+++ b/src/libslic3r/Arachne/utils/SquareGrid.cpp
@@ -3,6 +3,10 @@
 
 #include "SquareGrid.hpp"
 
+#include <cassert>
+
+#include "libslic3r/Point.hpp"
+
 using namespace Slic3r::Arachne;
 
 
diff --git a/src/libslic3r/Arachne/utils/SquareGrid.hpp b/src/libslic3r/Arachne/utils/SquareGrid.hpp
index 5787e3bf12..8372bfe494 100644
--- a/src/libslic3r/Arachne/utils/SquareGrid.hpp
+++ b/src/libslic3r/Arachne/utils/SquareGrid.hpp
@@ -4,11 +4,14 @@
 #ifndef UTILS_SQUARE_GRID_H
 #define UTILS_SQUARE_GRID_H
 
-#include "../../Point.hpp"
-
+#include <stdint.h>
 #include <cassert>
 #include <vector>
 #include <functional>
+#include <utility>
+
+#include "../../Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 
diff --git a/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.cpp b/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.cpp
index fcd8e209c6..0eacb70f9d 100644
--- a/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.cpp
+++ b/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.cpp
@@ -4,6 +4,10 @@
 ///|/
 #include "ArrangeSettingsDb_AppCfg.hpp"
 
+#include "LocalesUtils.hpp"
+#include "libslic3r/AppConfig.hpp"
+#include "libslic3r/Arrange/ArrangeSettingsView.hpp"
+
 namespace Slic3r {
 
 ArrangeSettingsDb_AppCfg::ArrangeSettingsDb_AppCfg(AppConfig *appcfg) : m_appcfg{appcfg}
diff --git a/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.hpp b/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.hpp
index dec64fa0d5..02228f7fb2 100644
--- a/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.hpp
+++ b/src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.hpp
@@ -5,11 +5,14 @@
 #ifndef ARRANGESETTINGSDB_APPCFG_HPP
 #define ARRANGESETTINGSDB_APPCFG_HPP
 
+#include <string>
+
 #include "ArrangeSettingsView.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
+class AppConfig;
 
 class ArrangeSettingsDb_AppCfg: public arr2::ArrangeSettingsDb
 {
diff --git a/src/libslic3r/Arrange/Core/Beds.cpp b/src/libslic3r/Arrange/Core/Beds.cpp
index e08375b198..48c9c5a935 100644
--- a/src/libslic3r/Arrange/Core/Beds.cpp
+++ b/src/libslic3r/Arrange/Core/Beds.cpp
@@ -4,6 +4,12 @@
 ///|/
 #include "Beds.hpp"
 
+#include <algorithm>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+
 namespace Slic3r { namespace arr2 {
 
 BoundingBox bounding_box(const InfiniteBed &bed)
diff --git a/src/libslic3r/Arrange/Core/Beds.hpp b/src/libslic3r/Arrange/Core/Beds.hpp
index 56566a0b40..5bb2ddfb31 100644
--- a/src/libslic3r/Arrange/Core/Beds.hpp
+++ b/src/libslic3r/Arrange/Core/Beds.hpp
@@ -5,14 +5,19 @@
 #ifndef BEDS_HPP
 #define BEDS_HPP
 
-#include <numeric>
-
 #include <libslic3r/Point.hpp>
 #include <libslic3r/ExPolygon.hpp>
 #include <libslic3r/BoundingBox.hpp>
 #include <libslic3r/ClipperUtils.hpp>
-
 #include <boost/variant.hpp>
+#include <boost/variant/variant.hpp>
+#include <numeric>
+#include <cmath>
+#include <limits>
+#include <type_traits>
+
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/EdgeCache.cpp b/src/libslic3r/Arrange/Core/NFP/EdgeCache.cpp
index 7ed3ec451f..85760e5125 100644
--- a/src/libslic3r/Arrange/Core/NFP/EdgeCache.cpp
+++ b/src/libslic3r/Arrange/Core/NFP/EdgeCache.cpp
@@ -3,7 +3,12 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "EdgeCache.hpp"
+
+#include <iterator>
+
 #include "CircularEdgeIterator.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r { namespace arr2 {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/EdgeCache.hpp b/src/libslic3r/Arrange/Core/NFP/EdgeCache.hpp
index f6ab592106..6a087adda0 100644
--- a/src/libslic3r/Arrange/Core/NFP/EdgeCache.hpp
+++ b/src/libslic3r/Arrange/Core/NFP/EdgeCache.hpp
@@ -5,9 +5,16 @@
 #ifndef EDGECACHE_HPP
 #define EDGECACHE_HPP
 
-#include <vector>
-
 #include <libslic3r/ExPolygon.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/NFP.cpp b/src/libslic3r/Arrange/Core/NFP/NFP.cpp
index c38516875a..44ddacfcee 100644
--- a/src/libslic3r/Arrange/Core/NFP/NFP.cpp
+++ b/src/libslic3r/Arrange/Core/NFP/NFP.cpp
@@ -6,18 +6,33 @@
 #define NFP_CPP
 
 #include "NFP.hpp"
-#include "CircularEdgeIterator.hpp"
 
+#include "CircularEdgeIterator.hpp"
 #include "NFPConcave_Tesselate.hpp"
+#include "libslic3r/Arrange/Core/Beds.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/libslic3r.h"
 
 #if !defined(_MSC_VER) && defined(__SIZEOF_INT128__) && !defined(__APPLE__)
 namespace Slic3r { using LargeInt = __int128; }
 #else
 #include <boost/multiprecision/integer.hpp>
+
 namespace Slic3r { using LargeInt = boost::multiprecision::int128_t; }
 #endif
 
 #include <boost/rational.hpp>
+#include <assert.h>
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <utility>
+#include <vector>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/NFP.hpp b/src/libslic3r/Arrange/Core/NFP/NFP.hpp
index 1724144da6..fc28925385 100644
--- a/src/libslic3r/Arrange/Core/NFP/NFP.hpp
+++ b/src/libslic3r/Arrange/Core/NFP/NFP.hpp
@@ -7,6 +7,11 @@
 
 #include <libslic3r/ExPolygon.hpp>
 #include <libslic3r/Arrange/Core/Beds.hpp>
+#include <stdint.h>
+#include <boost/variant.hpp>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.cpp b/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.cpp
index a36331c58c..12f8f2db16 100644
--- a/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.cpp
+++ b/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.cpp
@@ -2,16 +2,22 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "NFP.hpp"
-#include "NFPConcave_CGAL.hpp"
-
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/partition_2.h>
 #include <CGAL/Partition_traits_2.h>
 #include <CGAL/property_map.h>
 #include <CGAL/Polygon_vertical_decomposition_2.h>
+#include <stddef.h>
+#include <iterator>
+#include <utility>
+#include <vector>
 
+#include "NFP.hpp"
+#include "NFPConcave_CGAL.hpp"
 #include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.hpp b/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.hpp
index 36b5583117..caf9f9a7b1 100644
--- a/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.hpp
+++ b/src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.hpp
@@ -7,6 +7,8 @@
 
 #include <libslic3r/ExPolygon.hpp>
 
+#include "libslic3r/Polygon.hpp"
+
 namespace Slic3r {
 
 Polygons convex_decomposition_cgal(const Polygon &expoly);
diff --git a/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.cpp b/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.cpp
index c1fc269ba3..f2c260f66f 100644
--- a/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.cpp
+++ b/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.cpp
@@ -6,8 +6,15 @@
 
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Tesselate.hpp>
+#include <stddef.h>
+#include <algorithm>
+#include <iterator>
+#include <vector>
 
 #include "NFP.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp b/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp
index 65d375ea37..5d02180738 100644
--- a/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp
+++ b/src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp
@@ -7,6 +7,8 @@
 
 #include <libslic3r/ExPolygon.hpp>
 
+#include "libslic3r/Polygon.hpp"
+
 namespace Slic3r {
 
 Polygons convex_decomposition_tess(const Polygon &expoly);
diff --git a/src/libslic3r/Arrange/Items/ArrangeItem.cpp b/src/libslic3r/Arrange/Items/ArrangeItem.cpp
index 391d8f8f45..ee600a6860 100644
--- a/src/libslic3r/Arrange/Items/ArrangeItem.cpp
+++ b/src/libslic3r/Arrange/Items/ArrangeItem.cpp
@@ -4,13 +4,13 @@
 ///|/
 #include "ArrangeItem.hpp"
 
-#include "libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp"
+#include <numeric>
 
+#include "libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp"
 #include "libslic3r/Arrange/ArrangeImpl.hpp" // IWYU pragma: keep
 #include "libslic3r/Arrange/Tasks/ArrangeTaskImpl.hpp" // IWYU pragma: keep
 #include "libslic3r/Arrange/Tasks/FillBedTaskImpl.hpp" // IWYU pragma: keep
 #include "libslic3r/Arrange/Tasks/MultiplySelectionTaskImpl.hpp" // IWYU pragma: keep
-
 #include "libslic3r/Geometry/ConvexHull.hpp"
 
 namespace Slic3r { namespace arr2 {
diff --git a/src/libslic3r/Arrange/Items/ArrangeItem.hpp b/src/libslic3r/Arrange/Items/ArrangeItem.hpp
index b3a40ff019..5f2f62f443 100644
--- a/src/libslic3r/Arrange/Items/ArrangeItem.hpp
+++ b/src/libslic3r/Arrange/Items/ArrangeItem.hpp
@@ -5,29 +5,40 @@
 #ifndef ARRANGEITEM_HPP
 #define ARRANGEITEM_HPP
 
-#include <optional>
 #include <boost/variant.hpp>
+#include <libslic3r/ClipperUtils.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <optional>
+#include <algorithm>
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/AnyPtr.hpp"
-
 #include "libslic3r/Arrange/Core/PackingContext.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFPArrangeItemTraits.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFP.hpp"
-
 #include "libslic3r/Arrange/Items/MutableItemTraits.hpp"
-
 #include "libslic3r/Arrange/Arrange.hpp"
 #include "libslic3r/Arrange/Tasks/ArrangeTask.hpp"
 #include "libslic3r/Arrange/Tasks/FillBedTask.hpp"
 #include "libslic3r/Arrange/Tasks/MultiplySelectionTask.hpp"
-
 #include "libslic3r/Arrange/Items/ArbitraryDataStore.hpp"
-
-#include <libslic3r/ClipperUtils.hpp>
+#include "libslic3r/Arrange/Core/ArrangeBase.hpp"
+#include "libslic3r/Arrange/Core/ArrangeItemTraits.hpp"
+#include "libslic3r/Arrange/Core/DataStoreTraits.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
+struct InfiniteBed;
 
 inline bool check_polygons_are_convex(const Polygons &pp) {
     return std::all_of(pp.begin(), pp.end(), [](const Polygon &p) {
diff --git a/src/libslic3r/Arrange/Items/SimpleArrangeItem.hpp b/src/libslic3r/Arrange/Items/SimpleArrangeItem.hpp
index 28cdd1bb77..6263ba5c7d 100644
--- a/src/libslic3r/Arrange/Items/SimpleArrangeItem.hpp
+++ b/src/libslic3r/Arrange/Items/SimpleArrangeItem.hpp
@@ -5,22 +5,30 @@
 #ifndef SIMPLEARRANGEITEM_HPP
 #define SIMPLEARRANGEITEM_HPP
 
-#include "libslic3r/Arrange/Core/PackingContext.hpp"
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
+#include "libslic3r/Arrange/Core/PackingContext.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFPArrangeItemTraits.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFP.hpp"
-
 #include "libslic3r/Arrange/Arrange.hpp"
 #include "libslic3r/Arrange/Tasks/ArrangeTask.hpp"
 #include "libslic3r/Arrange/Tasks/FillBedTask.hpp"
 #include "libslic3r/Arrange/Tasks/MultiplySelectionTask.hpp"
-
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/Geometry/ConvexHull.hpp"
-
 #include "MutableItemTraits.hpp"
+#include "libslic3r/Arrange/Core/ArrangeItemTraits.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ObjectID.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r { namespace arr2 {
+struct InfiniteBed;
 
 class SimpleArrangeItem {
     Polygon m_shape;
diff --git a/src/libslic3r/Arrange/Scene.hpp b/src/libslic3r/Arrange/Scene.hpp
index c05cf77104..004f4eaed8 100644
--- a/src/libslic3r/Arrange/Scene.hpp
+++ b/src/libslic3r/Arrange/Scene.hpp
@@ -5,13 +5,29 @@
 #ifndef ARR2_SCENE_HPP
 #define ARR2_SCENE_HPP
 
+#include <stddef.h>
+#include <boost/variant.hpp>
+#include <boost/variant/variant.hpp>
 #include <any>
 #include <string_view>
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <set>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ObjectID.hpp"
 #include "libslic3r/AnyPtr.hpp"
 #include "libslic3r/Arrange/ArrangeSettingsView.hpp"
 #include "libslic3r/Arrange/SegmentedRectangleBed.hpp"
+#include "libslic3r/Arrange/Core/Beds.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
 
diff --git a/src/libslic3r/Arrange/SceneBuilder.cpp b/src/libslic3r/Arrange/SceneBuilder.cpp
index 67d3d2b263..786232b1de 100644
--- a/src/libslic3r/Arrange/SceneBuilder.cpp
+++ b/src/libslic3r/Arrange/SceneBuilder.cpp
@@ -7,12 +7,22 @@
 
 #include "SceneBuilder.hpp"
 
+#include <cmath>
+#include <limits>
+#include <numeric>
+
 #include "libslic3r/Model.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/SLAPrint.hpp"
-
 #include "libslic3r/Arrange/Core/ArrangeItemTraits.hpp"
 #include "libslic3r/Geometry/ConvexHull.hpp"
+#include "libslic3r/Arrange/Scene.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SLA/Pad.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/TriangleMeshSlicer.hpp"
 
 namespace Slic3r { namespace arr2 {
 
diff --git a/src/libslic3r/Arrange/SceneBuilder.hpp b/src/libslic3r/Arrange/SceneBuilder.hpp
index 5b3ec97233..8a11a17361 100644
--- a/src/libslic3r/Arrange/SceneBuilder.hpp
+++ b/src/libslic3r/Arrange/SceneBuilder.hpp
@@ -5,9 +5,27 @@
 #ifndef SCENEBUILDER_HPP
 #define SCENEBUILDER_HPP
 
-#include "Scene.hpp"
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
+#include "Scene.hpp"
 #include "Core/ArrangeItemTraits.hpp"
+#include "libslic3r/AnyPtr.hpp"
+#include "libslic3r/Arrange/Core/Beds.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/ObjectID.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/BlacklistedLibraryCheck.cpp b/src/libslic3r/BlacklistedLibraryCheck.cpp
index 9408f0e652..1e3a8d5441 100644
--- a/src/libslic3r/BlacklistedLibraryCheck.cpp
+++ b/src/libslic3r/BlacklistedLibraryCheck.cpp
@@ -5,9 +5,6 @@
 ///|/
 #include "BlacklistedLibraryCheck.hpp"
 
-#include <cstdio>
-#include <boost/nowide/convert.hpp>
-
 #ifdef  WIN32
 #include <psapi.h>
 # endif //WIN32
diff --git a/src/libslic3r/BoundingBox.cpp b/src/libslic3r/BoundingBox.cpp
index 2c75dd3513..a0c88c2375 100644
--- a/src/libslic3r/BoundingBox.cpp
+++ b/src/libslic3r/BoundingBox.cpp
@@ -8,10 +8,13 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BoundingBox.hpp"
-#include <algorithm>
-#include <assert.h>
 
-#include <Eigen/Dense>
+#include <assert.h>
+#include <algorithm>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/BoundingBox.hpp b/src/libslic3r/BoundingBox.hpp
index 9f1d16b27a..0b52e28738 100644
--- a/src/libslic3r/BoundingBox.hpp
+++ b/src/libslic3r/BoundingBox.hpp
@@ -6,12 +6,17 @@
 #ifndef slic3r_BoundingBox_hpp_
 #define slic3r_BoundingBox_hpp_
 
+#include <assert.h>
+#include <algorithm>
+#include <vector>
+
 #include "libslic3r.h"
 #include "Exception.hpp"
 #include "Point.hpp"
 #include "Polygon.hpp"
 
 namespace Slic3r {
+class BoundingBox;
 
 template <typename PointType, typename APointsType = std::vector<PointType>>
 class BoundingBoxBase
diff --git a/src/libslic3r/BranchingTree/BranchingTree.cpp b/src/libslic3r/BranchingTree/BranchingTree.cpp
index 156f03e0bd..91b79f9ce3 100644
--- a/src/libslic3r/BranchingTree/BranchingTree.cpp
+++ b/src/libslic3r/BranchingTree/BranchingTree.cpp
@@ -3,13 +3,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BranchingTree.hpp"
-#include "PointCloud.hpp"
 
-#include <numeric>
+#include <stddef.h>
 #include <optional>
 #include <algorithm>
 
+#include "PointCloud.hpp"
 #include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/BoundingBox.hpp"
+
+struct indexed_triangle_set;
 
 namespace Slic3r { namespace branchingtree {
 
diff --git a/src/libslic3r/BranchingTree/BranchingTree.hpp b/src/libslic3r/BranchingTree/BranchingTree.hpp
index f74b6941ab..dc8e125925 100644
--- a/src/libslic3r/BranchingTree/BranchingTree.hpp
+++ b/src/libslic3r/BranchingTree/BranchingTree.hpp
@@ -7,8 +7,15 @@
 
 // For indexed_triangle_set
 #include <admesh/stl.h>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+
+struct indexed_triangle_set;
 
 namespace Slic3r { namespace branchingtree {
 
diff --git a/src/libslic3r/BranchingTree/PointCloud.cpp b/src/libslic3r/BranchingTree/PointCloud.cpp
index 009f8c4359..5c736f0ecc 100644
--- a/src/libslic3r/BranchingTree/PointCloud.cpp
+++ b/src/libslic3r/BranchingTree/PointCloud.cpp
@@ -4,10 +4,15 @@
 ///|/
 #include "PointCloud.hpp"
 
+#include <igl/random_points_on_mesh.h> // IWYU pragma: keep
+#include <array>
+#include <limits>
+
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/SLA/SupportTreeUtils.hpp"
-
-#include <igl/random_points_on_mesh.h> // IWYU pragma: keep
+#include "admesh/stl.h"
+#include "libslic3r/BranchingTree/BranchingTree.hpp"
+#include "libslic3r/SLA/Pad.hpp"
 
 namespace Slic3r { namespace branchingtree {
 
diff --git a/src/libslic3r/BranchingTree/PointCloud.hpp b/src/libslic3r/BranchingTree/PointCloud.hpp
index a4ff68f19b..e37d03f078 100644
--- a/src/libslic3r/BranchingTree/PointCloud.hpp
+++ b/src/libslic3r/BranchingTree/PointCloud.hpp
@@ -5,15 +5,28 @@
 #ifndef POINTCLOUD_HPP
 #define POINTCLOUD_HPP
 
+#include <assert.h>
+#include <stddef.h>
+#include <boost/geometry.hpp>
 #include <optional>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <cmath>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "BranchingTree.hpp"
-
 //#include "libslic3r/Execution/Execution.hpp"
 #include "libslic3r/MutablePriorityQueue.hpp"
-
 #include "libslic3r/BoostAdapter.hpp"
 #include "boost/geometry/index/rtree.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+
+struct indexed_triangle_set;
 
 namespace Slic3r { namespace branchingtree {
 
diff --git a/src/libslic3r/BridgeDetector.cpp b/src/libslic3r/BridgeDetector.cpp
index 5ac72bbbc0..648bf0c697 100644
--- a/src/libslic3r/BridgeDetector.cpp
+++ b/src/libslic3r/BridgeDetector.cpp
@@ -5,9 +5,19 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BridgeDetector.hpp"
+
+#include <stddef.h>
+#include <algorithm>
+
 #include "ClipperUtils.hpp"
 #include "Geometry.hpp"
-#include <algorithm>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/BridgeDetector.hpp b/src/libslic3r/BridgeDetector.hpp
index 4bcc76ddd2..def3b7b532 100644
--- a/src/libslic3r/BridgeDetector.hpp
+++ b/src/libslic3r/BridgeDetector.hpp
@@ -6,6 +6,15 @@
 #ifndef slic3r_BridgeDetector_hpp_
 #define slic3r_BridgeDetector_hpp_
 
+#include <cmath>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <algorithm>
+#include <limits>
+#include <tuple>
+#include <utility>
+
 #include "ClipperUtils.hpp"
 #include "Line.hpp"
 #include "Point.hpp"
@@ -14,10 +23,6 @@
 #include "PrincipalComponents2D.hpp"
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
-#include <cmath>
-#include <string>
-#include <unordered_map>
-#include <vector>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Brim.cpp b/src/libslic3r/Brim.cpp
index b6cdf4dde7..f4873e0184 100644
--- a/src/libslic3r/Brim.cpp
+++ b/src/libslic3r/Brim.cpp
@@ -3,26 +3,42 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "clipper/clipper_z.hpp"
+#include <boost/thread/lock_guard.hpp>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <numeric>
+#include <unordered_set>
+#include <mutex>
+#include <cmath>
+#include <functional>
+#include <utility>
+#include <vector>
 
+#include "clipper/clipper_z.hpp"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"
 #include "Layer.hpp"
 #include "Print.hpp"
 #include "ShortestPath.hpp"
 #include "libslic3r.h"
-
-#include <algorithm>
-#include <numeric>
-#include <unordered_set>
-#include <mutex>
-
-#include <tbb/parallel_for.h>
-#include <boost/thread/lock_guard.hpp>
-
-#ifndef NDEBUG
-    // #define BRIM_DEBUG_TO_SVG
-#endif
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/PrintBase.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 #if defined(BRIM_DEBUG_TO_SVG)
     #include "SVG.hpp"
diff --git a/src/libslic3r/BuildVolume.cpp b/src/libslic3r/BuildVolume.cpp
index babb3e71e0..cebc884b74 100644
--- a/src/libslic3r/BuildVolume.cpp
+++ b/src/libslic3r/BuildVolume.cpp
@@ -3,12 +3,23 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BuildVolume.hpp"
+
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
 #include "ClipperUtils.hpp"
 #include "Geometry/ConvexHull.hpp"
 #include "libslic3r/GCode/GCodeProcessor.hpp"
 #include "Point.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "admesh/stl.h"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Geometry/Circle.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/BuildVolume.hpp b/src/libslic3r/BuildVolume.hpp
index e559fcd6a5..f99683a3a4 100644
--- a/src/libslic3r/BuildVolume.hpp
+++ b/src/libslic3r/BuildVolume.hpp
@@ -5,13 +5,18 @@
 #ifndef slic3r_BuildVolume_hpp_
 #define slic3r_BuildVolume_hpp_
 
+#include <admesh/stl.h>
+#include <string_view>
+#include <utility>
+#include <vector>
+
 #include "Point.hpp"
 #include "Geometry/Circle.hpp"
 #include "Polygon.hpp"
 #include "BoundingBox.hpp"
-#include <admesh/stl.h>
+#include "libslic3r/libslic3r.h"
 
-#include <string_view>
+struct indexed_triangle_set;
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ClipperUtils.cpp b/src/libslic3r/ClipperUtils.cpp
index d8d3b1d5af..c7417b657d 100644
--- a/src/libslic3r/ClipperUtils.cpp
+++ b/src/libslic3r/ClipperUtils.cpp
@@ -10,9 +10,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ClipperUtils.hpp"
-#include "Geometry.hpp"
+
+#include <stddef.h>
+#include <cmath>
+
 #include "ShortestPath.hpp"
-#include "Utils.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/libslic3r.h"
 
 // #define CLIPPER_UTILS_TIMING
 
@@ -20,7 +27,9 @@
     // time limit for one ClipperLib operation (union / diff / offset), in ms
     #define CLIPPER_UTILS_TIME_LIMIT_DEFAULT 50
     #include <boost/current_function.hpp>
+
     #include "Timer.hpp"
+
     #define CLIPPER_UTILS_TIME_LIMIT_SECONDS(limit) Timing::TimeLimitAlarm time_limit_alarm(uint64_t(limit) * 1000000000l, BOOST_CURRENT_FUNCTION)
     #define CLIPPER_UTILS_TIME_LIMIT_MILLIS(limit) Timing::TimeLimitAlarm time_limit_alarm(uint64_t(limit) * 1000000l, BOOST_CURRENT_FUNCTION)
 #else
@@ -1272,12 +1281,6 @@ static void variable_offset_inner_raw(const ExPolygon &expoly, const std::vector
     holes.reserve(expoly.holes.size());
     for (const Polygon &hole : expoly.holes)
         append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole.points, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, false));
-#ifndef NDEBUG
-    // Offsetting a hole curve of a C shape may close the C into a ring with a new hole inside, thus creating a hole inside a hole shape, thus a hole will be created with negative area
-    // and the following test will fail.
-//    for (auto &c : holes)
-//        assert(ClipperLib::Area(c) > 0.);
-#endif /* NDEBUG */
 }
 
 Polygons variable_offset_inner(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit)
@@ -1351,12 +1354,6 @@ static void variable_offset_outer_raw(const ExPolygon &expoly, const std::vector
     contours = fix_after_outer_offset(mittered_offset_path_scaled(expoly.contour.points, deltas.front(), miter_limit), ClipperLib::pftPositive, false);
     // Inflating a contour must not remove it.
     assert(contours.size() >= 1);
-#ifndef NDEBUG
-    // Offsetting a positive curve of a C shape may close the C into a ring with hole shape, thus a hole will be created with negative area
-    // and the following test will fail.
-//  for (auto &c : contours)
-//      assert(ClipperLib::Area(c) > 0.);
-#endif /* NDEBUG */
 
     // 2) Offset the holes one by one, collect the results.
     holes.reserve(expoly.holes.size());
diff --git a/src/libslic3r/ClipperUtils.hpp b/src/libslic3r/ClipperUtils.hpp
index 98bb077f79..a192b7c34e 100644
--- a/src/libslic3r/ClipperUtils.hpp
+++ b/src/libslic3r/ClipperUtils.hpp
@@ -8,10 +8,20 @@
 
 //#define SLIC3R_USE_CLIPPER2
 
+#include <assert.h>
+#include <cstddef>
+#include <iterator>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
 #include "Polygon.hpp"
 #include "Surface.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 #ifdef SLIC3R_USE_CLIPPER2
 
diff --git a/src/libslic3r/Color.cpp b/src/libslic3r/Color.cpp
index 356b2be652..9221860497 100644
--- a/src/libslic3r/Color.cpp
+++ b/src/libslic3r/Color.cpp
@@ -2,10 +2,11 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r.h"
-#include "Color.hpp"
-
+#include <stdio.h>
 #include <random>
+#include <cmath>
+
+#include "Color.hpp"
 
 static const float INV_255 = 1.0f / 255.0f;
 
diff --git a/src/libslic3r/Color.hpp b/src/libslic3r/Color.hpp
index 8c4c13d95a..6678c1ff01 100644
--- a/src/libslic3r/Color.hpp
+++ b/src/libslic3r/Color.hpp
@@ -5,8 +5,11 @@
 #ifndef slic3r_Color_hpp_
 #define slic3r_Color_hpp_
 
+#include <assert.h>
 #include <array>
 #include <algorithm>
+#include <string>
+#include <vector>
 
 #include "Point.hpp"
 
diff --git a/src/libslic3r/Config.cpp b/src/libslic3r/Config.cpp
index 44ff6f0022..4fcd01b481 100644
--- a/src/libslic3r/Config.cpp
+++ b/src/libslic3r/Config.cpp
@@ -19,36 +19,34 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Config.hpp"
-#include "format.hpp"
-#include "Utils.hpp"
-#include "LocalesUtils.hpp"
 
 #include <assert.h>
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/erase.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/config.hpp>
-#include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/nowide/cstdlib.hpp>
 #include <boost/nowide/iostream.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <boost/nowide/cstdio.hpp>
 #include <boost/property_tree/ini_parser.hpp>
-#include <boost/format.hpp>
 #include <string.h>
-
 #include <LibBGCode/binarize/binarize.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/multi_index_container.hpp>
+#include <cereal/cereal.hpp>
+#include <core/core.hpp>
+#include <iostream>
+#include <iomanip>
+#include <cstddef>
+#include <set>
 
-//FIXME for GCodeFlavor and gcfMarlin (for forward-compatibility conversion)
-// This is not nice, likely it would be better to pass the ConfigSubstitutionContext to handle_legacy().
-#include "PrintConfig.hpp"
+#include "format.hpp"
+#include "Utils.hpp"
+#include "LocalesUtils.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Semver.hpp"
 
 namespace Slic3r {
 
@@ -1432,6 +1430,7 @@ t_config_option_keys DynamicConfig::equal(const DynamicConfig &other) const
 }
 
 #include <cereal/types/polymorphic.hpp> // IWYU pragma: keep
+
 CEREAL_REGISTER_TYPE(Slic3r::ConfigOption)
 CEREAL_REGISTER_TYPE(Slic3r::ConfigOptionSingle<double>)
 CEREAL_REGISTER_TYPE(Slic3r::ConfigOptionSingle<int>)
diff --git a/src/libslic3r/Config.hpp b/src/libslic3r/Config.hpp
index 0b743ac22d..df8ff88a49 100644
--- a/src/libslic3r/Config.hpp
+++ b/src/libslic3r/Config.hpp
@@ -23,6 +23,17 @@
 #define slic3r_Config_hpp_
 
 #include <assert.h>
+#include <float.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/format/format_fwd.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/property_tree/ptree_fwd.hpp>
+#include <cereal/access.hpp>
+#include <cereal/types/base_class.hpp>
+#include <ctype.h>
+#include <boost/container_hash/hash.hpp>
+#include <cereal/cereal.hpp>
 #include <map>
 #include <climits>
 #include <limits>
@@ -35,20 +46,19 @@
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include <float.h>
+#include <algorithm>
+#include <cmath>
+#include <initializer_list>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <variant>
+
 #include "libslic3r.h"
 #include "clonable_ptr.hpp"
 #include "Exception.hpp"
 #include "Point.hpp"
-
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/format/format_fwd.hpp>
-#include <boost/functional/hash.hpp>
-#include <boost/property_tree/ptree_fwd.hpp>
-
-#include <cereal/access.hpp>
-#include <cereal/types/base_class.hpp>
+#include "LocalesUtils.hpp"
 
 namespace Slic3r {
     struct FloatOrPercent
@@ -254,6 +264,7 @@ enum ForwardCompatibilitySubstitutionRule
 class  ConfigDef;
 class  ConfigOption;
 class  ConfigOptionDef;
+
 // For forward definition of ConfigOption in ConfigOptionUniquePtr, we have to define a custom deleter.
 struct ConfigOptionDeleter { void operator()(ConfigOption* p); };
 using  ConfigOptionUniquePtr = std::unique_ptr<ConfigOption, ConfigOptionDeleter>;
diff --git a/src/libslic3r/CustomGCode.cpp b/src/libslic3r/CustomGCode.cpp
index eace7ca9c0..a56d5545a3 100644
--- a/src/libslic3r/CustomGCode.cpp
+++ b/src/libslic3r/CustomGCode.cpp
@@ -3,9 +3,12 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "CustomGCode.hpp"
+
+#include <assert.h>
+
 #include "Config.hpp"
 #include "GCode.hpp"
-#include "libslic3r/GCode/GCodeWriter.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/CustomGCode.hpp b/src/libslic3r/CustomGCode.hpp
index a78fdb05ad..515a07fcb4 100644
--- a/src/libslic3r/CustomGCode.hpp
+++ b/src/libslic3r/CustomGCode.hpp
@@ -5,8 +5,10 @@
 #ifndef slic3r_CustomGCode_hpp_
 #define slic3r_CustomGCode_hpp_
 
+#include <stddef.h>
 #include <string>
 #include <vector>
+#include <utility>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/CutSurface.cpp b/src/libslic3r/CutSurface.cpp
index b2cf3d9659..14e2df76e2 100644
--- a/src/libslic3r/CutSurface.cpp
+++ b/src/libslic3r/CutSurface.cpp
@@ -27,18 +27,42 @@
 //#define DEBUG_OUTPUT_DIR std::string("C:/data/temp/cutSurface/")
 
 using namespace Slic3r;
-#include "ExPolygonsIndex.hpp"
-
 #include <CGAL/Polygon_mesh_processing/corefinement.h>
 #include <CGAL/Exact_integer.h>
 #include <CGAL/Surface_mesh.h>
 #include <CGAL/Cartesian_converter.h>
-#include <tbb/parallel_for.h>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <boost/property_map/property_map.hpp>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <optional>
+#include <queue>
+#include <set>
+#include <tuple>
+#include <utility>
 
+#include "ExPolygonsIndex.hpp"
 // libslic3r
 #include "TriangleMesh.hpp" // its_merge
 #include "Utils.hpp" // next_highest_power_of_2
 #include "ClipperUtils.hpp" // union_ex + offset_ex
+#include "admesh/stl.h"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Emboss.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace priv {
 
@@ -521,9 +545,10 @@ void store(const Emboss::IProjection &projection, const Point &point_to_project,
 } // namespace privat
 
 #ifdef DEBUG_OUTPUT_DIR
-#include "libslic3r/SVG.hpp"
 #include <boost/log/trivial.hpp>
 #include <filesystem>
+
+#include "libslic3r/SVG.hpp"
 #endif // DEBUG_OUTPUT_DIR
 
 SurfaceCut Slic3r::cut_surface(const ExPolygons &shapes,
@@ -1779,6 +1804,7 @@ priv::VDistances priv::calc_distances(const SurfacePatches &patches,
 
 #include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/Line.hpp"
+
 // functions for choose_best_distance
 namespace priv {
 
@@ -2560,6 +2586,7 @@ void priv::create_face_types(FaceTypeMap           &map,
 
 #include <CGAL/Polygon_mesh_processing/clip.h>
 #include <CGAL/Polygon_mesh_processing/corefinement.h>
+
 bool priv::clip_cut(SurfacePatch &cut, CutMesh clipper)
 {
     CutMesh& tm = cut.mesh; 
diff --git a/src/libslic3r/CutSurface.hpp b/src/libslic3r/CutSurface.hpp
index f5b41cdaeb..4d3313cf93 100644
--- a/src/libslic3r/CutSurface.hpp
+++ b/src/libslic3r/CutSurface.hpp
@@ -5,12 +5,19 @@
 #ifndef slic3r_CutSurface_hpp_
 #define slic3r_CutSurface_hpp_
 
-#include <vector>
 #include <admesh/stl.h> // indexed_triangle_set
+#include <vector>
+#include <string>
+
 #include "ExPolygon.hpp"
 #include "Emboss.hpp" // IProjection
+#include "libslic3r/BoundingBox.hpp"
 
 namespace Slic3r{
+namespace Emboss {
+class IProject3d;
+class IProjection;
+}  // namespace Emboss
 
 /// <summary>
 /// Represents cutted surface from object
diff --git a/src/libslic3r/CutUtils.cpp b/src/libslic3r/CutUtils.cpp
index d039dc06a5..ccd2081fd4 100644
--- a/src/libslic3r/CutUtils.cpp
+++ b/src/libslic3r/CutUtils.cpp
@@ -4,14 +4,23 @@
 ///|/
 
 #include "CutUtils.hpp"
+
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <Eigen/Geometry>
+#include <cmath>
+#include <string>
+#include <utility>
+
 #include "Geometry.hpp"
 #include "libslic3r.h"
 #include "Model.hpp"
 #include "TriangleMeshSlicer.hpp"
-#include "TriangleSelector.hpp"
-#include "ObjectID.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "admesh/stl.h"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/EdgeGrid.cpp b/src/libslic3r/EdgeGrid.cpp
index fa7595b8df..28ba3d80d9 100644
--- a/src/libslic3r/EdgeGrid.cpp
+++ b/src/libslic3r/EdgeGrid.cpp
@@ -2,12 +2,13 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <float.h>
+#include <math.h>
 #include <algorithm>
 #include <vector>
-#include <float.h>
 #include <unordered_map>
-
-#include <png.h>
+#include <cstdint>
+#include <set>
 
 #include "libslic3r.h"
 #include "ClipperUtils.hpp"
@@ -15,6 +16,9 @@
 #include "Geometry.hpp"
 #include "SVG.hpp"
 #include "PNGReadWrite.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
 
 // #define EDGE_GRID_DEBUG_OUTPUT
 
diff --git a/src/libslic3r/EdgeGrid.hpp b/src/libslic3r/EdgeGrid.hpp
index 2f54dd5771..a48ac4b96e 100644
--- a/src/libslic3r/EdgeGrid.hpp
+++ b/src/libslic3r/EdgeGrid.hpp
@@ -7,10 +7,22 @@
 
 #include <stdint.h>
 #include <math.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "Point.hpp"
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 namespace EdgeGrid {
diff --git a/src/libslic3r/ElephantFootCompensation.cpp b/src/libslic3r/ElephantFootCompensation.cpp
index 2ac0707c2b..1e6ed8b5b5 100644
--- a/src/libslic3r/ElephantFootCompensation.cpp
+++ b/src/libslic3r/ElephantFootCompensation.cpp
@@ -2,7 +2,13 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "clipper/clipper_z.hpp"
+#include <stddef.h>
+#include <cmath>
+#include <cassert>
+#include <algorithm>
+#include <limits>
+#include <utility>
+#include <vector>
 
 #include "libslic3r.h"
 #include "ClipperUtils.hpp"
@@ -11,11 +17,10 @@
 #include "ElephantFootCompensation.hpp"
 #include "Flow.hpp"
 #include "Geometry.hpp"
-#include "SVG.hpp"
 #include "Utils.hpp"
-
-#include <cmath>
-#include <cassert>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 // #define CONTOUR_DISTANCE_DEBUG_SVG
 
diff --git a/src/libslic3r/ElephantFootCompensation.hpp b/src/libslic3r/ElephantFootCompensation.hpp
index 50b032c07c..763d9417ac 100644
--- a/src/libslic3r/ElephantFootCompensation.hpp
+++ b/src/libslic3r/ElephantFootCompensation.hpp
@@ -5,9 +5,10 @@
 #ifndef slic3r_ElephantFootCompensation_hpp_
 #define slic3r_ElephantFootCompensation_hpp_
 
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
-#include <vector>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Emboss.cpp b/src/libslic3r/Emboss.cpp
index 22af0c43b9..ad4093e43c 100644
--- a/src/libslic3r/Emboss.cpp
+++ b/src/libslic3r/Emboss.cpp
@@ -2,24 +2,36 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <numeric>
-#include "Emboss.hpp"
-#include <stdio.h>
-#include <numeric>
-#include <cstdlib>
 #include <boost/nowide/convert.hpp>
 #include <boost/log/trivial.hpp>
+#include <numeric>
+#include <cstdlib>
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <iterator>
+#include <limits>
+
+#include "Emboss.hpp"
 #include "IntersectionPoints.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/EmbossShape.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/TextConfiguration.hpp"
 
 #define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
 
+#include <libslic3r/Triangulation.hpp> // CGAL project
+
 // Explicit horror include (used to be implicit) - libslic3r "officialy" does not depend on imgui.
 #include "../../bundled_deps/imgui/imgui/imstb_truetype.h" // stbtt_fontinfo
 #include "Utils.hpp" // ScopeGuard
-
-#include <libslic3r/Triangulation.hpp> // CGAL project
 #include "libslic3r.h"
-
 // to heal shape
 #include "libslic3r/ClipperUtils.hpp" // union_ex + for boldness(polygon extend(offset))
 #include "libslic3r/ExPolygonsIndex.hpp"
@@ -58,6 +70,7 @@ namespace {
 // for debug purpose only
 // NOTE: check scale when store svg !!
 #include "libslic3r/SVG.hpp" // for visualize_heal
+
 Points get_unique_intersections(const Slic3r::IntersectionsLines &intersections); // fast forward declaration
 static std::string visualize_heal_svg_filepath = "C:/data/temp/heal.svg";
 void               visualize_heal(const std::string &svg_filepath, const ExPolygons &expolygons)
@@ -1349,7 +1362,6 @@ ExPolygonsWithIds Emboss::text2vshapes(FontFileWithCache &font_with_cache, const
     return result;
 }
 
-#include <boost/range/adaptor/reversed.hpp>
 unsigned Emboss::get_count_lines(const std::wstring& ws)
 {
     if (ws.empty())
@@ -2051,6 +2063,7 @@ double Emboss::get_align_y_offset_in_mm(FontProp::VerticalAlign align, unsigned
 
 #ifdef REMOVE_SPIKES
 #include <Geometry.hpp>
+
 void remove_spikes(Polygon &polygon, const SpikeDesc &spike_desc)
 {
     enum class Type {
diff --git a/src/libslic3r/Emboss.hpp b/src/libslic3r/Emboss.hpp
index d629b3a4ef..9cae18909f 100644
--- a/src/libslic3r/Emboss.hpp
+++ b/src/libslic3r/Emboss.hpp
@@ -5,16 +5,26 @@
 #ifndef slic3r_Emboss_hpp_
 #define slic3r_Emboss_hpp_
 
+#include <admesh/stl.h> // indexed_triangle_set
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 #include <set>
 #include <optional>
 #include <memory>
-#include <admesh/stl.h> // indexed_triangle_set
+#include <Eigen/Geometry>
+#include <functional>
+#include <map>
+#include <string>
+#include <utility>
+
 #include "Polygon.hpp"
 #include "ExPolygon.hpp"
 #include "EmbossShape.hpp" // ExPolygonsWithIds
 #include "BoundingBox.hpp"
 #include "TextConfiguration.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ExPolygon.cpp b/src/libslic3r/ExPolygon.cpp
index e962096cf4..3f40c3bd6b 100644
--- a/src/libslic3r/ExPolygon.cpp
+++ b/src/libslic3r/ExPolygon.cpp
@@ -10,19 +10,23 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <ankerl/unordered_dense.h>
+#include <string.h>
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <limits>
+
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
-#include "Exception.hpp"
 #include "Geometry/MedialAxis.hpp"
 #include "Polygon.hpp"
 #include "Line.hpp"
 #include "ClipperUtils.hpp"
-#include "SVG.hpp"
-#include <algorithm>
-#include <cassert>
-#include <list>
-
-#include <ankerl/unordered_dense.h>
+#include "libslic3r/MultiPoint.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ExPolygon.hpp b/src/libslic3r/ExPolygon.hpp
index ce6750308a..4bcd18f643 100644
--- a/src/libslic3r/ExPolygon.hpp
+++ b/src/libslic3r/ExPolygon.hpp
@@ -12,15 +12,27 @@
 #ifndef slic3r_ExPolygon_hpp_
 #define slic3r_ExPolygon_hpp_
 
+#include <assert.h>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <stdint.h>
+#include <vector>
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
 #include "Point.hpp"
 #include "libslic3r.h"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
-#include <vector>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r {
 
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 
 class ExPolygon
@@ -493,6 +505,7 @@ bool        remove_small_and_small_holes(ExPolygons &expolygons, double min_area
 
 // start Boost
 #include <boost/polygon/polygon.hpp>
+
 namespace boost { namespace polygon {
     template <>
         struct polygon_traits<Slic3r::ExPolygon> {
diff --git a/src/libslic3r/ExPolygonsIndex.cpp b/src/libslic3r/ExPolygonsIndex.cpp
index 976531799f..6f29eff607 100644
--- a/src/libslic3r/ExPolygonsIndex.cpp
+++ b/src/libslic3r/ExPolygonsIndex.cpp
@@ -1,4 +1,13 @@
 #include "ExPolygonsIndex.hpp"
+
+#include <assert.h>
+#include <algorithm>
+#include <utility>
+
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Polygon.hpp"
+
 using namespace Slic3r;
 
 // IMPROVE: use one dimensional vector for polygons offset with searching by std::lower_bound
diff --git a/src/libslic3r/ExPolygonsIndex.hpp b/src/libslic3r/ExPolygonsIndex.hpp
index b46fd50890..720dbdc46b 100644
--- a/src/libslic3r/ExPolygonsIndex.hpp
+++ b/src/libslic3r/ExPolygonsIndex.hpp
@@ -1,7 +1,11 @@
 #ifndef slic3r_ExPolygonsIndex_hpp_
 #define slic3r_ExPolygonsIndex_hpp_
 
+#include <cstdint>
+#include <vector>
+
 #include "ExPolygon.hpp"
+
 namespace Slic3r {
 
 /// <summary>
diff --git a/src/libslic3r/Extruder.cpp b/src/libslic3r/Extruder.cpp
index 1700998d55..7ee2ac21ea 100644
--- a/src/libslic3r/Extruder.cpp
+++ b/src/libslic3r/Extruder.cpp
@@ -8,8 +8,15 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Extruder.hpp"
+
+#include <assert.h>
+#include <math.h>
+#include <algorithm>
+
 #include "libslic3r/GCode/GCodeWriter.hpp"
 #include "PrintConfig.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Extruder.hpp b/src/libslic3r/Extruder.hpp
index fca76bf32a..2ff6d24869 100644
--- a/src/libslic3r/Extruder.hpp
+++ b/src/libslic3r/Extruder.hpp
@@ -10,6 +10,8 @@
 #ifndef slic3r_Extruder_hpp_
 #define slic3r_Extruder_hpp_
 
+#include <utility>
+
 #include "libslic3r.h"
 #include "Point.hpp"
 
diff --git a/src/libslic3r/ExtrusionEntity.cpp b/src/libslic3r/ExtrusionEntity.cpp
index b5a9868e9b..5a0ff7e2a7 100644
--- a/src/libslic3r/ExtrusionEntity.cpp
+++ b/src/libslic3r/ExtrusionEntity.cpp
@@ -6,15 +6,18 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ExtrusionEntity.hpp"
+
+#include <limits>
+#include <iterator>
+
 #include "ExtrusionEntityCollection.hpp"
 #include "ExPolygon.hpp"
 #include "ClipperUtils.hpp"
 #include "Exception.hpp"
-#include "Extruder.hpp"
 #include "Flow.hpp"
-#include <cmath>
-#include <limits>
-#include <sstream>
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ExtrusionEntity.hpp b/src/libslic3r/ExtrusionEntity.hpp
index 2b29559f43..4007d421b1 100644
--- a/src/libslic3r/ExtrusionEntity.hpp
+++ b/src/libslic3r/ExtrusionEntity.hpp
@@ -8,20 +8,28 @@
 #ifndef slic3r_ExtrusionEntity_hpp_
 #define slic3r_ExtrusionEntity_hpp_
 
+#include <assert.h>
+#include <stddef.h>
+#include <optional>
+#include <string_view>
+#include <numeric>
+#include <cmath>
+#include <limits>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExtrusionRole.hpp"
 #include "Flow.hpp"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
-
-#include <assert.h>
-#include <optional>
-#include <string_view>
-#include <numeric>
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 class ExtrusionEntityCollection;
 class Extruder;
diff --git a/src/libslic3r/ExtrusionEntityCollection.cpp b/src/libslic3r/ExtrusionEntityCollection.cpp
index 7d5e46c977..d838e15684 100644
--- a/src/libslic3r/ExtrusionEntityCollection.cpp
+++ b/src/libslic3r/ExtrusionEntityCollection.cpp
@@ -7,10 +7,11 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ExtrusionEntityCollection.hpp"
-#include "ShortestPath.hpp"
+
 #include <algorithm>
-#include <cmath>
-#include <map>
+#include <limits>
+
+#include "libslic3r/ExtrusionEntity.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ExtrusionEntityCollection.hpp b/src/libslic3r/ExtrusionEntityCollection.hpp
index 477270adee..c1c175b89f 100644
--- a/src/libslic3r/ExtrusionEntityCollection.hpp
+++ b/src/libslic3r/ExtrusionEntityCollection.hpp
@@ -7,9 +7,18 @@
 #ifndef slic3r_ExtrusionEntityCollection_hpp_
 #define slic3r_ExtrusionEntityCollection_hpp_
 
+#include <stddef.h>
+#include <iterator>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "Exception.hpp"
 #include "ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ExtrusionSimulator.cpp b/src/libslic3r/ExtrusionSimulator.cpp
index fcd89b1f2d..78669acba5 100644
--- a/src/libslic3r/ExtrusionSimulator.cpp
+++ b/src/libslic3r/ExtrusionSimulator.cpp
@@ -7,18 +7,23 @@
 //#undef SLIC3R_DEBUG
 //#define NDEBUG
 
-#include <cmath>
-#include <cassert>
-
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/box.hpp>
 #include <boost/geometry/geometries/point.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
-
 #include <boost/multi_array.hpp>
+#include <string.h>
+#include <cmath>
+#include <cassert>
+#include <algorithm>
+#include <complex>
+#include <utility>
+#include <vector>
 
 #include "libslic3r.h"
 #include "ExtrusionSimulator.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
 
 #ifndef M_PI
 #define M_PI 3.1415926535897932384626433832795
diff --git a/src/libslic3r/ExtrusionSimulator.hpp b/src/libslic3r/ExtrusionSimulator.hpp
index aef74a7419..1997b547d9 100644
--- a/src/libslic3r/ExtrusionSimulator.hpp
+++ b/src/libslic3r/ExtrusionSimulator.hpp
@@ -8,6 +8,7 @@
 #include "libslic3r.h"
 #include "ExtrusionEntity.hpp"
 #include "BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/Fill.cpp b/src/libslic3r/Fill/Fill.cpp
index d358f2cde6..96d59d9632 100644
--- a/src/libslic3r/Fill/Fill.cpp
+++ b/src/libslic3r/Fill/Fill.cpp
@@ -9,7 +9,16 @@
 ///|/
 #include <assert.h>
 #include <stdio.h>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <stdint.h>
+#include <boost/container/vector.hpp>
 #include <memory>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <set>
+#include <utility>
+#include <vector>
 
 #include "../ClipperUtils.hpp"
 #include "../Geometry.hpp"
@@ -19,15 +28,30 @@
 #include "../Surface.hpp"
 // for Arachne based infills
 #include "../PerimeterGenerator.hpp"
-
 #include "FillBase.hpp"
 #include "FillRectilinear.hpp"
 #include "FillLightning.hpp"
-#include "FillConcentric.hpp"
 #include "FillEnsuring.hpp"
 #include "libslic3r/Polygon.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
+namespace FillAdaptive {
+struct Octree;
+}  // namespace FillAdaptive
+namespace FillLightning {
+class Generator;
+}  // namespace FillLightning
 
 //static constexpr const float NarrowInfillAreaThresholdMM = 3.f;
 
@@ -446,10 +470,6 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
 {
 	this->clear_fills();
 
-#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
-//	this->export_region_fill_surfaces_to_svg_debug("10_fill-initial");
-#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
-
     std::vector<SurfaceFill>  surface_fills       = group_fills(*this);
     const Slic3r::BoundingBox bbox                = this->object()->bounding_box();
     const auto                resolution          = this->object()->print()->config().gcode_resolution.value;
diff --git a/src/libslic3r/Fill/Fill3DHoneycomb.cpp b/src/libslic3r/Fill/Fill3DHoneycomb.cpp
index ed8281f3d3..f40d4795f8 100644
--- a/src/libslic3r/Fill/Fill3DHoneycomb.cpp
+++ b/src/libslic3r/Fill/Fill3DHoneycomb.cpp
@@ -3,11 +3,20 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
 #include "../ClipperUtils.hpp"
 #include "../ShortestPath.hpp"
-#include "../Surface.hpp"
-
 #include "Fill3DHoneycomb.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/Fill3DHoneycomb.hpp b/src/libslic3r/Fill/Fill3DHoneycomb.hpp
index b3b0e08dcc..063e977e0b 100644
--- a/src/libslic3r/Fill/Fill3DHoneycomb.hpp
+++ b/src/libslic3r/Fill/Fill3DHoneycomb.hpp
@@ -7,12 +7,15 @@
 #define slic3r_Fill3DHoneycomb_hpp_
 
 #include <map>
+#include <utility>
 
 #include "libslic3r/libslic3r.h"
-
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class Point;
 
 class Fill3DHoneycomb : public Fill
 {
diff --git a/src/libslic3r/Fill/FillAdaptive.cpp b/src/libslic3r/Fill/FillAdaptive.cpp
index 4b216d5b44..8fbd0c6d6e 100644
--- a/src/libslic3r/Fill/FillAdaptive.cpp
+++ b/src/libslic3r/Fill/FillAdaptive.cpp
@@ -2,32 +2,41 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "../ClipperUtils.hpp"
-#include "../ExPolygon.hpp"
-#include "../Surface.hpp"
-#include "../Geometry.hpp"
-#include "../Layer.hpp"
-#include "../Print.hpp"
-#include "../ShortestPath.hpp"
-
-#include "FillAdaptive.hpp"
-
 // for indexed_triangle_set
 #include <admesh/stl.h>
-
+#include <assert.h>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/static_assert.hpp>
 #include <cstdlib>
 #include <cmath>
 #include <algorithm>
 #include <numeric>
+#include <array>
+#include <iterator>
+#include <limits>
+#include <optional>
+
+#include "../ClipperUtils.hpp"
+#include "../ExPolygon.hpp"
+#include "../Geometry.hpp"
+#include "../Layer.hpp"
+#include "../Print.hpp"
+#include "../ShortestPath.hpp"
+#include "FillAdaptive.hpp"
+#include "libslic3r/Fill/FillAdaptive.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "tcbspan/span.hpp"
 
 // Boost pool: Don't use mutexes to synchronize memory allocation.
 #define BOOST_POOL_NO_MT
 #include <boost/pool/object_pool.hpp>
-
 #include <boost/geometry.hpp>
-#include <boost/geometry/geometries/point.hpp>
 #include <boost/geometry/geometries/segment.hpp>
-#include <boost/geometry/index/rtree.hpp>
 
 
 namespace Slic3r {
@@ -508,10 +517,6 @@ static void generate_infill_lines_recursive(
     }
 }
 
-#ifndef NDEBUG
-//    #define ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT
-#endif
-
 #ifdef ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT
 static void export_infill_lines_to_svg(const ExPolygon &expoly, const Polylines &polylines, const std::string &path, const Points &pts = Points())
 {
diff --git a/src/libslic3r/Fill/FillAdaptive.hpp b/src/libslic3r/Fill/FillAdaptive.hpp
index 7e2df90c15..4889c84c49 100644
--- a/src/libslic3r/Fill/FillAdaptive.hpp
+++ b/src/libslic3r/Fill/FillAdaptive.hpp
@@ -15,7 +15,16 @@
 #ifndef slic3r_FillAdaptive_hpp_
 #define slic3r_FillAdaptive_hpp_
 
+#include <Eigen/Geometry>
+#include <memory>
+#include <utility>
+#include <vector>
+
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 struct indexed_triangle_set;
 
@@ -27,6 +36,7 @@ namespace FillAdaptive
 {
 
 struct Octree;
+
 // To keep the definition of Octree opaque, we have to define a custom deleter.
 struct OctreeDeleter { void operator()(Octree *p); };
 using  OctreePtr = std::unique_ptr<Octree, OctreeDeleter>;
diff --git a/src/libslic3r/Fill/FillBase.cpp b/src/libslic3r/Fill/FillBase.cpp
index e9ff9edd20..91f0cfc7cb 100644
--- a/src/libslic3r/Fill/FillBase.cpp
+++ b/src/libslic3r/Fill/FillBase.cpp
@@ -8,7 +8,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include <stdio.h>
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
 #include <numeric>
+#include <algorithm>
+#include <cmath>
+#include <limits>
 
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/EdgeGrid.hpp"
@@ -18,7 +25,6 @@
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/Surface.hpp"
 #include "libslic3r/libslic3r.h"
-
 #include "FillBase.hpp"
 #include "FillConcentric.hpp"
 #include "FillHoneycomb.hpp"
@@ -30,8 +36,8 @@
 #include "FillAdaptive.hpp"
 #include "FillLightning.hpp"
 #include "FillEnsuring.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Line.hpp"
 
 // #define INFILL_DEBUG_OUTPUT
 
@@ -925,9 +931,6 @@ void mark_boundary_segments_touching_infill(
                 BoundingBoxf bbox_seg;
                 bbox_seg.merge(seg_pt1);
                 bbox_seg.merge(seg_pt2);
-#ifdef INFILL_DEBUG_OUTPUT
-                //if (this->infill_bbox.overlap(bbox_seg)) this->perimeter_overlaps.push_back({ segment.first, segment.second });
-#endif // INFILL_DEBUG_OUTPUT
                 if (this->infill_bbox.overlap(bbox_seg) && line_rounded_thick_segment_collision(seg_pt1, seg_pt2, *this->infill_pt1, *this->infill_pt2, this->radius, interval)) {
                     // The boundary segment intersects with the infill segment thickened by radius.
                     // Interval is specified in Euclidian length from seg_pt1 to seg_pt2.
@@ -1083,9 +1086,6 @@ void mark_boundary_segments_touching_infill(
                 assert(grid.bbox().contains(b.cast<coord_t>()));
                 grid.visit_cells_intersecting_line(a.cast<coord_t>(), b.cast<coord_t>(), visitor);
 #endif
-#ifdef INFILL_DEBUG_OUTPUT
-//                export_infill_to_svg(boundary, boundary_parameters, boundary_intersections, infill, distance_colliding * 2, debug_out_path("%s-%03d-%03d-%03d.svg", "FillBase-mark_boundary_segments_touching_infill-step", iRun, iStep, int(point_idx)), { polyline });
-#endif // INFILL_DEBUG_OUTPUT
 			}
 #ifdef INFILL_DEBUG_OUTPUT
             Polylines perimeter_overlaps;
diff --git a/src/libslic3r/Fill/FillBase.hpp b/src/libslic3r/Fill/FillBase.hpp
index 7804a4fb56..6b26baf00b 100644
--- a/src/libslic3r/Fill/FillBase.hpp
+++ b/src/libslic3r/Fill/FillBase.hpp
@@ -14,9 +14,13 @@
 #include <memory.h>
 #include <float.h>
 #include <stdint.h>
+#include <math.h>
+#include <stddef.h>
 #include <stdexcept>
-
 #include <type_traits>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/BoundingBox.hpp"
@@ -24,10 +28,16 @@
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
 class Surface;
+class PrintConfig;
+class PrintObjectConfig;
+
 enum InfillPattern : int;
 
 namespace FillAdaptive {
diff --git a/src/libslic3r/Fill/FillConcentric.cpp b/src/libslic3r/Fill/FillConcentric.cpp
index c5648ef14a..9c41b42eb5 100644
--- a/src/libslic3r/Fill/FillConcentric.cpp
+++ b/src/libslic3r/Fill/FillConcentric.cpp
@@ -7,12 +7,22 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <vector>
+
 #include "../ClipperUtils.hpp"
 #include "../ExPolygon.hpp"
-#include "../Surface.hpp"
 #include "libslic3r/Arachne/WallToolPaths.hpp"
-
 #include "FillConcentric.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillConcentric.hpp b/src/libslic3r/Fill/FillConcentric.hpp
index a2e53e1df2..da5944e147 100644
--- a/src/libslic3r/Fill/FillConcentric.hpp
+++ b/src/libslic3r/Fill/FillConcentric.hpp
@@ -11,9 +11,14 @@
 #ifndef slic3r_FillConcentric_hpp_
 #define slic3r_FillConcentric_hpp_
 
+#include <utility>
+
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class Point;
 
 class FillConcentric : public Fill
 {
diff --git a/src/libslic3r/Fill/FillEnsuring.cpp b/src/libslic3r/Fill/FillEnsuring.cpp
index 4b06cc5154..ea3fecc1c3 100644
--- a/src/libslic3r/Fill/FillEnsuring.cpp
+++ b/src/libslic3r/Fill/FillEnsuring.cpp
@@ -5,10 +5,18 @@
 
 #include "FillEnsuring.hpp"
 
+#include <assert.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <unordered_set>
+#include <vector>
+#include <cmath>
+#include <set>
+#include <utility>
+
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ShortestPath.hpp"
 #include "libslic3r/Arachne/WallToolPaths.hpp"
-
 #include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/Algorithm/PathSorting.hpp"
 #include "libslic3r/BoundingBox.hpp"
@@ -18,16 +26,10 @@
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/Polyline.hpp"
-#include "libslic3r/SVG.hpp"
 #include "libslic3r/libslic3r.h"
-
-#include <algorithm>
-#include <boost/log/trivial.hpp>
-#include <functional>
-#include <string>
-#include <type_traits>
-#include <unordered_set>
-#include <vector>
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Surface.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillEnsuring.hpp b/src/libslic3r/Fill/FillEnsuring.hpp
index 152f9772ef..67336afdfc 100644
--- a/src/libslic3r/Fill/FillEnsuring.hpp
+++ b/src/libslic3r/Fill/FillEnsuring.hpp
@@ -7,8 +7,11 @@
 
 #include "FillBase.hpp"
 #include "FillRectilinear.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class PrintRegionConfig;
+class Surface;
 
 ThickPolylines make_fill_polylines(
     const Fill *fill, const Surface *surface, const FillParams &params, bool stop_vibrations, bool fill_gaps, bool connect_extrusions);
diff --git a/src/libslic3r/Fill/FillGyroid.cpp b/src/libslic3r/Fill/FillGyroid.cpp
index bab68ff630..da3f3aadd5 100644
--- a/src/libslic3r/Fill/FillGyroid.cpp
+++ b/src/libslic3r/Fill/FillGyroid.cpp
@@ -3,14 +3,19 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "../ClipperUtils.hpp"
-#include "../ShortestPath.hpp"
-#include "../Surface.hpp"
+#include <stddef.h>
 #include <cmath>
 #include <algorithm>
-#include <iostream>
+#include <vector>
 
+#include "../ClipperUtils.hpp"
+#include "../ShortestPath.hpp"
 #include "FillGyroid.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillGyroid.hpp b/src/libslic3r/Fill/FillGyroid.hpp
index 63226294cd..28dc6b7c7b 100644
--- a/src/libslic3r/Fill/FillGyroid.hpp
+++ b/src/libslic3r/Fill/FillGyroid.hpp
@@ -6,11 +6,15 @@
 #ifndef slic3r_FillGyroid_hpp_
 #define slic3r_FillGyroid_hpp_
 
-#include "libslic3r/libslic3r.h"
+#include <utility>
 
+#include "libslic3r/libslic3r.h"
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class Point;
 
 class FillGyroid : public Fill
 {
diff --git a/src/libslic3r/Fill/FillHoneycomb.cpp b/src/libslic3r/Fill/FillHoneycomb.cpp
index 0234bc36bd..6d4c9f0b3f 100644
--- a/src/libslic3r/Fill/FillHoneycomb.cpp
+++ b/src/libslic3r/Fill/FillHoneycomb.cpp
@@ -7,11 +7,15 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <algorithm>
+#include <cmath>
+
 #include "../ClipperUtils.hpp"
 #include "../ShortestPath.hpp"
-#include "../Surface.hpp"
-
 #include "FillHoneycomb.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillHoneycomb.hpp b/src/libslic3r/Fill/FillHoneycomb.hpp
index f3ae60e589..f061be4a87 100644
--- a/src/libslic3r/Fill/FillHoneycomb.hpp
+++ b/src/libslic3r/Fill/FillHoneycomb.hpp
@@ -10,11 +10,16 @@
 #ifndef slic3r_FillHoneycomb_hpp_
 #define slic3r_FillHoneycomb_hpp_
 
+#include <math.h>
+#include <stddef.h>
 #include <map>
+#include <utility>
 
 #include "libslic3r/libslic3r.h"
-
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillLightning.cpp b/src/libslic3r/Fill/FillLightning.cpp
index bc67d68204..2ca07725d7 100644
--- a/src/libslic3r/Fill/FillLightning.cpp
+++ b/src/libslic3r/Fill/FillLightning.cpp
@@ -4,9 +4,12 @@
 ///|/
 #include "../Print.hpp"
 #include "../ShortestPath.hpp"
-
 #include "FillLightning.hpp"
 #include "Lightning/Generator.hpp"
+#include "libslic3r/Fill/FillLightning.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Fill/Lightning/Layer.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::FillLightning {
 
diff --git a/src/libslic3r/Fill/FillLightning.hpp b/src/libslic3r/Fill/FillLightning.hpp
index 48a5da624a..fa359ab4de 100644
--- a/src/libslic3r/Fill/FillLightning.hpp
+++ b/src/libslic3r/Fill/FillLightning.hpp
@@ -5,15 +5,24 @@
 #ifndef slic3r_FillLightning_hpp_
 #define slic3r_FillLightning_hpp_
 
+#include <functional>
+#include <memory>
+#include <utility>
+
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
 class PrintObject;
+class Point;
 
 namespace FillLightning {
 
 class Generator;
+
 // To keep the definition of Octree opaque, we have to define a custom deleter.
 struct GeneratorDeleter { void operator()(Generator *p); };
 using  GeneratorPtr = std::unique_ptr<Generator, GeneratorDeleter>;
diff --git a/src/libslic3r/Fill/FillLine.cpp b/src/libslic3r/Fill/FillLine.cpp
index 6bb07e1a30..767ef8e14c 100644
--- a/src/libslic3r/Fill/FillLine.cpp
+++ b/src/libslic3r/Fill/FillLine.cpp
@@ -2,12 +2,18 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <cmath>
+
 #include "../ClipperUtils.hpp"
 #include "../ExPolygon.hpp"
 #include "../ShortestPath.hpp"
-#include "../Surface.hpp"
-
 #include "FillLine.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillLine.hpp b/src/libslic3r/Fill/FillLine.hpp
index 2f80933e48..7ded77162c 100644
--- a/src/libslic3r/Fill/FillLine.hpp
+++ b/src/libslic3r/Fill/FillLine.hpp
@@ -6,9 +6,14 @@
 #ifndef slic3r_FillLine_hpp_
 #define slic3r_FillLine_hpp_
 
-#include "libslic3r/libslic3r.h"
+#include <utility>
 
+#include "libslic3r/libslic3r.h"
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillPlanePath.cpp b/src/libslic3r/Fill/FillPlanePath.cpp
index cfbe9b3738..8beac64bbc 100644
--- a/src/libslic3r/Fill/FillPlanePath.cpp
+++ b/src/libslic3r/Fill/FillPlanePath.cpp
@@ -7,11 +7,13 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <cmath>
+
 #include "../ClipperUtils.hpp"
 #include "../ShortestPath.hpp"
-#include "../Surface.hpp"
-
 #include "FillPlanePath.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillPlanePath.hpp b/src/libslic3r/Fill/FillPlanePath.hpp
index 606245908a..bd1aa223fa 100644
--- a/src/libslic3r/Fill/FillPlanePath.hpp
+++ b/src/libslic3r/Fill/FillPlanePath.hpp
@@ -10,11 +10,17 @@
 #ifndef slic3r_FillPlanePath_hpp_
 #define slic3r_FillPlanePath_hpp_
 
+#include <math.h>
+#include <stddef.h>
 #include <map>
+#include <algorithm>
+#include <utility>
 
 #include "libslic3r/libslic3r.h"
-
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/FillRectilinear.cpp b/src/libslic3r/Fill/FillRectilinear.cpp
index abcbd84e1e..1b11f2df2f 100644
--- a/src/libslic3r/Fill/FillRectilinear.cpp
+++ b/src/libslic3r/Fill/FillRectilinear.cpp
@@ -8,24 +8,28 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include <stdlib.h>
-#include <stdint.h>
-
+#include <boost/container/small_vector.hpp>
+#include <boost/log/trivial.hpp>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <boost/container/vector.hpp>
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <random>
-
-#include <boost/container/small_vector.hpp>
-#include <boost/log/trivial.hpp>
-#include <boost/static_assert.hpp>
+#include <cstdint>
+#include <numeric>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/Surface.hpp"
 #include "libslic3r/ShortestPath.hpp"
-
 #include "FillRectilinear.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Utils.hpp"
 
 // #define SLIC3R_DEBUG
 // #define INFILL_DEBUG_OUTPUT
diff --git a/src/libslic3r/Fill/FillRectilinear.hpp b/src/libslic3r/Fill/FillRectilinear.hpp
index a2bd198f76..b66b223860 100644
--- a/src/libslic3r/Fill/FillRectilinear.hpp
+++ b/src/libslic3r/Fill/FillRectilinear.hpp
@@ -11,9 +11,17 @@
 #ifndef slic3r_FillRectilinear_hpp_
 #define slic3r_FillRectilinear_hpp_
 
-#include "libslic3r/libslic3r.h"
+#include <stddef.h>
+#include <initializer_list>
 
+#include "libslic3r/libslic3r.h"
 #include "FillBase.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/ShortestPath.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Fill/Lightning/DistanceField.cpp b/src/libslic3r/Fill/Lightning/DistanceField.cpp
index ad1a85ac65..4f07dc2ee7 100644
--- a/src/libslic3r/Fill/Lightning/DistanceField.cpp
+++ b/src/libslic3r/Fill/Lightning/DistanceField.cpp
@@ -2,10 +2,20 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "DistanceField.hpp" //Class we're implementing.
+
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stdlib.h>
+#include <cmath>
+#include <utility>
+
 #include "../FillRectilinear.hpp"
 #include "../../ClipperUtils.hpp"
-
-#include <tbb/parallel_for.h>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 #ifdef LIGHTNING_DISTANCE_FIELD_DEBUG_OUTPUT
 #include "../../SVG.hpp"
diff --git a/src/libslic3r/Fill/Lightning/DistanceField.hpp b/src/libslic3r/Fill/Lightning/DistanceField.hpp
index 6e72243841..5150e27f3f 100644
--- a/src/libslic3r/Fill/Lightning/DistanceField.hpp
+++ b/src/libslic3r/Fill/Lightning/DistanceField.hpp
@@ -4,9 +4,18 @@
 #ifndef LIGHTNING_DISTANCE_FIELD_H
 #define LIGHTNING_DISTANCE_FIELD_H
 
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <vector>
+
 #include "../../BoundingBox.hpp"
 #include "../../Point.hpp"
 #include "../../Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 //#define LIGHTNING_DISTANCE_FIELD_DEBUG_OUTPUT
 
diff --git a/src/libslic3r/Fill/Lightning/Generator.cpp b/src/libslic3r/Fill/Lightning/Generator.cpp
index 185cb60af4..4715f67375 100644
--- a/src/libslic3r/Fill/Lightning/Generator.cpp
+++ b/src/libslic3r/Fill/Lightning/Generator.cpp
@@ -2,11 +2,25 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "Generator.hpp"
-#include "TreeNode.hpp"
 
+#include <assert.h>
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+#include "TreeNode.hpp"
 #include "../../ClipperUtils.hpp"
 #include "../../Layer.hpp"
 #include "../../Print.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/EdgeGrid.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Fill/Lightning/Layer.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Surface.hpp"
 
 /* Possible future tasks/optimizations,etc.:
  * - Improve connecting heuristic to favor connecting to shorter trees
diff --git a/src/libslic3r/Fill/Lightning/Generator.hpp b/src/libslic3r/Fill/Lightning/Generator.hpp
index 15ac7b2c72..03fe10a2df 100644
--- a/src/libslic3r/Fill/Lightning/Generator.hpp
+++ b/src/libslic3r/Fill/Lightning/Generator.hpp
@@ -4,12 +4,15 @@
 #ifndef LIGHTNING_GENERATOR_H
 #define LIGHTNING_GENERATOR_H
 
-#include "Layer.hpp"
-
+#include <stddef.h>
 #include <functional>
 #include <memory>
 #include <vector>
 
+#include "Layer.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
+
 namespace Slic3r 
 {
 class PrintObject;
diff --git a/src/libslic3r/Fill/Lightning/Layer.cpp b/src/libslic3r/Fill/Lightning/Layer.cpp
index 6cf8a84de9..6f64a28305 100644
--- a/src/libslic3r/Fill/Lightning/Layer.cpp
+++ b/src/libslic3r/Fill/Lightning/Layer.cpp
@@ -3,16 +3,23 @@
 
 #include "Layer.hpp" //The class we're implementing.
 
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/blocked_range2d.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
+#include <mutex>
+#include <algorithm>
+#include <limits>
+#include <utility>
+
 #include "DistanceField.hpp"
 #include "TreeNode.hpp"
-
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/Geometry.hpp"
-#include "libslic3r/Utils.hpp"
-
-#include <tbb/parallel_for.h>
-#include <tbb/blocked_range2d.h>
-#include <mutex>
+#include "libslic3r/EdgeGrid.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r::FillLightning {
 
diff --git a/src/libslic3r/Fill/Lightning/Layer.hpp b/src/libslic3r/Fill/Lightning/Layer.hpp
index e8c0a38b4d..df5cb2d361 100644
--- a/src/libslic3r/Fill/Lightning/Layer.hpp
+++ b/src/libslic3r/Fill/Lightning/Layer.hpp
@@ -4,19 +4,25 @@
 #ifndef LIGHTNING_LAYER_H
 #define LIGHTNING_LAYER_H
 
-#include "../../EdgeGrid.hpp"
-#include "../../Polygon.hpp"
-
 #include <memory>
 #include <vector>
 #include <list>
 #include <unordered_map>
 #include <optional>
+#include <functional>
+
+#include "../../EdgeGrid.hpp"
+#include "../../Polygon.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::FillLightning
 {
 
 class Node;
+
 using NodeSPtr = std::shared_ptr<Node>;
 using SparseNodeGrid = std::unordered_multimap<Point, std::weak_ptr<Node>, PointHash>;
 
diff --git a/src/libslic3r/Fill/Lightning/TreeNode.cpp b/src/libslic3r/Fill/Lightning/TreeNode.cpp
index 801a46df49..1d664e0182 100644
--- a/src/libslic3r/Fill/Lightning/TreeNode.cpp
+++ b/src/libslic3r/Fill/Lightning/TreeNode.cpp
@@ -3,7 +3,13 @@
 
 #include "TreeNode.hpp"
 
+#include <assert.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <limits>
+
 #include "../../Geometry.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r::FillLightning {
 
diff --git a/src/libslic3r/Fill/Lightning/TreeNode.hpp b/src/libslic3r/Fill/Lightning/TreeNode.hpp
index 18f9e05aca..0c73f20fba 100644
--- a/src/libslic3r/Fill/Lightning/TreeNode.hpp
+++ b/src/libslic3r/Fill/Lightning/TreeNode.hpp
@@ -4,14 +4,21 @@
 #ifndef LIGHTNING_TREE_NODE_H
 #define LIGHTNING_TREE_NODE_H
 
+#include <stddef.h>
+#include <stdint.h>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <vector>
+#include <utility>
 
 #include "libslic3r/EdgeGrid.hpp"
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/SVG.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 //#define LIGHTNING_TREE_NODE_DEBUG_OUTPUT
 
diff --git a/src/libslic3r/Flow.cpp b/src/libslic3r/Flow.cpp
index e6290cdff0..aa64f45c37 100644
--- a/src/libslic3r/Flow.cpp
+++ b/src/libslic3r/Flow.cpp
@@ -9,12 +9,18 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Flow.hpp"
+
+#include <assert.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/format.hpp>
+#include <cmath>
+
 #include "I18N.hpp"
 #include "Print.hpp"
-#include <cmath>
-#include <assert.h>
-
-#include <boost/algorithm/string/predicate.hpp>
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Flow.hpp b/src/libslic3r/Flow.hpp
index e396a8ff68..a953d14249 100644
--- a/src/libslic3r/Flow.hpp
+++ b/src/libslic3r/Flow.hpp
@@ -10,6 +10,9 @@
 #ifndef slic3r_Flow_hpp_
 #define slic3r_Flow_hpp_
 
+#include <assert.h>
+#include <string>
+
 #include "libslic3r.h"
 #include "Config.hpp"
 #include "Exception.hpp"
@@ -18,6 +21,8 @@
 namespace Slic3r {
 
 class PrintObject;
+class ConfigOptionFloatOrPercent;
+class ConfigOptionResolver;
 
 // Extra spacing of bridge threads, in mm.
 #define BRIDGE_EXTRA_SPACING 0.05
diff --git a/src/libslic3r/Format/AnycubicSLA.cpp b/src/libslic3r/Format/AnycubicSLA.cpp
index 5ac2324428..e694220a31 100644
--- a/src/libslic3r/Format/AnycubicSLA.cpp
+++ b/src/libslic3r/Format/AnycubicSLA.cpp
@@ -5,16 +5,27 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "AnycubicSLA.hpp"
-#include "libslic3r/GCode/ThumbnailData.hpp"
-#include "libslic3r/SLA/RasterBase.hpp"
-#include "libslic3r/SLAPrint.hpp"
-
-#include <sstream>
-#include <iostream>
-#include <fstream> // IWYU pragma: keep
 
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stdio.h>
+#include <fstream> // IWYU pragma: keep
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <exception>
+#include <iterator>
+#include <map>
+#include <vector>
+
+#include "libslic3r/GCode/ThumbnailData.hpp"
+#include "libslic3r/SLA/RasterBase.hpp"
+#include "libslic3r/SLAPrint.hpp"
+#include "LocalesUtils.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/libslic3r.h"
 
 
 #define TAG_INTRO "ANYCUBIC\0\0\0\0"
diff --git a/src/libslic3r/Format/AnycubicSLA.hpp b/src/libslic3r/Format/AnycubicSLA.hpp
index 73f71ea804..172bd71e5b 100644
--- a/src/libslic3r/Format/AnycubicSLA.hpp
+++ b/src/libslic3r/Format/AnycubicSLA.hpp
@@ -6,12 +6,20 @@
 #ifndef _SLIC3R_FORMAT_PWMX_HPP_
 #define _SLIC3R_FORMAT_PWMX_HPP_
 
+#include <stdint.h>
 #include <string>
+#include <memory>
+#include <utility>
 
 #include "SLAArchiveWriter.hpp"
 #include "SLAArchiveFormatRegistry.hpp"
-
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/GCode/ThumbnailData.hpp"
+#include "libslic3r/SLA/RasterBase.hpp"
+
+namespace Slic3r {
+class SLAPrint;
+}  // namespace Slic3r
 
 constexpr uint16_t ANYCUBIC_SLA_FORMAT_VERSION_1 = 1;
 constexpr uint16_t ANYCUBIC_SLA_FORMAT_VERSION_515 = 515;
diff --git a/src/libslic3r/Format/OBJ.cpp b/src/libslic3r/Format/OBJ.cpp
index 18980cbcd9..5bc95dd04d 100644
--- a/src/libslic3r/Format/OBJ.cpp
+++ b/src/libslic3r/Format/OBJ.cpp
@@ -6,16 +6,17 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/libslic3r.h"
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <string.h>
+#include <string>
+#include <utility>
+
 #include "libslic3r/Model.hpp"
 #include "libslic3r/TriangleMesh.hpp"
-
 #include "OBJ.hpp"
 #include "objparser.hpp"
-
-#include <string>
-
-#include <boost/log/trivial.hpp>
+#include "admesh/stl.h"
 
 #ifdef _WIN32
 #define DIR_SEPARATOR '\\'
diff --git a/src/libslic3r/Format/SL1_SVG.cpp b/src/libslic3r/Format/SL1_SVG.cpp
index 0e25773bf2..27cb18a827 100644
--- a/src/libslic3r/Format/SL1_SVG.cpp
+++ b/src/libslic3r/Format/SL1_SVG.cpp
@@ -3,19 +3,37 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "SL1_SVG.hpp"
-#include "libslic3r/SLA/RasterBase.hpp"
+
 #include <LocalesUtils.hpp>
+#include <stddef.h>
+
+#include "libslic3r/SLA/RasterBase.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Format/ZipperArchiveImport.hpp"
+#include "libslic3r/Format/SL1.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Zipper.hpp"
+#include "libslic3r/libslic3r.h"
 
 #define NANOSVG_IMPLEMENTATION
-#include "nanosvg/nanosvg.h"
-
-#include <limits>
 #include <cstdint>
 #include <algorithm>
 #include <string_view>
+#include <array>
+#include <cmath>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include "nanosvg/nanosvg.h"
+
+namespace Slic3r {
+class SLAPrint;
+}  // namespace Slic3r
+
 using namespace std::literals;
 
 namespace Slic3r {
diff --git a/src/libslic3r/Format/SL1_SVG.hpp b/src/libslic3r/Format/SL1_SVG.hpp
index 86ea97af27..0e35b66948 100644
--- a/src/libslic3r/Format/SL1_SVG.hpp
+++ b/src/libslic3r/Format/SL1_SVG.hpp
@@ -5,9 +5,21 @@
 #ifndef SL1_SVG_HPP
 #define SL1_SVG_HPP
 
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "SL1.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Format/SLAArchiveReader.hpp"
+#include "libslic3r/GCode/ThumbnailData.hpp"
+#include "libslic3r/SLA/RasterBase.hpp"
 
 namespace Slic3r {
+class DynamicPrintConfig;
+class SLAPrint;
 
 class SL1_SVGArchive: public SL1Archive {
 protected:
diff --git a/src/libslic3r/Format/SLAArchiveFormatRegistry.cpp b/src/libslic3r/Format/SLAArchiveFormatRegistry.cpp
index c6780e6226..de97759b18 100644
--- a/src/libslic3r/Format/SLAArchiveFormatRegistry.cpp
+++ b/src/libslic3r/Format/SLAArchiveFormatRegistry.cpp
@@ -3,15 +3,15 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include <set>
-#include <mutex>
 #include <memory>
 
 #include "SL1.hpp"
 #include "SL1_SVG.hpp"
 #include "AnycubicSLA.hpp"
 #include "libslic3r/I18N.hpp"
-
 #include "SLAArchiveFormatRegistry.hpp"
+#include "libslic3r/Format/SLAArchiveReader.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Format/SLAArchiveFormatRegistry.hpp b/src/libslic3r/Format/SLAArchiveFormatRegistry.hpp
index 071849eaf2..925dc11895 100644
--- a/src/libslic3r/Format/SLAArchiveFormatRegistry.hpp
+++ b/src/libslic3r/Format/SLAArchiveFormatRegistry.hpp
@@ -5,11 +5,19 @@
 #ifndef SLA_ARCHIVE_FORMAT_REGISTRY_HPP
 #define SLA_ARCHIVE_FORMAT_REGISTRY_HPP
 
+#include <cstring>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
 #include "SLAArchiveWriter.hpp"
 #include "SLAArchiveReader.hpp"
-#include <cstring>
 
 namespace Slic3r {
+class SLAPrinterConfig;
 
 // Factory function that returns an implementation of SLAArchiveWriter given
 // a printer configuration.
diff --git a/src/libslic3r/Format/SLAArchiveWriter.cpp b/src/libslic3r/Format/SLAArchiveWriter.cpp
index 93b273a7d7..5af3e0bf4f 100644
--- a/src/libslic3r/Format/SLAArchiveWriter.cpp
+++ b/src/libslic3r/Format/SLAArchiveWriter.cpp
@@ -4,7 +4,9 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "SLAArchiveWriter.hpp"
+
 #include "SLAArchiveFormatRegistry.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Format/SLAArchiveWriter.hpp b/src/libslic3r/Format/SLAArchiveWriter.hpp
index 8ef8df8b33..8b6863a55b 100644
--- a/src/libslic3r/Format/SLAArchiveWriter.hpp
+++ b/src/libslic3r/Format/SLAArchiveWriter.hpp
@@ -5,11 +5,15 @@
 #ifndef SLAARCHIVE_HPP
 #define SLAARCHIVE_HPP
 
+#include <stddef.h>
 #include <vector>
+#include <memory>
+#include <string>
 
 #include "libslic3r/SLA/RasterBase.hpp"
 #include "libslic3r/Execution/ExecutionTBB.hpp"
 #include "libslic3r/GCode/ThumbnailData.hpp"
+#include "libslic3r/Execution/Execution.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Format/STL.cpp b/src/libslic3r/Format/STL.cpp
index 264cd17c37..94c558963f 100644
--- a/src/libslic3r/Format/STL.cpp
+++ b/src/libslic3r/Format/STL.cpp
@@ -7,14 +7,14 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/libslic3r.h"
+#include <string.h>
+#include <string>
+#include <utility>
+
 #include "libslic3r/Model.hpp"
 #include "libslic3r/TriangleMesh.hpp"
-
 #include "STL.hpp"
 
-#include <string>
-
 #ifdef _WIN32
 #define DIR_SEPARATOR '\\'
 #else
diff --git a/src/libslic3r/Format/STL.hpp b/src/libslic3r/Format/STL.hpp
index 242ebcbabf..93550bcaf6 100644
--- a/src/libslic3r/Format/STL.hpp
+++ b/src/libslic3r/Format/STL.hpp
@@ -14,6 +14,7 @@ namespace Slic3r {
 
 class TriangleMesh;
 class ModelObject;
+class Model;
 
 // Load an STL file into a provided model.
 extern bool load_stl(const char *path, Model *model, const char *object_name = nullptr);
diff --git a/src/libslic3r/Format/SVG.cpp b/src/libslic3r/Format/SVG.cpp
index a84d0abdd0..1642614b9e 100644
--- a/src/libslic3r/Format/SVG.cpp
+++ b/src/libslic3r/Format/SVG.cpp
@@ -6,13 +6,23 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/libslic3r.h"
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <nanosvg/nanosvg.h>
+#include <stddef.h>
+#include <Eigen/Geometry>
+#include <memory>
+#include <string>
+#include <utility>
+
 #include "libslic3r/Model.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/NSVGUtils.hpp"
 #include "libslic3r/Emboss.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "admesh/stl.h"
+#include "libslic3r/EmbossShape.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace {
 std::string get_file_name(const std::string &file_path)
diff --git a/src/libslic3r/Format/objparser.cpp b/src/libslic3r/Format/objparser.cpp
index 3add398152..6f2d4ba71f 100644
--- a/src/libslic3r/Format/objparser.cpp
+++ b/src/libslic3r/Format/objparser.cpp
@@ -4,14 +4,17 @@
 ///|/
 #include <stdlib.h>
 #include <string.h>
-
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/cstdio.hpp>
-
-#include "objparser.hpp"
-
 #include <LocalesUtils.hpp>
 #include <fast_float.h>
+#include <assert.h>
+#include <stdio.h>
+#include <new>
+#include <system_error>
+#include <utility>
+
+#include "objparser.hpp"
 
 namespace ObjParser {
 
diff --git a/src/libslic3r/GCode/AvoidCrossingPerimeters.cpp b/src/libslic3r/GCode/AvoidCrossingPerimeters.cpp
index 062362d5ec..aa35e6d846 100644
--- a/src/libslic3r/GCode/AvoidCrossingPerimeters.cpp
+++ b/src/libslic3r/GCode/AvoidCrossingPerimeters.cpp
@@ -2,6 +2,18 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/range/adaptor/reversed.hpp>
+#include <assert.h>
+#include <math.h>
+#include <stddef.h>
+#include <boost/container_hash/hash.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+#include <unordered_set>
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <utility>
+
 #include "../Layer.hpp"
 #include "../GCode.hpp"
 #include "../EdgeGrid.hpp"
@@ -10,12 +22,17 @@
 #include "../ExPolygon.hpp"
 #include "../Geometry.hpp"
 #include "../ClipperUtils.hpp"
-#include "../SVG.hpp"
 #include "AvoidCrossingPerimeters.hpp"
-
-#include <numeric>
-#include <unordered_set>
-#include <boost/range/adaptor/reversed.hpp>
+#include "libslic3r/GCode/AvoidCrossingPerimeters.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 //#define AVOID_CROSSING_PERIMETERS_DEBUG_OUTPUT
 
diff --git a/src/libslic3r/GCode/AvoidCrossingPerimeters.hpp b/src/libslic3r/GCode/AvoidCrossingPerimeters.hpp
index f7c761336e..3db3c313a1 100644
--- a/src/libslic3r/GCode/AvoidCrossingPerimeters.hpp
+++ b/src/libslic3r/GCode/AvoidCrossingPerimeters.hpp
@@ -5,9 +5,15 @@
 #ifndef slic3r_AvoidCrossingPerimeters_hpp_
 #define slic3r_AvoidCrossingPerimeters_hpp_
 
+#include <vector>
+
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/EdgeGrid.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Layer.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/ConflictChecker.cpp b/src/libslic3r/GCode/ConflictChecker.cpp
index dc27d7e140..de92aa38e9 100644
--- a/src/libslic3r/GCode/ConflictChecker.cpp
+++ b/src/libslic3r/GCode/ConflictChecker.cpp
@@ -5,12 +5,22 @@
 ///|/
 #include "ConflictChecker.hpp"
 
-#include <tbb/parallel_for.h>
-#include <tbb/concurrent_vector.h>
-
+#include <assert.h>
+#include <float.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/concurrent_vector.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stdlib.h>
 #include <map>
 #include <functional>
-#include <atomic>
+#include <cmath>
+#include <cstdint>
+
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/GCode/WipeTower.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/ConflictChecker.hpp b/src/libslic3r/GCode/ConflictChecker.hpp
index 2e76b3f4e9..26d01ff768 100644
--- a/src/libslic3r/GCode/ConflictChecker.hpp
+++ b/src/libslic3r/GCode/ConflictChecker.hpp
@@ -6,13 +6,24 @@
 #ifndef slic3r_ConflictChecker_hpp_
 #define slic3r_ConflictChecker_hpp_
 
-#include "libslic3r/Print.hpp"
-
 #include <queue>
 #include <vector>
 #include <optional>
+#include <map>
+#include <string>
+#include <utility>
+
+#include "libslic3r/Print.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/GCode/GCodeProcessor.hpp"
+#include "libslic3r/Layer.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class ExtrusionEntityCollection;
 
 struct LineWithID
 {
diff --git a/src/libslic3r/GCode/CoolingBuffer.cpp b/src/libslic3r/GCode/CoolingBuffer.cpp
index 1905fb8dc8..efee06644c 100644
--- a/src/libslic3r/GCode/CoolingBuffer.cpp
+++ b/src/libslic3r/GCode/CoolingBuffer.cpp
@@ -8,14 +8,29 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "../GCode.hpp"
-#include "CoolingBuffer.hpp"
-#include <algorithm>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/log/trivial.hpp>
-#include <iostream>
 #include <float.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <charconv>
+#include <cmath>
+#include <iterator>
+#include <string_view>
+#include <system_error>
+#include <utility>
+
+#include "../GCode.hpp"
+#include "CoolingBuffer.hpp"
+#include "libslic3r/GCode/CoolingBuffer.hpp"
+#include "libslic3r/Extruder.hpp"
+#include "libslic3r/GCode/GCodeWriter.hpp"
+#include "libslic3r/Geometry/ArcWelder.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 #if 0
     #define DEBUG
@@ -24,7 +39,6 @@
 #endif
 
 #include <assert.h>
-
 #include <fast_float.h>
 
 namespace Slic3r {
diff --git a/src/libslic3r/GCode/CoolingBuffer.hpp b/src/libslic3r/GCode/CoolingBuffer.hpp
index 7d34e77f28..6028c14dca 100644
--- a/src/libslic3r/GCode/CoolingBuffer.hpp
+++ b/src/libslic3r/GCode/CoolingBuffer.hpp
@@ -11,15 +11,21 @@
 #ifndef slic3r_CoolingBuffer_hpp_
 #define slic3r_CoolingBuffer_hpp_
 
-#include "libslic3r/libslic3r.h"
+#include <stddef.h>
 #include <map>
 #include <string>
+#include <array>
+#include <vector>
+
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
 class GCodeGenerator;
 class Layer;
 struct PerExtruderAdjustments;
+class PrintConfig;
 
 // A standalone G-code filter, to control cooling of the print.
 // The G-code is processed per layer. Once a layer is collected, fan start / stop commands are edited
diff --git a/src/libslic3r/GCode/ExtrusionProcessor.cpp b/src/libslic3r/GCode/ExtrusionProcessor.cpp
index 1e2e3bf6a4..51acead1cc 100644
--- a/src/libslic3r/GCode/ExtrusionProcessor.cpp
+++ b/src/libslic3r/GCode/ExtrusionProcessor.cpp
@@ -1,5 +1,15 @@
 #include "ExtrusionProcessor.hpp"
-#include <string>
+
+#include <cassert>
+#include <iterator>
+#include <map>
+#include <optional>
+
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r { namespace ExtrusionProcessor {
 
diff --git a/src/libslic3r/GCode/ExtrusionProcessor.hpp b/src/libslic3r/GCode/ExtrusionProcessor.hpp
index ce455a3ded..2dc94b2f65 100644
--- a/src/libslic3r/GCode/ExtrusionProcessor.hpp
+++ b/src/libslic3r/GCode/ExtrusionProcessor.hpp
@@ -5,6 +5,21 @@
 #ifndef slic3r_ExtrusionProcessor_hpp_
 #define slic3r_ExtrusionProcessor_hpp_
 
+#include <stdlib.h>
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <numeric>
+#include <optional>
+#include <ostream>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#include <functional>
+
 #include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/SupportSpotsGenerator.hpp"
 #include "libslic3r/libslic3r.h"
@@ -20,19 +35,12 @@
 #include "libslic3r/Line.hpp"
 #include "libslic3r/Exception.hpp"
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
 
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstddef>
-#include <iterator>
-#include <limits>
-#include <numeric>
-#include <optional>
-#include <ostream>
-#include <unordered_map>
-#include <utility>
-#include <vector>
+namespace Slic3r {
+class CurledLine;
+class Linef;
+}  // namespace Slic3r
 
 namespace Slic3r { namespace ExtrusionProcessor {
 
diff --git a/src/libslic3r/GCode/FindReplace.cpp b/src/libslic3r/GCode/FindReplace.cpp
index 71ed616390..5f7dc369a3 100644
--- a/src/libslic3r/GCode/FindReplace.cpp
+++ b/src/libslic3r/GCode/FindReplace.cpp
@@ -3,10 +3,19 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "FindReplace.hpp"
-#include "../Utils.hpp"
 
-#include <cctype> // isalpha
 #include <boost/algorithm/string/replace.hpp>
+#include <string.h>
+#include <boost/algorithm/string/find.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <cctype> // isalpha
+#include <exception>
+#include <iterator>
+#include <tuple>
+#include <utility>
+
+#include "../Utils.hpp"
+#include "libslic3r/Exception.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/FindReplace.hpp b/src/libslic3r/GCode/FindReplace.hpp
index 9326b442ac..91a461a708 100644
--- a/src/libslic3r/GCode/FindReplace.hpp
+++ b/src/libslic3r/GCode/FindReplace.hpp
@@ -5,9 +5,12 @@
 #ifndef slic3r_FindReplace_hpp_
 #define slic3r_FindReplace_hpp_
 
-#include "../PrintConfig.hpp"
-
 #include <boost/regex.hpp>
+#include <boost/regex/v5/regex.hpp>
+#include <string>
+#include <vector>
+
+#include "../PrintConfig.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/GCodeWriter.cpp b/src/libslic3r/GCode/GCodeWriter.cpp
index 270b576454..dd290d9c89 100644
--- a/src/libslic3r/GCode/GCodeWriter.cpp
+++ b/src/libslic3r/GCode/GCodeWriter.cpp
@@ -12,15 +12,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "GCodeWriter.hpp"
-#include "../CustomGCode.hpp"
 
-#include <algorithm>
-#include <iomanip>
-#include <iostream>
-#include <map>
 #include <assert.h>
+#include <stdint.h>
+#include <algorithm>
+#include <iostream>
 #include <string_view>
-#include <boost/math/special_functions/pow.hpp>
+
+#include "libslic3r/libslic3r.h"
 
 #ifdef __APPLE__
     #include <boost/spirit/include/karma.hpp>
diff --git a/src/libslic3r/GCode/GCodeWriter.hpp b/src/libslic3r/GCode/GCodeWriter.hpp
index d5cced25a4..ce4d6411f8 100644
--- a/src/libslic3r/GCode/GCodeWriter.hpp
+++ b/src/libslic3r/GCode/GCodeWriter.hpp
@@ -9,16 +9,21 @@
 #ifndef slic3r_GCodeWriter_hpp_
 #define slic3r_GCodeWriter_hpp_
 
+#include <string.h>
+#include <string>
+#include <string_view>
+#include <charconv>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <vector>
+
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Extruder.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/PrintConfig.hpp"
 #include "CoolingBuffer.hpp"
 
-#include <string>
-#include <string_view>
-#include <charconv>
-
 namespace Slic3r {
 
 class GCodeWriter {
diff --git a/src/libslic3r/GCode/LabelObjects.cpp b/src/libslic3r/GCode/LabelObjects.cpp
index ed5c7b5330..abf30df471 100644
--- a/src/libslic3r/GCode/LabelObjects.cpp
+++ b/src/libslic3r/GCode/LabelObjects.cpp
@@ -1,12 +1,21 @@
 #include "LabelObjects.hpp"
 
+#include <assert.h>
+#include <algorithm>
+#include <cstdio>
+#include <map>
+
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/GCode/GCodeWriter.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/TriangleMeshSlicer.hpp"
-
-#include <boost/algorithm/string/replace.hpp>
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/libslic3r.h"
 
 
 namespace Slic3r::GCode {
diff --git a/src/libslic3r/GCode/ModelVisibility.cpp b/src/libslic3r/GCode/ModelVisibility.cpp
index 63f3beffc3..de3aa5fb42 100644
--- a/src/libslic3r/GCode/ModelVisibility.cpp
+++ b/src/libslic3r/GCode/ModelVisibility.cpp
@@ -1,8 +1,16 @@
 #include <boost/log/trivial.hpp>
+#include <igl/Hit.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stdlib.h>
+#include <cmath>
 
 #include "libslic3r/ShortEdgeCollapse.hpp"
 #include "libslic3r/GCode/ModelVisibility.hpp"
 #include "libslic3r/AABBTreeIndirect.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::ModelInfo {
 namespace Impl {
diff --git a/src/libslic3r/GCode/ModelVisibility.hpp b/src/libslic3r/GCode/ModelVisibility.hpp
index a6ce29fba2..5bf4492418 100644
--- a/src/libslic3r/GCode/ModelVisibility.hpp
+++ b/src/libslic3r/GCode/ModelVisibility.hpp
@@ -1,6 +1,10 @@
 #ifndef libslic3r_ModelVisibility_hpp_
 #define libslic3r_ModelVisibility_hpp_
 
+#include <stddef.h>
+#include <functional>
+#include <vector>
+
 #include "libslic3r/KDTreeIndirect.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Model.hpp"
diff --git a/src/libslic3r/GCode/PressureEqualizer.cpp b/src/libslic3r/GCode/PressureEqualizer.cpp
index 3d59616f68..20c9ab157e 100644
--- a/src/libslic3r/GCode/PressureEqualizer.cpp
+++ b/src/libslic3r/GCode/PressureEqualizer.cpp
@@ -3,19 +3,23 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <memory.h>
-#include <cstring>
-#include <cfloat>
-#include <algorithm>
-
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/PrintConfig.hpp"
-#include <LocalesUtils.hpp>
-#include "libslic3r/GCode.hpp"
-
-#include "PressureEqualizer.hpp"
 #include <fast_float.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <cstring>
+#include <algorithm>
+#include <array>
+#include <iosfwd>
+#include <iterator>
+#include <limits>
+
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/GCode.hpp"
+#include "PressureEqualizer.hpp"
 #include "GCodeWriter.hpp"
+#include "libslic3r/GCode/PressureEqualizer.hpp"
+#include "libslic3r/Exception.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/PressureEqualizer.hpp b/src/libslic3r/GCode/PressureEqualizer.hpp
index 8d17a33643..7301305a18 100644
--- a/src/libslic3r/GCode/PressureEqualizer.hpp
+++ b/src/libslic3r/GCode/PressureEqualizer.hpp
@@ -6,16 +6,21 @@
 #ifndef slic3r_GCode_PressureEqualizer_hpp_
 #define slic3r_GCode_PressureEqualizer_hpp_
 
+#include <assert.h>
+#include <stddef.h>
+#include <queue>
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <vector>
+
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/ExtrusionRole.hpp"
 
-#include <queue>
-
 namespace Slic3r {
 
 struct LayerResult;
-
 class GCodeG1Formatter;
 
 //#define PRESSURE_EQUALIZER_STATISTIC
diff --git a/src/libslic3r/GCode/PrintExtents.cpp b/src/libslic3r/GCode/PrintExtents.cpp
index 1381d33b6f..7f200f13c9 100644
--- a/src/libslic3r/GCode/PrintExtents.cpp
+++ b/src/libslic3r/GCode/PrintExtents.cpp
@@ -8,14 +8,23 @@
 // to decide whether to pause the print after the priming towers are extruded
 // to let the operator remove them from the print bed.
 
+#include <stddef.h>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <vector>
+
 #include "../BoundingBox.hpp"
 #include "../ExtrusionEntity.hpp"
 #include "../ExtrusionEntityCollection.hpp"
 #include "../Layer.hpp"
 #include "../Print.hpp"
-
 #include "PrintExtents.hpp"
 #include "WipeTower.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/RetractWhenCrossingPerimeters.cpp b/src/libslic3r/GCode/RetractWhenCrossingPerimeters.cpp
index 1593a74b3d..1de5cf9358 100644
--- a/src/libslic3r/GCode/RetractWhenCrossingPerimeters.cpp
+++ b/src/libslic3r/GCode/RetractWhenCrossingPerimeters.cpp
@@ -2,11 +2,19 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <algorithm>
+
 #include "../ClipperUtils.hpp"
 #include "../Layer.hpp"
 #include "../Polyline.hpp"
-
 #include "RetractWhenCrossingPerimeters.hpp"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Surface.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/RetractWhenCrossingPerimeters.hpp b/src/libslic3r/GCode/RetractWhenCrossingPerimeters.hpp
index 40c4a31543..b40a5891a2 100644
--- a/src/libslic3r/GCode/RetractWhenCrossingPerimeters.hpp
+++ b/src/libslic3r/GCode/RetractWhenCrossingPerimeters.hpp
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "../AABBTreeIndirect.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/SeamAligned.cpp b/src/libslic3r/GCode/SeamAligned.cpp
index 895146898c..7a16d0bfea 100644
--- a/src/libslic3r/GCode/SeamAligned.cpp
+++ b/src/libslic3r/GCode/SeamAligned.cpp
@@ -1,7 +1,17 @@
 #include "libslic3r/GCode/SeamAligned.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <iterator>
+#include <limits>
+#include <stdexcept>
+#include <utility>
+
 #include "libslic3r/GCode/SeamGeometry.hpp"
 #include "libslic3r/GCode/ModelVisibility.hpp"
-#include <fstream>
+#include "libslic3r/KDTreeIndirect.hpp"
+#include "libslic3r/Line.hpp"
+#include "tcbspan/span.hpp"
 
 namespace Slic3r::Seams::Aligned {
 using Perimeters::PointType;
diff --git a/src/libslic3r/GCode/SeamAligned.hpp b/src/libslic3r/GCode/SeamAligned.hpp
index ee3b581ec1..dc35eb7719 100644
--- a/src/libslic3r/GCode/SeamAligned.hpp
+++ b/src/libslic3r/GCode/SeamAligned.hpp
@@ -1,9 +1,15 @@
 #ifndef libslic3r_SeamAligned_hpp_
 #define libslic3r_SeamAligned_hpp_
 
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <vector>
+
 #include "libslic3r/GCode/SeamPerimeters.hpp"
 #include "libslic3r/GCode/SeamChoice.hpp"
 #include "libslic3r/Point.hpp"
+#include "libslic3r/GCode/SeamShells.hpp"
 
 namespace Slic3r::ModelInfo {
     struct Visibility;
diff --git a/src/libslic3r/GCode/SeamChoice.cpp b/src/libslic3r/GCode/SeamChoice.cpp
index 2a577413d8..7ed3474f92 100644
--- a/src/libslic3r/GCode/SeamChoice.cpp
+++ b/src/libslic3r/GCode/SeamChoice.cpp
@@ -1,5 +1,7 @@
 #include "libslic3r/GCode/SeamChoice.hpp"
 
+#include <vector>
+
 namespace Slic3r::Seams {
 std::optional<SeamChoice> maybe_choose_seam_point(
     const Perimeters::Perimeter &perimeter, const SeamPicker &seam_picker
diff --git a/src/libslic3r/GCode/SeamChoice.hpp b/src/libslic3r/GCode/SeamChoice.hpp
index 484c1d53da..d31833ed50 100644
--- a/src/libslic3r/GCode/SeamChoice.hpp
+++ b/src/libslic3r/GCode/SeamChoice.hpp
@@ -1,8 +1,17 @@
 #ifndef libslic3r_SeamChoice_hpp_
 #define libslic3r_SeamChoice_hpp_
 
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <utility>
+
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/GCode/SeamShells.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/GCode/SeamGeometry.hpp"
+#include "libslic3r/GCode/SeamPerimeters.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Seams {
 
diff --git a/src/libslic3r/GCode/SeamGeometry.cpp b/src/libslic3r/GCode/SeamGeometry.cpp
index 14dfd78a82..1b581476bc 100644
--- a/src/libslic3r/GCode/SeamGeometry.cpp
+++ b/src/libslic3r/GCode/SeamGeometry.cpp
@@ -1,11 +1,17 @@
 #include "libslic3r/GCode/SeamGeometry.hpp"
-#include "libslic3r/ClipperUtils.hpp"
-#include "libslic3r/KDTreeIndirect.hpp"
-#include "libslic3r/Layer.hpp"
-#include <fstream>
+
+#include <stdint.h>
 #include <numeric>
-#include <oneapi/tbb/blocked_range.h>
-#include <oneapi/tbb/parallel_for.h>
+#include <cmath>
+#include <iterator>
+#include <limits>
+
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Layer.hpp"
+#include "libslic3r/AABBTreeLines.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
 
 namespace Slic3r::Seams::Geometry {
 
diff --git a/src/libslic3r/GCode/SeamGeometry.hpp b/src/libslic3r/GCode/SeamGeometry.hpp
index 80faa53440..d11f5db5ef 100644
--- a/src/libslic3r/GCode/SeamGeometry.hpp
+++ b/src/libslic3r/GCode/SeamGeometry.hpp
@@ -1,17 +1,30 @@
 #ifndef libslic3r_SeamGeometry_hpp_
 #define libslic3r_SeamGeometry_hpp_
 
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <vector>
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <numeric>
+#include <optional>
+#include <utility>
+
 #include "libslic3r/ExtrusionEntity.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/Point.hpp"
-#include <oneapi/tbb/blocked_range.h>
-#include <oneapi/tbb/parallel_for.h>
-#include <vector>
 #include "tcbspan/span.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 class Layer;
+namespace AABBTreeLines {
+template <typename LineType> class LinesDistancer;
+}  // namespace AABBTreeLines
 }
 
 namespace Slic3r::Seams::Geometry {
diff --git a/src/libslic3r/GCode/SeamPainting.cpp b/src/libslic3r/GCode/SeamPainting.cpp
index 1f029bc5e8..d745316285 100644
--- a/src/libslic3r/GCode/SeamPainting.cpp
+++ b/src/libslic3r/GCode/SeamPainting.cpp
@@ -1,5 +1,8 @@
 #include "libslic3r/GCode/SeamPainting.hpp"
 
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+
 namespace Slic3r::Seams::ModelInfo {
 Painting::Painting(const Transform3d &obj_transform, const ModelVolumePtrs &volumes) {
     for (const ModelVolume *mv : volumes) {
diff --git a/src/libslic3r/GCode/SeamPainting.hpp b/src/libslic3r/GCode/SeamPainting.hpp
index a6fa6ff8d0..ccc6c52719 100644
--- a/src/libslic3r/GCode/SeamPainting.hpp
+++ b/src/libslic3r/GCode/SeamPainting.hpp
@@ -4,6 +4,7 @@
 #include "libslic3r/AABBTreeIndirect.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Model.hpp"
+#include "admesh/stl.h"
 
 namespace Slic3r::Seams::ModelInfo {
 class Painting
diff --git a/src/libslic3r/GCode/SeamPerimeters.cpp b/src/libslic3r/GCode/SeamPerimeters.cpp
index ef991093b3..9241c98867 100644
--- a/src/libslic3r/GCode/SeamPerimeters.cpp
+++ b/src/libslic3r/GCode/SeamPerimeters.cpp
@@ -1,11 +1,17 @@
-#include <fstream>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <cstdint>
+#include <iterator>
+#include <tuple>
 
 #include "libslic3r/ClipperUtils.hpp"
-
 #include "libslic3r/Layer.hpp"
-
 #include "libslic3r/GCode/SeamGeometry.hpp"
 #include "libslic3r/GCode/SeamPerimeters.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/GCode/SeamPainting.hpp"
+#include "libslic3r/MultiPoint.hpp"
+#include "tcbspan/span.hpp"
 
 namespace Slic3r::Seams::Perimeters::Impl {
 
diff --git a/src/libslic3r/GCode/SeamPerimeters.hpp b/src/libslic3r/GCode/SeamPerimeters.hpp
index 47be8806eb..2dcee2ddc9 100644
--- a/src/libslic3r/GCode/SeamPerimeters.hpp
+++ b/src/libslic3r/GCode/SeamPerimeters.hpp
@@ -2,11 +2,21 @@
 #define libslic3r_SeamPerimeters_hpp_
 
 #include <tcbspan/span.hpp>
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/GCode/SeamPainting.hpp"
 #include "libslic3r/KDTreeIndirect.hpp"
 #include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/GCode/SeamGeometry.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
     class Layer;
diff --git a/src/libslic3r/GCode/SeamRandom.cpp b/src/libslic3r/GCode/SeamRandom.cpp
index 03fa33e6ed..5681e57157 100644
--- a/src/libslic3r/GCode/SeamRandom.cpp
+++ b/src/libslic3r/GCode/SeamRandom.cpp
@@ -1,7 +1,11 @@
 #include <random>
+#include <algorithm>
+#include <limits>
+#include <utility>
 
 #include "libslic3r/GCode/SeamRandom.hpp"
-#include "libslic3r/GCode/SeamGeometry.hpp"
+#include "libslic3r/GCode/SeamChoice.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Seams::Random {
 using Perimeters::PointType;
diff --git a/src/libslic3r/GCode/SeamRandom.hpp b/src/libslic3r/GCode/SeamRandom.hpp
index c7eb0f3644..a21268d58d 100644
--- a/src/libslic3r/GCode/SeamRandom.hpp
+++ b/src/libslic3r/GCode/SeamRandom.hpp
@@ -1,5 +1,17 @@
-#include "libslic3r/GCode/SeamChoice.hpp"
 #include <random>
+#include <cstddef>
+#include <optional>
+#include <vector>
+
+#include "libslic3r/GCode/SeamChoice.hpp"
+#include "libslic3r/GCode/SeamPerimeters.hpp"
+
+namespace Slic3r {
+namespace Seams {
+struct SeamChoice;
+struct SeamPerimeterChoice;
+}  // namespace Seams
+}  // namespace Slic3r
 
 namespace Slic3r::Seams::Random {
 namespace Impl {
diff --git a/src/libslic3r/GCode/SeamRear.cpp b/src/libslic3r/GCode/SeamRear.cpp
index bb5ba03fca..f17dd79997 100644
--- a/src/libslic3r/GCode/SeamRear.cpp
+++ b/src/libslic3r/GCode/SeamRear.cpp
@@ -1,5 +1,14 @@
 #include "libslic3r/GCode/SeamRear.hpp"
-#include "libslic3r/GCode/SeamGeometry.hpp"
+
+#include <algorithm>
+#include <optional>
+#include <utility>
+
+#include "libslic3r/AABBTreeLines.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/GCode/SeamChoice.hpp"
+#include "libslic3r/GCode/SeamPerimeters.hpp"
+#include "libslic3r/GCode/SeamShells.hpp"
 
 namespace Slic3r::Seams::Rear {
 using Perimeters::PointType;
diff --git a/src/libslic3r/GCode/SeamRear.hpp b/src/libslic3r/GCode/SeamRear.hpp
index 5ab2fe4269..de36a03e88 100644
--- a/src/libslic3r/GCode/SeamRear.hpp
+++ b/src/libslic3r/GCode/SeamRear.hpp
@@ -1,8 +1,21 @@
 #ifndef libslic3r_SeamRear_hpp_
 #define libslic3r_SeamRear_hpp_
 
+#include <cstddef>
+#include <vector>
+
 #include "libslic3r/GCode/SeamPerimeters.hpp"
 #include "libslic3r/GCode/SeamChoice.hpp"
+#include "libslic3r/Point.hpp"
+
+namespace Slic3r {
+namespace Seams {
+namespace Perimeters {
+struct BoundedPerimeter;
+}  // namespace Perimeters
+struct SeamPerimeterChoice;
+}  // namespace Seams
+}  // namespace Slic3r
 
 namespace Slic3r::Seams::Rear {
 namespace Impl {
diff --git a/src/libslic3r/GCode/SeamShells.cpp b/src/libslic3r/GCode/SeamShells.cpp
index b3ee128424..dbe60a12cf 100644
--- a/src/libslic3r/GCode/SeamShells.cpp
+++ b/src/libslic3r/GCode/SeamShells.cpp
@@ -1,7 +1,11 @@
 #include "libslic3r/GCode/SeamShells.hpp"
-#include "libslic3r/ClipperUtils.hpp"
-#include <oneapi/tbb/blocked_range.h>
-#include <oneapi/tbb/parallel_for.h>
+
+#include <algorithm>
+#include <optional>
+#include <utility>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/GCode/SeamGeometry.hpp"
 
 namespace Slic3r::Seams::Shells::Impl {
 
diff --git a/src/libslic3r/GCode/SeamShells.hpp b/src/libslic3r/GCode/SeamShells.hpp
index 2a5d0ce19b..d428d76ca6 100644
--- a/src/libslic3r/GCode/SeamShells.hpp
+++ b/src/libslic3r/GCode/SeamShells.hpp
@@ -1,8 +1,9 @@
 #ifndef libslic3r_SeamShells_hpp_
 #define libslic3r_SeamShells_hpp_
 
-#include <vector>
 #include <tcbspan/span.hpp>
+#include <vector>
+#include <cstddef>
 
 #include "libslic3r/GCode/SeamPerimeters.hpp"
 #include "libslic3r/Polygon.hpp"
diff --git a/src/libslic3r/GCode/SmoothPath.cpp b/src/libslic3r/GCode/SmoothPath.cpp
index 30361aa3a7..233b7caf55 100644
--- a/src/libslic3r/GCode/SmoothPath.cpp
+++ b/src/libslic3r/GCode/SmoothPath.cpp
@@ -1,7 +1,17 @@
 #include "SmoothPath.hpp"
 
+#include <assert.h>
+#include <algorithm>
+#include <cmath>
+#include <iterator>
+#include <utility>
+
 #include "../ExtrusionEntity.hpp"
 #include "../ExtrusionEntityCollection.hpp"
+#include "libslic3r/Geometry/ArcWelder.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::GCode {
 
diff --git a/src/libslic3r/GCode/SmoothPath.hpp b/src/libslic3r/GCode/SmoothPath.hpp
index 8157146f80..f4240e8cc1 100644
--- a/src/libslic3r/GCode/SmoothPath.hpp
+++ b/src/libslic3r/GCode/SmoothPath.hpp
@@ -2,6 +2,8 @@
 #define slic3r_GCode_SmoothPath_hpp_
 
 #include <ankerl/unordered_dense.h>
+#include <optional>
+#include <vector>
 
 #include "../ExtrusionEntity.hpp"
 #include "../Geometry/ArcWelder.hpp"
@@ -9,6 +11,8 @@
 namespace Slic3r {
 
 class ExtrusionEntityCollection;
+class Point;
+class Polyline;
 
 namespace GCode {
 
diff --git a/src/libslic3r/GCode/SpiralVase.cpp b/src/libslic3r/GCode/SpiralVase.cpp
index 3450204aa0..6dbfea94f5 100644
--- a/src/libslic3r/GCode/SpiralVase.cpp
+++ b/src/libslic3r/GCode/SpiralVase.cpp
@@ -7,10 +7,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "SpiralVase.hpp"
-#include "libslic3r/GCode.hpp"
-#include <sstream>
-#include <cmath>
-#include <limits>
+
+#include <stddef.h>
+#include <utility>
+
+#include "libslic3r/AABBTreeLines.hpp"
+#include "libslic3r/GCode/GCodeWriter.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/SpiralVase.hpp b/src/libslic3r/GCode/SpiralVase.hpp
index b88abd7d3c..4b7088b48f 100644
--- a/src/libslic3r/GCode/SpiralVase.hpp
+++ b/src/libslic3r/GCode/SpiralVase.hpp
@@ -9,8 +9,14 @@
 #ifndef slic3r_SpiralVase_hpp_
 #define slic3r_SpiralVase_hpp_
 
+#include <algorithm>
+#include <string>
+#include <vector>
+
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/GCodeReader.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/ThumbnailData.hpp b/src/libslic3r/GCode/ThumbnailData.hpp
index d0cc1cee2c..dd240463b1 100644
--- a/src/libslic3r/GCode/ThumbnailData.hpp
+++ b/src/libslic3r/GCode/ThumbnailData.hpp
@@ -6,6 +6,8 @@
 #define slic3r_ThumbnailData_hpp_
 
 #include <vector>
+#include <functional>
+
 #include "libslic3r/Point.hpp"
 
 namespace Slic3r {
diff --git a/src/libslic3r/GCode/Thumbnails.cpp b/src/libslic3r/GCode/Thumbnails.cpp
index b13259394b..50d5aa3818 100644
--- a/src/libslic3r/GCode/Thumbnails.cpp
+++ b/src/libslic3r/GCode/Thumbnails.cpp
@@ -3,15 +3,23 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Thumbnails.hpp"
-#include "libslic3r/miniz_extension.hpp" // IWYU pragma: keep
-#include "../format.hpp"
 
 #include <qoi.h>
 #include <jpeglib.h>
-#include <jerror.h>
-
-#include <boost/algorithm/string.hpp>
+#include <jmorecfg.h>
+#include <stdlib.h>
+#include <boost/algorithm/string/case_conv.hpp>
+#include <boost/log/trivial.hpp>
 #include <string>
+#include <cstdint>
+
+#include "libslic3r/miniz_extension.hpp" // IWYU pragma: keep
+#include "../format.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/GCode/ThumbnailData.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "miniz.h"
 
 namespace Slic3r::GCodeThumbnails {
 
diff --git a/src/libslic3r/GCode/Thumbnails.hpp b/src/libslic3r/GCode/Thumbnails.hpp
index bd94978a9a..827360df61 100644
--- a/src/libslic3r/GCode/Thumbnails.hpp
+++ b/src/libslic3r/GCode/Thumbnails.hpp
@@ -5,21 +5,29 @@
 #ifndef slic3r_GCodeThumbnails_hpp_
 #define slic3r_GCodeThumbnails_hpp_
 
-#include "../Point.hpp"
-#include "../PrintConfig.hpp"
-#include "ThumbnailData.hpp"
-
+#include <LibBGCode/binarize/binarize.hpp>
+#include <boost/beast/core/detail/base64.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+#include <boost/beast/core.hpp>
+#include <boost/format.hpp>
+#include <core/core.hpp>
 #include <vector>
 #include <memory>
 #include <string_view>
+#include <algorithm>
+#include <string>
+#include <utility>
 
-#include <LibBGCode/binarize/binarize.hpp>
-
-#include <boost/beast/core/detail/base64.hpp>
-
+#include "../Point.hpp"
+#include "../PrintConfig.hpp"
+#include "ThumbnailData.hpp"
 #include "libslic3r/enum_bitmask.hpp"
 
 namespace Slic3r {
+class ConfigBase;
+
     enum class ThumbnailError : int { InvalidVal, OutOfRange, InvalidExt };
     using ThumbnailErrors = enum_bitmask<ThumbnailError>;
     ENABLE_ENUM_BITMASK_OPERATORS(ThumbnailError);
diff --git a/src/libslic3r/GCode/ToolOrdering.cpp b/src/libslic3r/GCode/ToolOrdering.cpp
index 37afc50558..8a7466dba2 100644
--- a/src/libslic3r/GCode/ToolOrdering.cpp
+++ b/src/libslic3r/GCode/ToolOrdering.cpp
@@ -6,6 +6,14 @@
 #include "libslic3r/Print.hpp"
 #include "ToolOrdering.hpp"
 #include "libslic3r/Layer.hpp"
+#include "libslic3r/GCode/ToolOrdering.hpp"
+#include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Model.hpp"
+#include "tcbspan/span.hpp"
 
 // #define SLIC3R_DEBUG
 
@@ -16,12 +24,12 @@
     #undef NDEBUG
 #endif
 
+#include <boost/log/trivial.hpp>
+#include <libslic3r/libslic3r.h>
+#include <string.h>
 #include <cassert>
 #include <limits>
-
-#include <boost/log/trivial.hpp>
-
-#include <libslic3r/libslic3r.h>
+#include <cmath>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCode/ToolOrdering.hpp b/src/libslic3r/GCode/ToolOrdering.hpp
index fecc518a03..39999f55b3 100644
--- a/src/libslic3r/GCode/ToolOrdering.hpp
+++ b/src/libslic3r/GCode/ToolOrdering.hpp
@@ -7,12 +7,18 @@
 #ifndef slic3r_ToolOrdering_hpp_
 #define slic3r_ToolOrdering_hpp_
 
-#include "libslic3r/libslic3r.h"
-
+#include <boost/container/small_vector.hpp>
+#include <stdint.h>
+#include <boost/container/vector.hpp>
+#include <boost/cstdint.hpp>
 #include <utility>
 #include <cstddef>
+#include <algorithm>
+#include <map>
+#include <vector>
 
-#include <boost/container/small_vector.hpp>
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
 
@@ -20,8 +26,12 @@ class Print;
 class PrintObject;
 class LayerTools;
 class ToolOrdering;
-namespace CustomGCode { struct Item; }
+namespace CustomGCode {
+struct Item;
+}  // namespace CustomGCode
 class PrintRegion;
+class ExtrusionEntity;
+class ExtrusionEntityCollection;
 
 // Object of this class holds information about whether an extrusion is printed immediately
 // after a toolchange (as part of infill/perimeter wiping) or not. One extrusion can be a part
diff --git a/src/libslic3r/GCode/Travels.cpp b/src/libslic3r/GCode/Travels.cpp
index 67954448e6..f88aa50a1e 100644
--- a/src/libslic3r/GCode/Travels.cpp
+++ b/src/libslic3r/GCode/Travels.cpp
@@ -1,10 +1,28 @@
 #include "Travels.hpp"
 
+#include <assert.h>
+#include <stdint.h>
+#include <boost/math/special_functions/pow.hpp>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <tuple>
+#include <utility>
+
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Print.hpp"
-
 #include "../GCode.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
+#include "tcbspan/span.hpp"
 
 namespace Slic3r::GCode {
 
diff --git a/src/libslic3r/GCode/Travels.hpp b/src/libslic3r/GCode/Travels.hpp
index 7f7c017840..2b109b3c98 100644
--- a/src/libslic3r/GCode/Travels.hpp
+++ b/src/libslic3r/GCode/Travels.hpp
@@ -6,15 +6,19 @@
 #ifndef slic3r_GCode_Travels_hpp_
 #define slic3r_GCode_Travels_hpp_
 
-#include <vector>
 #include <tcbspan/span.hpp>
-#include <functional>
-#include <optional>
-
 #include <boost/functional/hash.hpp>
 #include <boost/math/special_functions/pow.hpp>
+#include <boost/container_hash/hash.hpp>
+#include <vector>
+#include <functional>
+#include <optional>
+#include <cstddef>
+#include <unordered_set>
 
 #include "libslic3r/AABBTreeLines.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
 
 // Forward declarations.
 namespace Slic3r {
@@ -29,6 +33,7 @@ class ExtrusionEntity;
 
 namespace Slic3r::GCode {
 struct ObjectLayerToPrint;
+
 using ObjectsLayerToPrint = std::vector<ObjectLayerToPrint>;
 
 class ObjectOrExtrusionLinef : public Linef
diff --git a/src/libslic3r/GCode/Wipe.cpp b/src/libslic3r/GCode/Wipe.cpp
index e66f385692..a895d07f04 100644
--- a/src/libslic3r/GCode/Wipe.cpp
+++ b/src/libslic3r/GCode/Wipe.cpp
@@ -1,9 +1,21 @@
 #include "Wipe.hpp"
-#include "../GCode.hpp"
 
+#include <stdint.h>
 #include <string_view>
-
 #include <Eigen/Geometry>
+#include <algorithm>
+#include <cmath>
+#include <iterator>
+
+#include "../GCode.hpp"
+#include "libslic3r/Extruder.hpp"
+#include "libslic3r/GCode/GCodeProcessor.hpp"
+#include "libslic3r/GCode/GCodeWriter.hpp"
+#include "libslic3r/GCode/SmoothPath.hpp"
+#include "libslic3r/Geometry/ArcWelder.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 using namespace std::string_view_literals;
 
diff --git a/src/libslic3r/GCode/Wipe.hpp b/src/libslic3r/GCode/Wipe.hpp
index fcd6eeedfc..e90135d5a8 100644
--- a/src/libslic3r/GCode/Wipe.hpp
+++ b/src/libslic3r/GCode/Wipe.hpp
@@ -1,15 +1,18 @@
 #ifndef slic3r_GCode_Wipe_hpp_
 #define slic3r_GCode_Wipe_hpp_
 
-#include "SmoothPath.hpp"
+#include <math.h>
+#include <cassert>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
 
+#include "SmoothPath.hpp"
 #include "../Geometry/ArcWelder.hpp"
 #include "../Point.hpp"
 #include "../PrintConfig.hpp"
 
-#include <cassert>
-#include <optional>
-
 namespace Slic3r {
 
 class GCodeGenerator;
diff --git a/src/libslic3r/GCode/WipeTower.cpp b/src/libslic3r/GCode/WipeTower.cpp
index f439cc2468..7a5c7243b7 100644
--- a/src/libslic3r/GCode/WipeTower.cpp
+++ b/src/libslic3r/GCode/WipeTower.cpp
@@ -7,23 +7,27 @@
 ///|/
 #include "WipeTower.hpp"
 
+#include <LocalesUtils.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <stdio.h>
 #include <cassert>
-#include <iostream>
 #include <vector>
 #include <numeric>
 #include <memory>
 #include <sstream>
-#include <iomanip>
 
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/GCode/GCodeProcessor.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/Surface.hpp"
-#include "libslic3r/Fill/FillRectilinear.hpp"
-
-#include <LocalesUtils.hpp>
-#include <boost/algorithm/string/predicate.hpp>
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 
 namespace Slic3r
diff --git a/src/libslic3r/GCode/WipeTower.hpp b/src/libslic3r/GCode/WipeTower.hpp
index f99018fbe0..579b44a8f9 100644
--- a/src/libslic3r/GCode/WipeTower.hpp
+++ b/src/libslic3r/GCode/WipeTower.hpp
@@ -5,11 +5,14 @@
 #ifndef slic3r_GCode_WipeTower_hpp_
 #define slic3r_GCode_WipeTower_hpp_
 
+#include <stddef.h>
 #include <cmath>
 #include <string>
 #include <sstream>
 #include <utility>
 #include <algorithm>
+#include <limits>
+#include <vector>
 
 #include "libslic3r/Point.hpp"
 
@@ -19,6 +22,7 @@ namespace Slic3r
 class WipeTowerWriter;
 class PrintConfig;
 class PrintRegionConfig;
+
 enum GCodeFlavor : unsigned char;
 
 
diff --git a/src/libslic3r/GCode/WipeTowerIntegration.cpp b/src/libslic3r/GCode/WipeTowerIntegration.cpp
index d8ee62b962..ef69b98b43 100644
--- a/src/libslic3r/GCode/WipeTowerIntegration.cpp
+++ b/src/libslic3r/GCode/WipeTowerIntegration.cpp
@@ -1,9 +1,24 @@
 #include "WipeTowerIntegration.hpp"
 
+#include <assert.h>
+#include <stddef.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <Eigen/Geometry>
+#include <cmath>
+#include <iomanip>
+#include <istream>
+#include <iterator>
+#include <utility>
+
 #include "libslic3r/GCode.hpp"
 #include "libslic3r/libslic3r.h"
-
 #include "boost/algorithm/string/replace.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/GCode/Wipe.hpp"
+#include "libslic3r/GCode/WipeTower.hpp"
+#include "libslic3r/Geometry/ArcWelder.hpp"
 
 namespace Slic3r::GCode {
 
diff --git a/src/libslic3r/GCode/WipeTowerIntegration.hpp b/src/libslic3r/GCode/WipeTowerIntegration.hpp
index 231e6659c6..85553425de 100644
--- a/src/libslic3r/GCode/WipeTowerIntegration.hpp
+++ b/src/libslic3r/GCode/WipeTowerIntegration.hpp
@@ -1,8 +1,12 @@
 #ifndef slic3r_GCode_WipeTowerIntegration_hpp_
 #define slic3r_GCode_WipeTowerIntegration_hpp_
 
+#include <string>
+#include <vector>
+
 #include "WipeTower.hpp"
 #include "../PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCodeReader.cpp b/src/libslic3r/GCodeReader.cpp
index f3bb163761..b4fe9a37bc 100644
--- a/src/libslic3r/GCodeReader.cpp
+++ b/src/libslic3r/GCodeReader.cpp
@@ -3,18 +3,17 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "GCodeReader.hpp"
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/nowide/fstream.hpp>
+
 #include <boost/nowide/cstdio.hpp>
-#include <fstream>
+#include <fast_float.h>
+#include <assert.h>
+#include <stdio.h>
 #include <iostream>
 #include <iomanip>
+
 #include "Utils.hpp"
-
-#include "LocalesUtils.hpp"
-
-#include <fast_float.h>
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/GCodeReader.hpp b/src/libslic3r/GCodeReader.hpp
index 957aa92694..1f3a0fbfb0 100644
--- a/src/libslic3r/GCodeReader.hpp
+++ b/src/libslic3r/GCodeReader.hpp
@@ -5,13 +5,19 @@
 #ifndef slic3r_GCodeReader_hpp_
 #define slic3r_GCodeReader_hpp_
 
-#include "libslic3r.h"
+#include <stdint.h>
+#include <string.h>
 #include <cmath>
 #include <cstdlib>
 #include <functional>
 #include <string>
 #include <string_view>
+#include <utility>
+#include <vector>
+
+#include "libslic3r.h"
 #include "PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Geometry.cpp b/src/libslic3r/Geometry.cpp
index 236a187381..5e5c3b84cc 100644
--- a/src/libslic3r/Geometry.cpp
+++ b/src/libslic3r/Geometry.cpp
@@ -12,27 +12,29 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r.h"
-#include "Exception.hpp"
-#include "Geometry.hpp"
-#include "ClipperUtils.hpp"
-#include "ExPolygon.hpp"
-#include "Line.hpp"
-#include "clipper.hpp"
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/constants.hpp>
 #include <algorithm>
 #include <cassert>
 #include <cmath>
-#include <list>
-#include <map>
-#include <numeric>
-#include <set>
 #include <utility>
-#include <stack>
 #include <vector>
+#include <Eigen/SVD>
+#include <array>
 
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/log/trivial.hpp>
+#include "libslic3r.h"
+#include "Geometry.hpp"
+#include "ClipperUtils.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/MultiPoint.hpp"
+#include "libslic3r/Polygon.hpp"
+
+namespace boost {
+namespace polygon {
+template <typename T> class point_data;
+}  // namespace polygon
+}  // namespace boost
 
 #if defined(_MSC_VER) && defined(__clang__)
 #define BOOST_NO_CXX17_HDR_STRING_VIEW
diff --git a/src/libslic3r/Geometry.hpp b/src/libslic3r/Geometry.hpp
index ec3c317518..1bcae53124 100644
--- a/src/libslic3r/Geometry.hpp
+++ b/src/libslic3r/Geometry.hpp
@@ -16,14 +16,25 @@
 #ifndef slic3r_Geometry_hpp_
 #define slic3r_Geometry_hpp_
 
+// Serialization through the Cereal library
+#include <cereal/access.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <cereal/cereal.hpp>
+#include <Eigen/Geometry>
+#include <cmath>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
-
-// Serialization through the Cereal library
-#include <cereal/access.hpp>
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Geometry {
 
diff --git a/src/libslic3r/Geometry/ArcWelder.cpp b/src/libslic3r/Geometry/ArcWelder.cpp
index 0bc71aea3a..34e59834ba 100644
--- a/src/libslic3r/Geometry/ArcWelder.cpp
+++ b/src/libslic3r/Geometry/ArcWelder.cpp
@@ -26,15 +26,16 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "ArcWelder.hpp"
-#include "Circle.hpp"
 
-#include "../MultiPoint.hpp"
-#include "../Polygon.hpp"
-
-#include <numeric>
-#include <random>
-#include <boost/log/trivial.hpp>
 #include <boost/container/small_vector.hpp>
+#include <array>
+#include <cstdint>
+#include <iterator>
+
+#include "Circle.hpp"
+#include "../MultiPoint.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r { namespace Geometry { namespace ArcWelder {
 
diff --git a/src/libslic3r/Geometry/ArcWelder.hpp b/src/libslic3r/Geometry/ArcWelder.hpp
index dceec568a4..f8c6da2768 100644
--- a/src/libslic3r/Geometry/ArcWelder.hpp
+++ b/src/libslic3r/Geometry/ArcWelder.hpp
@@ -1,9 +1,20 @@
 #ifndef slic3r_Geometry_ArcWelder_hpp_
 #define slic3r_Geometry_ArcWelder_hpp_
 
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <optional>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "../Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace Geometry { namespace ArcWelder {
 
diff --git a/src/libslic3r/Geometry/Circle.cpp b/src/libslic3r/Geometry/Circle.cpp
index cb8af30cec..37a23d8316 100644
--- a/src/libslic3r/Geometry/Circle.cpp
+++ b/src/libslic3r/Geometry/Circle.cpp
@@ -4,11 +4,14 @@
 ///|/
 #include "Circle.hpp"
 
-#include "../Polygon.hpp"
-
+#include <boost/log/trivial.hpp>
 #include <numeric>
 #include <random>
-#include <boost/log/trivial.hpp>
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r { namespace Geometry {
 
diff --git a/src/libslic3r/Geometry/Circle.hpp b/src/libslic3r/Geometry/Circle.hpp
index 487ee84e8f..15fd3a90f0 100644
--- a/src/libslic3r/Geometry/Circle.hpp
+++ b/src/libslic3r/Geometry/Circle.hpp
@@ -5,9 +5,16 @@
 #ifndef slic3r_Geometry_Circle_hpp_
 #define slic3r_Geometry_Circle_hpp_
 
-#include "../Point.hpp"
-
+#include <assert.h>
+#include <stddef.h>
 #include <Eigen/Geometry>
+#include <cmath>
+#include <iterator>
+#include <optional>
+#include <type_traits>
+
+#include "../Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace Geometry {
 
diff --git a/src/libslic3r/Geometry/ConvexHull.cpp b/src/libslic3r/Geometry/ConvexHull.cpp
index b1c16a9971..d10916ec94 100644
--- a/src/libslic3r/Geometry/ConvexHull.cpp
+++ b/src/libslic3r/Geometry/ConvexHull.cpp
@@ -2,12 +2,15 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/libslic3r.h"
+#include <boost/multiprecision/integer.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
 #include "ConvexHull.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Geometry.hpp"
-
-#include <boost/multiprecision/integer.hpp>
+#include "libslic3r/ExPolygon.hpp"
 
 namespace Slic3r { namespace Geometry {
 
diff --git a/src/libslic3r/Geometry/ConvexHull.hpp b/src/libslic3r/Geometry/ConvexHull.hpp
index eb9d8c065e..133e18e38f 100644
--- a/src/libslic3r/Geometry/ConvexHull.hpp
+++ b/src/libslic3r/Geometry/ConvexHull.hpp
@@ -6,8 +6,12 @@
 #define slic3r_Geometry_ConvexHull_hpp_
 
 #include <vector>
+#include <utility>
 
 #include "../ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Geometry/MedialAxis.cpp b/src/libslic3r/Geometry/MedialAxis.cpp
index cd2ce80a46..35d2a51df5 100644
--- a/src/libslic3r/Geometry/MedialAxis.cpp
+++ b/src/libslic3r/Geometry/MedialAxis.cpp
@@ -4,11 +4,17 @@
 ///|/
 #include "MedialAxis.hpp"
 
-#include "libslic3r/clipper.hpp"
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <math.h>
+#include <boost/polygon/polygon.hpp>
+#include <algorithm>
+
 #include "VoronoiOffset.hpp"
 #include "libslic3r/ClipperUtils.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 #ifdef SLIC3R_DEBUG
 namespace boost { namespace polygon {
diff --git a/src/libslic3r/Geometry/MedialAxis.hpp b/src/libslic3r/Geometry/MedialAxis.hpp
index bcf693cc8d..37f58f4486 100644
--- a/src/libslic3r/Geometry/MedialAxis.hpp
+++ b/src/libslic3r/Geometry/MedialAxis.hpp
@@ -5,8 +5,14 @@
 #ifndef slic3r_Geometry_MedialAxis_hpp_
 #define slic3r_Geometry_MedialAxis_hpp_
 
+#include <stddef.h>
+#include <utility>
+#include <vector>
+
 #include "Voronoi.hpp"
 #include "../ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r::Geometry {
 
diff --git a/src/libslic3r/Geometry/Voronoi.cpp b/src/libslic3r/Geometry/Voronoi.cpp
index 71c67b9cc1..219426f355 100644
--- a/src/libslic3r/Geometry/Voronoi.cpp
+++ b/src/libslic3r/Geometry/Voronoi.cpp
@@ -1,11 +1,14 @@
 #include "Voronoi.hpp"
 
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
+
 #include "libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp"
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
 #include "libslic3r/Geometry/VoronoiUtilsCgal.hpp"
 #include "libslic3r/MultiMaterialSegmentation.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r::Geometry {
 
diff --git a/src/libslic3r/Geometry/Voronoi.hpp b/src/libslic3r/Geometry/Voronoi.hpp
index 72fa387e18..3c5e8e5dae 100644
--- a/src/libslic3r/Geometry/Voronoi.hpp
+++ b/src/libslic3r/Geometry/Voronoi.hpp
@@ -5,8 +5,15 @@
 #ifndef slic3r_Geometry_Voronoi_hpp_
 #define slic3r_Geometry_Voronoi_hpp_
 
+#include <boost/polygon/polygon.hpp>
+#include <cstddef>
+#include <iterator>
+#include <vector>
+
 #include "../Line.hpp"
 #include "../Polyline.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 #ifdef _MSC_VER
 // Suppress warning C4146 in OpenVDB: unary minus operator applied to unsigned type, result still unsigned
@@ -14,6 +21,12 @@
 #pragma warning(disable : 4146)
 #endif // _MSC_VER
 #include "boost/polygon/voronoi.hpp"
+
+namespace boost {
+namespace polygon {
+template <typename Segment> struct segment_traits;
+}  // namespace polygon
+}  // namespace boost
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif // _MSC_VER
diff --git a/src/libslic3r/Geometry/VoronoiOffset.cpp b/src/libslic3r/Geometry/VoronoiOffset.cpp
index 7ebff32b33..659f0790e4 100644
--- a/src/libslic3r/Geometry/VoronoiOffset.cpp
+++ b/src/libslic3r/Geometry/VoronoiOffset.cpp
@@ -4,16 +4,22 @@
 ///|/
 // Polygon offsetting using Voronoi diagram prodiced by boost::polygon.
 
+#include <assert.h>
+#include <stddef.h>
+#include <cmath>
+#include <algorithm>
+#include <array>
+#include <limits>
+#include <tuple>
+#include <utility>
+
 #include "libslic3r/Geometry.hpp"
 #include "VoronoiOffset.hpp"
 #include "libslic3r/libslic3r.h"
-
-#include <cmath>
+#include "libslic3r/Geometry/Voronoi.hpp"
 
 // #define VORONOI_DEBUG_OUT
 
-#include <boost/polygon/detail/voronoi_ctypes.hpp>
-
 #ifdef VORONOI_DEBUG_OUT
 #include <libslic3r/VoronoiVisualUtils.hpp>
 #endif
diff --git a/src/libslic3r/Geometry/VoronoiOffset.hpp b/src/libslic3r/Geometry/VoronoiOffset.hpp
index 1e4329e97d..89f3231ca1 100644
--- a/src/libslic3r/Geometry/VoronoiOffset.hpp
+++ b/src/libslic3r/Geometry/VoronoiOffset.hpp
@@ -7,9 +7,15 @@
 #ifndef slic3r_VoronoiOffset_hpp_
 #define slic3r_VoronoiOffset_hpp_
 
-#include "libslic3r/libslic3r.h"
+#include <boost/polygon/polygon.hpp>
+#include <cmath>
+#include <vector>
 
+#include "libslic3r/libslic3r.h"
 #include "Voronoi.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Geometry/VoronoiUtils.cpp b/src/libslic3r/Geometry/VoronoiUtils.cpp
index daf3d93b11..e56f901bc8 100644
--- a/src/libslic3r/Geometry/VoronoiUtils.cpp
+++ b/src/libslic3r/Geometry/VoronoiUtils.cpp
@@ -1,10 +1,17 @@
 #include <boost/log/trivial.hpp>
-
 #include <libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp>
 #include <libslic3r/MultiMaterialSegmentation.hpp>
 #include <libslic3r/Geometry.hpp>
+#include <assert.h>
+#include <stdlib.h>
+#include <cmath>
+#include <cstdint>
+#include <utility>
+#include <vector>
 
 #include "VoronoiUtils.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r::Geometry {
 
diff --git a/src/libslic3r/Geometry/VoronoiUtils.hpp b/src/libslic3r/Geometry/VoronoiUtils.hpp
index 9c915e223b..6872e4ea72 100644
--- a/src/libslic3r/Geometry/VoronoiUtils.hpp
+++ b/src/libslic3r/Geometry/VoronoiUtils.hpp
@@ -1,8 +1,15 @@
 #ifndef slic3r_VoronoiUtils_hpp_
 #define slic3r_VoronoiUtils_hpp_
 
+#include <boost/polygon/polygon.hpp>
+#include <iterator>
+#include <limits>
+
 #include "libslic3r/Geometry/Voronoi.hpp"
 #include "libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 using VD = Slic3r::Geometry::VoronoiDiagram;
 
diff --git a/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp b/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp
index e80f1a5a88..f7b21e0f57 100644
--- a/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp
+++ b/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp
@@ -5,13 +5,21 @@
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 #include <CGAL/Arr_segment_traits_2.h>
 #include <CGAL/Surface_sweep_2_algorithms.h>
+#include <assert.h>
+#include <boost/variant/get.hpp>
+#include <vector>
 
 #include "libslic3r/Geometry/Voronoi.hpp"
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
 #include "libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp"
 #include "libslic3r/MultiMaterialSegmentation.hpp"
-
 #include "VoronoiUtilsCgal.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+
+namespace CGAL {
+class MP_Float;
+}  // namespace CGAL
 
 using VD = Slic3r::Geometry::VoronoiDiagram;
 
diff --git a/src/libslic3r/Geometry/VoronoiUtilsCgal.hpp b/src/libslic3r/Geometry/VoronoiUtilsCgal.hpp
index 924b6d76d7..34398d5458 100644
--- a/src/libslic3r/Geometry/VoronoiUtilsCgal.hpp
+++ b/src/libslic3r/Geometry/VoronoiUtilsCgal.hpp
@@ -5,6 +5,9 @@
 #ifndef slic3r_VoronoiUtilsCgal_hpp_
 #define slic3r_VoronoiUtilsCgal_hpp_
 
+#include <boost/polygon/polygon.hpp>
+#include <iterator>
+
 #include "Voronoi.hpp"
 #include "../Arachne/utils/PolygonsSegmentIndex.hpp"
 
diff --git a/src/libslic3r/IntersectionPoints.cpp b/src/libslic3r/IntersectionPoints.cpp
index bdf66d5905..13336fdad6 100644
--- a/src/libslic3r/IntersectionPoints.cpp
+++ b/src/libslic3r/IntersectionPoints.cpp
@@ -3,8 +3,13 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "IntersectionPoints.hpp"
+
 #include <libslic3r/AABBTreeLines.hpp>
 
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+
 //NOTE: using CGAL SweepLines is slower !!! (example in git history)
 
 namespace {    
diff --git a/src/libslic3r/IntersectionPoints.hpp b/src/libslic3r/IntersectionPoints.hpp
index cf06c718a0..f0a6c3b2a5 100644
--- a/src/libslic3r/IntersectionPoints.hpp
+++ b/src/libslic3r/IntersectionPoints.hpp
@@ -5,7 +5,13 @@
 #ifndef slic3r_IntersectionPoints_hpp_
 #define slic3r_IntersectionPoints_hpp_
 
+#include <stdint.h>
+#include <vector>
+
 #include "ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/JumpPointSearch.cpp b/src/libslic3r/JumpPointSearch.cpp
index a18ae89b6a..5516cdaa4d 100644
--- a/src/libslic3r/JumpPointSearch.cpp
+++ b/src/libslic3r/JumpPointSearch.cpp
@@ -3,27 +3,24 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "JumpPointSearch.hpp"
-#include "BoundingBox.hpp"
-#include "ExPolygon.hpp"
-#include "Point.hpp"
-#include "libslic3r/AStar.hpp"
-#include "libslic3r/KDTreeIndirect.hpp"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/libslic3r.h"
+
 #include <algorithm>
 #include <cmath>
-#include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>
 #include <limits>
-#include <optional>
-#include <string>
 #include <unordered_map>
 #include <vector>
+#include <utility>
 
-#include <oneapi/tbb/scalable_allocator.h>
+#include "BoundingBox.hpp"
+#include "Point.hpp"
+#include "libslic3r/AStar.hpp"
+#include "libslic3r/KDTreeIndirect.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Layer.hpp"
 
 //#define DEBUG_FILES
 #ifdef DEBUG_FILES
diff --git a/src/libslic3r/JumpPointSearch.hpp b/src/libslic3r/JumpPointSearch.hpp
index 256d2290ed..60869a86f3 100644
--- a/src/libslic3r/JumpPointSearch.hpp
+++ b/src/libslic3r/JumpPointSearch.hpp
@@ -5,16 +5,19 @@
 #ifndef SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
 #define SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
 
+#include <unordered_map>
+#include <unordered_set>
+
 #include "BoundingBox.hpp"
 #include "Polygon.hpp"
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Polyline.hpp"
 #include "libslic3r/libslic3r.h"
-#include <unordered_map>
-#include <unordered_set>
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r {
+class Layer;
 
 class JPSPathFinder
 {
diff --git a/src/libslic3r/Layer.cpp b/src/libslic3r/Layer.cpp
index 804999c796..df88b5aa3c 100644
--- a/src/libslic3r/Layer.cpp
+++ b/src/libslic3r/Layer.cpp
@@ -9,6 +9,15 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Layer.hpp"
+
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <clipper/clipper_z.hpp>
+#include <cstdint>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+
 #include "ClipperZUtils.hpp"
 #include "ClipperUtils.hpp"
 #include "Point.hpp"
@@ -17,9 +26,14 @@
 #include "ShortestPath.hpp"
 #include "SVG.hpp"
 #include "BoundingBox.hpp"
-#include "clipper/clipper.hpp"
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/SurfaceCollection.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Layer.hpp b/src/libslic3r/Layer.hpp
index 0a2e457df9..c71fe9dc89 100644
--- a/src/libslic3r/Layer.hpp
+++ b/src/libslic3r/Layer.hpp
@@ -11,6 +11,16 @@
 #ifndef slic3r_Layer_hpp_
 #define slic3r_Layer_hpp_
 
+#include <boost/container/small_vector.hpp>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "Line.hpp"
 #include "libslic3r.h"
 #include "BoundingBox.hpp"
@@ -18,16 +28,19 @@
 #include "SurfaceCollection.hpp"
 #include "ExtrusionEntityCollection.hpp"
 #include "LayerRegion.hpp"
-
-#include <boost/container/small_vector.hpp>
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 class Layer;
+
 using LayerPtrs = std::vector<Layer*>;
 class LayerRegion;
+
 using LayerRegionPtrs = std::vector<LayerRegion*>;
 class PrintRegion;
 class PrintObject;
diff --git a/src/libslic3r/LayerRegion.cpp b/src/libslic3r/LayerRegion.cpp
index b5ae16b8fa..94c5d4fbb6 100644
--- a/src/libslic3r/LayerRegion.cpp
+++ b/src/libslic3r/LayerRegion.cpp
@@ -3,6 +3,22 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <string>
+#include <map>
+#include <array>
+#include <cmath>
+#include <initializer_list>
+#include <iterator>
+#include <optional>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
 #include "ExPolygon.hpp"
 #include "Flow.hpp"
 #include "Layer.hpp"
@@ -15,12 +31,17 @@
 #include "BoundingBox.hpp"
 #include "SVG.hpp"
 #include "Algorithm/RegionExpansion.hpp"
-
-#include <algorithm>
-#include <string>
-#include <map>
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SurfaceCollection.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/LayerRegion.hpp b/src/libslic3r/LayerRegion.hpp
index fa8bb8d988..d22d08ed40 100644
--- a/src/libslic3r/LayerRegion.hpp
+++ b/src/libslic3r/LayerRegion.hpp
@@ -1,15 +1,29 @@
 #ifndef slic3r_LayerRegion_hpp_
 #define slic3r_LayerRegion_hpp_
 
+#include <assert.h>
+#include <stdint.h>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "BoundingBox.hpp"
 #include "ExtrusionEntityCollection.hpp"
 #include "SurfaceCollection.hpp"
 #include "libslic3r/Algorithm/RegionExpansion.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/Surface.hpp"
 
 
 namespace Slic3r {
 
 class Layer;
+class PrintObject;
+
 using LayerPtrs = std::vector<Layer*>;
 class PrintRegion;
 
diff --git a/src/libslic3r/Line.cpp b/src/libslic3r/Line.cpp
index e72445c8a3..1596b34e72 100644
--- a/src/libslic3r/Line.cpp
+++ b/src/libslic3r/Line.cpp
@@ -8,12 +8,15 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <string.h>
+#include <cmath>
+#include <limits>
+
 #include "Geometry.hpp"
 #include "Line.hpp"
-#include "Polyline.hpp"
-#include <algorithm>
-#include <cmath>
-#include <sstream>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Line.hpp b/src/libslic3r/Line.hpp
index fdbac86a33..b593d2f7b7 100644
--- a/src/libslic3r/Line.hpp
+++ b/src/libslic3r/Line.hpp
@@ -11,11 +11,14 @@
 #ifndef slic3r_Line_hpp_
 #define slic3r_Line_hpp_
 
+#include <type_traits>
+#include <cmath>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "Point.hpp"
 
-#include <type_traits>
-
 namespace Slic3r {
 
 class BoundingBox;
@@ -24,6 +27,7 @@ class Line3;
 class Linef3;
 class Polyline;
 class ThickLine;
+
 typedef std::vector<Line> Lines;
 typedef std::vector<Line3> Lines3;
 typedef std::vector<ThickLine> ThickLines;
@@ -315,6 +319,7 @@ BoundingBox get_extents(const Lines &lines);
 
 // start Boost
 #include <boost/polygon/polygon.hpp>
+
 namespace boost { namespace polygon {
     template <>
     struct geometry_concept<Slic3r::Line> { typedef segment_concept type; };
diff --git a/src/libslic3r/Measure.cpp b/src/libslic3r/Measure.cpp
index 2e6156a88e..60db9aad82 100644
--- a/src/libslic3r/Measure.cpp
+++ b/src/libslic3r/Measure.cpp
@@ -2,16 +2,24 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stdint.h>
+#include <boost/container/small_vector.hpp>
+#include <algorithm>
+#include <array>
+#include <iterator>
+#include <limits>
+#include <set>
+
 #include "libslic3r/libslic3r.h"
 #include "Measure.hpp"
 #include "MeasureUtils.hpp"
-
 #include "libslic3r/Geometry/Circle.hpp"
 #include "libslic3r/SurfaceMesh.hpp"
-
-
-#include <numeric>
-#include <tbb/parallel_for.h>
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 #define DEBUG_EXTRACT_ALL_FEATURES_AT_ONCE 0
 
diff --git a/src/libslic3r/Measure.hpp b/src/libslic3r/Measure.hpp
index dcccafb70d..80395a3a06 100644
--- a/src/libslic3r/Measure.hpp
+++ b/src/libslic3r/Measure.hpp
@@ -5,11 +5,17 @@
 #ifndef Slic3r_Measure_hpp_
 #define Slic3r_Measure_hpp_
 
+#include <assert.h>
+#include <stddef.h>
 #include <optional>
 #include <memory>
+#include <cmath>
+#include <tuple>
+#include <utility>
+#include <vector>
 
 #include "Point.hpp"
-
+#include "libslic3r/libslic3r.h"
 
 struct indexed_triangle_set;
 
diff --git a/src/libslic3r/MeshBoolean.cpp b/src/libslic3r/MeshBoolean.cpp
index c9e9e99d0f..7c464a26fa 100644
--- a/src/libslic3r/MeshBoolean.cpp
+++ b/src/libslic3r/MeshBoolean.cpp
@@ -6,10 +6,16 @@
 #include "MeshBoolean.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/TryCatchSignal.hpp"
+#include "libslic3r/Point.hpp"
+
 #undef PI
 
 // Include igl first. It defines "L" macro which then clashes with our localization
 #include <igl/copyleft/cgal/mesh_boolean.h> // IWYU pragma: keep
+#include <igl/MeshBooleanType.h>
+#include <signal.h>
+#include <boost/property_map/property_map.hpp>
+
 #undef L
 
 // CGAL headers
@@ -17,6 +23,8 @@
 #include <CGAL/Exact_integer.h>
 #include <CGAL/Surface_mesh.h>
 #include <CGAL/Cartesian_converter.h>
+#include <algorithm>
+#include <set>
 
 namespace Slic3r {
 namespace MeshBoolean {
diff --git a/src/libslic3r/MeshBoolean.hpp b/src/libslic3r/MeshBoolean.hpp
index 26c486a247..f580b505f6 100644
--- a/src/libslic3r/MeshBoolean.hpp
+++ b/src/libslic3r/MeshBoolean.hpp
@@ -5,11 +5,14 @@
 #ifndef libslic3r_MeshBoolean_hpp_
 #define libslic3r_MeshBoolean_hpp_
 
+#include <libslic3r/TriangleMesh.hpp>
 #include <memory>
 #include <exception>
-
-#include <libslic3r/TriangleMesh.hpp>
 #include <Eigen/Geometry>
+#include <utility>
+#include <vector>
+
+#include "admesh/stl.h"
 
 namespace Slic3r {
 
@@ -29,6 +32,7 @@ void self_union(TriangleMesh& mesh);
 namespace cgal {
 
 struct CGALMesh;
+
 struct CGALMeshDeleter { void operator()(CGALMesh *ptr); };
 using CGALMeshPtr = std::unique_ptr<CGALMesh, CGALMeshDeleter>;
 
diff --git a/src/libslic3r/MeshNormals.cpp b/src/libslic3r/MeshNormals.cpp
index e96f36eb59..35434ae90a 100644
--- a/src/libslic3r/MeshNormals.cpp
+++ b/src/libslic3r/MeshNormals.cpp
@@ -4,8 +4,16 @@
 ///|/
 #include "MeshNormals.hpp"
 
-#include <numeric>
 #include <boost/container/small_vector.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <numeric>
+#include <algorithm>
+#include <cmath>
+
+#include "libslic3r/AABBMesh.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/MeshNormals.hpp b/src/libslic3r/MeshNormals.hpp
index d5a535f16a..9be7896010 100644
--- a/src/libslic3r/MeshNormals.hpp
+++ b/src/libslic3r/MeshNormals.hpp
@@ -5,12 +5,17 @@
 #ifndef MESHNORMALS_HPP
 #define MESHNORMALS_HPP
 
-#include "AABBMesh.hpp"
+#include <Eigen/Geometry>
+#include <functional>
+#include <vector>
 
+#include "AABBMesh.hpp"
 #include "libslic3r/Execution/ExecutionSeq.hpp"
 #include "libslic3r/Execution/ExecutionTBB.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
+class AABBMesh;
 
 // Get a good approximation of the normal for any picking point on the mesh.
 // For points projecting to a face, this is the face normal, but when the
diff --git a/src/libslic3r/MinAreaBoundingBox.cpp b/src/libslic3r/MinAreaBoundingBox.cpp
index 18a9a57f85..1c2b1db78d 100644
--- a/src/libslic3r/MinAreaBoundingBox.cpp
+++ b/src/libslic3r/MinAreaBoundingBox.cpp
@@ -6,13 +6,13 @@
 
 #include <libslic3r/ExPolygon.hpp>
 #include <libslic3r/BoundingBox.hpp>
+#include <stdint.h>
 
 #if defined(_MSC_VER) && defined(__clang__)
 #define BOOST_NO_CXX17_HDR_STRING_VIEW
 #endif
 
 #include <boost/rational.hpp>
-
 #include <Int128.hpp>
 
 #if !defined(HAS_INTRINSIC_128_TYPE) || defined(__APPLE__)
@@ -21,6 +21,12 @@
 
 #include <libnest2d/backends/libslic3r/geometries.hpp> // IWYU pragma: keep
 #include <libnest2d/utils/rotcalipers.hpp>
+#include <cmath>
+
+#include "libnest2d/common.hpp"
+#include "libnest2d/geometry_traits.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/MinAreaBoundingBox.hpp b/src/libslic3r/MinAreaBoundingBox.hpp
index fad7d323d1..dc286c8d13 100644
--- a/src/libslic3r/MinAreaBoundingBox.hpp
+++ b/src/libslic3r/MinAreaBoundingBox.hpp
@@ -6,6 +6,7 @@
 #define MINAREABOUNDINGBOX_HPP
 
 #include "libslic3r/Point.hpp"
+#include "libslic3r/BoundingBox.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ModelArrange.cpp b/src/libslic3r/ModelArrange.cpp
index 91119879e8..3da5a0b3fc 100644
--- a/src/libslic3r/ModelArrange.cpp
+++ b/src/libslic3r/ModelArrange.cpp
@@ -7,9 +7,11 @@
 #include <libslic3r/Arrange/SceneBuilder.hpp>
 #include <libslic3r/Arrange/Items/ArrangeItem.hpp>
 #include <libslic3r/Arrange/Tasks/MultiplySelectionTask.hpp>
-
 #include <libslic3r/Model.hpp>
-#include <libslic3r/Geometry/ConvexHull.hpp>
+#include <utility>
+
+#include "libslic3r/Arrange/ArrangeSettingsView.hpp"
+#include "libslic3r/Arrange/Scene.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ModelArrange.hpp b/src/libslic3r/ModelArrange.hpp
index 0b5e4c33ce..f402ef8433 100644
--- a/src/libslic3r/ModelArrange.hpp
+++ b/src/libslic3r/ModelArrange.hpp
@@ -6,11 +6,19 @@
 #define MODELARRANGE_HPP
 
 #include <libslic3r/Arrange/Scene.hpp>
+#include <stddef.h>
+#include <vector>
+
+#include "libslic3r/Arrange/Core/Beds.hpp"
 
 namespace Slic3r {
 
 class Model;
 class ModelInstance;
+namespace arr2 {
+class ArrangeSettingsView;
+}  // namespace arr2
+
 using ModelInstancePtrs = std::vector<ModelInstance*>;
 
 //void duplicate(Model &model, ArrangePolygons &copies, VirtualBedFn);
diff --git a/src/libslic3r/MultiMaterialSegmentation.cpp b/src/libslic3r/MultiMaterialSegmentation.cpp
index 155f26e13d..04b6acbc2d 100644
--- a/src/libslic3r/MultiMaterialSegmentation.cpp
+++ b/src/libslic3r/MultiMaterialSegmentation.cpp
@@ -2,23 +2,48 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/log/trivial.hpp>
+#include <boost/thread/lock_guard.hpp>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
+#include <boost/container_hash/hash.hpp>
+#include <utility>
+#include <unordered_set>
+#include <mutex>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <queue>
+#include <vector>
+
 #include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"
 #include "Layer.hpp"
 #include "Print.hpp"
-#include "Geometry/VoronoiVisualUtils.hpp"
 #include "Geometry/VoronoiUtils.hpp"
 #include "MutablePolygon.hpp"
-#include "format.hpp"
-
-#include <utility>
-#include <unordered_set>
-
-#include <boost/log/trivial.hpp>
-#include <tbb/parallel_for.h>
-#include <mutex>
-#include <boost/thread/lock_guard.hpp>
+#include "admesh/stl.h"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Geometry/VoronoiOffset.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/TriangleMeshSlicer.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 //#define MM_SEGMENTATION_DEBUG_GRAPH
 //#define MM_SEGMENTATION_DEBUG_REGIONS
diff --git a/src/libslic3r/MultiMaterialSegmentation.hpp b/src/libslic3r/MultiMaterialSegmentation.hpp
index 2de93f9f05..6a9c37cd47 100644
--- a/src/libslic3r/MultiMaterialSegmentation.hpp
+++ b/src/libslic3r/MultiMaterialSegmentation.hpp
@@ -5,13 +5,21 @@
 #ifndef slic3r_MultiMaterialSegmentation_hpp_
 #define slic3r_MultiMaterialSegmentation_hpp_
 
+#include <boost/polygon/polygon.hpp>
 #include <utility>
 #include <vector>
+#include <functional>
+
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
 class PrintObject;
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 
 struct ColoredLine
diff --git a/src/libslic3r/MultiPoint.cpp b/src/libslic3r/MultiPoint.cpp
index 5c7b62f3a1..7de92d4c1b 100644
--- a/src/libslic3r/MultiPoint.cpp
+++ b/src/libslic3r/MultiPoint.cpp
@@ -4,7 +4,15 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "MultiPoint.hpp"
+
+#include <stdlib.h>
+#include <cmath>
+#include <limits>
+#include <queue>
+
 #include "BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/MultiPoint.hpp b/src/libslic3r/MultiPoint.hpp
index 9040217628..34ca063af8 100644
--- a/src/libslic3r/MultiPoint.hpp
+++ b/src/libslic3r/MultiPoint.hpp
@@ -6,9 +6,18 @@
 #ifndef slic3r_MultiPoint_hpp_
 #define slic3r_MultiPoint_hpp_
 
-#include "libslic3r.h"
+#include <assert.h>
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <algorithm>
 #include <vector>
+#include <Eigen/Geometry>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
+#include "libslic3r.h"
 #include "Line.hpp"
 #include "Point.hpp"
 
diff --git a/src/libslic3r/MutablePolygon.cpp b/src/libslic3r/MutablePolygon.cpp
index ae72733586..d7388bc9e6 100644
--- a/src/libslic3r/MutablePolygon.cpp
+++ b/src/libslic3r/MutablePolygon.cpp
@@ -3,8 +3,13 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "MutablePolygon.hpp"
-#include "Line.hpp"
+
+#include <math.h>
+#include <cstdint>
+#include <utility>
+
 #include "libslic3r.h"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/MutablePolygon.hpp b/src/libslic3r/MutablePolygon.hpp
index 4df44d4ee1..2ad5866138 100644
--- a/src/libslic3r/MutablePolygon.hpp
+++ b/src/libslic3r/MutablePolygon.hpp
@@ -5,9 +5,17 @@
 #ifndef slic3r_MutablePolygon_hpp_
 #define slic3r_MutablePolygon_hpp_
 
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <initializer_list>
+#include <vector>
+
 #include "Point.hpp"
 #include "Polygon.hpp"
 #include "ExPolygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/NSVGUtils.cpp b/src/libslic3r/NSVGUtils.cpp
index 6bfb89b74e..9e162a46f9 100644
--- a/src/libslic3r/NSVGUtils.cpp
+++ b/src/libslic3r/NSVGUtils.cpp
@@ -3,13 +3,22 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "NSVGUtils.hpp"
-#include <array>
-#include <charconv> // to_chars
 
-#include <boost/nowide/iostream.hpp>
 #include <boost/nowide/fstream.hpp>
+#include <assert.h>
+#include <nanosvg/nanosvg.h>
+#include <string.h>
+#include <array>
+#include <algorithm>
+#include <sstream>
+
 #include "ClipperUtils.hpp"
 #include "Emboss.hpp" // heal for shape
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/EmbossShape.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace {    
 using namespace Slic3r; // Polygon
diff --git a/src/libslic3r/NSVGUtils.hpp b/src/libslic3r/NSVGUtils.hpp
index fe76fa0459..e508b8b712 100644
--- a/src/libslic3r/NSVGUtils.hpp
+++ b/src/libslic3r/NSVGUtils.hpp
@@ -5,13 +5,18 @@
 #ifndef slic3r_NSVGUtils_hpp_
 #define slic3r_NSVGUtils_hpp_
 
+#include <stddef.h>
 #include <memory>
 #include <string>
 #include <sstream>
+#include <cmath>
+
 #include "Polygon.hpp"
 #include "ExPolygon.hpp"
 #include "EmbossShape.hpp" // ExPolygonsWithIds
 #include "nanosvg/nanosvg.h"    // load SVG file
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 // Helper function to work with nano svg
 namespace Slic3r {
diff --git a/src/libslic3r/NormalUtils.cpp b/src/libslic3r/NormalUtils.cpp
index ed111a926e..213306c5b6 100644
--- a/src/libslic3r/NormalUtils.cpp
+++ b/src/libslic3r/NormalUtils.cpp
@@ -4,6 +4,12 @@
 ///|/
 #include "NormalUtils.hpp"
 
+#include <stddef.h>
+#include <cmath>
+
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Point.hpp"
+
 using namespace Slic3r;
 
 Vec3f NormalUtils::create_triangle_normal(
diff --git a/src/libslic3r/NormalUtils.hpp b/src/libslic3r/NormalUtils.hpp
index 95c3a34fa7..240a6fc4dd 100644
--- a/src/libslic3r/NormalUtils.hpp
+++ b/src/libslic3r/NormalUtils.hpp
@@ -5,8 +5,11 @@
 #ifndef slic3r_NormalUtils_hpp_
 #define slic3r_NormalUtils_hpp_
 
+#include <vector>
+
 #include "Point.hpp"
 #include "Model.hpp"
+#include "admesh/stl.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ObjectID.hpp b/src/libslic3r/ObjectID.hpp
index e058961cff..a4cc9a9e61 100644
--- a/src/libslic3r/ObjectID.hpp
+++ b/src/libslic3r/ObjectID.hpp
@@ -7,6 +7,9 @@
 
 #include <cereal/access.hpp>
 #include <cereal/types/base_class.hpp>
+#include <stddef.h>
+#include <stdint.h>
+#include <cereal/cereal.hpp>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/OpenVDBUtils.cpp b/src/libslic3r/OpenVDBUtils.cpp
index cb6d591572..1eed9c1085 100644
--- a/src/libslic3r/OpenVDBUtils.cpp
+++ b/src/libslic3r/OpenVDBUtils.cpp
@@ -11,6 +11,14 @@
 #endif // _MSC_VER
 #include <openvdb/openvdb.h>
 #include <openvdb/tools/MeshToVolume.h>
+#include <openvdb/Grid.h>
+#include <openvdb/Metadata.h>
+#include <openvdb/Types.h>
+#include <openvdb/math/Transform.h>
+#include <openvdb/math/Vec3.h>
+#include <openvdb/math/Vec4.h>
+#include <openvdb/tools/Morphology.h>
+#include <stddef.h>
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif // _MSC_VER
@@ -19,6 +27,14 @@
 #include <openvdb/tools/Composite.h>
 #include <openvdb/tools/LevelSetRebuild.h>
 #include <openvdb/tools/FastSweeping.h>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/OpenVDBUtils.hpp b/src/libslic3r/OpenVDBUtils.hpp
index 40109ba0f2..c20a452d2d 100644
--- a/src/libslic3r/OpenVDBUtils.hpp
+++ b/src/libslic3r/OpenVDBUtils.hpp
@@ -6,10 +6,16 @@
 #define OPENVDBUTILS_HPP
 
 #include <libslic3r/TriangleMesh.hpp>
+#include <functional>
+#include <memory>
+
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
 struct VoxelGrid;
+
 struct VoxelGridDeleter { void operator()(VoxelGrid *ptr); };
 using VoxelGridPtr = std::unique_ptr<VoxelGrid, VoxelGridDeleter>;
 
diff --git a/src/libslic3r/PNGReadWrite.cpp b/src/libslic3r/PNGReadWrite.cpp
index 0bd7ae566e..a4f4b9f5c9 100644
--- a/src/libslic3r/PNGReadWrite.cpp
+++ b/src/libslic3r/PNGReadWrite.cpp
@@ -7,13 +7,15 @@
 ///|/
 #include "PNGReadWrite.hpp"
 
-#include <memory>
-
-#include <cstdio>
 #include <png.h>
-
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/cstdio.hpp>
+#include <assert.h>
+#include <pngconf.h>
+#include <pnglibconf.h>
+#include <setjmp.h>
+#include <string.h>
+#include <cstdio>
 
 namespace Slic3r { namespace png {
 
diff --git a/src/libslic3r/PNGReadWrite.hpp b/src/libslic3r/PNGReadWrite.hpp
index ab82ead463..bf8286d965 100644
--- a/src/libslic3r/PNGReadWrite.hpp
+++ b/src/libslic3r/PNGReadWrite.hpp
@@ -6,10 +6,12 @@
 #ifndef PNGREAD_HPP
 #define PNGREAD_HPP
 
+#include <stddef.h>
 #include <vector>
 #include <string>
 #include <istream>
 #include <cstdint>
+#include <algorithm>
 
 namespace Slic3r { namespace png {
 
diff --git a/src/libslic3r/PerimeterGenerator.cpp b/src/libslic3r/PerimeterGenerator.cpp
index 722294321b..f5cb1d127f 100644
--- a/src/libslic3r/PerimeterGenerator.cpp
+++ b/src/libslic3r/PerimeterGenerator.cpp
@@ -6,6 +6,20 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "PerimeterGenerator.hpp"
+
+#include <ankerl/unordered_dense.h>
+#include <algorithm>
+#include <cmath>
+#include <cassert>
+#include <cstdlib>
+#include <iterator>
+#include <limits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+#include <tuple>
+
 #include "AABBTreeLines.hpp"
 #include "BoundingBox.hpp"
 #include "BridgeDetector.hpp"
@@ -13,36 +27,21 @@
 #include "ExPolygon.hpp"
 #include "ExtrusionEntity.hpp"
 #include "ExtrusionEntityCollection.hpp"
-#include "MultiPoint.hpp"
 #include "Point.hpp"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
 #include "PrintConfig.hpp"
 #include "ShortestPath.hpp"
 #include "Surface.hpp"
-
 #include "Geometry/ConvexHull.hpp"
 #include "clipper/clipper_z.hpp"
-
 #include "Arachne/PerimeterOrder.hpp"
 #include "Arachne/WallToolPaths.hpp"
 #include "Arachne/utils/ExtrusionLine.hpp"
 #include "Arachne/utils/ExtrusionJunction.hpp"
 #include "libslic3r.h"
-
-#include <algorithm>
-#include <cmath>
-#include <cassert>
-#include <cstdlib>
-#include <iterator>
-#include <limits>
-#include <stack>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include <ankerl/unordered_dense.h>
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Line.hpp"
 
 //#define ARACHNE_DEBUG
 
diff --git a/src/libslic3r/PerimeterGenerator.hpp b/src/libslic3r/PerimeterGenerator.hpp
index 3c41bc1688..6df0923635 100644
--- a/src/libslic3r/PerimeterGenerator.hpp
+++ b/src/libslic3r/PerimeterGenerator.hpp
@@ -7,15 +7,23 @@
 #ifndef slic3r_PerimeterGenerator_hpp_
 #define slic3r_PerimeterGenerator_hpp_
 
-#include "libslic3r.h"
 #include <vector>
+
+#include "libslic3r.h"
 #include "ExtrusionEntityCollection.hpp"
 #include "Flow.hpp"
 #include "Polygon.hpp"
 #include "PrintConfig.hpp"
 #include "SurfaceCollection.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
+class ExtrusionEntityCollection;
+class Surface;
+struct ThickPolyline;
 
 namespace PerimeterGenerator
 {
diff --git a/src/libslic3r/PlaceholderParser.cpp b/src/libslic3r/PlaceholderParser.cpp
index 9eede0d740..3e5b75f895 100644
--- a/src/libslic3r/PlaceholderParser.cpp
+++ b/src/libslic3r/PlaceholderParser.cpp
@@ -7,22 +7,31 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "PlaceholderParser.hpp"
-#include "Exception.hpp"
-#include "Flow.hpp"
-#include "Utils.hpp"
+
 #include <cstring>
 #include <ctime>
 #include <iomanip>
-#include <sstream>
 #include <map>
+#include <algorithm>
+#include <cmath>
+#include <iterator>
+#include <utility>
+
+#include "Exception.hpp"
+#include "Flow.hpp"
+#include "Utils.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r_version.h"
 #ifdef _MSC_VER
     #include <stdlib.h>  // provides **_environ
 #else
-    #include <unistd.h>  // provides **environ
 #endif
 
 #ifdef __APPLE__
 #include <crt_externs.h>
+
 #undef environ
 #define environ (*_NSGetEnviron())
 #else
@@ -33,8 +42,22 @@
     #endif
 #endif
 
-#include <boost/algorithm/string.hpp>
 #include <boost/nowide/convert.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/phoenix/phoenix.hpp>
+#include <boost/proto/operators.hpp>
+#include <boost/proto/proto.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/regex/v5/regex.hpp>
+#include <boost/spirit/repository/include/qi.hpp>
+#include <boost/throw_exception.hpp>
 
 // Spirit v2.5 allows you to suppress automatic generation
 // of predefined terminals to speed up complation. With
@@ -45,30 +68,17 @@
 
 #define BOOST_RESULT_OF_USE_DECLTYPE
 #define BOOST_SPIRIT_USE_PHOENIX_V3
-#include <boost/config/warning_disable.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/include/qi_lit.hpp>
-#include <boost/phoenix/core.hpp>
-#include <boost/phoenix/operator.hpp>
-#include <boost/phoenix/fusion.hpp>
-#include <boost/phoenix/stl.hpp>
-#include <boost/phoenix/object.hpp>
-#include <boost/fusion/include/adapt_struct.hpp>
-#include <boost/spirit/repository/include/qi_distinct.hpp>
-#include <boost/spirit/repository/include/qi_iter_pos.hpp>
-#include <boost/variant/recursive_variant.hpp>
 #include <boost/phoenix/bind/bind_function.hpp>
-
 #include <iostream>
 #include <string>
 
 // #define USE_CPP11_REGEX
 #ifdef USE_CPP11_REGEX
     #include <regex>
+
     #define SLIC3R_REGEX_NAMESPACE std
 #else /* USE_CPP11_REGEX */
-    #include <boost/regex.hpp>
     #define SLIC3R_REGEX_NAMESPACE boost
 #endif /* USE_CPP11_REGEX */
 
diff --git a/src/libslic3r/PlaceholderParser.hpp b/src/libslic3r/PlaceholderParser.hpp
index 30fe2591d8..9d98dc3273 100644
--- a/src/libslic3r/PlaceholderParser.hpp
+++ b/src/libslic3r/PlaceholderParser.hpp
@@ -6,15 +6,19 @@
 #ifndef slic3r_PlaceholderParser_hpp_
 #define slic3r_PlaceholderParser_hpp_
 
-#include "libslic3r.h"
 #include <map>
 #include <random>
 #include <string>
 #include <string_view>
 #include <vector>
+#include <memory>
+
+#include "libslic3r.h"
 #include "PrintConfig.hpp"
+#include "libslic3r/Config.hpp"
 
 namespace Slic3r {
+class DynamicPrintConfig;
 
 class PlaceholderParser
 {
diff --git a/src/libslic3r/Point.cpp b/src/libslic3r/Point.cpp
index f78b47e8b2..431f529bf8 100644
--- a/src/libslic3r/Point.cpp
+++ b/src/libslic3r/Point.cpp
@@ -11,11 +11,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Point.hpp"
-#include "Line.hpp"
-#include "MultiPoint.hpp"
+
+#include <stdint.h>
+#include <string.h>
+#include <algorithm>
+
 #include "Int128.hpp"
 #include "BoundingBox.hpp"
-#include <algorithm>
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Point.hpp b/src/libslic3r/Point.hpp
index 690c30cda1..a9c5c7408d 100644
--- a/src/libslic3r/Point.hpp
+++ b/src/libslic3r/Point.hpp
@@ -12,19 +12,24 @@
 #ifndef slic3r_Point_hpp_
 #define slic3r_Point_hpp_
 
-#include "libslic3r.h"
+#include <oneapi/tbb/scalable_allocator.h>
+#include <assert.h>
 #include <cstddef>
 #include <vector>
 #include <cmath>
 #include <string>
 #include <sstream>
 #include <unordered_map>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <optional>
+#include <type_traits>
+#include <utility>
 
-#include <oneapi/tbb/scalable_allocator.h>
-
-
-#include <Eigen/Geometry> 
-
+#include "libslic3r.h"
 #include "LocalesUtils.hpp"
 
 namespace Slic3r {
@@ -32,6 +37,7 @@ namespace Slic3r {
 class BoundingBox;
 class BoundingBoxf;
 class Point;
+
 using Vector = Point;
 
 // Base template for eigen derived vectors
@@ -610,6 +616,7 @@ static bool apply(T &val, const MinMax<T> &limit)
 // start Boost
 #include <boost/version.hpp>
 #include <boost/polygon/polygon.hpp>
+
 namespace boost { namespace polygon {
     template <>
     struct geometry_concept<Slic3r::Point> { using type = point_concept; };
@@ -637,6 +644,7 @@ namespace boost { namespace polygon {
 // end Boost
 
 #include <cereal/cereal.hpp>
+
 // Serialization through the Cereal library
 namespace cereal {
 //    template<class Archive> void serialize(Archive& archive, Slic3r::Vec2crd &v) { archive(v.x(), v.y()); }
diff --git a/src/libslic3r/Polygon.cpp b/src/libslic3r/Polygon.cpp
index 2cbfeb6c71..7887fa9af9 100644
--- a/src/libslic3r/Polygon.cpp
+++ b/src/libslic3r/Polygon.cpp
@@ -9,13 +9,22 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <ankerl/unordered_dense.h>
+#include <stdint.h>
+#include <string.h>
+#include <cmath>
+#include <limits>
+
 #include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
 #include "Exception.hpp"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
-
-#include <ankerl/unordered_dense.h>
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/MultiPoint.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Polygon.hpp b/src/libslic3r/Polygon.hpp
index 6cfb121ba2..f9d2d50e2a 100644
--- a/src/libslic3r/Polygon.hpp
+++ b/src/libslic3r/Polygon.hpp
@@ -11,9 +11,18 @@
 #ifndef slic3r_Polygon_hpp_
 #define slic3r_Polygon_hpp_
 
-#include "libslic3r.h"
+#include <assert.h>
+#include <math.h>
+#include <oneapi/tbb/scalable_allocator.h>
 #include <vector>
 #include <string>
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
+#include "libslic3r.h"
 #include "Line.hpp"
 #include "Point.hpp"
 #include "MultiPoint.hpp"
@@ -22,6 +31,8 @@
 namespace Slic3r {
 
 class Polygon;
+class BoundingBox;
+
 using Polygons          = std::vector<Polygon, PointsAllocator<Polygon>>;
 using PolygonPtrs       = std::vector<Polygon*, PointsAllocator<Polygon*>>;
 using ConstPolygonPtrs  = std::vector<const Polygon*, PointsAllocator<const Polygon*>>;
@@ -319,6 +330,7 @@ template<class I> IntegerOnly<I, Polygons> reserve_polygons(I cap)
 
 // start Boost
 #include <boost/polygon/polygon.hpp>
+
 namespace boost { namespace polygon {
     template <>
     struct geometry_concept<Slic3r::Polygon>{ typedef polygon_concept type; };
diff --git a/src/libslic3r/PolygonTrimmer.cpp b/src/libslic3r/PolygonTrimmer.cpp
index 2bd4d6392d..bc3a3a2e5f 100644
--- a/src/libslic3r/PolygonTrimmer.cpp
+++ b/src/libslic3r/PolygonTrimmer.cpp
@@ -3,8 +3,13 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "PolygonTrimmer.hpp"
+
+#include <assert.h>
+
 #include "EdgeGrid.hpp"
 #include "Geometry.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/PolygonTrimmer.hpp b/src/libslic3r/PolygonTrimmer.hpp
index 8b013b1219..6746103793 100644
--- a/src/libslic3r/PolygonTrimmer.hpp
+++ b/src/libslic3r/PolygonTrimmer.hpp
@@ -5,13 +5,15 @@
 #ifndef slic3r_PolygonTrimmer_hpp_
 #define slic3r_PolygonTrimmer_hpp_
 
-#include "libslic3r.h"
 #include <vector>
 #include <string>
+
+#include "libslic3r.h"
 #include "Line.hpp"
 #include "MultiPoint.hpp"
 #include "Polyline.hpp"
 #include "Polygon.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Polyline.cpp b/src/libslic3r/Polyline.cpp
index 3a5c91cdc9..3635b93faa 100644
--- a/src/libslic3r/Polyline.cpp
+++ b/src/libslic3r/Polyline.cpp
@@ -10,14 +10,17 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <utility>
+#include <cmath>
+#include <limits>
+
 #include "BoundingBox.hpp"
 #include "Polyline.hpp"
 #include "Exception.hpp"
-#include "ExPolygon.hpp"
 #include "Line.hpp"
-#include "Polygon.hpp"
-#include <iostream>
-#include <utility>
+#include "libslic3r/MultiPoint.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Polyline.hpp b/src/libslic3r/Polyline.hpp
index 8c7503648d..0357ebb534 100644
--- a/src/libslic3r/Polyline.hpp
+++ b/src/libslic3r/Polyline.hpp
@@ -11,16 +11,25 @@
 #ifndef slic3r_Polyline_hpp_
 #define slic3r_Polyline_hpp_
 
+#include <stddef.h>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
 #include "libslic3r.h"
 #include "Line.hpp"
 #include "MultiPoint.hpp"
-#include <string>
-#include <vector>
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
 class Polyline;
 struct ThickPolyline;
+class BoundingBox;
+
 typedef std::vector<Polyline> Polylines;
 typedef std::vector<ThickPolyline> ThickPolylines;
 
diff --git a/src/libslic3r/PrincipalComponents2D.cpp b/src/libslic3r/PrincipalComponents2D.cpp
index 187323bc27..f519cf9211 100644
--- a/src/libslic3r/PrincipalComponents2D.cpp
+++ b/src/libslic3r/PrincipalComponents2D.cpp
@@ -3,7 +3,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "PrincipalComponents2D.hpp"
+
+#include <stdlib.h>
+#include <cmath>
+#include <vector>
+
 #include "Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/PrincipalComponents2D.hpp b/src/libslic3r/PrincipalComponents2D.hpp
index edc8072645..1e1318a423 100644
--- a/src/libslic3r/PrincipalComponents2D.hpp
+++ b/src/libslic3r/PrincipalComponents2D.hpp
@@ -5,11 +5,14 @@
 #ifndef slic3r_PrincipalComponents2D_hpp_
 #define slic3r_PrincipalComponents2D_hpp_
 
+#include <vector>
+#include <tuple>
+
 #include "AABBTreeLines.hpp"
 #include "BoundingBox.hpp"
 #include "libslic3r.h"
-#include <vector>
 #include "Polygon.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/PrintApply.cpp b/src/libslic3r/PrintApply.cpp
index 57c20a6b4d..f89f161550 100644
--- a/src/libslic3r/PrintApply.cpp
+++ b/src/libslic3r/PrintApply.cpp
@@ -2,10 +2,36 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stddef.h>
+#include <cfloat>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "Model.hpp"
 #include "Print.hpp"
-
-#include <cfloat>
+#include "admesh/stl.h"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/ObjectID.hpp"
+#include "libslic3r/PlaceholderParser.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintBase.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Slicing.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/PrintConfig.cpp b/src/libslic3r/PrintConfig.cpp
index 602bc1d09c..8e74797534 100644
--- a/src/libslic3r/PrintConfig.cpp
+++ b/src/libslic3r/PrintConfig.cpp
@@ -20,22 +20,28 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "PrintConfig.hpp"
-#include "Config.hpp"
-#include "I18N.hpp"
-#include "format.hpp"
 
-#include "SLA/SupportTree.hpp"
-#include "libslic3r/GCode/Thumbnails.hpp"
-
-#include <set>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/log/trivial.hpp>
-#include <boost/thread.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/lexical_cast/bad_lexical_cast.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <cereal/cereal.hpp>
+#include <set>
+#include <cmath>
+#include <optional>
+#include <string_view>
 
-#include <float.h>
+#include "Config.hpp"
+#include "I18N.hpp"
+#include "format.hpp"
+#include "libslic3r/GCode/Thumbnails.hpp"
+#include "libslic3r/SLA/SupportTreeStrategies.hpp"
+#include "libslic3r/enum_bitmask.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
@@ -6115,5 +6121,6 @@ bool is_XL_printer(const PrintConfig &cfg)
 } // namespace Slic3r
 
 #include <cereal/types/polymorphic.hpp> // IWYU pragma: keep
+
 CEREAL_REGISTER_TYPE(Slic3r::DynamicPrintConfig)
 CEREAL_REGISTER_POLYMORPHIC_RELATION(Slic3r::DynamicConfig, Slic3r::DynamicPrintConfig)
diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp
index ebd63716c9..e3769e4313 100644
--- a/src/libslic3r/PrintConfig.hpp
+++ b/src/libslic3r/PrintConfig.hpp
@@ -33,10 +33,6 @@
 #ifndef slic3r_PrintConfig_hpp_
 #define slic3r_PrintConfig_hpp_
 
-#include "libslic3r.h"
-#include "Config.hpp"
-#include "SLA/SupportTreeStrategies.hpp"
-
 #include <boost/preprocessor/facilities/empty.hpp>
 #include <boost/preprocessor/punctuation/comma_if.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
@@ -44,8 +40,35 @@
 #include <boost/preprocessor/stringize.hpp>
 #include <boost/preprocessor/tuple/elem.hpp>
 #include <boost/preprocessor/tuple/to_seq.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <boost/container_hash/hash.hpp>
+#include <cereal/cereal.hpp>
+#include <algorithm>
+#include <initializer_list>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "libslic3r.h"
+#include "Config.hpp"
+#include "SLA/SupportTreeStrategies.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
+class FullPrintConfig;
+class GCodeConfig;
+class MachineEnvelopeConfig;
+class PrintConfig;
+class PrintObjectConfig;
+class PrintRegionConfig;
+class SLAFullPrintConfig;
+class SLAMaterialConfig;
+class SLAPrintConfig;
+class SLAPrintObjectConfig;
+class SLAPrinterConfig;
 
 enum class ArcFittingType {
     Disabled,
diff --git a/src/libslic3r/PrintObject.cpp b/src/libslic3r/PrintObject.cpp
index d809c08aed..eae115d59e 100644
--- a/src/libslic3r/PrintObject.cpp
+++ b/src/libslic3r/PrintObject.cpp
@@ -7,13 +7,32 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <float.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/concurrent_vector.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+#include <Eigen/Geometry>
+#include <array>
+#include <initializer_list>
+#include <memory>
+
 #include "AABBTreeLines.hpp"
-#include "BridgeDetector.hpp"
 #include "ExPolygon.hpp"
-#include "Exception.hpp"
 #include "Flow.hpp"
 #include "libslic3r/GCode/ExtrusionProcessor.hpp"
-#include "KDTreeIndirect.hpp"
 #include "Line.hpp"
 #include "Point.hpp"
 #include "Polygon.hpp"
@@ -21,11 +40,9 @@
 #include "Print.hpp"
 #include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
-#include "ElephantFootCompensation.hpp"
 #include "Geometry.hpp"
 #include "I18N.hpp"
 #include "Layer.hpp"
-#include "MutablePolygon.hpp"
 #include "PrintBase.hpp"
 #include "PrintConfig.hpp"
 #include "Support/SupportMaterial.hpp"
@@ -38,35 +55,16 @@
 #include "Utils.hpp"
 #include "libslic3r/Fill/FillAdaptive.hpp"
 #include "libslic3r/Fill/FillLightning.hpp"
-#include "Format/STL.hpp"
-#include "Support/SupportMaterial.hpp"
 #include "SupportSpotsGenerator.hpp"
-#include "TriangleSelectorWrapper.hpp"
-#include "format.hpp"
 #include "libslic3r.h"
-
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <float.h>
-#include <functional>
-#include <limits>
-#include <map>
-#include <oneapi/tbb/blocked_range.h>
-#include <oneapi/tbb/concurrent_vector.h>
-#include <oneapi/tbb/parallel_for.h>
-#include <string>
-#include <string_view>
-#include <tuple>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-
-#include <boost/log/trivial.hpp>
-
-#include <tbb/parallel_for.h>
-#include <vector>
+#include "admesh/stl.h"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+#include "tcbspan/span.hpp"
 
 using namespace std::literals;
 
@@ -76,7 +74,9 @@ using namespace std::literals;
     // time limit for one ClipperLib operation (union / diff / offset), in ms
     #define PRINT_OBJECT_TIME_LIMIT_DEFAULT 50
     #include <boost/current_function.hpp>
+
     #include "Timer.hpp"
+
     #define PRINT_OBJECT_TIME_LIMIT_SECONDS(limit) Timing::TimeLimitAlarm time_limit_alarm(uint64_t(limit) * 1000000000l, BOOST_CURRENT_FUNCTION)
     #define PRINT_OBJECT_TIME_LIMIT_MILLIS(limit) Timing::TimeLimitAlarm time_limit_alarm(uint64_t(limit) * 1000000l, BOOST_CURRENT_FUNCTION)
 #else
@@ -96,12 +96,11 @@ using namespace std::literals;
     #define DEBUG
     #define _DEBUG
     #include "SVG.hpp"
+
     #undef assert 
     #include <cassert>
 #endif
 
-    #include "SVG.hpp"
-
 namespace Slic3r {
 
 // Constructor is called from the main thread, therefore all Model / ModelObject / ModelIntance data are valid.
diff --git a/src/libslic3r/PrintObjectSlice.cpp b/src/libslic3r/PrintObjectSlice.cpp
index d285cab41b..e2d7f1e610 100644
--- a/src/libslic3r/PrintObjectSlice.cpp
+++ b/src/libslic3r/PrintObjectSlice.cpp
@@ -2,6 +2,19 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "ClipperUtils.hpp"
 #include "ElephantFootCompensation.hpp"
 #include "I18N.hpp"
@@ -9,10 +22,25 @@
 #include "MultiMaterialSegmentation.hpp"
 #include "Print.hpp"
 #include "ShortestPath.hpp"
-
-#include <boost/log/trivial.hpp>
-
-#include <tbb/parallel_for.h>
+#include "admesh/stl.h"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/ObjectID.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintBase.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Slicing.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/TriangleMeshSlicer.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
+#include "tcbspan/span.hpp"
 
 
 namespace Slic3r {
diff --git a/src/libslic3r/PrintRegion.cpp b/src/libslic3r/PrintRegion.cpp
index 579ed57bc9..8af89a4637 100644
--- a/src/libslic3r/PrintRegion.cpp
+++ b/src/libslic3r/PrintRegion.cpp
@@ -4,8 +4,17 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <math.h>
+#include <stddef.h>
+#include <algorithm>
+#include <vector>
+
 #include "Exception.hpp"
 #include "Print.hpp"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/QuadricEdgeCollapse.cpp b/src/libslic3r/QuadricEdgeCollapse.cpp
index c7df3dac25..d93c3d9ec6 100644
--- a/src/libslic3r/QuadricEdgeCollapse.cpp
+++ b/src/libslic3r/QuadricEdgeCollapse.cpp
@@ -3,17 +3,30 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "QuadricEdgeCollapse.hpp"
+
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
 #include <tuple>
 #include <optional>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <iterator>
+#include <limits>
+#include <utility>
+#include <vector>
+
 #include "MutablePriorityQueue.hpp"
-#include <tbb/parallel_for.h>
+#include "admesh/stl.h"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 using namespace Slic3r;
 
-#ifndef NDEBUG
-//    #define EXPENSIVE_DEBUG_CHECKS
-#endif // NDEBUG
-
 // only private namespace not neccessary be in .hpp
 namespace QuadricEdgeCollapse {
     // SymetricMatrix
diff --git a/src/libslic3r/QuadricEdgeCollapse.hpp b/src/libslic3r/QuadricEdgeCollapse.hpp
index 2d68b72ba2..b6c3fbef21 100644
--- a/src/libslic3r/QuadricEdgeCollapse.hpp
+++ b/src/libslic3r/QuadricEdgeCollapse.hpp
@@ -5,6 +5,7 @@
 #ifndef slic3r_quadric_edge_collapse_hpp_
 #define slic3r_quadric_edge_collapse_hpp_
 
+struct indexed_triangle_set;
 // paper: https://people.eecs.berkeley.edu/~jrs/meshpapers/GarlandHeckbert2.pdf
 // sum up: https://users.csc.calpoly.edu/~zwood/teaching/csc570/final06/jseeba/
 // inspiration: https://github.com/sp4cerat/Fast-Quadric-Mesh-Simplification
@@ -13,6 +14,7 @@
 
 #include <cstdint>
 #include <functional>
+
 #include "TriangleMesh.hpp"
 
 namespace Slic3r {
diff --git a/src/libslic3r/SLA/BranchingTreeSLA.cpp b/src/libslic3r/SLA/BranchingTreeSLA.cpp
index 72a38ee669..5e8db164b6 100644
--- a/src/libslic3r/SLA/BranchingTreeSLA.cpp
+++ b/src/libslic3r/SLA/BranchingTreeSLA.cpp
@@ -4,16 +4,29 @@
 ///|/
 #include "BranchingTreeSLA.hpp"
 
+#include <stddef.h>
+#include <boost/container/vector.hpp>
+#include <boost/geometry.hpp>
+#include <boost/log/trivial.hpp>
+#include <map>
+#include <algorithm>
+#include <mutex>
+#include <optional>
+#include <utility>
+#include <vector>
+
 #include "libslic3r/Execution/ExecutionTBB.hpp"
-
 #include "libslic3r/KDTreeIndirect.hpp"
-
 #include "SupportTreeUtils.hpp"
 #include "libslic3r/BranchingTree/PointCloud.hpp"
-
 #include "Pad.hpp"
-
-#include <map>
+#include "libslic3r/BranchingTree/BranchingTree.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/Execution/ExecutionSeq.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/SLA/SupportTree.hpp"
+#include "libslic3r/SLA/SupportTreeBuilder.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/BranchingTreeSLA.hpp b/src/libslic3r/SLA/BranchingTreeSLA.hpp
index 274419433b..df4fce57fc 100644
--- a/src/libslic3r/SLA/BranchingTreeSLA.hpp
+++ b/src/libslic3r/SLA/BranchingTreeSLA.hpp
@@ -5,12 +5,14 @@
 #ifndef BRANCHINGTREESLA_HPP
 #define BRANCHINGTREESLA_HPP
 
+#include <boost/log/trivial.hpp>
+
 #include "libslic3r/BranchingTree/BranchingTree.hpp"
 #include "SupportTreeBuilder.hpp"
 
-#include <boost/log/trivial.hpp>
-
 namespace Slic3r { namespace sla {
+class SupportTreeBuilder;
+struct SupportableMesh;
 
 void create_branching_tree(SupportTreeBuilder& builder, const SupportableMesh &sm);
 
diff --git a/src/libslic3r/SLA/Clustering.cpp b/src/libslic3r/SLA/Clustering.cpp
index 73d7133e77..03c081ee25 100644
--- a/src/libslic3r/SLA/Clustering.cpp
+++ b/src/libslic3r/SLA/Clustering.cpp
@@ -3,10 +3,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Clustering.hpp"
-#include "boost/geometry/index/rtree.hpp"
 
 #include <libslic3r/SLA/SpatIndex.hpp>
 #include <libslic3r/BoostAdapter.hpp> // IWYU pragma: keep
+#include <boost/geometry.hpp>
+#include <iterator>
+#include <utility>
+
+#include "boost/geometry/index/rtree.hpp"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/Clustering.hpp b/src/libslic3r/SLA/Clustering.hpp
index 39320ce7b5..1068120f58 100644
--- a/src/libslic3r/SLA/Clustering.hpp
+++ b/src/libslic3r/SLA/Clustering.hpp
@@ -5,10 +5,14 @@
 #ifndef SLA_CLUSTERING_HPP
 #define SLA_CLUSTERING_HPP
 
-#include <vector>
-
 #include <libslic3r/Point.hpp>
 #include <libslic3r/SLA/SpatIndex.hpp>
+#include <stddef.h>
+#include <vector>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <array>
+#include <functional>
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/ConcaveHull.cpp b/src/libslic3r/SLA/ConcaveHull.cpp
index 1d8fd50d0c..73d144fefc 100644
--- a/src/libslic3r/SLA/ConcaveHull.cpp
+++ b/src/libslic3r/SLA/ConcaveHull.cpp
@@ -4,11 +4,14 @@
 ///|/
 #include <libslic3r/SLA/ConcaveHull.hpp>
 #include <libslic3r/SLA/SpatIndex.hpp>
-
-#include <libslic3r/MTUtils.hpp>
 #include <libslic3r/ClipperUtils.hpp>
+#include <cmath>
+#include <iterator>
+#include <limits>
 
-#include <boost/log/trivial.hpp>
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r {
 namespace sla {
diff --git a/src/libslic3r/SLA/ConcaveHull.hpp b/src/libslic3r/SLA/ConcaveHull.hpp
index ae985e0dad..0efdc6811e 100644
--- a/src/libslic3r/SLA/ConcaveHull.hpp
+++ b/src/libslic3r/SLA/ConcaveHull.hpp
@@ -6,6 +6,12 @@
 #define SLA_CONCAVEHULL_HPP
 
 #include <libslic3r/ExPolygon.hpp>
+#include <algorithm>
+#include <functional>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 namespace sla {
diff --git a/src/libslic3r/SLA/DefaultSupportTree.cpp b/src/libslic3r/SLA/DefaultSupportTree.cpp
index d8f37195fc..49751521c2 100644
--- a/src/libslic3r/SLA/DefaultSupportTree.cpp
+++ b/src/libslic3r/SLA/DefaultSupportTree.cpp
@@ -8,6 +8,24 @@
 #include <libslic3r/SLA/Clustering.hpp>
 #include <libslic3r/MeshNormals.hpp>
 #include <libslic3r/Execution/ExecutionTBB.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <boost/log/trivial.hpp>
+#include <cmath>
+#include <functional>
+#include <iterator>
+#include <set>
+#include <string>
+
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/Optimize/Optimizer.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/SLA/SpatIndex.hpp"
+#include "libslic3r/SLA/SupportPoint.hpp"
+#include "libslic3r/SLA/SupportTreeStrategies.hpp"
+#include "libslic3r/SLA/SupportTreeUtils.hpp"
+#include "libslic3r/SLA/SupportTreeUtilsLegacy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/DefaultSupportTree.hpp b/src/libslic3r/SLA/DefaultSupportTree.hpp
index 1675d800c2..a1d5c5ee8b 100644
--- a/src/libslic3r/SLA/DefaultSupportTree.hpp
+++ b/src/libslic3r/SLA/DefaultSupportTree.hpp
@@ -5,10 +5,22 @@
 #ifndef LEGACYSUPPORTTREE_HPP
 #define LEGACYSUPPORTTREE_HPP
 
-#include "SupportTreeUtilsLegacy.hpp"
-
 #include <libslic3r/SLA/SpatIndex.hpp>
 #include <libslic3r/Execution/ExecutionTBB.hpp>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "SupportTreeUtilsLegacy.hpp"
+#include "libslic3r/AABBMesh.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/SLA/Pad.hpp"
+#include "libslic3r/SLA/SupportTree.hpp"
+#include "libslic3r/SLA/SupportTreeBuilder.hpp"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/Hollowing.cpp b/src/libslic3r/SLA/Hollowing.cpp
index e4133a43d5..b566cedaf3 100644
--- a/src/libslic3r/SLA/Hollowing.cpp
+++ b/src/libslic3r/SLA/Hollowing.cpp
@@ -2,12 +2,6 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <functional>
-#include <optional>
-#include <numeric>
-#include <unordered_set>
-#include <random>
-
 #include <libslic3r/OpenVDBUtils.hpp>
 #include <libslic3r/TriangleMesh.hpp>
 #include <libslic3r/TriangleMeshSlicer.hpp>
@@ -15,19 +9,32 @@
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/AABBMesh.hpp>
 #include <libslic3r/ClipperUtils.hpp>
-#include <libslic3r/QuadricEdgeCollapse.hpp>
-#include <libslic3r/SLA/SupportTreeMesher.hpp>
 #include <libslic3r/Execution/ExecutionSeq.hpp>
 #include <libslic3r/Model.hpp>
-
 #include <libslic3r/MeshBoolean.hpp>
-
 #include <boost/log/trivial.hpp>
-
-#include <libslic3r/MTUtils.hpp>
 #include <libslic3r/I18N.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <functional>
+#include <numeric>
+#include <unordered_set>
+#include <random>
+#include <cmath>
+#include <mutex>
+#include <string>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/SLA/JobController.hpp"
+#include "libslic3r/SLA/Pad.hpp"
 
 namespace Slic3r {
+struct VoxelGrid;
+
 namespace sla {
 
 struct Interior {
diff --git a/src/libslic3r/SLA/Hollowing.hpp b/src/libslic3r/SLA/Hollowing.hpp
index 77aecd4175..fa5cc6ff65 100644
--- a/src/libslic3r/SLA/Hollowing.hpp
+++ b/src/libslic3r/SLA/Hollowing.hpp
@@ -5,15 +5,28 @@
 #ifndef SLA_HOLLOWING_HPP
 #define SLA_HOLLOWING_HPP
 
-#include <memory>
 #include <libslic3r/TriangleMesh.hpp>
 #include <libslic3r/OpenVDBUtils.hpp>
 #include <libslic3r/SLA/JobController.hpp>
 #include <libslic3r/CSGMesh/VoxelizeCSGMesh.hpp>
+#include <stddef.h>
+#include <memory>
+#include <algorithm>
+#include <array>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "admesh/stl.h"
+#include "libslic3r/CSGMesh/CSGMesh.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
 class ModelObject;
+struct VoxelGrid;
 
 namespace sla {
 
@@ -30,6 +43,7 @@ enum HollowingFlags { hfRemoveInsideTriangles = 0x1 };
 // All data related to a generated mesh interior. Includes the 3D grid and mesh
 // and various metadata. No need to manipulate from outside.
 struct Interior;
+
 struct InteriorDeleter { void operator()(Interior *p); };
 using  InteriorPtr = std::unique_ptr<Interior, InteriorDeleter>;
 
diff --git a/src/libslic3r/SLA/Pad.cpp b/src/libslic3r/SLA/Pad.cpp
index 3fc386590f..a1cab4e890 100644
--- a/src/libslic3r/SLA/Pad.cpp
+++ b/src/libslic3r/SLA/Pad.cpp
@@ -4,25 +4,23 @@
 ///|/
 #include <libslic3r/SLA/Pad.hpp>
 #include <libslic3r/SLA/SpatIndex.hpp>
-#include <libslic3r/BoostAdapter.hpp>
 //#include <libslic3r/SLA/Contour3D.hpp>
 #include <libslic3r/TriangleMeshSlicer.hpp>
+#include <boost/log/trivial.hpp>
+#include <stddef.h>
+#include <algorithm>
+#include <utility>
 
 #include "ConcaveHull.hpp"
-
-#include "boost/log/trivial.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/MTUtils.hpp"
-
 #include "libslic3r/TriangulateWall.hpp"
-
-// For debugging:
-// #include <fstream>
-#include "libslic3r/SVG.hpp"
-
 #include "libslic3r/I18N.hpp"
-#include <boost/log/trivial.hpp>
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/libslic3r.h"
 
 
 namespace Slic3r { namespace sla {
diff --git a/src/libslic3r/SLA/Pad.hpp b/src/libslic3r/SLA/Pad.hpp
index 31df0c4ab2..81f929e596 100644
--- a/src/libslic3r/SLA/Pad.hpp
+++ b/src/libslic3r/SLA/Pad.hpp
@@ -5,12 +5,14 @@
 #ifndef SLA_PAD_HPP
 #define SLA_PAD_HPP
 
+#include <libslic3r/Point.hpp>
 #include <vector>
 #include <functional>
 #include <cmath>
 #include <string>
 
-#include <libslic3r/Point.hpp>
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polygon.hpp"
 
 struct indexed_triangle_set;
 
@@ -18,6 +20,7 @@ namespace Slic3r {
 
 class ExPolygon;
 class Polygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 using Polygons = std::vector<Polygon, PointsAllocator<Polygon>>;
 
diff --git a/src/libslic3r/SLA/RasterBase.cpp b/src/libslic3r/SLA/RasterBase.cpp
index 9f599e0486..2c82992490 100644
--- a/src/libslic3r/SLA/RasterBase.cpp
+++ b/src/libslic3r/SLA/RasterBase.cpp
@@ -6,13 +6,15 @@
 #ifndef SLARASTER_CPP
 #define SLARASTER_CPP
 
-#include <functional>
-
 #include <libslic3r/SLA/RasterBase.hpp>
 #include <libslic3r/SLA/AGGRaster.hpp>
-
 // minz image write:
 #include <miniz.h>
+#include <algorithm>
+#include <cmath>
+#include <iterator>
+
+#include "agg/agg_gamma_functions.h"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/RasterBase.hpp b/src/libslic3r/SLA/RasterBase.hpp
index 5f2826aec4..b640c1fadd 100644
--- a/src/libslic3r/SLA/RasterBase.hpp
+++ b/src/libslic3r/SLA/RasterBase.hpp
@@ -6,14 +6,19 @@
 #ifndef SLA_RASTERBASE_HPP
 #define SLA_RASTERBASE_HPP
 
+#include <libslic3r/ExPolygon.hpp>
+#include <stddef.h>
 #include <ostream>
 #include <memory>
 #include <vector>
 #include <array>
 #include <utility>
 #include <cstdint>
+#include <functional>
+#include <string>
 
-#include <libslic3r/ExPolygon.hpp>
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SLA/RasterToPolygons.cpp b/src/libslic3r/SLA/RasterToPolygons.cpp
index 5efa04d980..1737e41f91 100644
--- a/src/libslic3r/SLA/RasterToPolygons.cpp
+++ b/src/libslic3r/SLA/RasterToPolygons.cpp
@@ -4,10 +4,17 @@
 ///|/
 #include "RasterToPolygons.hpp"
 
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <utility>
+#include <vector>
+
 #include "AGGRaster.hpp"
 #include "libslic3r/MarchingSquares.hpp"
-#include "libslic3r/MTUtils.hpp"
 #include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace marchsq {
 
diff --git a/src/libslic3r/SLA/RasterToPolygons.hpp b/src/libslic3r/SLA/RasterToPolygons.hpp
index 15cde8a9f6..327215c705 100644
--- a/src/libslic3r/SLA/RasterToPolygons.hpp
+++ b/src/libslic3r/SLA/RasterToPolygons.hpp
@@ -6,6 +6,7 @@
 #define RASTERTOPOLYGONS_HPP
 
 #include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 namespace sla {
diff --git a/src/libslic3r/SLA/Rotfinder.cpp b/src/libslic3r/SLA/Rotfinder.cpp
index 2b943e58fe..c53ba492ed 100644
--- a/src/libslic3r/SLA/Rotfinder.cpp
+++ b/src/libslic3r/SLA/Rotfinder.cpp
@@ -2,22 +2,30 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <limits>
-
 #include <libslic3r/SLA/Rotfinder.hpp>
-
 #include <libslic3r/Execution/ExecutionTBB.hpp>
-#include <libslic3r/Execution/ExecutionSeq.hpp>
-
 #include <libslic3r/Optimize/BruteforceOptimizer.hpp>
-#include <libslic3r/Optimize/NLoptOptimizer.hpp>
-
-#include "libslic3r/SLAPrint.hpp"
-#include "libslic3r/PrintConfig.hpp"
-
 #include <libslic3r/Geometry.hpp>
-
+#include <stddef.h>
+#include <stdint.h>
+#include <limits>
 #include <thread>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <iterator>
+#include <vector>
+
+#include "libslic3r/PrintConfig.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/Optimize/Optimizer.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/Rotfinder.hpp b/src/libslic3r/SLA/Rotfinder.hpp
index 8454f08259..6f277b68ec 100644
--- a/src/libslic3r/SLA/Rotfinder.hpp
+++ b/src/libslic3r/SLA/Rotfinder.hpp
@@ -5,10 +5,10 @@
 #ifndef SLA_ROTFINDER_HPP
 #define SLA_ROTFINDER_HPP
 
+#include <libslic3r/Point.hpp>
 #include <functional>
 #include <array>
-
-#include <libslic3r/Point.hpp>
+#include <utility>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SLA/SpatIndex.cpp b/src/libslic3r/SLA/SpatIndex.cpp
index b7f9eca4ec..9d9ac26ce9 100644
--- a/src/libslic3r/SLA/SpatIndex.cpp
+++ b/src/libslic3r/SLA/SpatIndex.cpp
@@ -6,6 +6,8 @@
 
 // for concave hull merging decisions
 #include <libslic3r/BoostAdapter.hpp> // IWYU pragma: keep
+#include <boost/geometry.hpp>
+#include <iterator>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -14,6 +16,7 @@
 #endif
 
 #include "boost/geometry/index/rtree.hpp"
+#include "libslic3r/BoundingBox.hpp"
 
 #ifdef _MSC_VER
 #pragma warning(pop)
diff --git a/src/libslic3r/SLA/SpatIndex.hpp b/src/libslic3r/SLA/SpatIndex.hpp
index 6c96a58383..342b72ee79 100644
--- a/src/libslic3r/SLA/SpatIndex.hpp
+++ b/src/libslic3r/SLA/SpatIndex.hpp
@@ -5,13 +5,13 @@
 #ifndef SLA_SPATINDEX_HPP
 #define SLA_SPATINDEX_HPP
 
+#include <libslic3r/BoundingBox.hpp>
+#include <stddef.h>
 #include <memory>
 #include <utility>
 #include <vector>
-
 #include <Eigen/Geometry>
-
-#include <libslic3r/BoundingBox.hpp>
+#include <functional>
 
 namespace Slic3r {
 namespace sla {
diff --git a/src/libslic3r/SLA/SupportPointGenerator.cpp b/src/libslic3r/SLA/SupportPointGenerator.cpp
index e68d22d5c2..98b7ee0aac 100644
--- a/src/libslic3r/SLA/SupportPointGenerator.cpp
+++ b/src/libslic3r/SLA/SupportPointGenerator.cpp
@@ -2,21 +2,25 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <tbb/parallel_for.h>
+#include <assert.h>
+#include <random>
+#include <cstdlib>
+#include <limits>
+#include <numeric>
 
 #include "SupportPointGenerator.hpp"
 #include "libslic3r/Execution/ExecutionTBB.hpp"
 #include "libslic3r/Geometry/ConvexHull.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/ExPolygon.hpp"
-#include "libslic3r/SVG.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/MinAreaBoundingBox.hpp"
 #include "libslic3r/libslic3r.h"
-#include <iostream>
-#include <random>
+#include "libslic3r/AABBMesh.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/SLA/SupportPoint.hpp"
 
 namespace Slic3r {
 namespace sla {
@@ -283,14 +287,6 @@ void SupportPointGenerator::process(const std::vector<ExPolygons>& slices, const
 
         status += increment;
         m_statusfn(int(std::round(status)));
-
-#ifdef SLA_SUPPORTPOINTGEN_DEBUG
-        /*std::string layer_num_str = std::string((i<10 ? "0" : "")) + std::string((i<100 ? "0" : "")) + std::to_string(i);
-        output_expolygons(expolys_top, "top" + layer_num_str + ".svg");
-        output_expolygons(diff, "diff" + layer_num_str + ".svg");
-        if (!islands.empty())
-            output_expolygons(islands, "islands" + layer_num_str + ".svg");*/
-#endif /* SLA_SUPPORTPOINTGEN_DEBUG */
     }
 }
 
diff --git a/src/libslic3r/SLA/SupportPointGenerator.hpp b/src/libslic3r/SLA/SupportPointGenerator.hpp
index c24167a39a..be8de14923 100644
--- a/src/libslic3r/SLA/SupportPointGenerator.hpp
+++ b/src/libslic3r/SLA/SupportPointGenerator.hpp
@@ -5,16 +5,28 @@
 #ifndef SLA_SUPPORTPOINTGENERATOR_HPP
 #define SLA_SUPPORTPOINTGENERATOR_HPP
 
-#include <random>
-
 #include <libslic3r/AABBMesh.hpp>
-
 #include <libslic3r/SLA/SupportPoint.hpp>
 #include <libslic3r/BoundingBox.hpp>
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Point.hpp>
-
 #include <boost/container/small_vector.hpp>
+#include <stdint.h>
+#include <random>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
+
+namespace Slic3r {
+class AABBMesh;
+}  // namespace Slic3r
 
 // #define SLA_SUPPORTPOINTGEN_DEBUG
 
diff --git a/src/libslic3r/SLA/SupportTree.cpp b/src/libslic3r/SLA/SupportTree.cpp
index 8d2f44a6fd..3dcb2f1178 100644
--- a/src/libslic3r/SLA/SupportTree.cpp
+++ b/src/libslic3r/SLA/SupportTree.cpp
@@ -7,19 +7,23 @@
  *
  */
 
-#include <numeric>
 #include <libslic3r/SLA/SupportTree.hpp>
-#include <libslic3r/SLA/SpatIndex.hpp>
 #include <libslic3r/SLA/SupportTreeBuilder.hpp>
 #include <libslic3r/SLA/DefaultSupportTree.hpp>
 #include <libslic3r/SLA/BranchingTreeSLA.hpp>
-
 #include <libslic3r/MTUtils.hpp>
-#include <libslic3r/ClipperUtils.hpp>
-#include <libslic3r/Model.hpp>
 #include <libslic3r/TriangleMeshSlicer.hpp>
-
 #include <boost/log/trivial.hpp>
+#include <stddef.h>
+#include <chrono>
+#include <iterator>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/SLA/JobController.hpp"
+#include "libslic3r/SLA/Pad.hpp"
+#include "libslic3r/SLA/SupportTreeStrategies.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/libslic3r.h"
 
 
 namespace Slic3r { namespace sla {
diff --git a/src/libslic3r/SLA/SupportTree.hpp b/src/libslic3r/SLA/SupportTree.hpp
index e0646a9d8c..136210bc86 100644
--- a/src/libslic3r/SLA/SupportTree.hpp
+++ b/src/libslic3r/SLA/SupportTree.hpp
@@ -5,21 +5,24 @@
 #ifndef SLA_SUPPORTTREE_HPP
 #define SLA_SUPPORTTREE_HPP
 
-#include <vector>
-#include <memory>
-
 #include <libslic3r/Polygon.hpp>
 #include <libslic3r/ExPolygon.hpp>
 #include <libslic3r/AABBMesh.hpp>
-
 #include <libslic3r/SLA/Pad.hpp>
 #include <libslic3r/SLA/SupportPoint.hpp>
 #include <libslic3r/SLA/JobController.hpp>
 #include <libslic3r/SLA/SupportTreeStrategies.hpp>
+#include <math.h>
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+#include "admesh/stl.h"
 
 namespace Slic3r {
 
 namespace sla {
+struct JobController;
 
 struct SupportTreeConfig
 {
diff --git a/src/libslic3r/SLA/SupportTreeBuilder.cpp b/src/libslic3r/SLA/SupportTreeBuilder.cpp
index 324f4f2fc8..58e16808fd 100644
--- a/src/libslic3r/SLA/SupportTreeBuilder.cpp
+++ b/src/libslic3r/SLA/SupportTreeBuilder.cpp
@@ -3,9 +3,12 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include <libslic3r/SLA/SupportTreeBuilder.hpp>
-#include <libslic3r/SLA/SupportTreeUtils.hpp>
 #include <libslic3r/SLA/SupportTreeMesher.hpp>
 
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/SLA/SupportTree.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+
 namespace Slic3r {
 namespace sla {
 
diff --git a/src/libslic3r/SLA/SupportTreeBuilder.hpp b/src/libslic3r/SLA/SupportTreeBuilder.hpp
index ccba91cd80..3678a613e1 100644
--- a/src/libslic3r/SLA/SupportTreeBuilder.hpp
+++ b/src/libslic3r/SLA/SupportTreeBuilder.hpp
@@ -10,6 +10,18 @@
 #include <libslic3r/TriangleMesh.hpp>
 #include <libslic3r/SLA/Pad.hpp>
 #include <libslic3r/MTUtils.hpp>
+#include <assert.h>
+#include <oneapi/tbb/spin_mutex.h>
+#include <stddef.h>
+#include <algorithm>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/SLA/JobController.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 namespace sla {
diff --git a/src/libslic3r/SLA/SupportTreeMesher.cpp b/src/libslic3r/SLA/SupportTreeMesher.cpp
index 18beb61873..9ee17249a9 100644
--- a/src/libslic3r/SLA/SupportTreeMesher.cpp
+++ b/src/libslic3r/SLA/SupportTreeMesher.cpp
@@ -4,6 +4,9 @@
 ///|/
 #include "SupportTreeMesher.hpp"
 
+#include <assert.h>
+#include <cmath>
+
 namespace Slic3r { namespace sla {
 
 indexed_triangle_set sphere(double rho, Portion portion, double fa) {
diff --git a/src/libslic3r/SLA/SupportTreeMesher.hpp b/src/libslic3r/SLA/SupportTreeMesher.hpp
index cba8f1019b..584d3e3f2f 100644
--- a/src/libslic3r/SLA/SupportTreeMesher.hpp
+++ b/src/libslic3r/SLA/SupportTreeMesher.hpp
@@ -5,10 +5,14 @@
 #ifndef SUPPORTTREEMESHER_HPP
 #define SUPPORTTREEMESHER_HPP
 
-#include "libslic3r/Point.hpp"
+#include <stddef.h>
+#include <tuple>
 
+#include "libslic3r/Point.hpp"
 #include "libslic3r/SLA/SupportTreeBuilder.hpp"
 #include "libslic3r/TriangleMesh.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/libslic3r.h"
 //#include "libslic3r/SLA/Contour3D.hpp"
 
 namespace Slic3r { namespace sla {
diff --git a/src/libslic3r/SLA/ZCorrection.cpp b/src/libslic3r/SLA/ZCorrection.cpp
index d072cd222a..5d7faaa0c7 100644
--- a/src/libslic3r/SLA/ZCorrection.cpp
+++ b/src/libslic3r/SLA/ZCorrection.cpp
@@ -1,8 +1,11 @@
 #include "ZCorrection.hpp"
 
-#include "libslic3r/Execution/ExecutionTBB.hpp"
+#include <iterator>
 
+#include "libslic3r/Execution/ExecutionTBB.hpp"
 #include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace sla {
 
diff --git a/src/libslic3r/SLA/ZCorrection.hpp b/src/libslic3r/SLA/ZCorrection.hpp
index 45c3e0cd76..ed32efbe56 100644
--- a/src/libslic3r/SLA/ZCorrection.hpp
+++ b/src/libslic3r/SLA/ZCorrection.hpp
@@ -1,6 +1,11 @@
 #ifndef ZCORRECTION_HPP
 #define ZCORRECTION_HPP
 
+#include <stddef.h>
+#include <algorithm>
+#include <map>
+#include <vector>
+
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/Execution/Execution.hpp"
 
diff --git a/src/libslic3r/SLAPrintSteps.cpp b/src/libslic3r/SLAPrintSteps.cpp
index 73734fe5cd..ceb23b5b50 100644
--- a/src/libslic3r/SLAPrintSteps.cpp
+++ b/src/libslic3r/SLAPrintSteps.cpp
@@ -2,41 +2,60 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <unordered_set>
-#include <chrono>
-
 #include <libslic3r/Exception.hpp>
 #include <libslic3r/SLAPrintSteps.hpp>
 #include <libslic3r/MeshBoolean.hpp>
 #include <libslic3r/TriangleMeshSlicer.hpp>
-
-// Need the cylinder method for the the drainholes in hollowing step
-#include <libslic3r/SLA/SupportTreeBuilder.hpp>
-
 #include <libslic3r/Execution/ExecutionTBB.hpp>
 #include <libslic3r/SLA/Pad.hpp>
 #include <libslic3r/SLA/SupportPointGenerator.hpp>
 #include <libslic3r/SLA/ZCorrection.hpp>
-
 #include <libslic3r/ElephantFootCompensation.hpp>
-#include <libslic3r/AABBTreeIndirect.hpp>
-#include <libslic3r/MeshSplitImpl.hpp>
-#include <libslic3r/SlicesToTriangleMesh.hpp>
 #include <libslic3r/CSGMesh/ModelToCSGMesh.hpp>
 #include <libslic3r/CSGMesh/SliceCSGMesh.hpp>
 #include <libslic3r/CSGMesh/VoxelizeCSGMesh.hpp>
 #include <libslic3r/CSGMesh/PerformCSGMeshBooleans.hpp>
 #include <libslic3r/OpenVDBUtils.hpp>
 #include <libslic3r/QuadricEdgeCollapse.hpp>
-
 #include <libslic3r/ClipperUtils.hpp>
+#include <assert.h>
+#include <chrono>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <numeric>
+#include <set>
+#include <tuple>
+#include <vector>
 //#include <libslic3r/ShortEdgeCollapse.hpp>
 
 #include <boost/log/trivial.hpp>
 
 #include "I18N.hpp"
-
 #include "format.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/CSGMesh/CSGMesh.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintBase.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SLA/Hollowing.hpp"
+#include "libslic3r/SLA/JobController.hpp"
+#include "libslic3r/SLA/RasterBase.hpp"
+#include "libslic3r/SLA/SupportPoint.hpp"
+#include "libslic3r/SLA/SupportTree.hpp"
+#include "libslic3r/SLA/SupportTreeStrategies.hpp"
+#include "libslic3r/SLAPrint.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SLAPrintSteps.hpp b/src/libslic3r/SLAPrintSteps.hpp
index 1c3d07bf8b..afa0309f55 100644
--- a/src/libslic3r/SLAPrintSteps.hpp
+++ b/src/libslic3r/SLAPrintSteps.hpp
@@ -5,12 +5,16 @@
 #ifndef SLAPRINTSTEPS_HPP
 #define SLAPRINTSTEPS_HPP
 
-#include <random>
-
 #include <libslic3r/SLAPrint.hpp>
-
 #include <libslic3r/SLA/Hollowing.hpp>
 #include <libslic3r/SLA/SupportTree.hpp>
+#include <stddef.h>
+#include <random>
+#include <string>
+#include <utility>
+
+#include "admesh/stl.h"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SVG.cpp b/src/libslic3r/SVG.cpp
index 406a6c6563..e6a5c1512e 100644
--- a/src/libslic3r/SVG.cpp
+++ b/src/libslic3r/SVG.cpp
@@ -9,9 +9,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "SVG.hpp"
-#include <iostream>
 
 #include <boost/nowide/cstdio.hpp>
+#include <math.h>
+#include <iostream>
+#include <algorithm>
+
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SVG.hpp b/src/libslic3r/SVG.hpp
index ba752c482e..066b88ff40 100644
--- a/src/libslic3r/SVG.hpp
+++ b/src/libslic3r/SVG.hpp
@@ -10,12 +10,23 @@
 #ifndef slic3r_SVG_hpp_
 #define slic3r_SVG_hpp_
 
+#include <stdio.h>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "libslic3r/clipper.hpp"
 #include "ExPolygon.hpp"
 #include "Line.hpp"
 #include "TriangleMesh.hpp"
 #include "Surface.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/MultiPoint.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Semver.cpp b/src/libslic3r/Semver.cpp
index 1519af0406..26dbc5ccc8 100644
--- a/src/libslic3r/Semver.cpp
+++ b/src/libslic3r/Semver.cpp
@@ -2,7 +2,9 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r.h"
+
+#include "libslic3r/Semver.hpp"
+#include "libslic3r_version.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Semver.hpp b/src/libslic3r/Semver.hpp
index e8b359a376..00fdf6d721 100644
--- a/src/libslic3r/Semver.hpp
+++ b/src/libslic3r/Semver.hpp
@@ -5,14 +5,17 @@
 #ifndef slic3r_Semver_hpp_
 #define slic3r_Semver_hpp_
 
+#include <boost/optional.hpp>
+#include <boost/format.hpp>
+#include <semver.h>
+#include <stdlib.h>
+#include <boost/none.hpp>
+#include <boost/optional/optional.hpp>
 #include <string>
 #include <cstring>
 #include <ostream>
 #include <stdexcept>
-#include <boost/optional.hpp>
-#include <boost/format.hpp>
-
-#include <semver.h>
+#include <limits>
 
 #include "Exception.hpp"
 
diff --git a/src/libslic3r/ShortEdgeCollapse.cpp b/src/libslic3r/ShortEdgeCollapse.cpp
index 9089bae6a7..00aaae4d0e 100644
--- a/src/libslic3r/ShortEdgeCollapse.cpp
+++ b/src/libslic3r/ShortEdgeCollapse.cpp
@@ -3,15 +3,18 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ShortEdgeCollapse.hpp"
-#include "libslic3r/NormalUtils.hpp"
 
-#include <unordered_map>
-#include <unordered_set>
+#include <boost/random/uniform_int_distribution.hpp>
+#include <ankerl/unordered_dense.h>
 #include <random>
 #include <algorithm>
-#include <boost/random/uniform_int_distribution.hpp>
+#include <utility>
+#include <vector>
 
-#include <ankerl/unordered_dense.h>
+#include "libslic3r/NormalUtils.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/ShortEdgeCollapse.hpp b/src/libslic3r/ShortEdgeCollapse.hpp
index bfc3a0e0ae..d18e9c765c 100644
--- a/src/libslic3r/ShortEdgeCollapse.hpp
+++ b/src/libslic3r/ShortEdgeCollapse.hpp
@@ -5,8 +5,12 @@
 #ifndef SRC_LIBSLIC3R_SHORTEDGECOLLAPSE_HPP_
 #define SRC_LIBSLIC3R_SHORTEDGECOLLAPSE_HPP_
 
+#include <stddef.h>
+
 #include "libslic3r/TriangleMesh.hpp"
 
+struct indexed_triangle_set;
+
 namespace Slic3r{
 
 // Decimates the model by collapsing short edges. It starts with very small edges and gradually increases the collapsible length,
diff --git a/src/libslic3r/ShortestPath.cpp b/src/libslic3r/ShortestPath.cpp
index b80a7c2b9c..3297d424df 100644
--- a/src/libslic3r/ShortestPath.cpp
+++ b/src/libslic3r/ShortestPath.cpp
@@ -8,14 +8,25 @@
 	#undef assert
 #endif
 
-#include "libslic3r/clipper.hpp"
+#include <cmath>
+#include <cassert>
+#include <Eigen/Geometry>
+#include <iterator>
+#include <limits>
+
 #include "ShortestPath.hpp"
 #include "KDTreeIndirect.hpp"
 #include "MutablePriorityQueue.hpp"
 #include "Print.hpp"
-
-#include <cmath>
-#include <cassert>
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
+#include "tcbspan/span.hpp"
 
 namespace Slic3r {
 
@@ -1120,10 +1131,6 @@ std::vector<size_t> chain_expolygons(const ExPolygons &expolygons, Point *start_
     return chain_points(ordering_points);
 }
 
-#ifndef NDEBUG
-	// #define DEBUG_SVG_OUTPUT
-#endif /* NDEBUG */
-
 #ifdef DEBUG_SVG_OUTPUT
 void svg_draw_polyline_chain(const char *name, size_t idx, const Polylines &polylines)
 {
diff --git a/src/libslic3r/ShortestPath.hpp b/src/libslic3r/ShortestPath.hpp
index 243bb221ea..01a4e6b8d0 100644
--- a/src/libslic3r/ShortestPath.hpp
+++ b/src/libslic3r/ShortestPath.hpp
@@ -5,21 +5,28 @@
 #ifndef slic3r_ShortestPath_hpp_
 #define slic3r_ShortestPath_hpp_
 
-#include "libslic3r.h"
-#include "ExtrusionEntity.hpp"
-#include "Point.hpp"
-
+#include <stddef.h>
 #include <utility>
 #include <vector>
 
+#include "libslic3r.h"
+#include "ExtrusionEntity.hpp"
+#include "Point.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
+
 namespace Slic3r {
+class ExtrusionEntityCollection;
+class Line;
 
 	namespace ClipperLib {
 		class PolyNode;
+
 		using PolyNodes = std::vector<PolyNode*, PointsAllocator<PolyNode*>>;
 	}
 
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 
 // Used by chain_expolygons()
@@ -54,6 +61,7 @@ ClipperLib::PolyNodes				 chain_clipper_polynodes(const Points &points, const Cl
 // Returns pairs of PrintObject idx and instance of that PrintObject.
 class Print;
 struct PrintInstance;
+
 std::vector<const PrintInstance*> 	 chain_print_object_instances(const Print &print);
 
 // Chain lines into polylines.
diff --git a/src/libslic3r/SlicesToTriangleMesh.cpp b/src/libslic3r/SlicesToTriangleMesh.cpp
index 4deb0bbdde..d6bec4a57c 100644
--- a/src/libslic3r/SlicesToTriangleMesh.cpp
+++ b/src/libslic3r/SlicesToTriangleMesh.cpp
@@ -2,18 +2,17 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <numeric>
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
 
 #include "SlicesToTriangleMesh.hpp"
-
 #include "libslic3r/Execution/ExecutionTBB.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/Tesselate.hpp"
-
-#include <tbb/parallel_for.h>
-#include <tbb/parallel_reduce.h>
-
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Execution/Execution.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SlicesToTriangleMesh.hpp b/src/libslic3r/SlicesToTriangleMesh.hpp
index 7389494ccf..e6010f7687 100644
--- a/src/libslic3r/SlicesToTriangleMesh.hpp
+++ b/src/libslic3r/SlicesToTriangleMesh.hpp
@@ -5,8 +5,11 @@
 #ifndef SLICESTOTRIANGLEMESH_HPP
 #define SLICESTOTRIANGLEMESH_HPP
 
+#include <vector>
+
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/ExPolygon.hpp"
+#include "admesh/stl.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Slicing.cpp b/src/libslic3r/Slicing.cpp
index 091c46dc54..83faae15f6 100644
--- a/src/libslic3r/Slicing.cpp
+++ b/src/libslic3r/Slicing.cpp
@@ -3,12 +3,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include <limits>
+#include <algorithm>
+#include <cmath>
 
 #include "libslic3r.h"
 #include "Slicing.hpp"
 #include "SlicingAdaptive.hpp"
 #include "PrintConfig.hpp"
-#include "Model.hpp"
+#include "libslic3r/Point.hpp"
 
 // #define SLIC3R_DEBUG
 
@@ -18,6 +20,7 @@
     #define DEBUG
     #define _DEBUG
     #include "SVG.hpp"
+
     #undef assert 
     #include <cassert>
 #endif
diff --git a/src/libslic3r/Slicing.hpp b/src/libslic3r/Slicing.hpp
index f1f99e5952..39b28fb260 100644
--- a/src/libslic3r/Slicing.hpp
+++ b/src/libslic3r/Slicing.hpp
@@ -7,15 +7,18 @@
 #ifndef slic3r_Slicing_hpp_
 #define slic3r_Slicing_hpp_
 
+#include <assert.h>
 #include <cstring>
 #include <map>
 #include <set>
 #include <type_traits>
 #include <vector>
+#include <utility>
 
 #include "Point.hpp"
 #include "libslic3r.h"
 #include "Utils.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r
 {
diff --git a/src/libslic3r/SlicingAdaptive.cpp b/src/libslic3r/SlicingAdaptive.cpp
index ecca116cc2..8932d7536d 100644
--- a/src/libslic3r/SlicingAdaptive.cpp
+++ b/src/libslic3r/SlicingAdaptive.cpp
@@ -2,13 +2,16 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <cfloat>
+#include <algorithm>
+#include <cmath>
+
 #include "libslic3r.h"
 #include "Model.hpp"
 #include "TriangleMesh.hpp"
 #include "SlicingAdaptive.hpp"
-
-#include <boost/log/trivial.hpp>
-#include <cfloat>
+#include "admesh/stl.h"
 
 // Based on the work of Florens Waserfall (@platch on github)
 // and his paper
diff --git a/src/libslic3r/SlicingAdaptive.hpp b/src/libslic3r/SlicingAdaptive.hpp
index 6a71f848a9..b8a3ab6ee5 100644
--- a/src/libslic3r/SlicingAdaptive.hpp
+++ b/src/libslic3r/SlicingAdaptive.hpp
@@ -7,6 +7,10 @@
 #ifndef slic3r_SlicingAdaptive_hpp_
 #define slic3r_SlicingAdaptive_hpp_
 
+#include <stddef.h>
+#include <utility>
+#include <vector>
+
 #include "Slicing.hpp"
 #include "admesh/stl.h"
 
@@ -14,6 +18,7 @@ namespace Slic3r
 {
 
 class ModelVolume;
+class ModelObject;
 
 class SlicingAdaptive
 {
diff --git a/src/libslic3r/Subdivide.cpp b/src/libslic3r/Subdivide.cpp
index 0811a1bba2..20b57e090a 100644
--- a/src/libslic3r/Subdivide.cpp
+++ b/src/libslic3r/Subdivide.cpp
@@ -3,6 +3,17 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Subdivide.hpp"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <queue>
+#include <tuple>
+#include <utility>
+#include <vector>
+
 #include "Point.hpp"
 
 namespace Slic3r{
diff --git a/src/libslic3r/Subdivide.hpp b/src/libslic3r/Subdivide.hpp
index e644e57c87..6366e0422b 100644
--- a/src/libslic3r/Subdivide.hpp
+++ b/src/libslic3r/Subdivide.hpp
@@ -6,6 +6,7 @@
 #define libslic3r_Subdivide_hpp_
 
 #include "TriangleMesh.hpp"
+#include "admesh/stl.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Support/OrganicSupport.cpp b/src/libslic3r/Support/OrganicSupport.cpp
index 69cc0cf7e1..ef634d241f 100644
--- a/src/libslic3r/Support/OrganicSupport.cpp
+++ b/src/libslic3r/Support/OrganicSupport.cpp
@@ -3,25 +3,46 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "OrganicSupport.hpp"
-#include "SupportCommon.hpp"
+
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/partitioner.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/vector.hpp>
+#include <cassert>
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <limits>
+#include <optional>
+#include <utility>
 
 #include "../AABBTreeLines.hpp"
 #include "../ClipperUtils.hpp"
 #include "../Polygon.hpp"
-#include "../Polyline.hpp"
 #include "../MutablePolygon.hpp"
 #include "../TriangleMeshSlicer.hpp"
-
-#include <cassert>
-
-#include <tbb/parallel_for.h>
+#include "admesh/stl.h"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Print.hpp"
+#include "libslic3r/Slicing.hpp"
+#include "libslic3r/Support/TreeModelVolumes.hpp"
+#include "libslic3r/Support/TreeSupport.hpp"
+#include "libslic3r/Support/TreeSupportCommon.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 #define TREE_SUPPORT_ORGANIC_NUDGE_NEW 1
 
 #ifndef TREE_SUPPORT_ORGANIC_NUDGE_NEW
+    #include <openvdb/tools/VolumeToSpheres.h>
+
     // Old version using OpenVDB, works but it is extremely slow for complex meshes.
     #include "../OpenVDBUtilsLegacy.hpp"
-    #include <openvdb/tools/VolumeToSpheres.h>
 #endif // TREE_SUPPORT_ORGANIC_NUDGE_NEW
 
 namespace Slic3r
diff --git a/src/libslic3r/Support/OrganicSupport.hpp b/src/libslic3r/Support/OrganicSupport.hpp
index c7b13b9db5..1afc451990 100644
--- a/src/libslic3r/Support/OrganicSupport.hpp
+++ b/src/libslic3r/Support/OrganicSupport.hpp
@@ -5,8 +5,12 @@
 #ifndef slic3r_OrganicSupport_hpp
 #define slic3r_OrganicSupport_hpp
 
+#include <functional>
+#include <vector>
+
 #include "SupportCommon.hpp"
 #include "TreeSupport.hpp"
+#include "libslic3r/Support/SupportLayer.hpp"
 
 namespace Slic3r
 {
@@ -17,6 +21,8 @@ namespace FFFTreeSupport
 {
 
 class TreeModelVolumes;
+class InterfacePlacer;
+struct TreeSupportSettings;
 
 // Organic specific: Smooth branches and produce one cummulative mesh to be sliced.
 void organic_draw_branches(
diff --git a/src/libslic3r/Support/SupportCommon.cpp b/src/libslic3r/Support/SupportCommon.cpp
index ed2fbdc98a..4b2444ff82 100644
--- a/src/libslic3r/Support/SupportCommon.cpp
+++ b/src/libslic3r/Support/SupportCommon.cpp
@@ -2,6 +2,17 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/container/static_vector.hpp>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
+#include <boost/log/trivial.hpp>
+#include <cmath>
+#include <initializer_list>
+#include <limits>
+#include <memory>
+#include <unordered_map>
+
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ClipperZUtils.hpp" // IWYU pragma: keep
 #include "libslic3r/ExtrusionEntityCollection.hpp"
@@ -11,15 +22,22 @@
 #include "libslic3r/MutablePolygon.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/Point.hpp"
-
-#include <cmath>
-#include <boost/container/static_vector.hpp>
-
-#include <tbb/parallel_for.h>
-
 #include "SupportCommon.hpp"
 #include "SupportLayer.hpp"
 #include "SupportParameters.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/Slicing.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 // #define SLIC3R_DEBUG
 
diff --git a/src/libslic3r/Support/SupportCommon.hpp b/src/libslic3r/Support/SupportCommon.hpp
index f8df25e503..f3a26675db 100644
--- a/src/libslic3r/Support/SupportCommon.hpp
+++ b/src/libslic3r/Support/SupportCommon.hpp
@@ -5,16 +5,24 @@
 #ifndef slic3r_SupportCommon_hpp_
 #define slic3r_SupportCommon_hpp_
 
+#include <algorithm>
+#include <utility>
+#include <vector>
+
 #include "../Layer.hpp"
 #include "../Polygon.hpp"
 #include "../Print.hpp"
 #include "SupportLayer.hpp"
 #include "SupportParameters.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
 
 class PrintObject;
 class SupportLayer;
+class Layer;
+class LayerRegion;
+struct SlicingParameters;
 
 namespace FFFSupport {
 
diff --git a/src/libslic3r/Support/SupportDebug.cpp b/src/libslic3r/Support/SupportDebug.cpp
index 24e92a0eb1..f95bd58c07 100644
--- a/src/libslic3r/Support/SupportDebug.cpp
+++ b/src/libslic3r/Support/SupportDebug.cpp
@@ -4,11 +4,16 @@
 ///|/
 #if 1 //#ifdef SLIC3R_DEBUG
 
+#include <algorithm>
+
 #include "../ClipperUtils.hpp"
 #include "../SVG.hpp"
 #include "../Layer.hpp"
-
 #include "SupportLayer.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::FFFSupport {
 
diff --git a/src/libslic3r/Support/SupportMaterial.cpp b/src/libslic3r/Support/SupportMaterial.cpp
index 5d0b7b4fd5..805a29b1d5 100644
--- a/src/libslic3r/Support/SupportMaterial.cpp
+++ b/src/libslic3r/Support/SupportMaterial.cpp
@@ -10,27 +10,47 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/log/trivial.hpp>
+#include <float.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/task_group.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <cmath>
+#include <memory>
+#include <algorithm>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <utility>
+
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExtrusionEntityCollection.hpp"
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Print.hpp"
-#include "libslic3r/Fill/FillBase.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/MutablePolygon.hpp"
-
 #include "libslic3r/Support/SupportCommon.hpp"
 #include "SupportMaterial.hpp"
-
-#include <clipper/clipper_z.hpp>
-
-#include <cmath>
-#include <memory>
-#include <boost/log/trivial.hpp>
-#include <boost/container/static_vector.hpp>
-
-#include <tbb/parallel_for.h>
-#include <tbb/task_group.h>
+#include "agg/agg_renderer_base.h"
+#include "agg/agg_rendering_buffer.h"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Slicing.hpp"
+#include "libslic3r/Support/SupportLayer.hpp"
+#include "libslic3r/Support/SupportParameters.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+#include "tcbspan/span.hpp"
 
 #define SUPPORT_USE_AGG_RASTERIZER
 
@@ -40,7 +60,6 @@
     #include <agg/agg_scanline_p.h>
     #include <agg/agg_rasterizer_scanline_aa.h>
     #include <agg/agg_path_storage.h>
-    #include "libslic3r/PNGReadWrite.hpp"
 #else
     #include "EdgeGrid.hpp"
 #endif // SUPPORT_USE_AGG_RASTERIZER
diff --git a/src/libslic3r/Support/SupportMaterial.hpp b/src/libslic3r/Support/SupportMaterial.hpp
index fb623266b6..f9e60481ab 100644
--- a/src/libslic3r/Support/SupportMaterial.hpp
+++ b/src/libslic3r/Support/SupportMaterial.hpp
@@ -6,12 +6,15 @@
 #ifndef slic3r_SupportMaterial_hpp_
 #define slic3r_SupportMaterial_hpp_
 
+#include <vector>
+
 #include "../Flow.hpp"
 #include "../PrintConfig.hpp"
 #include "../Slicing.hpp"
-
 #include "SupportLayer.hpp"
 #include "SupportParameters.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Support/SupportParameters.cpp b/src/libslic3r/Support/SupportParameters.cpp
index f932567bc3..b691a99f89 100644
--- a/src/libslic3r/Support/SupportParameters.cpp
+++ b/src/libslic3r/Support/SupportParameters.cpp
@@ -2,10 +2,15 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <algorithm>
+
 #include "../Print.hpp"
 #include "../PrintConfig.hpp"
 #include "../Slicing.hpp"
 #include "SupportParameters.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::FFFSupport {
 
diff --git a/src/libslic3r/Support/SupportParameters.hpp b/src/libslic3r/Support/SupportParameters.hpp
index aabdc013d2..fb07bcf6fa 100644
--- a/src/libslic3r/Support/SupportParameters.hpp
+++ b/src/libslic3r/Support/SupportParameters.hpp
@@ -5,12 +5,16 @@
 #ifndef slic3r_SupportParameters_hpp_
 #define slic3r_SupportParameters_hpp_
 
+#include <math.h>
+#include <stddef.h>
+
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Flow.hpp"
 
 namespace Slic3r {
 
 class PrintObject;
+
 enum InfillPattern : int;
 
 namespace FFFSupport {
diff --git a/src/libslic3r/Support/TreeModelVolumes.cpp b/src/libslic3r/Support/TreeModelVolumes.cpp
index 2e14e81f49..9fff0b971e 100644
--- a/src/libslic3r/Support/TreeModelVolumes.cpp
+++ b/src/libslic3r/Support/TreeModelVolumes.cpp
@@ -11,24 +11,31 @@
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "TreeModelVolumes.hpp"
-#include "TreeSupportCommon.hpp"
 
+#include <boost/log/trivial.hpp>
+#include <math.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/task_arena.h>
+#include <oneapi/tbb/task_group.h>
+#include <algorithm>
+#include <chrono>
+#include <limits>
+#include <numeric>
+#include <string>
+#include <unordered_map>
+
+#include "TreeSupportCommon.hpp"
 #include "../BuildVolume.hpp"
 #include "../ClipperUtils.hpp"
-#include "../Flow.hpp"
 #include "../Layer.hpp"
 #include "../Point.hpp"
 #include "../Print.hpp"
-#include "../PrintConfig.hpp"
 #include "../Utils.hpp"
 #include "../format.hpp"
-
-#include <string_view>
-
-#include <boost/log/trivial.hpp>
-
-#include <tbb/parallel_for.h>
-#include <tbb/task_group.h>
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r::FFFTreeSupport
 {
diff --git a/src/libslic3r/Support/TreeModelVolumes.hpp b/src/libslic3r/Support/TreeModelVolumes.hpp
index eeabccd55e..66e12076de 100644
--- a/src/libslic3r/Support/TreeModelVolumes.hpp
+++ b/src/libslic3r/Support/TreeModelVolumes.hpp
@@ -13,16 +13,23 @@
 #ifndef slic3r_TreeModelVolumes_hpp
 #define slic3r_TreeModelVolumes_hpp
 
+#include <boost/functional/hash.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <mutex>
 #include <unordered_map>
-
-#include <boost/functional/hash.hpp>
+#include <functional>
+#include <map>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include "TreeSupportCommon.hpp"
-
 #include "../Point.hpp"
 #include "../Polygon.hpp"
 #include "../PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r
 {
diff --git a/src/libslic3r/Support/TreeSupport.cpp b/src/libslic3r/Support/TreeSupport.cpp
index 3161c85cb6..e5aa62e9ae 100644
--- a/src/libslic3r/Support/TreeSupport.cpp
+++ b/src/libslic3r/Support/TreeSupport.cpp
@@ -11,10 +11,31 @@
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "TreeSupport.hpp"
+
+#include <stdio.h>
+#include <boost/log/trivial.hpp>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/partitioner.h>
+#include <oneapi/tbb/task_arena.h>
+#include <stdlib.h>
+#include <cassert>
+#include <chrono>
+#include <optional>
+#include <string_view>
+#include <cmath>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <numeric>
+#include <ratio>
+#include <tuple>
+#include <unordered_set>
+
 #include "TreeSupportCommon.hpp"
 #include "SupportCommon.hpp"
 #include "OrganicSupport.hpp"
-
 #include "../AABBTreeIndirect.hpp"
 #include "../BuildVolume.hpp"
 #include "../ClipperUtils.hpp"
@@ -25,18 +46,21 @@
 #include "../Polygon.hpp"
 #include "../Polyline.hpp"
 #include "../MutablePolygon.hpp"
-
-#include <cassert>
-#include <chrono>
-#include <fstream>
-#include <optional>
-#include <stdio.h>
-#include <string>
-#include <string_view>
-
-#include <boost/log/trivial.hpp>
-
-#include <tbb/parallel_for.h>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Support/SupportLayer.hpp"
+#include "libslic3r/Support/SupportParameters.hpp"
+#include "libslic3r/Support/TreeModelVolumes.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+#include "libslic3r/Utils.hpp"
 
 // #define TREESUPPORT_DEBUG_SVG
 
diff --git a/src/libslic3r/Support/TreeSupport.hpp b/src/libslic3r/Support/TreeSupport.hpp
index 76387146f7..451d54574b 100644
--- a/src/libslic3r/Support/TreeSupport.hpp
+++ b/src/libslic3r/Support/TreeSupport.hpp
@@ -13,15 +13,25 @@
 #ifndef slic3r_TreeSupport_hpp
 #define slic3r_TreeSupport_hpp
 
+#include <boost/container/small_vector.hpp>
+#include <stddef.h>
+#include <stdint.h>
+#include <boost/cstdint.hpp>
+#include <algorithm>
+#include <deque>
+#include <functional>
+#include <limits>
+#include <utility>
+#include <vector>
+
 #include "SupportLayer.hpp"
 #include "TreeModelVolumes.hpp"
 #include "TreeSupportCommon.hpp"
-
 #include "../BoundingBox.hpp"
 #include "../Point.hpp"
 #include "../Utils.hpp"
-
-#include <boost/container/small_vector.hpp>
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 
 // #define TREE_SUPPORT_SHOW_ERRORS
diff --git a/src/libslic3r/Support/TreeSupportCommon.cpp b/src/libslic3r/Support/TreeSupportCommon.cpp
index 711a91f0f0..02f1148a48 100644
--- a/src/libslic3r/Support/TreeSupportCommon.cpp
+++ b/src/libslic3r/Support/TreeSupportCommon.cpp
@@ -12,6 +12,13 @@
 
 #include "TreeSupportCommon.hpp"
 
+#include <stdio.h>
+#include <limits>
+
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Print.hpp"
+#include "libslic3r/Utils.hpp"
+
 namespace Slic3r::FFFTreeSupport {
 
 TreeSupportMeshGroupSettings::TreeSupportMeshGroupSettings(const PrintObject &print_object)
diff --git a/src/libslic3r/Support/TreeSupportCommon.hpp b/src/libslic3r/Support/TreeSupportCommon.hpp
index b3508ceac0..28d5d8dc37 100644
--- a/src/libslic3r/Support/TreeSupportCommon.hpp
+++ b/src/libslic3r/Support/TreeSupportCommon.hpp
@@ -13,11 +13,28 @@
 #ifndef slic3r_TreeSupportCommon_hpp
 #define slic3r_TreeSupportCommon_hpp
 
+#include <assert.h>
+#include <math.h>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <stddef.h>
+#include <string_view>
+#include <algorithm>
+#include <mutex>
+#include <utility>
+#include <vector>
+
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Polygon.hpp"
 #include "SupportCommon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Slicing.hpp"
+#include "libslic3r/Support/SupportLayer.hpp"
+#include "libslic3r/Support/SupportParameters.hpp"
 
-#include <string_view>
+namespace Slic3r {
+class PrintObject;
+}  // namespace Slic3r
 
 using namespace Slic3r::FFFSupport;
 
diff --git a/src/libslic3r/SupportSpotsGenerator.cpp b/src/libslic3r/SupportSpotsGenerator.cpp
index ddd2c0522e..629ddd6f93 100644
--- a/src/libslic3r/SupportSpotsGenerator.cpp
+++ b/src/libslic3r/SupportSpotsGenerator.cpp
@@ -5,6 +5,23 @@
 ///|/
 #include "SupportSpotsGenerator.hpp"
 
+#include <boost/log/trivial.hpp>
+#include <oneapi/tbb/concurrent_vector.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+#include <Eigen/Core>
+#include <iostream>
+#include <stdexcept>
+
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
 #include "ExtrusionEntity.hpp"
@@ -17,42 +34,24 @@
 #include "Print.hpp"
 #include "PrintBase.hpp"
 #include "PrintConfig.hpp"
-#include "Tesselate.hpp"
-#include "Utils.hpp"
 #include "libslic3r.h"
-#include "tbb/parallel_for.h"
-#include "tbb/blocked_range.h"
-#include "tbb/blocked_range2d.h"
-#include "tbb/parallel_reduce.h"
-#include <algorithm>
-#include <boost/log/trivial.hpp>
-#include <cmath>
-#include <cstddef>
-#include <cstdio>
-#include <functional>
-#include <limits>
-#include <math.h>
-#include <oneapi/tbb/concurrent_vector.h>
-#include <oneapi/tbb/parallel_for.h>
-#include <optional>
-#include <unordered_map>
-#include <unordered_set>
-#include <stack>
-#include <utility>
-#include <vector>
-
 #include "AABBTreeLines.hpp"
 #include "KDTreeIndirect.hpp"
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "Geometry/ConvexHull.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
 
 // #define DETAILED_DEBUG_LOGS
 // #define DEBUG_FILES
 
 #ifdef DEBUG_FILES
 #include <boost/nowide/cstdio.hpp>
+
 #include "libslic3r/Color.hpp"
+
 constexpr bool debug_files = true;
 #else
 constexpr bool debug_files = false;
diff --git a/src/libslic3r/SupportSpotsGenerator.hpp b/src/libslic3r/SupportSpotsGenerator.hpp
index 07f264e7da..1f7e811e09 100644
--- a/src/libslic3r/SupportSpotsGenerator.hpp
+++ b/src/libslic3r/SupportSpotsGenerator.hpp
@@ -5,15 +5,31 @@
 #ifndef SRC_LIBSLIC3R_SUPPORTABLEISSUESSEARCH_HPP_
 #define SRC_LIBSLIC3R_SUPPORTABLEISSUESSEARCH_HPP_
 
+#include <boost/log/trivial.hpp>
+#include <cstddef>
+#include <vector>
+#include <algorithm>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <utility>
+
 #include "Layer.hpp"
 #include "Line.hpp"
 #include "PrintBase.hpp"
 #include "PrintConfig.hpp"
-#include <boost/log/trivial.hpp>
-#include <cstddef>
-#include <vector>
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
+class ExtrusionEntity;
+class ExtrusionEntityCollection;
+class Layer;
+class PrintObject;
+class SupportLayer;
 
 namespace SupportSpotsGenerator {
 
diff --git a/src/libslic3r/Surface.cpp b/src/libslic3r/Surface.cpp
index 46c49b2012..fbecc33118 100644
--- a/src/libslic3r/Surface.cpp
+++ b/src/libslic3r/Surface.cpp
@@ -11,6 +11,8 @@
 #include "BoundingBox.hpp"
 #include "Surface.hpp"
 #include "SVG.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Surface.hpp b/src/libslic3r/Surface.hpp
index 63b7f88019..5aba2309cd 100644
--- a/src/libslic3r/Surface.hpp
+++ b/src/libslic3r/Surface.hpp
@@ -11,8 +11,17 @@
 #ifndef slic3r_Surface_hpp_
 #define slic3r_Surface_hpp_
 
+#include <stddef.h>
+#include <algorithm>
+#include <iterator>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SurfaceCollection.cpp b/src/libslic3r/SurfaceCollection.cpp
index 88c3eaae73..2188d8339c 100644
--- a/src/libslic3r/SurfaceCollection.cpp
+++ b/src/libslic3r/SurfaceCollection.cpp
@@ -5,10 +5,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "SurfaceCollection.hpp"
+
+#include <stdio.h>
+#include <algorithm>
+
 #include "BoundingBox.hpp"
 #include "SVG.hpp"
-
-#include <map>
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Surface.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/SurfaceCollection.hpp b/src/libslic3r/SurfaceCollection.hpp
index 988f41c980..03d79909ed 100644
--- a/src/libslic3r/SurfaceCollection.hpp
+++ b/src/libslic3r/SurfaceCollection.hpp
@@ -6,10 +6,15 @@
 #ifndef slic3r_SurfaceCollection_hpp_
 #define slic3r_SurfaceCollection_hpp_
 
-#include "libslic3r.h"
-#include "Surface.hpp"
+#include <stddef.h>
 #include <initializer_list>
 #include <vector>
+#include <utility>
+
+#include "libslic3r.h"
+#include "Surface.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Tesselate.cpp b/src/libslic3r/Tesselate.cpp
index 2a86896078..b802c4133b 100644
--- a/src/libslic3r/Tesselate.cpp
+++ b/src/libslic3r/Tesselate.cpp
@@ -4,9 +4,17 @@
 ///|/
 #include "Tesselate.hpp"
 
-#include "ExPolygon.hpp"
-
 #include <glu-libtess.h>
+#include <assert.h>
+#include <string.h>
+#include <algorithm>
+#include <deque>
+#include <utility>
+
+#include "ExPolygon.hpp"
+#include "admesh/stl.h"
+
+class GLUtesselator;
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Tesselate.hpp b/src/libslic3r/Tesselate.hpp
index f324b5c3d7..baf8c4beb9 100644
--- a/src/libslic3r/Tesselate.hpp
+++ b/src/libslic3r/Tesselate.hpp
@@ -5,10 +5,13 @@
 #ifndef slic3r_Tesselate_hpp_
 #define slic3r_Tesselate_hpp_
 
-#include <vector>
 #include <admesh/stl.h>
+#include <vector>
 
 #include "ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Thread.cpp b/src/libslic3r/Thread.cpp
index 36012c576f..b5e61ad724 100644
--- a/src/libslic3r/Thread.cpp
+++ b/src/libslic3r/Thread.cpp
@@ -13,12 +13,16 @@
 	#endif // __APPLE__
 #endif
 
-#include <atomic>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/task_arena.h>
+#include <stddef.h>
 #include <condition_variable>
 #include <mutex>
 #include <thread>
-#include <tbb/parallel_for.h>
-#include <tbb/task_arena.h>
+#include <algorithm>
+#include <ostream>
 
 #include "Thread.hpp"
 #include "Utils.hpp"
diff --git a/src/libslic3r/Thread.hpp b/src/libslic3r/Thread.hpp
index 7bcf5cc926..8daa384a10 100644
--- a/src/libslic3r/Thread.hpp
+++ b/src/libslic3r/Thread.hpp
@@ -5,14 +5,16 @@
 #ifndef GUI_THREAD_HPP
 #define GUI_THREAD_HPP
 
+#include <boost/thread.hpp>
+#include <tbb/task_scheduler_observer.h>
+#include <tbb/enumerable_thread_specific.h>
+#include <oneapi/tbb/task_scheduler_observer.h>
+#include <boost/thread/thread.hpp>
 #include <utility>
 #include <string>
 #include <thread>
 #include <random>
-#include <boost/thread.hpp>
-
-#include <tbb/task_scheduler_observer.h>
-#include <tbb/enumerable_thread_specific.h>
+#include <optional>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Time.cpp b/src/libslic3r/Time.cpp
index 53b2588f74..e987d8e28a 100644
--- a/src/libslic3r/Time.cpp
+++ b/src/libslic3r/Time.cpp
@@ -4,12 +4,11 @@
 ///|/
 #include "Time.hpp"
 
-#include <iomanip>
 #include <sstream>
 #include <chrono>
 #include <cassert>
 #include <ctime>
-#include <cstdio>
+#include <locale>
 
 #ifdef _MSC_VER
 #include <map>
diff --git a/src/libslic3r/Timer.hpp b/src/libslic3r/Timer.hpp
index 2fd63f234e..43e7bf0c30 100644
--- a/src/libslic3r/Timer.hpp
+++ b/src/libslic3r/Timer.hpp
@@ -5,8 +5,10 @@
 #ifndef libslic3r_Timer_hpp_
 #define libslic3r_Timer_hpp_
 
+#include <stdint.h>
 #include <string>
 #include <chrono>
+#include <string_view>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/TriangleMesh.cpp b/src/libslic3r/TriangleMesh.cpp
index 26264de916..12224aa91a 100644
--- a/src/libslic3r/TriangleMesh.cpp
+++ b/src/libslic3r/TriangleMesh.cpp
@@ -13,7 +13,31 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "Exception.hpp"
+#include <libqhullcpp/Qhull.h>
+#include <libqhullcpp/QhullFacetList.h>
+#include <libqhullcpp/QhullVertexSet.h>
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/cstdio.hpp>
+#include <boost/predef/other/endian.h>
+#include <assert.h>
+#include <libqhull_r/user_r.h>
+#include <libqhullcpp/QhullFacet.h>
+#include <libqhullcpp/QhullPoint.h>
+#include <libqhullcpp/QhullVertex.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/concurrent_vector.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cmath>
+#include <vector>
+#include <utility>
+#include <algorithm>
+#include <Eigen/Core>
+#include <iterator>
+#include <map>
+
 #include "TriangleMesh.hpp"
 #include "TriangleMeshSlicer.hpp"
 #include "MeshSplitImpl.hpp"
@@ -24,29 +48,10 @@
 #include "Execution/ExecutionTBB.hpp"
 #include "Execution/ExecutionSeq.hpp"
 #include "Utils.hpp"
-
-#include <libqhullcpp/Qhull.h>
-#include <libqhullcpp/QhullFacetList.h>
-#include <libqhullcpp/QhullVertexSet.h>
-
-#include <cmath>
-#include <deque>
-#include <queue>
-#include <vector>
-#include <utility>
-#include <algorithm>
-#include <type_traits>
-
-#include <boost/log/trivial.hpp>
-#include <boost/nowide/cstdio.hpp>
-#include <boost/predef/other/endian.h>
-
-#include <tbb/concurrent_vector.h>
-
-#include <Eigen/Core>
-#include <Eigen/Dense>
-
-#include <assert.h>
+#include "admesh/stl.h"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/TriangleMesh.hpp b/src/libslic3r/TriangleMesh.hpp
index 76f9d9c09b..176c39abb6 100644
--- a/src/libslic3r/TriangleMesh.hpp
+++ b/src/libslic3r/TriangleMesh.hpp
@@ -12,10 +12,18 @@
 #ifndef slic3r_TriangleMesh_hpp_
 #define slic3r_TriangleMesh_hpp_
 
-#include "libslic3r.h"
 #include <admesh/stl.h>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <cereal/cereal.hpp>
 #include <functional>
 #include <vector>
+#include <Eigen/Geometry>
+#include <array>
+#include <utility>
+
+#include "libslic3r.h"
 #include "BoundingBox.hpp"
 #include "Line.hpp"
 #include "Point.hpp"
@@ -385,6 +393,7 @@ inline BoundingBoxf3 bounding_box(const indexed_triangle_set& its, const Transfo
 
 // Serialization through the Cereal library
 #include <cereal/access.hpp>
+
 namespace cereal {
     template <class Archive> struct specialize<Archive, Slic3r::TriangleMesh, cereal::specialization::non_member_load_save> {};
     template<class Archive> void load(Archive &archive, Slic3r::TriangleMesh &mesh) {
diff --git a/src/libslic3r/TriangleMeshSlicer.cpp b/src/libslic3r/TriangleMeshSlicer.cpp
index 6a1c412147..2a07085a15 100644
--- a/src/libslic3r/TriangleMeshSlicer.cpp
+++ b/src/libslic3r/TriangleMeshSlicer.cpp
@@ -2,31 +2,33 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/log/trivial.hpp>
+#include <ankerl/unordered_dense.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <algorithm>
+#include <cmath>
+#include <mutex>
+#include <utility>
+#include <Eigen/Geometry>
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
 #include "ClipperUtils.hpp"
-#include "Geometry.hpp"
 #include "Tesselate.hpp"
 #include "TriangleMesh.hpp"
 #include "TriangleMeshSlicer.hpp"
 #include "Utils.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <deque>
-#include <queue>
-#include <mutex>
-#include <new>
-#include <utility>
-
-#include <boost/log/trivial.hpp>
-
-#include <tbb/parallel_for.h>
-#include <tbb/scalable_allocator.h>
-
-#include <ankerl/unordered_dense.h>
-
-#ifndef NDEBUG
-//    #define EXPENSIVE_DEBUG_CHECKS
-#endif // NDEBUG
+#include "admesh/stl.h"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/MultiPoint.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 #if 0
     #define DEBUG
@@ -37,7 +39,6 @@
 #endif
 
 #include <assert.h>
-#include <boost/thread/mutex.hpp>
 #include <boost/thread/lock_guard.hpp>
 
 #if defined(__cpp_lib_hardware_interference_size) && ! defined(__APPLE__)
diff --git a/src/libslic3r/TriangleMeshSlicer.hpp b/src/libslic3r/TriangleMeshSlicer.hpp
index a7ad62acd9..9d9a9e0183 100644
--- a/src/libslic3r/TriangleMeshSlicer.hpp
+++ b/src/libslic3r/TriangleMeshSlicer.hpp
@@ -5,10 +5,16 @@
 #ifndef slic3r_TriangleMeshSlicer_hpp_
 #define slic3r_TriangleMeshSlicer_hpp_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <functional>
 #include <vector>
+
 #include "Polygon.hpp"
 #include "ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+
+struct indexed_triangle_set;
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/TriangleSelector.cpp b/src/libslic3r/TriangleSelector.cpp
index 465160a449..29188a23cf 100644
--- a/src/libslic3r/TriangleSelector.cpp
+++ b/src/libslic3r/TriangleSelector.cpp
@@ -3,13 +3,18 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "TriangleSelector.hpp"
-#include "Model.hpp"
 
 #include <boost/container/small_vector.hpp>
+#include <string.h>
+#include <boost/container/vector.hpp>
+#include <cmath>
+#include <queue>
 
-#ifndef NDEBUG
-//    #define EXPENSIVE_DEBUG_CHECKS
-#endif // NDEBUG
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/TriangleSelector.hpp b/src/libslic3r/TriangleSelector.hpp
index 0e88fe3a7c..541f686bf6 100644
--- a/src/libslic3r/TriangleSelector.hpp
+++ b/src/libslic3r/TriangleSelector.hpp
@@ -8,11 +8,26 @@
 // #define PRUSASLICER_TRIANGLE_SELECTOR_DEBUG
 
 
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <cfloat>
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <utility>
+#include <vector>
+
 #include "Point.hpp"
 #include "TriangleMesh.hpp"
+#include "admesh/stl.h"
+
+namespace cereal {
+class access;
+}  // namespace cereal
 
 namespace Slic3r {
+class TriangleMesh;
 
 enum class TriangleStateType : int8_t {
     // Maximum is 3. The value is serialized in TriangleSelector into 2 bits.
diff --git a/src/libslic3r/TriangleSelectorWrapper.cpp b/src/libslic3r/TriangleSelectorWrapper.cpp
index 517170ed60..cf9ecad6ff 100644
--- a/src/libslic3r/TriangleSelectorWrapper.cpp
+++ b/src/libslic3r/TriangleSelectorWrapper.cpp
@@ -3,7 +3,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "TriangleSelectorWrapper.hpp"
+
+#include <igl/Hit.h>
 #include <memory>
+#include <utility>
+#include <vector>
+
+#include "admesh/stl.h"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/TriangleSelector.hpp"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/TriangleSelectorWrapper.hpp b/src/libslic3r/TriangleSelectorWrapper.hpp
index 226a3019e8..3dbf91fd9c 100644
--- a/src/libslic3r/TriangleSelectorWrapper.hpp
+++ b/src/libslic3r/TriangleSelectorWrapper.hpp
@@ -8,8 +8,10 @@
 #include "TriangleSelector.hpp"
 #include "Model.hpp"
 #include "AABBTreeIndirect.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
+class TriangleMesh;
 
 //NOTE: We need to replace the FacetsAnnotation struct for support storage (or extend/add another)
 // Problems: Does not support negative volumes, strange usage for supports computed from extrusion -
diff --git a/src/libslic3r/TriangleSetSampling.cpp b/src/libslic3r/TriangleSetSampling.cpp
index dd968fce77..ea7191f88d 100644
--- a/src/libslic3r/TriangleSetSampling.cpp
+++ b/src/libslic3r/TriangleSetSampling.cpp
@@ -3,11 +3,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "TriangleSetSampling.hpp"
+
+#include <boost/random/uniform_real_distribution.hpp>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
 #include <map>
 #include <random>
-#include <tbb/parallel_for.h>
-#include <tbb/blocked_range.h>
-#include <boost/random/uniform_real_distribution.hpp>
+#include <algorithm>
+#include <cmath>
+
+#include "admesh/stl.h"
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/TriangleSetSampling.hpp b/src/libslic3r/TriangleSetSampling.hpp
index 54110bcfae..002f4fc955 100644
--- a/src/libslic3r/TriangleSetSampling.hpp
+++ b/src/libslic3r/TriangleSetSampling.hpp
@@ -6,8 +6,13 @@
 #define SRC_LIBSLIC3R_TRIANGLESETSAMPLING_HPP_
 
 #include <admesh/stl.h>
+#include <stddef.h>
+#include <vector>
+
 #include "libslic3r/Point.hpp"
 
+struct indexed_triangle_set;
+
 namespace Slic3r {
 
 struct TriangleSetSamples {
diff --git a/src/libslic3r/Triangulation.cpp b/src/libslic3r/Triangulation.cpp
index c75a531973..22befe2628 100644
--- a/src/libslic3r/Triangulation.cpp
+++ b/src/libslic3r/Triangulation.cpp
@@ -3,11 +3,24 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Triangulation.hpp"
-#include "IntersectionPoints.hpp"
+
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Constrained_Delaunay_triangulation_2.h>
 #include <CGAL/Triangulation_vertex_base_with_info_2.h>
 #include <CGAL/spatial_sort.h>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <boost/variant/get.hpp>
+#include <limits>
+
+#include "IntersectionPoints.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 using namespace Slic3r;
 namespace priv{
@@ -73,6 +86,7 @@ inline bool has_self_intersection(
 //#define VISUALIZE_TRIANGULATION
 #ifdef VISUALIZE_TRIANGULATION
 #include "admesh/stl.h" // indexed triangle set
+
 static void visualize(const Points                 &points,
                const Triangulation::Indices &indices,
                const char                   *filename)
diff --git a/src/libslic3r/Triangulation.hpp b/src/libslic3r/Triangulation.hpp
index 1fb7b67824..e73613215b 100644
--- a/src/libslic3r/Triangulation.hpp
+++ b/src/libslic3r/Triangulation.hpp
@@ -5,11 +5,13 @@
 #ifndef libslic3r_Triangulation_hpp_
 #define libslic3r_Triangulation_hpp_
 
-#include <vector>
-#include <set>
 #include <libslic3r/Point.hpp>
 #include <libslic3r/Polygon.hpp>
 #include <libslic3r/ExPolygon.hpp>
+#include <vector>
+#include <set>
+#include <cstdint>
+#include <utility>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Utils/JsonUtils.cpp b/src/libslic3r/Utils/JsonUtils.cpp
index e4f4710b7c..50d70cff9b 100644
--- a/src/libslic3r/Utils/JsonUtils.cpp
+++ b/src/libslic3r/Utils/JsonUtils.cpp
@@ -1,6 +1,9 @@
 #include "JsonUtils.hpp"
+
 #include <boost/algorithm/string/replace.hpp>
+#include <boost/property_tree/json_parser.hpp>
 #include <regex>
+#include <sstream>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Utils/JsonUtils.hpp b/src/libslic3r/Utils/JsonUtils.hpp
index 08745a620c..faaddff747 100644
--- a/src/libslic3r/Utils/JsonUtils.hpp
+++ b/src/libslic3r/Utils/JsonUtils.hpp
@@ -2,6 +2,8 @@
 #define slic3r_JsonUtils_hpp_
 
 #include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree_fwd.hpp>
+#include <string>
 
 namespace Slic3r {
 
diff --git a/src/libslic3r/Zipper.cpp b/src/libslic3r/Zipper.cpp
index 4a418c823a..eef8007ef5 100644
--- a/src/libslic3r/Zipper.cpp
+++ b/src/libslic3r/Zipper.cpp
@@ -2,13 +2,14 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <exception>
+#include <boost/log/trivial.hpp>
+#include <string.h>
 
 #include "Exception.hpp"
 #include "Zipper.hpp"
 #include "miniz_extension.hpp"
-#include <boost/log/trivial.hpp>
 #include "I18N.hpp"
+#include "miniz.h"
 
 #if defined(_MSC_VER) &&  _MSC_VER <= 1800 || __cplusplus < 201103L
     #define SLIC3R_NORETURN
diff --git a/src/libslic3r/Zipper.hpp b/src/libslic3r/Zipper.hpp
index 9301d92867..cb581fe9d1 100644
--- a/src/libslic3r/Zipper.hpp
+++ b/src/libslic3r/Zipper.hpp
@@ -5,9 +5,12 @@
 #ifndef ZIPPER_HPP
 #define ZIPPER_HPP
 
+#include <stddef.h>
 #include <cstdint>
 #include <string>
 #include <memory>
+#include <type_traits>
+#include <utility>
 
 namespace Slic3r {
 
@@ -23,6 +26,7 @@ public:
 
 private:
     class Impl;
+
     std::unique_ptr<Impl> m_impl;
     std::string m_data;
     std::string m_entry;
diff --git a/src/libslic3r/miniz_extension.cpp b/src/libslic3r/miniz_extension.cpp
index 5c31ee0af2..01a23fd6b2 100644
--- a/src/libslic3r/miniz_extension.cpp
+++ b/src/libslic3r/miniz_extension.cpp
@@ -2,9 +2,10 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <exception>
+#include <stdio.h>
 
 #include "miniz_extension.hpp"
+#include "miniz.h"
 
 #if defined(_MSC_VER) || defined(__MINGW64__)
 #include "boost/nowide/cstdio.hpp"
diff --git a/src/slic3r/GUI/CameraUtils.cpp b/src/slic3r/GUI/CameraUtils.cpp
index 08fcc24aae..032a476247 100644
--- a/src/slic3r/GUI/CameraUtils.cpp
+++ b/src/slic3r/GUI/CameraUtils.cpp
@@ -3,11 +3,23 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "CameraUtils.hpp"
+
 #include <igl/project.h> // IWYU pragma: keep
 #include <igl/unproject.h> // IWYU pragma: keep
+#include <assert.h>
+#include <math.h>
+#include <stddef.h>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <limits>
 
 #include "slic3r/GUI/3DScene.hpp" // GLVolume
 #include "libslic3r/Geometry/ConvexHull.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "slic3r/GUI/Camera.hpp"
+#include "slic3r/GUI/GLModel.hpp"
 
 using namespace Slic3r;
 using namespace GUI;
diff --git a/src/slic3r/GUI/CameraUtils.hpp b/src/slic3r/GUI/CameraUtils.hpp
index eb09d2cefd..6f67b40aee 100644
--- a/src/slic3r/GUI/CameraUtils.hpp
+++ b/src/slic3r/GUI/CameraUtils.hpp
@@ -5,10 +5,17 @@
 #ifndef slic3r_CameraUtils_hpp_
 #define slic3r_CameraUtils_hpp_
 
+#include <vector>
+
 #include "Camera.hpp"
 #include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+
 namespace Slic3r {
 class GLVolume;
+namespace GUI {
+struct Camera;
+}  // namespace GUI
 }
 	
 namespace Slic3r::GUI {
diff --git a/src/slic3r/GUI/DoubleSliderForGcode.cpp b/src/slic3r/GUI/DoubleSliderForGcode.cpp
index 6704f8d1c0..aa65445a03 100644
--- a/src/slic3r/GUI/DoubleSliderForGcode.cpp
+++ b/src/slic3r/GUI/DoubleSliderForGcode.cpp
@@ -5,6 +5,8 @@
 
 #include "DoubleSliderForGcode.hpp"
 
+#include <algorithm>
+
 namespace DoubleSlider {
 
 static const float LEFT_MARGIN             = 13.0f + 100.0f;  // avoid thumbnail toolbar
diff --git a/src/slic3r/GUI/DoubleSliderForLayers.cpp b/src/slic3r/GUI/DoubleSliderForLayers.cpp
index 2f068671a0..42e6ae85f1 100644
--- a/src/slic3r/GUI/DoubleSliderForLayers.cpp
+++ b/src/slic3r/GUI/DoubleSliderForLayers.cpp
@@ -4,16 +4,26 @@
 ///|/
 #include "DoubleSliderForLayers.hpp"
 
-#include "libslic3r/Utils.hpp"  // -> get_time_dhms()
-#include "libslic3r/format.hpp" // -> format()
-#include "I18N.hpp"
-
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
+#include <stdio.h>
+#include <boost/algorithm/string/constants.hpp>
+#include <boost/format.hpp>
 #include <cmath>
+#include <algorithm>
+#include <array>
+#include <set>
 
+#include "libslic3r/Utils.hpp"  // -> get_time_dhms()
+#include "libslic3r/format.hpp" // -> format()
+#include "I18N.hpp"
 #include "ImGuiWrapper.hpp"
+#include "libslic3r/libslic3r.h"
+#include "slic3r/GUI/ImGuiDoubleSlider.hpp"
+#include "slic3r/GUI/ImGuiPureWrap.hpp"
+#include "slic3r/GUI/RulerForDoubleSlider.hpp"
+#include "slic3r/GUI/TickCodesManager.hpp"
 
 #ifndef IMGUI_DEFINE_MATH_OPERATORS
 #define IMGUI_DEFINE_MATH_OPERATORS
diff --git a/src/slic3r/GUI/DoubleSliderForLayers.hpp b/src/slic3r/GUI/DoubleSliderForLayers.hpp
index e25543a33e..cce1b84d33 100644
--- a/src/slic3r/GUI/DoubleSliderForLayers.hpp
+++ b/src/slic3r/GUI/DoubleSliderForLayers.hpp
@@ -5,12 +5,17 @@
 #ifndef slic3r_GUI_DoubleSliderForLayers_hpp_
 #define slic3r_GUI_DoubleSliderForLayers_hpp_
 
+#include <vector>
+#include <set>
+#include <functional>
+#include <string>
+
 #include "ImGuiDoubleSlider.hpp"
 #include "RulerForDoubleSlider.hpp"
 #include "TickCodesManager.hpp"
+#include "libslic3r/CustomGCode.hpp"
 
-#include <vector>
-#include <set>
+struct ImVec2;
 
 namespace Slic3r {
 class Print;
diff --git a/src/slic3r/GUI/GLShader.cpp b/src/slic3r/GUI/GLShader.cpp
index 8863c3e4fc..8521d533d6 100644
--- a/src/slic3r/GUI/GLShader.cpp
+++ b/src/slic3r/GUI/GLShader.cpp
@@ -5,20 +5,19 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/libslic3r.h"
-#include "GLShader.hpp"
+#include <boost/nowide/fstream.hpp>
+#include <GL/glew.h>
+#include <boost/log/trivial.hpp>
+#include <string.h>
+#include <cassert>
+#include <algorithm>
 
+#include "GLShader.hpp"
 #include "3DScene.hpp"
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/format.hpp"
 #include "libslic3r/Color.hpp"
 
-#include <boost/nowide/fstream.hpp>
-#include <GL/glew.h>
-#include <cassert>
-
-#include <boost/log/trivial.hpp>
-
 namespace Slic3r {
 
 GLShaderProgram::~GLShaderProgram()
diff --git a/src/slic3r/GUI/GLShader.hpp b/src/slic3r/GUI/GLShader.hpp
index ea8d01d45b..238365b00e 100644
--- a/src/slic3r/GUI/GLShader.hpp
+++ b/src/slic3r/GUI/GLShader.hpp
@@ -8,9 +8,13 @@
 #ifndef slic3r_GLShader_hpp_
 #define slic3r_GLShader_hpp_
 
+#include <stddef.h>
 #include <array>
 #include <string>
 #include <string_view>
+#include <initializer_list>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/Point.hpp"
 
diff --git a/src/slic3r/GUI/GUI_Geometry.cpp b/src/slic3r/GUI/GUI_Geometry.cpp
index 3cee023e12..240382f330 100644
--- a/src/slic3r/GUI/GUI_Geometry.cpp
+++ b/src/slic3r/GUI/GUI_Geometry.cpp
@@ -2,12 +2,4 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/libslic3r.h"
 #include "GUI_Geometry.hpp"
-
-namespace Slic3r {
-namespace GUI {
-
-
-} // namespace Slic3r
-} // namespace GUI
diff --git a/src/slic3r/GUI/I18N.hpp b/src/slic3r/GUI/I18N.hpp
index 562b652718..c39e2743db 100644
--- a/src/slic3r/GUI/I18N.hpp
+++ b/src/slic3r/GUI/I18N.hpp
@@ -2,6 +2,10 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <wx/strconv.h>
+#include <wx/string.h>
+#include <wx/translation.h>
+#include <string>
 #ifndef _
 #define _(s)    	Slic3r::GUI::I18N::translate((s))
 #define _L(s)    	Slic3r::GUI::I18N::translate((s))
diff --git a/src/slic3r/GUI/ImGuiDoubleSlider.cpp b/src/slic3r/GUI/ImGuiDoubleSlider.cpp
index 614ec759c1..7ad9dcd368 100644
--- a/src/slic3r/GUI/ImGuiDoubleSlider.cpp
+++ b/src/slic3r/GUI/ImGuiDoubleSlider.cpp
@@ -5,6 +5,10 @@
 
 #include "ImGuiDoubleSlider.hpp"
 
+#include <algorithm>
+
+#include "slic3r/GUI/ImGuiPureWrap.hpp"
+
 namespace DoubleSlider {
 
 const ImU32 tooltip_bg_clr  = ImGui::ColorConvertFloat4ToU32(ImGuiPureWrap::COL_GREY_LIGHT);
diff --git a/src/slic3r/GUI/ImGuiDoubleSlider.hpp b/src/slic3r/GUI/ImGuiDoubleSlider.hpp
index a7ad879d39..e747139c99 100644
--- a/src/slic3r/GUI/ImGuiDoubleSlider.hpp
+++ b/src/slic3r/GUI/ImGuiDoubleSlider.hpp
@@ -9,9 +9,13 @@
 #ifndef IMGUI_DEFINE_MATH_OPERATORS
 #define IMGUI_DEFINE_MATH_OPERATORS
 #endif
-#include "imgui/imgui_internal.h"
-
 #include <sstream>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "imgui/imgui_internal.h"
 
 // this code is borrowed from https://stackoverflow.com/questions/16605967/set-precision-of-stdto-string-when-converting-floating-point-values
 template <typename T>
diff --git a/src/slic3r/GUI/ImGuiPureWrap.cpp b/src/slic3r/GUI/ImGuiPureWrap.cpp
index 41ce243b1f..abcad86063 100644
--- a/src/slic3r/GUI/ImGuiPureWrap.cpp
+++ b/src/slic3r/GUI/ImGuiPureWrap.cpp
@@ -7,11 +7,17 @@
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/nowide/convert.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #ifndef IMGUI_DEFINE_MATH_OPERATORS
 #define IMGUI_DEFINE_MATH_OPERATORS
 #endif
 #include <imgui/imgui_internal.h>
+#include <algorithm>
+#include <cmath>
+#include <limits>
 
 namespace ImGuiPureWrap {
 
diff --git a/src/slic3r/GUI/ImGuiPureWrap.hpp b/src/slic3r/GUI/ImGuiPureWrap.hpp
index e883d6cce5..c2d586c929 100644
--- a/src/slic3r/GUI/ImGuiPureWrap.hpp
+++ b/src/slic3r/GUI/ImGuiPureWrap.hpp
@@ -5,6 +5,7 @@
 #ifndef slic3r_ImGuiPureWrap_hpp_
 #define slic3r_ImGuiPureWrap_hpp_
 
+#include <imgui/imgui.h>
 #include <functional>
 #include <string>
 #include <string_view>
@@ -12,8 +13,6 @@
 #include <optional>
 #include <functional>
 
-#include <imgui/imgui.h>
-
 struct IMGUI_API ImGuiWindow;
 
 namespace ImGuiPureWrap 
diff --git a/src/slic3r/GUI/Jobs/BoostThreadWorker.cpp b/src/slic3r/GUI/Jobs/BoostThreadWorker.cpp
index c390d4e3e2..f5a1c027fd 100644
--- a/src/slic3r/GUI/Jobs/BoostThreadWorker.cpp
+++ b/src/slic3r/GUI/Jobs/BoostThreadWorker.cpp
@@ -2,9 +2,14 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <boost/chrono/duration.hpp>
+#include <boost/variant/get.hpp>
 #include <exception>
 
 #include "BoostThreadWorker.hpp"
+#include "libslic3r/Thread.hpp"
+#include "slic3r/GUI/Jobs/ProgressIndicator.hpp"
+#include "slic3r/GUI/Jobs/ThreadSafeQueue.hpp"
 
 namespace Slic3r { namespace GUI {
 
diff --git a/src/slic3r/GUI/Jobs/BoostThreadWorker.hpp b/src/slic3r/GUI/Jobs/BoostThreadWorker.hpp
index 3d11097e2a..ea5198451e 100644
--- a/src/slic3r/GUI/Jobs/BoostThreadWorker.hpp
+++ b/src/slic3r/GUI/Jobs/BoostThreadWorker.hpp
@@ -6,13 +6,26 @@
 #define BOOSTTHREADWORKER_HPP
 
 #include <boost/variant.hpp>
-
-#include "Worker.hpp"
-
 #include <libslic3r/Thread.hpp>
 #include <boost/log/trivial.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/variant/variant.hpp>
+#include <atomic>
+#include <deque>
+#include <exception>
+#include <functional>
+#include <future>
+#include <memory>
+#include <string>
+#include <utility>
 
+#include "Worker.hpp"
 #include "ThreadSafeQueue.hpp"
+#include "slic3r/GUI/Jobs/Job.hpp"
+
+namespace Slic3r {
+class ProgressIndicator;
+}  // namespace Slic3r
 
 namespace Slic3r { namespace GUI {
 
diff --git a/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.cpp b/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.cpp
index cecdac10fa..5cd9ae9a8e 100644
--- a/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.cpp
+++ b/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.cpp
@@ -2,13 +2,33 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stdint.h>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <iterator>
+
 #include "libslic3r/libslic3r.h"
 #include "LibVGCodeWrapper.hpp"
-
 #include "libslic3r/Print.hpp"
 #include "libslic3r/Color.hpp"
+#include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/GCode/WipeTower.hpp"
+#include "libslic3r/Layer.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libvgcode/GCodeInputData.hpp"
+#include "libvgcode/PathVertex.hpp"
 
 namespace libvgcode {
+class Viewer;
 
 Vec3 convert(const Slic3r::Vec3f& v)
 {
diff --git a/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.hpp b/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.hpp
index 1f2f38f8e8..447b85b20b 100644
--- a/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.hpp
+++ b/src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.hpp
@@ -5,20 +5,30 @@
 #ifndef slic3r_LibVGCodeWrapper_hpp_
 #define slic3r_LibVGCodeWrapper_hpp_
 
-#include "libslic3r/Color.hpp"
-#include "libslic3r/GCode/GCodeProcessor.hpp"
-#include "slic3r/GUI/GUI_Preview.hpp"
-
 #include <libvgcode/Viewer.hpp>
 #include <libvgcode/PathVertex.hpp>
 #include <libvgcode/GCodeInputData.hpp>
 #include <libvgcode/ColorRange.hpp>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "libslic3r/Color.hpp"
+#include "libslic3r/GCode/GCodeProcessor.hpp"
+#include "slic3r/GUI/GUI_Preview.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Point.hpp"
+#include "libvgcode/Types.hpp"
 
 namespace Slic3r {
 class Print;
+namespace CustomGCode {
+struct Item;
+}  // namespace CustomGCode
 } // namespace Slic3r
 
 namespace libvgcode {
+class Viewer;
 
 // mapping from Slic3r::Vec3f to libvgcode::Vec3
 extern Vec3 convert(const Slic3r::Vec3f& v);
diff --git a/src/slic3r/GUI/RulerForDoubleSlider.hpp b/src/slic3r/GUI/RulerForDoubleSlider.hpp
index 90a7bf72b5..afdf70ff34 100644
--- a/src/slic3r/GUI/RulerForDoubleSlider.hpp
+++ b/src/slic3r/GUI/RulerForDoubleSlider.hpp
@@ -5,6 +5,7 @@
 #ifndef slic3r_GUI_RulerForDoubleSlider_hpp_
 #define slic3r_GUI_RulerForDoubleSlider_hpp_
 
+#include <stddef.h>
 #include <vector>
 #include <set>
 
diff --git a/src/slic3r/GUI/TickCodesManager.cpp b/src/slic3r/GUI/TickCodesManager.cpp
index c0bdfc563a..b11a409547 100644
--- a/src/slic3r/GUI/TickCodesManager.cpp
+++ b/src/slic3r/GUI/TickCodesManager.cpp
@@ -4,9 +4,18 @@
 ///|/
 #include "TickCodesManager.hpp"
 
+#include <math.h>
+#include <algorithm>
+#include <random>
+
 #include "I18N.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/Color.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/GCode/ToolOrdering.hpp"
+#include "libslic3r/Layer.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
 using namespace Slic3r;
 using namespace CustomGCode;
diff --git a/src/slic3r/GUI/TickCodesManager.hpp b/src/slic3r/GUI/TickCodesManager.hpp
index 5c055472b7..c736545a22 100644
--- a/src/slic3r/GUI/TickCodesManager.hpp
+++ b/src/slic3r/GUI/TickCodesManager.hpp
@@ -5,12 +5,14 @@
 #ifndef slic3r_GUI_TickCodesManager_hpp_
 #define slic3r_GUI_TickCodesManager_hpp_
 
-#include "libslic3r/CustomGCode.hpp"
-
+#include <stddef.h>
 #include <array>
 #include <functional>
 #include <vector>
 #include <set>
+#include <string>
+
+#include "libslic3r/CustomGCode.hpp"
 
 using namespace Slic3r::CustomGCode;
 namespace Slic3r {
diff --git a/src/slic3r/GUI/Widgets/BitmapToggleButton.cpp b/src/slic3r/GUI/Widgets/BitmapToggleButton.cpp
index ccb6b42f54..0ef3eb38eb 100644
--- a/src/slic3r/GUI/Widgets/BitmapToggleButton.cpp
+++ b/src/slic3r/GUI/Widgets/BitmapToggleButton.cpp
@@ -1,6 +1,14 @@
 #include "BitmapToggleButton.hpp"
 
 #include <wx/settings.h>
+#include <wx/button.h>
+#include <wx/event.h>
+#include <wx/gdicmn.h>
+#include <wx/setup.h>
+
+#include "wx/window.h"
+
+class wxWindow;
 
 BitmapToggleButton::BitmapToggleButton(wxWindow* parent, const wxString& label, wxWindowID id)
 {
diff --git a/src/slic3r/GUI/Widgets/BitmapToggleButton.hpp b/src/slic3r/GUI/Widgets/BitmapToggleButton.hpp
index db653e03fb..736010cb1d 100644
--- a/src/slic3r/GUI/Widgets/BitmapToggleButton.hpp
+++ b/src/slic3r/GUI/Widgets/BitmapToggleButton.hpp
@@ -2,6 +2,11 @@
 #define slic3r_GUI_BitmapToggleButton_hpp_
 
 #include <wx/tglbtn.h>
+#include <stddef.h>
+#include <wx/defs.h>
+#include <wx/string.h>
+
+class wxWindow;
 
 class BitmapToggleButton : public wxBitmapToggleButton
 {
diff --git a/src/slic3r/GUI/Widgets/StateColor.cpp b/src/slic3r/GUI/Widgets/StateColor.cpp
index 3809033633..939af0d841 100644
--- a/src/slic3r/GUI/Widgets/StateColor.cpp
+++ b/src/slic3r/GUI/Widgets/StateColor.cpp
@@ -1,5 +1,7 @@
 #include "StateColor.hpp"
 
+#include <stddef.h>
+
 StateColor::StateColor(wxColour const &color) { append(color, 0); }
 
 StateColor::StateColor(wxString const &color) { append(color, 0); }
diff --git a/src/slic3r/GUI/Widgets/StateColor.hpp b/src/slic3r/GUI/Widgets/StateColor.hpp
index 0855e64db4..147fe3085c 100644
--- a/src/slic3r/GUI/Widgets/StateColor.hpp
+++ b/src/slic3r/GUI/Widgets/StateColor.hpp
@@ -2,6 +2,9 @@
 #define slic3r_GUI_StateColor_hpp_
 
 #include <wx/colour.h>
+#include <wx/string.h>
+#include <utility>
+#include <vector>
 
 class StateColor
 {
diff --git a/src/slic3r/GUI/Widgets/StateHandler.cpp b/src/slic3r/GUI/Widgets/StateHandler.cpp
index b99c2dc483..3a8f6cc66f 100644
--- a/src/slic3r/GUI/Widgets/StateHandler.cpp
+++ b/src/slic3r/GUI/Widgets/StateHandler.cpp
@@ -1,6 +1,9 @@
 #include "StateHandler.hpp"
 
 #include <wx/window.h>
+#include <algorithm>
+
+#include "slic3r/GUI/Widgets/StateColor.hpp"
 
 wxDEFINE_EVENT(EVT_ENABLE_CHANGED, wxCommandEvent);
 
diff --git a/src/slic3r/GUI/Widgets/StateHandler.hpp b/src/slic3r/GUI/Widgets/StateHandler.hpp
index d7d6faeb40..0f8356e551 100644
--- a/src/slic3r/GUI/Widgets/StateHandler.hpp
+++ b/src/slic3r/GUI/Widgets/StateHandler.hpp
@@ -3,9 +3,12 @@
 
 #include <wx/event.h>
 #include <memory>
+#include <vector>
 
 #include "StateColor.hpp"
 
+class wxWindow;
+
 wxDECLARE_EVENT(EVT_ENABLE_CHANGED, wxCommandEvent);
 
 class StateHandler : public wxEvtHandler
diff --git a/src/slic3r/Utils/ASCIIFolding.cpp b/src/slic3r/Utils/ASCIIFolding.cpp
index af76eadf79..118b9b8248 100644
--- a/src/slic3r/Utils/ASCIIFolding.cpp
+++ b/src/slic3r/Utils/ASCIIFolding.cpp
@@ -4,10 +4,8 @@
 ///|/
 #include "ASCIIFolding.hpp"
 
-#include <stdio.h>
-#include <string.h>
-#include <locale>
 #include <boost/locale/encoding_utf.hpp>
+#include <iterator>
 
 namespace Slic3r {
 
diff --git a/src/slic3r/Utils/FontConfigHelp.cpp b/src/slic3r/Utils/FontConfigHelp.cpp
index 2746b0c000..74952c214d 100644
--- a/src/slic3r/Utils/FontConfigHelp.cpp
+++ b/src/slic3r/Utils/FontConfigHelp.cpp
@@ -4,10 +4,18 @@
 ///|/
 #include "FontConfigHelp.hpp"
 
+#include <stddef.h>
+#include <wx/buffer.h>
+#include <wx/chartype.h>
+#include <wx/defs.h>
+#include <wx/string.h>
+#include <optional>
+
 #ifdef EXIST_FONT_CONFIG_INCLUDE
 
 #include <wx/filename.h>
 #include <fontconfig/fontconfig.h>
+
 #include "libslic3r/Utils.hpp"
 
 using namespace Slic3r::GUI;
diff --git a/src/slic3r/Utils/FontConfigHelp.hpp b/src/slic3r/Utils/FontConfigHelp.hpp
index d60c7e7f07..7f58978833 100644
--- a/src/slic3r/Utils/FontConfigHelp.hpp
+++ b/src/slic3r/Utils/FontConfigHelp.hpp
@@ -5,12 +5,14 @@
 #ifndef slic3r_FontConfigHelp_hpp_
 #define slic3r_FontConfigHelp_hpp_
 
+#include <string>
 #ifdef __linux__
 #define EXIST_FONT_CONFIG_INCLUDE
 #endif
 
 #ifdef EXIST_FONT_CONFIG_INCLUDE
 #include <wx/font.h>
+
 namespace Slic3r::GUI {   
 
 /// <summary>
diff --git a/src/slic3r/Utils/UndoRedo.cpp b/src/slic3r/Utils/UndoRedo.cpp
index 1e2fcf0d6f..97e01273f2 100644
--- a/src/slic3r/Utils/UndoRedo.cpp
+++ b/src/slic3r/Utils/UndoRedo.cpp
@@ -4,34 +4,31 @@
 ///|/
 #include "UndoRedo.hpp"
 
-#include <algorithm>
-#include <iostream>
-#include <fstream>
-#include <memory>
-#include <typeinfo> 
-#include <cassert>
-#include <cstddef>
-
 #include <cereal/types/polymorphic.hpp> // IWYU pragma: keep
 #include <cereal/types/map.hpp> // IWYU pragma: keep
 #include <cereal/types/string.hpp> // IWYU pragma: keep
 #include <cereal/types/utility.hpp> // IWYU pragma: keep
 #include <cereal/types/vector.hpp> // IWYU pragma: keep
 #include <cereal/archives/binary.hpp> // IWYU pragma: keep
+#include <string.h>
+#include <boost/format.hpp>
+#include <cereal/cereal.hpp>
+#include <algorithm>
+#include <fstream>
+#include <memory>
+#include <cassert>
+#include <cstddef>
+#include <map>
+#include <type_traits>
+
 #define CEREAL_FUTURE_EXPERIMENTAL
 #include <cereal/archives/adapters.hpp>
-
-#include <libslic3r/PrintConfig.hpp>
 #include <libslic3r/ObjectID.hpp>
 #include <libslic3r/Utils.hpp>
 
 #include "slic3r/GUI/3DScene.hpp" // IWYU pragma: keep
-
-#include <boost/foreach.hpp>
-
-#ifndef NDEBUG
-// #define SLIC3R_UNDOREDO_DEBUG
-#endif /* NDEBUG */
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Exception.hpp"
 #if 0
 	// Stop at a fraction of the normal Undo / Redo stack size.
 	#define UNDO_REDO_DEBUG_LOW_MEM_FACTOR 10000
@@ -700,11 +697,6 @@ using OutputArchive = cereal::UserDataAdapter<StackImpl, cereal::BinaryOutputArc
 
 } // namespace UndoRedo
 
-class Model; // IWYU pragma: keep
-class ModelObject; // IWYU pragma: keep
-class ModelVolume; // IWYU pragma: keep
-class ModelInstance; // IWYU pragma: keep
-class ModelMaterial; // IWYU pragma: keep
 class DynamicPrintConfig; // IWYU pragma: keep
 class TriangleMesh; // IWYU pragma: keep
 
diff --git a/src/slic3r/Utils/UndoRedo.hpp b/src/slic3r/Utils/UndoRedo.hpp
index bc313cf062..b66be9109b 100644
--- a/src/slic3r/Utils/UndoRedo.hpp
+++ b/src/slic3r/Utils/UndoRedo.hpp
@@ -5,14 +5,16 @@
 #ifndef slic3r_Utils_UndoRedo_hpp_
 #define slic3r_Utils_UndoRedo_hpp_
 
+#include <libslic3r/ObjectID.hpp>
+#include <libslic3r/Config.hpp>
+#include <stddef.h>
+#include <stdint.h>
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
 #include <cassert>
-
-#include <libslic3r/ObjectID.hpp>
-#include <libslic3r/Config.hpp>
+#include <utility>
 
 typedef double                          coordf_t;
 typedef std::pair<coordf_t, coordf_t>   t_layer_height_range;
diff --git a/src/slic3r/Utils/WinRegistry.cpp b/src/slic3r/Utils/WinRegistry.cpp
index e719da7dde..221101abb2 100644
--- a/src/slic3r/Utils/WinRegistry.cpp
+++ b/src/slic3r/Utils/WinRegistry.cpp
@@ -2,7 +2,6 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r/Technologies.hpp"
 #include "WinRegistry.hpp"
 
 #ifdef _WIN32
diff --git a/src/slic3r/Utils/WxFontUtils.cpp b/src/slic3r/Utils/WxFontUtils.cpp
index b34499fb63..24e61bde1b 100644
--- a/src/slic3r/Utils/WxFontUtils.cpp
+++ b/src/slic3r/Utils/WxFontUtils.cpp
@@ -3,9 +3,15 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "WxFontUtils.hpp"
-#include <boost/assign.hpp>
+
 #include <boost/log/trivial.hpp>
-#include "libslic3r/Utils.hpp"
+#include <wx/string.h>
+#include <boost/assign/list_of.hpp>
+#include <optional>
+#include <vector>
+
+#include "libslic3r/Emboss.hpp"
+#include "libslic3r/Exception.hpp"
 
 #if defined(__APPLE__)
 #include <CoreText/CTFont.h>
diff --git a/src/slic3r/Utils/WxFontUtils.hpp b/src/slic3r/Utils/WxFontUtils.hpp
index 1ccd320b96..3443eef4b5 100644
--- a/src/slic3r/Utils/WxFontUtils.hpp
+++ b/src/slic3r/Utils/WxFontUtils.hpp
@@ -5,12 +5,21 @@
 #ifndef slic3r_WxFontUtils_hpp_
 #define slic3r_WxFontUtils_hpp_
 
+#include <boost/bimap.hpp>
+#include <wx/font.h>
 #include <memory>
 #include <optional>
 #include <string_view>
-#include <boost/bimap.hpp>
-#include <wx/font.h>
+#include <string>
+
 #include "libslic3r/Emboss.hpp"
+#include "libslic3r/TextConfiguration.hpp"
+
+namespace Slic3r {
+namespace Emboss {
+struct FontFile;
+}  // namespace Emboss
+}  // namespace Slic3r
 
 namespace Slic3r::GUI {