diff --git a/drawing_modules/draw_widget2d.py b/drawing_modules/draw_widget2d.py
index b00ef32..5e48ef3 100644
--- a/drawing_modules/draw_widget2d.py
+++ b/drawing_modules/draw_widget2d.py
@@ -1,6 +1,7 @@
 import math
 import re
 from copy import copy
+from typing import Optional
 
 import numpy as np
 from PySide6.QtWidgets import QApplication, QWidget, QMessageBox, QInputDialog
@@ -19,9 +20,6 @@ class SketchWidget(QWidget):
         self.drag_buffer = [None, None]
         self.main_buffer = [None, None]
 
-        self.proj_snap_points = []
-        self.proj_snap_lines = []
-
         self.hovered_point = None
         self.selected_line = None
 
@@ -30,11 +28,17 @@ class SketchWidget(QWidget):
 
         self.setMouseTracking(True)
         self.mouse_mode = False
-        self.wp = None
         self.solv = SolverSystem()
 
-        self.slv_points_main = []
-        self.slv_lines_main = []
+        self.sketch = None
+
+    def set_sketch(self, sketch) -> None:
+        print(sketch)
+        self.sketch = sketch
+        self.create_workplane()
+
+    def get_sketch(self):
+        return self.sketch
 
     def reset_buffers(self):
         self.line_draw_buffer = [None, None]
@@ -46,44 +50,28 @@ class SketchWidget(QWidget):
         #self.update()
 
     def create_workplane(self):
-        self.wp = self.solv.create_2d_base()
+        self.sketch.working_plane = self.solv.create_2d_base()
 
     def create_workplane_projected(self):
-        self.wp = self.solv.create_2d_base()
+        self.sketch.working_plane = self.solv.create_2d_base()
 
-    def create_proj_points(self, proj_points):
-        """Lines as orientation projected from the sketch"""
-
-        for point in proj_points:
+    def convert_proj_points(self):
+        out_points = []
+        for point in self.sketch.proj_points:
             x, y = point
             coord = QPoint(x, y)
-            self.proj_snap_points.append(coord)
+            out_points.append(coord)
 
-            """relation_point = {}  # Reinitialize the dictionary
-            #handle_nr = self.get_handle_nr(str(point))
-            #relation_point['handle_nr'] = handle_nr
-            #relation_point['solv_handle'] = point
-            relation_point['ui_point'] = QPoint(x, y)
+        self.sketch.proj_points = out_points
 
-            self.slv_points_main.append(relation_point)"""
-
-    def create_proj_lines(self, sel_edges):
-        """Lines as orientation projected from the sketch"""
-        print("Incoming corrd lines", sel_edges)
-        for line in sel_edges:
-
-            start = QPoint(line[0][0], line[0][1] )
+    def convert_proj_lines(self):
+        out_lines = []
+        for line in self.sketch.proj_lines:
+            start = QPoint(line[0][0], line[0][1])
             end = QPoint(line[1][0], line[1][1])
             coord = QLine(start, end)
-            self.proj_snap_lines.append(coord)
-
-            """relation_point = {}  # Reinitialize the dictionary
-            #handle_nr = self.get_handle_nr(str(point))
-            #relation_point['handle_nr'] = handle_nr
-            #relation_point['solv_handle'] = point
-            relation_point['ui_point'] = QPoint(x, y)
-
-            self.slv_points_main.append(relation_point)"""
+            out_lines.append(coord)
+        self.sketch.proj_lines = out_lines
 
     def find_duplicate_points_2d(self, edges):
         points = []
@@ -132,8 +120,8 @@ class SketchWidget(QWidget):
         qw, qx, qy, qz = self.normal_to_quaternion(normal)
 
         slv_normal = self.solv.add_normal_3d(qw, qx, qy, qz)
-        self.wp = self.solv.add_work_plane(origin_handle, slv_normal)
-        print(self.wp)
+        self.sketch.working_plane = self.solv.add_work_plane(origin_handle, slv_normal)
+        print(self.sketch.working_plane)
 
     def get_handle_nr(self, input_str: str) -> int:
         # Define the regex pattern to extract the handle number
@@ -168,7 +156,7 @@ class SketchWidget(QWidget):
 
     def get_handle_from_ui_point(self, ui_point: QPoint):
         """Input QPoint and you shall reveive a slvs entity handle!"""
-        for point in self.slv_points_main:
+        for point in self.sketch.slv_points:
             if ui_point == point['ui_point']:
                 slv_handle = point['solv_handle']
 
@@ -176,7 +164,7 @@ class SketchWidget(QWidget):
 
     def get_line_handle_from_ui_point(self, ui_point: QPoint):
         """Input Qpoint that is on a line and you shall receive the handle of the line!"""
-        for target_line_con in self.slv_lines_main:
+        for target_line_con in self.sketch.slv_lines:
             if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
                 slv_handle = target_line_con['solv_handle']
 
@@ -184,7 +172,7 @@ class SketchWidget(QWidget):
 
     def get_point_line_handles_from_ui_point(self, ui_point: QPoint) -> tuple:
         """Input Qpoint that is on a line and you shall receive the handles of the points of the line!"""
-        for target_line_con in self.slv_lines_main:
+        for target_line_con in self.sketch.slv_lines:
             if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
                 lines_to_cons = target_line_con['solv_entity_points']
 
@@ -231,7 +219,7 @@ class SketchWidget(QWidget):
         old_points_ui = []
         new_points_ui = []
 
-        for old_point_ui in self.slv_points_main:
+        for old_point_ui in self.sketch.slv_points:
             old_points_ui.append(old_point_ui['ui_point'])
 
         for i in range(self.solv.entity_len()):
@@ -265,14 +253,14 @@ class SketchWidget(QWidget):
                 index, old_point, new_point = tbu_points_idx
 
                 # Update the point in slv_points_main
-                self.slv_points_main[index]['ui_point'] = new_point
+                self.sketch.slv_points[index]['ui_point'] = new_point
             # Print updated state
             # print("Updated slv_points_main:", self.slv_points_main)
 
     def check_all_lines_and_update(self,changed_points: list):
         for tbu_points_idx in changed_points:
             index, old_point, new_point = tbu_points_idx
-            for line_needs_update in self.slv_lines_main:
+            for line_needs_update in self.sketch.slv_lines:
                 if old_point == line_needs_update['ui_points'][0]:
                     line_needs_update['ui_points'][0] = new_point
                 elif old_point == line_needs_update['ui_points'][1]:
@@ -334,7 +322,7 @@ class SketchWidget(QWidget):
                 u = clicked_pos.x()
                 v = clicked_pos.y()
 
-                point = self.solv.add_point_2d(u, v, self.wp)
+                point = self.solv.add_point_2d(u, v, self.sketch.working_plane)
 
                 relation_point = {}  # Reinitialize the dictionary
                 handle_nr = self.get_handle_nr(str(point))
@@ -342,17 +330,17 @@ class SketchWidget(QWidget):
                 relation_point['solv_handle'] = point
                 relation_point['ui_point'] = clicked_pos
 
-                self.slv_points_main.append(relation_point)
+                self.sketch.slv_points.append(relation_point)
 
-                print("points", self.slv_points_main)
-                print("lines", self.slv_lines_main)
+                print("points", self.sketch.slv_points)
+                print("lines", self.sketch.slv_lines)
 
             elif self.line_draw_buffer[0]:
                 self.line_draw_buffer[1] = clicked_pos
                 u = clicked_pos.x()
                 v = clicked_pos.y()
 
-                point2 = self.solv.add_point_2d(u, v, self.wp)
+                point2 = self.solv.add_point_2d(u, v, self.sketch.working_plane)
 
                 relation_point = {}  # Reinitialize the dictionary
                 handle_nr = self.get_handle_nr(str(point2))
@@ -360,19 +348,18 @@ class SketchWidget(QWidget):
                 relation_point['solv_handle'] = point2
                 relation_point['ui_point'] = clicked_pos
 
-                self.slv_points_main.append(relation_point)
+                self.sketch.slv_points.append(relation_point)
 
-                print("points", self.slv_points_main)
-                print("lines", self.slv_lines_main)
+                print("points", self.sketch.slv_points)
+                print("lines", self.sketch.slv_lines)
 
             print("Buffer state", self.line_draw_buffer)
+
             if self.line_draw_buffer[0] and self.line_draw_buffer[1]:
                 point_slv1 = self.get_handle_from_ui_point(self.line_draw_buffer[0])
                 point_slv2 = self.get_handle_from_ui_point(self.line_draw_buffer[1])
-                print(point_slv1)
-                print(point_slv2)
 
-                line = self.solv.add_line_2d(point_slv1, point_slv2, self.wp)
+                line = self.solv.add_line_2d(point_slv1, point_slv2, self.sketch.working_plane)
 
                 relation_line = {}  # Reinitialize the dictionary
                 handle_nr_line = self.get_handle_nr(str(line))
@@ -384,7 +371,7 @@ class SketchWidget(QWidget):
                 # Track relationship of point in line
                 relation_point['part_of_entity'] = handle_nr_line
 
-                self.slv_lines_main.append(relation_line)
+                self.sketch.slv_lines.append(relation_line)
 
                 # Reset the buffer for the next line segment
                 self.line_draw_buffer[0] = self.line_draw_buffer[1]
@@ -403,7 +390,7 @@ class SketchWidget(QWidget):
             if self.main_buffer[0] and self.main_buffer[1]:
                 print("buf", self.main_buffer)
 
-                self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.wp)
+                self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
 
                 if self.solv.solve() == ResultFlag.OKAY:
                     print("Fuck yeah")
@@ -431,7 +418,7 @@ class SketchWidget(QWidget):
 
                 # Contrain point to line
                 if self.main_buffer[1]:
-                    self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.wp)
+                    self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
 
                     if self.solv.solve() == ResultFlag.OKAY:
                         print("Fuck yeah")
@@ -462,7 +449,7 @@ class SketchWidget(QWidget):
 
                 # Contrain point to line
                 if self.main_buffer[1]:
-                    self.solv.midpoint(self.main_buffer[0], self.main_buffer[1], self.wp)
+                    self.solv.midpoint(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
 
                     if self.solv.solve() == ResultFlag.OKAY:
                         print("Fuck yeah")
@@ -484,7 +471,7 @@ class SketchWidget(QWidget):
             line_selected = self.get_line_handle_from_ui_point(local_event_pos)
 
             if line_selected:
-                self.solv.horizontal(line_selected, self.wp)
+                self.solv.horizontal(line_selected, self.sketch.working_plane)
 
             if self.solv.solve() == ResultFlag.OKAY:
                 print("Fuck yeah")
@@ -502,7 +489,7 @@ class SketchWidget(QWidget):
             line_selected = self.get_line_handle_from_ui_point(local_event_pos)
 
             if line_selected:
-                self.solv.vertical(line_selected, self.wp)
+                self.solv.vertical(line_selected, self.sketch.working_plane)
 
                 if self.solv.solve() == ResultFlag.OKAY:
                     print("Fuck yeah")
@@ -543,7 +530,7 @@ class SketchWidget(QWidget):
             if e1 and e2:
                 # Ask fo the dimension and solve if both elements are present
                 length, ok = QInputDialog.getDouble(self, 'Distance', 'Enter a mm value:', value=100, decimals=2)
-                self.solv.distance(e1, e2, length, self.wp)
+                self.solv.distance(e1, e2, length, self.sketch.working_plane)
 
                 if self.solv.solve() == ResultFlag.OKAY:
                     print("Fuck yeah")
@@ -574,33 +561,35 @@ class SketchWidget(QWidget):
         min_distance = float('inf')
         threshold = 10  # Distance threshold for highlighting
 
-        for point in self.slv_points_main:
-            distance = (local_event_pos - point['ui_point']).manhattanLength()
-            if distance < threshold and distance < min_distance:
-                closest_point = point['ui_point']
-                min_distance = distance
+        if self.sketch:
 
-        for point in self.proj_snap_points:
-            distance = (local_event_pos - point).manhattanLength()
-            if distance < threshold and distance < min_distance:
-                closest_point = point
-                min_distance = distance
+            for point in self.sketch.slv_points:
+                distance = (local_event_pos - point['ui_point']).manhattanLength()
+                if distance < threshold and distance < min_distance:
+                    closest_point = point['ui_point']
+                    min_distance = distance
 
-        if closest_point != self.hovered_point:
-            self.hovered_point = closest_point
-            print(self.hovered_point)
+            for point in self.sketch.proj_points:
+                distance = (local_event_pos - point).manhattanLength()
+                if distance < threshold and distance < min_distance:
+                    closest_point = point
+                    min_distance = distance
 
-        for dic in self.slv_lines_main:
-            p1 = dic['ui_points'][0]
-            p2 = dic['ui_points'][1]
+            if closest_point != self.hovered_point:
+                self.hovered_point = closest_point
+                print(self.hovered_point)
 
-            if self.is_point_on_line(local_event_pos, p1, p2):
-                self.selected_line = p1, p2
-                break
-            else:
-                self.selected_line = None
+            for dic in self.sketch.slv_lines:
+                p1 = dic['ui_points'][0]
+                p2 = dic['ui_points'][1]
 
-        self.update()
+                if self.is_point_on_line(local_event_pos, p1, p2):
+                    self.selected_line = p1, p2
+                    break
+                else:
+                    self.selected_line = None
+
+            self.update()
 
     def mouseDoubleClickEvent(self, event):
         pass
@@ -722,50 +711,51 @@ class SketchWidget(QWidget):
         painter.setPen(pen)
 
         # Draw points
-        for point in self.slv_points_main:
-            painter.drawEllipse(point['ui_point'], 3 / self.zoom, 3 / self.zoom)
+        if self.sketch:
+            for point in self.sketch.slv_points:
+                painter.drawEllipse(point['ui_point'], 3 / self.zoom, 3 / self.zoom)
 
-        for dic in self.slv_lines_main:
-            p1 = dic['ui_points'][0]
-            p2 = dic['ui_points'][1]
-            painter.drawLine(p1, p2)
+            for dic in self.sketch.slv_lines:
+                p1 = dic['ui_points'][0]
+                p2 = dic['ui_points'][1]
+                painter.drawLine(p1, p2)
 
-            dis = self.distance(p1, p2)
-            mid = self.calculate_midpoint(p1, p2)
-            painter.drawText(mid, str(round(dis, 2)))
+                dis = self.distance(p1, p2)
+                mid = self.calculate_midpoint(p1, p2)
+                painter.drawText(mid, str(round(dis, 2)))
 
-        pen = QPen(Qt.green)
-        pen.setWidthF(2 / self.zoom)
-        painter.setPen(pen)
-
-        if self.solv.entity_len():
-            for i in range(self.solv.entity_len()):
-                entity = self.solv.entity(i)
-                if entity.is_point_2d() and self.solv.params(entity.params):
-                    x, y = self.solv.params(entity.params)
-                    point = QPointF(x, y)
-                    painter.drawEllipse(point, 6 / self.zoom, 6 / self.zoom)
-
-        # Highlight point hovered
-        if self.hovered_point:
-            highlight_pen = QPen(QColor(255, 0, 0))
-            highlight_pen.setWidthF(2 / self.zoom)
-            painter.setPen(highlight_pen)
-            painter.drawEllipse(self.hovered_point, 5 / self.zoom, 5 / self.zoom)
-
-        # Highlight line hovered
-        if self.selected_line and not self.hovered_point:
-            p1, p2 = self.selected_line
-            painter.setPen(QPen(Qt.red, 2 / self.zoom))
-            painter.drawLine(p1, p2)
-
-        for cross in self.proj_snap_points:
-            self.draw_cross(painter, cross, 10 / self.zoom)
-
-        for selected in self.proj_snap_lines:
-            pen = QPen(Qt.white, 1, Qt.DashLine)
+            pen = QPen(Qt.green)
+            pen.setWidthF(2 / self.zoom)
             painter.setPen(pen)
-            painter.drawLine(selected)
+
+            if self.solv.entity_len():
+                for i in range(self.solv.entity_len()):
+                    entity = self.solv.entity(i)
+                    if entity.is_point_2d() and self.solv.params(entity.params):
+                        x, y = self.solv.params(entity.params)
+                        point = QPointF(x, y)
+                        painter.drawEllipse(point, 6 / self.zoom, 6 / self.zoom)
+
+            # Highlight point hovered
+            if self.hovered_point:
+                highlight_pen = QPen(QColor(255, 0, 0))
+                highlight_pen.setWidthF(2 / self.zoom)
+                painter.setPen(highlight_pen)
+                painter.drawEllipse(self.hovered_point, 5 / self.zoom, 5 / self.zoom)
+
+            # Highlight line hovered
+            if self.selected_line and not self.hovered_point:
+                p1, p2 = self.selected_line
+                painter.setPen(QPen(Qt.red, 2 / self.zoom))
+                painter.drawLine(p1, p2)
+
+            for cross in self.sketch.proj_points:
+                self.draw_cross(painter, cross, 10 / self.zoom)
+
+            for selected in self.sketch.proj_lines:
+                pen = QPen(Qt.white, 1, Qt.DashLine)
+                painter.setPen(pen)
+                painter.drawLine(selected)
 
         painter.end()
 
@@ -777,13 +767,6 @@ class SketchWidget(QWidget):
     def aspect_ratio(self):
         return self.width() / self.height() * (1.0 / abs(self.zoom))
 
-    def clear_sketch(self):
-        self.slv_points_main = []
-        self.slv_lines_main = []
-        self.proj_snap_lines.clear()
-        self.proj_snap_points.clear()
-        self.reset_buffers()
-        self.solv = SolverSystem()
 
 # Example usage
 if __name__ == "__main__":
diff --git a/drawing_modules/vtk_widget.py b/drawing_modules/vtk_widget.py
index 658afa7..2f33bb5 100644
--- a/drawing_modules/vtk_widget.py
+++ b/drawing_modules/vtk_widget.py
@@ -146,7 +146,6 @@ class VTKWidget(QtWidgets.QWidget):
         self.renderer_indicators.ResetCameraClippingRange()
         self.vtk_widget.GetRenderWindow().Render()
 
-
     def create_grid(self, size=100, spacing=10):
         # Create a vtkPoints object and store the points in it
         points = vtk.vtkPoints()
diff --git a/main.py b/main.py
index 86513c8..935998f 100644
--- a/main.py
+++ b/main.py
@@ -23,6 +23,7 @@ class ExtrudeDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setWindowTitle('Extrude Options')
+
         def create_hline():
             line = QLabel()
             line.setStyleSheet("border-top: 1px solid #cccccc;")  # Light grey line
@@ -76,6 +77,7 @@ class ExtrudeDialog(QDialog):
     def get_values(self):
         return self.length_input.value(), self.symmetric_checkbox.isChecked() ,self.invert_checkbox.isChecked(), self.cut_checkbox.isChecked(), self.union_checkbox.isChecked(), self.rounded_checkbox.isChecked()
 
+
 class MainWindow(QMainWindow):
     send_command = Signal(str)
 
@@ -100,7 +102,7 @@ class MainWindow(QMainWindow):
 
         ### Main Model
         self.model = {
-            'sketch': {},
+            'sketches': {},
             'operation': {},
         }
         self.list_selected = []
@@ -145,8 +147,6 @@ class MainWindow(QMainWindow):
 
         """Project -> Timeline -> Component -> Sketch -> Body / Interactor -> Connector -> Assembly -> PB Render"""
 
-
-
     def on_flip_face(self):
         self.send_command.emit("flip")
 
@@ -208,7 +208,7 @@ class MainWindow(QMainWindow):
     def draw_mesh(self):
         name = self.ui.body_list.currentItem().text()
         print("selected_for disp", name)
-        model = self.project.timeline[-1].body.sdf_body
+        model = self.project.timeline[-1].body[name].sdf_body
 
         vesta = vesta_mesh
         model_data = vesta.generate_mesh_from_sdf(model, resolution=64, threshold=0)
@@ -234,6 +234,8 @@ class MainWindow(QMainWindow):
         compo = Component()
         compo.id = "New Compo"
         compo.descript = "Initial Component"
+        compo.sketches = {}
+        compo.body = {}
         self.project.timeline.append(compo)
 
         # Create a horizontal layout
@@ -257,61 +259,67 @@ class MainWindow(QMainWindow):
         horizontal_layout.setAlignment(Qt.AlignLeft)
 
     def add_new_sketch_origin(self):
-        self.sketchWidget.clear_sketch()
-        self.sketchWidget.create_workplane()
+        name = f"sketches-{str(names.get_first_name())}"
+        sketch = Sketch()
+        sketch.id = name
+        sketch.origin = [0,0,0]
+        sketch.slv_points = []
+        sketch.slv_lines = []
+        sketch.proj_points = []
+        sketch.proj_lines = []
+        self.sketchWidget.set_sketch(sketch)
 
     def add_new_sketch_wp(self):
-        self.sketchWidget.clear_sketch()
-        #edges = [((-158.0, -20.0, -25.0), (286.0, -195.0, -25.0)), ((-158.0, -20.0, 25.0), (-158.0, -20.0, -25.0))]
-        points = self.custom_3D_Widget.project_tosketch_points
-        normal = self.custom_3D_Widget.selected_normal
-        selected_lines = self.custom_3D_Widget.project_tosketch_lines
-        print("Selected lines", selected_lines)
-
+        name = f"sketches-{str(names.get_first_name())}"
+        sketch = Sketch()
+        sketch.id = name
+        sketch.origin = self.custom_3D_Widget.centroid
+        sketch.normal = self.custom_3D_Widget.selected_normal
+        sketch.slv_points = []
+        sketch.slv_lines = []
+        sketch.proj_points = self.custom_3D_Widget.project_tosketch_points
+        sketch.proj_lines = self.custom_3D_Widget.project_tosketch_lines
+        self.sketchWidget.set_sketch(sketch)
         self.sketchWidget.create_workplane_projected()
-        self.sketchWidget.create_proj_points(points)
-        self.sketchWidget.create_proj_lines(selected_lines)
+        self.sketchWidget.convert_proj_points()
+        self.sketchWidget.convert_proj_lines()
+        self.sketchWidget.update()
 
         # CLear all selections after it has been projected
         self.custom_3D_Widget.project_tosketch_points.clear()
         self.custom_3D_Widget.project_tosketch_lines.clear()
         self.custom_3D_Widget.clear_actors_projection()
         self.custom_3D_Widget.clear_actors_normals()
-        #self.custom_3D_Widget.clear_actors_projection()
-
-        #self.sketchWidget.create_workplane_space(edges, normal)
 
     def add_sketch(self):
-        name = f"sketch-{str(names.get_first_name())}"
 
-        sketch = Sketch()
-        sketch.id = name
-        sketch.slv_points = self.sketchWidget.slv_points_main
-        sketch.slv_lines = self.sketchWidget.slv_lines_main
+        sketch = self.sketchWidget.get_sketch()
         sketch.convert_points_for_sdf()
 
-        self.project.timeline[-1].sketch = sketch
+        self.project.timeline[-1].sketches[sketch.id] = sketch
 
-        self.ui.sketch_list.addItem(name)
+        self.ui.sketch_list.addItem(sketch.id)
         self.ui.pb_linetool.setChecked(False)
         self.sketchWidget.line_mode = False
 
-        items = self.ui.sketch_list.findItems(name, Qt.MatchExactly)[0]
+        items = self.ui.sketch_list.findItems(sketch.id, Qt.MatchExactly)[0]
         self.ui.sketch_list.setCurrentItem(items)
 
     def edit_sketch(self):
         name = self.ui.sketch_list.currentItem().text()
-        #self.sketchWidget.clear_sketch()
 
-        self.sketchWidget.slv_points_main = self.model['sketch'][name]['point_list']
-        self.sketchWidget.slv_lines_main = self.model['sketch'][name]['line_list']
-        self.sketchWidget.solv = self.model['sketch'][name]['solver']
+        selected = self.ui.sketch_list.currentItem()
+        name = selected.text()
+        # TODO: add selected element from timeline
+        sel_compo = self.project.timeline[-1]
+        sketch = sel_compo.sketches[name]
+
+        self.sketchWidget.set_sketch(sketch)
 
         self.sketchWidget.update()
-        print("model",self.model)
-        print("widget", self.sketchWidget.slv_points_main)
 
     def del_sketch(self):
+        # Old
         print("Deleting")
         name = self.ui.sketch_list.currentItem()  # Get the current item
 
@@ -321,14 +329,14 @@ class MainWindow(QMainWindow):
             item_name = name.text()
             print("obj_name", item_name)
 
-            # Check if the 'sketch' key exists in the model dictionary
-            if 'sketch' in self.model and item_name in self.model['sketch']:
-                if self.model['sketch'][item_name]['id'] == item_name:
+            # Check if the 'sketches' key exists in the model dictionary
+            if 'sketches' in self.model and item_name in self.model['sketches']:
+                if self.model['sketches'][item_name]['id'] == item_name:
                     row = self.ui.sketch_list.row(name)  # Get the row of the current item
                     self.ui.sketch_list.takeItem(row)  # Remove the item from the list widget
                     self.sketchWidget.clear_sketch()
-                    self.model['sketch'].pop(item_name)  # Remove the item from the sketch dictionary
-                    print(f"Removed sketch: {item_name}")
+                    self.model['sketches'].pop(item_name)  # Remove the item from the sketches dictionary
+                    print(f"Removed sketches: {item_name}")
 
             # Check if the 'operation' key exists in the model dictionary
             elif 'operation' in self.model and item_name in self.model['operation']:
@@ -340,7 +348,7 @@ class MainWindow(QMainWindow):
                     print(f"Removed operation: {item_name}")
 
             else:
-                print(f"Item '{item_name}' not found in either 'sketch' or 'operation' dictionary.")
+                print(f"Item '{item_name}' not found in either 'sketches' or 'operation' dictionary.")
         else:
             print("No item selected.")
 
@@ -374,7 +382,7 @@ class MainWindow(QMainWindow):
         name = selected.text()
         # TODO: add selected element from timeline
         sel_compo = self.project.timeline[-1]
-        sketch = sel_compo.sketch
+        sketch = sel_compo.sketches[name]
         points = sketch.sdf_points
 
         if points[-1] == points[0]:
@@ -389,7 +397,6 @@ class MainWindow(QMainWindow):
             length = 0
             print("Extrude cancelled")
 
-
         normal = self.custom_3D_Widget.selected_normal
         #print("Normie enter", normal)
         if normal is None:
@@ -408,21 +415,25 @@ class MainWindow(QMainWindow):
         f = sketch.extrude(length, is_symmetric, invert, 0)
 
         name_op = f"extrd-{name}"
-        sel_compo.body = Body()
-        sel_compo.body.sketch = sketch #we add the sketch for reference here
-        sel_compo.body.id = name_op
-        sel_compo.body.sdf_body = f
+        sel_compo.body
+        body = Body()
+        body.sketch = sketch #we add the sketches for reference here
+        body.id = name_op
+        body.sdf_body = f
 
         ### Interactor
-        sel_compo.interactor = Interactor()
-        sel_compo.interactor.add_lines_for_interactor(sketch.slv_lines)
+        interactor = Interactor()
+        interactor.add_lines_for_interactor(sketch.slv_lines)
 
         if not invert:
-            edges = interactor_mesh.generate_mesh(sel_compo.interactor.lines, 0, length)
+            edges = interactor_mesh.generate_mesh(interactor.lines, 0, length)
         else:
-            edges = interactor_mesh.generate_mesh(sel_compo.interactor.lines, 0, -length)
+            edges = interactor_mesh.generate_mesh(interactor.lines, 0, -length)
 
-        offset_vector = sel_compo.interactor.vector_to_centroid(None, centroid, normal)
+        body.interactor = interactor
+        sel_compo.body[name_op] = body
+
+        offset_vector = interactor.vector_to_centroid(None, centroid, normal)
         #print("off_ved", offset_vector)
         if len(offset_vector) == 0 :
             offset_vector = [0, 0, 0]
@@ -483,7 +494,7 @@ class Assembly:
 class Component:
     """The base container combining all related elements
     id : The unique ID
-    sketch : the base sketch, bodys can contain additonal sketches for features
+    sketches : the base sketches, bodys can contain additonal sketches for features
     interactor : A smiplified model used as interactor
     body : The body class that contains the actual 3d information
     connector : Vector and Nomral information for assembly
@@ -491,9 +502,8 @@ class Component:
     materil : Speicfy a material for pbr rendering
     """
     id = None
-    sketch = None
-    interactor = None
-    body = None
+    sketches: dict = None
+    body: dict = None
     connector = None
 
     # Description
@@ -531,7 +541,7 @@ class Code:
 
 @dataclass
 class Sketch:
-    """All of the 2D Information of a sketch"""
+    """All of the 2D Information of a sketches"""
     id = None
 
     # Space Information
@@ -539,7 +549,7 @@ class Sketch:
     slv_plane = None
     normal = None
 
-    # Points in UI form the sketch widget
+    # Points in UI form the sketches widget
     ui_points: list = None
     ui_lines: list = None
 
@@ -553,6 +563,9 @@ class Sketch:
     proj_points: list = None
     proj_lines: list = None
 
+    # Workingplane
+    working_plane = None
+
     def translate_points_tup(self, point: QPoint):
         """QPoints from Display to mesh data
         input: Qpoints
@@ -712,6 +725,7 @@ class Body:
     id = None
     sketch = None
     height = None
+    interactor = None
     sdf_body = None
 
     def mirror_body(self, sdf_object3d):