diff --git a/src/airunner/aihandler/engine.py b/src/airunner/aihandler/engine.py
index aed93b0c2..d6264a274 100644
--- a/src/airunner/aihandler/engine.py
+++ b/src/airunner/aihandler/engine.py
@@ -104,9 +104,9 @@ def unload_llm(self):
         VRAM to keep the LLM loaded while
         using other models.
         """
-        do_unload_model = self.settings_manager.unload_unused_model
-        do_move_to_cpu = not do_unload_model and self.settings_manager.move_unused_model_to_cpu
-        dtype = self.settings_manager.llm_generator_setting.dtype
+        do_unload_model = self.settings_manager.settings.unload_unused_model
+        do_move_to_cpu = not do_unload_model and self.settings_manager.settings.move_unused_model_to_cpu
+        dtype = self.settings_manager.llm_generator_settings.dtype
         if dtype in ["2bit", "4bit", "8bit"]:
             do_unload_model = True
             do_move_to_cpu = False
diff --git a/src/airunner/aihandler/settings_manager.py b/src/airunner/aihandler/settings_manager.py
deleted file mode 100644
index 6dc272a54..000000000
--- a/src/airunner/aihandler/settings_manager.py
+++ /dev/null
@@ -1,328 +0,0 @@
-from PyQt6.QtCore import QObject, pyqtSignal
-
-from airunner.aihandler.qtvar import StringVar, IntVar, BooleanVar, FloatVar, DictVar
-from airunner.data.models import LLMGenerator, Settings, GeneratorSetting, AIModel, Pipeline, ControlnetModel, ImageFilter, \
-    SavedPrompt, StandardImageWidgetSettings
-from airunner.aihandler.logger import Logger as logger
-from airunner.data.models import Document
-from airunner.data.session_scope import session_scope, path_settings_scope
-
-
-document = None
-_app = None
-variables = {}
-variable_types = {
-    "VARCHAR": StringVar,
-    "INTEGER": IntVar,
-    "BOOLEAN": BooleanVar,
-    "FLOAT": FloatVar,
-    "JSON": DictVar,
-}
-
-
-class SettingsSignal(QObject):
-    _instances = {}
-    changed_signal = pyqtSignal(str, object, object)
-
-    def __new__(cls):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(SettingsSignal, cls).__new__(cls)
-        return cls._instances[cls]
-
-
-class SettingsManager(QObject):
-    saved_signal = pyqtSignal()
-    changed_signal = SettingsSignal().changed_signal
-
-    @property
-    def prompts(self):
-        """
-        Return Prompt objects from the database
-        :return:
-        """
-        with session_scope() as session:
-            return session.query(SavedPrompt).all()
-
-    def create_saved_prompt(self, prompt, negative_prompt):
-        if prompt == "" and negative_prompt == "":
-            return
-
-        saved_prompt = SavedPrompt(
-            prompt=prompt,
-            negative_prompt=negative_prompt
-        )
-        with session_scope() as session:
-            session.add(saved_prompt)
-            self.changed_signal.emit("saved_prompt", saved_prompt, self)
-
-    def delete_prompt(self, saved_prompt):
-        with session_scope() as session:
-            session.delete(saved_prompt)
-        self.save_and_emit("saved_prompt", saved_prompt)
-        self.changed_signal.emit("saved_prompt", saved_prompt, self)
-
-    def save_and_emit(self, key, value):
-        self.changed_signal.emit(key, value, self)
-
-    def available_models_by_category(self, category):
-        categories = [category]
-        if category in ["img2img", "txt2vid"]:
-            categories.append("txt2img")
-        with session_scope() as session:
-            return session.query(AIModel).filter(
-                AIModel.category.in_(categories),
-                AIModel.enabled.is_(True)
-            ).all()
-
-    def set_model_enabled(self, key, model, enabled):
-        with session_scope() as session:
-            session.query(AIModel).filter_by(
-                name=model["name"],
-                path=model["path"],
-                branch=model["branch"],
-                version=model["version"],
-                category=model["category"]
-            ).update({"enabled": enabled == 2})
-        self.save_settings()
-
-    def available_pipeline_by_section(self, pipeline_action, version, category):
-        with session_scope() as session:
-            return session.query(Pipeline).filter_by(
-                category=category,
-                pipeline_action=pipeline_action,
-                version=version
-            ).first()
-
-    def available_model_names(self, pipeline_action, category):
-        # returns a list of names of models
-        # that match the pipeline_action and category
-        with session_scope() as session:
-            names = []
-            models = session.query(AIModel).filter_by(
-                pipeline_action=pipeline_action,
-                category=category,
-                enabled=True
-            ).all()
-            for model in models:
-                if model.name not in names:
-                    names.append(model.name)
-            return names
-
-    def add_model(self, model_data):
-        with session_scope() as session:
-            model = AIModel(**model_data)
-            session.add(model)
-
-    def delete_model(self, model):
-        with session_scope() as session:
-            session.delete(model)
-
-    def update_model(self, model):
-        with session_scope() as session:
-            session.add(model)
-
-    def get_image_filter(self, name):
-        with session_scope() as session:
-            return session.query(ImageFilter).filter_by(name=name).first()
-
-    def get_image_filters(self):
-        with session_scope() as session:
-            return session.query(ImageFilter).all()
-
-    @property
-    def standard_image_widget_settings(self):
-        with session_scope() as session:
-            standard_image_widget_settings = session.query(StandardImageWidgetSettings).first()
-            if standard_image_widget_settings is None:
-                standard_image_widget_settings = StandardImageWidgetSettings()
-                session.add(standard_image_widget_settings)
-            return standard_image_widget_settings
-
-    @property
-    def pipelines(self):
-        with session_scope() as session:
-            return session.query(Settings).all()
-
-    @property
-    def models(self):
-        with session_scope() as session:
-            return session.query(AIModel).filter_by(enabled=True)
-
-    def models_by_pipeline_action(self, pipeline_action):
-        return self.models.filter_by(pipeline_action=pipeline_action).all()
-
-    @property
-    def controlnet_models(self):
-        with session_scope() as session:
-            return session.query(ControlnetModel).filter_by(enabled=True)
-
-    def controlnet_model_by_name(self, name):
-        return self.controlnet_models.filter_by(name=name).first()
-
-    @property
-    def pipeline_actions(self):
-        # return a list of unique pipeline_action properties from the AIModel table and
-        actions = []
-        for model in self.models.all():
-            if model.pipeline_action not in actions:
-                actions.append(model.pipeline_action)
-        return actions
-
-    @property
-    def model_categories(self):
-        cateogires = []
-        for model in self.models.all():
-            if model.category not in cateogires:
-                cateogires.append(model.category)
-        return cateogires
-
-    def get_pipeline_classname(self, pipeline_action, version, category):
-        try:
-            with session_scope() as session:
-                return session.query(Pipeline).filter_by(
-                    category=category,
-                    pipeline_action=pipeline_action,
-                    version=version
-                ).first().classname
-        except AttributeError:
-            logger.error(f"Unable to find pipeline classname for {pipeline_action} {version} {category}")
-            return None
-
-    @property
-    def model_versions(self):
-        versions = []
-        for model in self.models.all():
-            if model.version not in versions:
-                versions.append(model.version)
-        return versions
-
-    @property
-    def current_prompt_generator_settings(self):
-        items = list(filter(lambda x: x.active, self.prompt_generator_settings))
-        return items[0] if len(items) > 0 else None
-
-    @property
-    def generator(self):
-        generator = self.find_generator(self.generator_section, self.generator_name)
-        if not generator:
-            logger.error(f"Unable to find generator {self.generator_section} {self.generator_name}")
-        return generator
-    
-    @property
-    def llm_generator_setting(self):
-        with session_scope() as session:
-            llm_generator = session.query(LLMGenerator).filter(LLMGenerator.name == self.current_llm_generator).first()
-            return llm_generator.generator_settings[0]
-    
-    _generator = None
-
-    def find_generator(self, generator_section, generator_name):
-        # using sqlalchemy, query the document.settings.generator_settings column
-        # and find any with GeneratorSettings.section == self.generator_section and GeneratorSettings.generator_name == self.generator_name
-        # return the first result
-        with session_scope() as session:
-            if self.generator_settings_override_id:
-                generator_settings = session.query(GeneratorSetting).filter_by(
-                    id=self.generator_settings_override_id
-                ).first()
-            else:
-                generator_settings = session.query(GeneratorSetting).filter_by(
-                    is_preset=0
-                ).first()
-            if generator_settings is None:
-                if not generator_section or generator_section == "" or not generator_name or generator_name == "":
-                    return None
-                # generator_settings = GeneratorSetting(
-                #     section=generator_section,
-                #     generator_name=generator_name,
-                #     is_preset=False
-                # )
-                # session.add(generator_settings)
-            return generator_settings
-
-    def __init__(self, app=None, *args, **kwargs):
-        global _app, document
-        self.can_save = True
-
-        if app:
-            _app = app
-            document = _app.document
-        else:
-            with session_scope() as session:
-                document = session.query(Document).first()
-
-        super().__init__(*args, **kwargs)
-
-    _generator_section = None
-    _generator_name = None
-
-    @property
-    def generator_section(self):
-        if self._generator_section:
-            return self._generator_section
-        return getattr(self, f"current_section_{self.current_tab}")
-
-    @property
-    def generator_name(self):
-        if self._generator_name:
-            return self._generator_name
-        return self.current_tab
-
-    @generator_section.setter
-    def generator_section(self, value):
-        self._generator_section = value
-
-    @generator_name.setter
-    def generator_name(self, value):
-        self._generator_name = value
-
-    def create_variable(self, name):
-        var_type = str(getattr(Settings, name).property.columns[0].type)
-        variables[name] = variable_types[var_type](_app, getattr(Settings, name).default.arg)
-
-    def get_database_value(self, name):
-        return getattr(document.settings, name)
-
-    def __getattr__(self, name):
-        with session_scope() as session:
-            session.add(document)
-            session.add(document.settings)
-            if document and hasattr(document.settings, name):
-                return getattr(document.settings, name)
-        return None
-
-    def __setattr__(self, name, value):
-        if name in ["can_save", "generator_section", "generator_name", "_generator_section", "_generator_name"]:
-            super().__setattr__(name, value)
-            return
-        if document and hasattr(document.settings, name):
-            setattr(document.settings, name, value)
-            self.changed_signal.emit(name, value, self)
-
-    def set_value(self, key, value):
-        keys = key.split('.')
-        obj = self
-        for k in keys[:-1]:  # Traverse till second last key
-            obj = getattr(self, k)
-        setattr(obj, keys[-1], value)
-        self.save()
-        self.changed_signal.emit(key, value, self)
-
-    def get_value(self, key):
-        keys = key.split('.')
-        obj = self
-        for k in keys:
-            try:
-                obj = getattr(obj, k)
-            except AttributeError:
-                logger.error(f"Unable to find key {key}")
-        return obj
-
-    @property
-    def current_tab_action(self):
-        current_tab = self.current_tab
-        if current_tab == "stablediffusion":
-            return self.current_section_stablediffusion
-
-    def save(self):
-        pass
diff --git a/src/airunner/data/managers.py b/src/airunner/data/managers.py
index 0da848ce3..32b264967 100644
--- a/src/airunner/data/managers.py
+++ b/src/airunner/data/managers.py
@@ -19,7 +19,8 @@
     llm_generator_scope,
     llm_generator_settings_scope,
     canvas_settings_scope,
-    memory_settings_scope
+    memory_settings_scope,
+    metadata_settings_scope
 )
 
 
@@ -40,16 +41,14 @@ def get_property(self, name: str) -> str:
         except Exception as e:
             import traceback
             traceback.print_exc()
-            print(f"Error while getting property {name}: {e}")
+            Logger.error(f"Error while getting property {name}: {e}")
             value = None  # Return None if there's an error
         return value
 
     def get_properties(self, name: str = None) -> Iterator[str]:
         try:
-            print(f"Scope function: {self.scope_function}")
             with self.scope_function() as objects:
                 for object in objects:
-                    print(f"Object: {object}, attributes: {dir(object)}")
                     if name is None:
                         yield object
                     else:
@@ -61,7 +60,7 @@ def get_properties(self, name: str = None) -> Iterator[str]:
         except Exception as e:
             import traceback
             traceback.print_exc()
-            print(f"Error while getting property {name}: {e}")
+            Logger.error(f"Error while getting property {name}: {e}")
             yield None  # Yield None if there's an error
 
     def __getattr__(self, name):
@@ -111,7 +110,27 @@ def __init__(self):
         self.llm_generator_settings = Modelmanager(llm_generator_settings_scope)
         self.canvas_settings = Modelmanager(canvas_settings_scope)
         self.memory_settings = Modelmanager(memory_settings_scope)
+        self.metadata_settings = Modelmanager(metadata_settings_scope)
     
+    @contextmanager
+    def available_pipeline_by_section(self, pipeline_action, version, category):
+        from airunner.data.models import Pipeline
+        with session_scope() as session:
+            pipelines = session.query(Pipeline).filter_by(
+                category=category,
+                pipeline_action=pipeline_action,
+                version=version
+            ).first()
+            yield pipelines
+    
+    @contextmanager
+    def model_by_name(self, name):
+        from airunner.data.models import AIModel
+        with session_scope() as session:
+            model = session.query(AIModel).options(joinedload('*')).filter(
+                AIModel.name.like(f"%{name}%") if name != "" else True).first()
+            yield model
+
     @contextmanager
     def brushes(self):
         from airunner.data.models import Brush
@@ -176,7 +195,6 @@ def get_value(self, key):
         return obj
     
     def set_value(self, key, value):
-        print(f"Setting value {key} to {value}")
         keys = key.split('.')
         obj = self
         for k in keys[:-1]:  # Traverse till second last key
@@ -185,5 +203,4 @@ def set_value(self, key, value):
                     obj = object
                     setattr(obj, keys[-1], value)
 
-        self.changed_signal.emit(key, value)
-        print(f"Emitted changed_signal with {key}, {value}")  # Debug print statement
\ No newline at end of file
+        self.changed_signal.emit(key, value)
\ No newline at end of file
diff --git a/src/airunner/data/session_scope.py b/src/airunner/data/session_scope.py
index ea719443b..46c754704 100644
--- a/src/airunner/data/session_scope.py
+++ b/src/airunner/data/session_scope.py
@@ -131,4 +131,11 @@ def memory_settings_scope():
     from airunner.data.models import MemorySettings
     with session_scope() as session:
         memory_settings = session.query(MemorySettings).options(joinedload('*')).first()
-        yield memory_settings
\ No newline at end of file
+        yield memory_settings
+
+@contextmanager
+def metadata_settings_scope():
+    from airunner.data.models import MetadataSettings
+    with session_scope() as session:
+        metadata_settings = session.query(MetadataSettings).options(joinedload('*')).first()
+        yield metadata_settings
\ No newline at end of file
diff --git a/src/airunner/utils.py b/src/airunner/utils.py
index 32734eb12..4b2f976d9 100644
--- a/src/airunner/utils.py
+++ b/src/airunner/utils.py
@@ -257,7 +257,7 @@ def prepare_metadata(data, index=0):
     from airunner.data.managers import SettingsManager
     settings_manager = SettingsManager()
     if not settings_manager.metadata_settings.export_metadata or \
-            settings_manager.image_export_type != "png":
+            settings_manager.settings.image_export_type != "png":
         return None
     metadata = PngImagePlugin.PngInfo()
     options = data.get("options", {})
@@ -339,7 +339,7 @@ def auto_export_image(
     if not os.path.exists(path):
         os.makedirs(path)
     
-    extension = settings_manager.image_export_type
+    extension = settings_manager.settings.image_export_type
     if extension == "":
         extension = "png"
     extension = f".{extension}"
diff --git a/src/airunner/widgets/canvas_plus/canvas_plus_widget.py b/src/airunner/widgets/canvas_plus/canvas_plus_widget.py
index 3271dd71f..d72c981f6 100644
--- a/src/airunner/widgets/canvas_plus/canvas_plus_widget.py
+++ b/src/airunner/widgets/canvas_plus/canvas_plus_widget.py
@@ -33,17 +33,19 @@ def __init__(self, widget, image, is_outpaint, image_root_point):
         self.image_root_point = image_root_point
 
     def run(self):
-        with session_scope() as session:
-            self.widget.current_active_image = self.image
-            if self.image_root_point is not None:
-                self.widget.current_layer.pos_x = self.image_root_point.x()
-                self.widget.current_layer.pos_y = self.image_root_point.y()
-            elif not self.is_outpaint:
-                self.widget.current_layer.pos_x = self.widget.active_grid_area_rect.x()
-                self.widget.current_layer.pos_y = self.widget.active_grid_area_rect.y()
-            session.add(self.widget.current_layer)
-            self.widget.do_draw()
-            self.finished.emit()
+        print("setting current_active_image")
+        self.widget.current_active_image = self.image
+        print("setting current_active_image 2")
+        # with self.widget.current_layer() as layer:
+        #     if self.image_root_point is not None:
+        #         layer.pos_x = self.image_root_point.x()
+        #         layer.pos_y = self.image_root_point.y()
+        #     elif not self.is_outpaint:
+        #         layer.current_layer.pos_x = self.widget.active_grid_area_rect.x()
+        #         layer.current_layer.pos_y = self.widget.active_grid_area_rect.y()
+        self.widget.do_draw()
+        print("setting current_active_image 3")
+        self.finished.emit()
 
 
 class DraggablePixmap(QGraphicsPixmapItem):
@@ -273,18 +275,18 @@ def current_image(self):
     
     @property
     def image_pivot_point(self):
-        try:
-            return QPoint(self.current_layer.pivot_x, self.current_layer.pivot_y)
-        except Exception as e:
-            pass
-        return QPoint(0, 0)
+        with self.layer_container_widget.current_layer() as layer:
+            try:
+                return QPoint(layer.pivot_x, layer.pivot_y)
+            except Exception as e:
+                pass
+            return QPoint(0, 0)
 
     @image_pivot_point.setter
     def image_pivot_point(self, value):
-        with session_scope() as session:
-            session.add(self.current_layer)
-            self.current_layer.pivot_x = value.x()
-            self.current_layer.pivot_y = value.y()
+        with self.layer_container_widget.current_layer() as layer:
+            layer.pivot_x = value.x()
+            layer.pivot_y = value.y()
 
     @property
     def active_grid_area_selected(self):
@@ -326,15 +328,13 @@ def active_grid_area_rect(self):
 
     @property
     def current_active_image(self):
-        return self.current_layer.image
+        with self.layer_container_widget.current_layer() as layer:
+            return layer.image
     
     @current_active_image.setter
     def current_active_image(self, value):
-        self.current_layer.image = value
-
-    @property
-    def current_layer(self):
-        return self.layer_container_widget.current_layer
+        with self.layer_container_widget.current_layer() as layer:
+            layer.image = value
 
     @property
     def current_layer_index(self):
@@ -483,59 +483,68 @@ def initialize(self):
         self.do_draw()
 
     def draw_layers(self):
-        for layer in self.layers:
-            image = layer.image
-            if image is None:
-                continue
-
-            image = apply_opacity_to_image(
-                image,
-                layer.opacity / 100.0
-            )
+        print("draw layers")
+        with self.app.settings_manager.layers() as layers:
+            for layer in layers:
+                image = layer.image
+                print("layer image", image)
+                if image is None:
+                    continue
+
+                image = apply_opacity_to_image(
+                    image,
+                    layer.opacity / 100.0
+                )
 
-            if layer.id in self.layers:
-                if not layer.visible:
-                    if self.layers[layer.id] in self.scene.items():
-                        self.scene.removeItem(self.layers[layer.id])
-                elif layer.visible:
-                    if not self.layers[layer.id] in self.scene.items():
-                        self.scene.addItem(self.layers[layer.id])
+                if layer.id in self.layers:
+                    if not layer.visible:
+                        if self.layers[layer.id] in self.scene.items():
+                            self.scene.removeItem(self.layers[layer.id])
+                    elif layer.visible:
+                        if not self.layers[layer.id] in self.scene.items():
+                            self.scene.addItem(self.layers[layer.id])
+                        self.layers[layer.id].pixmap.convertFromImage(ImageQt(image))
+                    continue
+
+                draggable_pixmap = None
+                if layer.id in self.layers:
                     self.layers[layer.id].pixmap.convertFromImage(ImageQt(image))
-                continue
-
-            draggable_pixmap = None
-            if layer.id in self.layers:
-                self.layers[layer.id].pixmap.convertFromImage(ImageQt(image))
-                draggable_pixmap = self.layers[layer.id]
-                self.scene.removeItem(draggable_pixmap)
-            
-            if not draggable_pixmap:
-                draggable_pixmap = DraggablePixmap(self, QPixmap.fromImage(ImageQt(image)))
-                self.layers[layer.id] = draggable_pixmap
-
-            if layer.visible:
-                self.scene.addItem(draggable_pixmap)
-
-            pos = QPoint(layer.pos_x, layer.pos_y)
-            draggable_pixmap.setPos(QPointF(
-                self.app.settings_manager.canvas_settings.pos_x + pos.x(),
-                self.app.settings_manager.canvas_settings.pos_y + pos.y()
-            ))
+                    draggable_pixmap = self.layers[layer.id]
+                    self.scene.removeItem(draggable_pixmap)
+                
+                if not draggable_pixmap:
+                    draggable_pixmap = DraggablePixmap(self, QPixmap.fromImage(ImageQt(image)))
+                    self.layers[layer.id] = draggable_pixmap
+
+                if layer.visible:
+                    self.scene.addItem(draggable_pixmap)
+
+                pos = QPoint(layer.pos_x, layer.pos_y)
+                draggable_pixmap.setPos(QPointF(
+                    self.app.settings_manager.canvas_settings.pos_x + pos.x(),
+                    self.app.settings_manager.canvas_settings.pos_y + pos.y()
+                ))
+            print("draw layers 2")
 
     def set_scene_rect(self):
+        print("set_scene_rect")
         self.scene.setSceneRect(0, 0, self.view_size.width(), self.view_size.height())
 
     def draw_lines(self):
+        print("draw_lines")
         width_cells = math.ceil(self.view_size.width() / self.cell_size)
         height_cells = math.ceil(self.view_size.height() / self.cell_size)
+        print("draw_lines2")
 
         pen = QPen(
             QBrush(self.line_color),
             self.line_width,
             Qt.PenStyle.SolidLine
         )
+        print("draw_lines3")
 
         if self.app.settings_manager.grid_settings.show_grid:
+            print("draw_lines4")
             # vertical lines
             h = self.view_size.height() + abs(self.app.settings_manager.canvas_settings.pos_y) % self.cell_size
             y = 0
@@ -549,11 +558,13 @@ def draw_lines(self):
             for i in range(height_cells):
                 y = i * self.cell_size + self.app.settings_manager.canvas_settings.pos_y % self.cell_size
                 self.scene.addLine(x, y, w, y, pen)
+        print("draw_lines6")
 
     def draw_active_grid_area_container(self):
         """
         Draw a rectangle around the active grid area of
         """
+        print("draw_active_grid_area_container")
         if not self.active_grid_area:
             self.active_grid_area = ActiveGridArea(
                 parent=self,
@@ -572,7 +583,9 @@ def action_button_clicked_focus(self):
         self.do_draw()
 
     def do_draw(self):
+        print("DO DRAW")
         if self.drawing or not self.initialized:
+            print("returning")
             return
         self.drawing = True
         self.view_size = self.view.viewport().size()
@@ -606,6 +619,8 @@ def update_cursor(self):
             self.canvas_container.setCursor(QCursor(Qt.CursorShape.ArrowCursor))
 
     def handle_image_data(self, data):
+        print("canvas plus widget handle image data")
+        print(data)
         options = data["data"]["options"]
         images = data["images"]
         outpaint_box_rect = options["outpaint_box_rect"]
@@ -633,7 +648,8 @@ def handle_outpaint(self, outpaint_box_rect, outpainted_image, action=None):
 
         pivot_point = self.image_pivot_point
         root_point = QPoint(0, 0)
-        current_image_position = QPoint(self.current_layer.pos_x, self.current_layer.pos_y)
+        with self.layer_container_widget.current_layer() as layer:
+            current_image_position = QPoint(layer.pos_x, layer.pos_y)
 
         is_drawing_left = outpaint_box_rect.x() < current_image_position.x()
         is_drawing_right = outpaint_box_rect.x() > current_image_position.x()
@@ -674,12 +690,14 @@ def handle_outpaint(self, outpaint_box_rect, outpainted_image, action=None):
         return new_image, image_root_point, image_pivot_point
     
     def load_image_from_path(self, image_path):
+        print("canvas_plus_widget load_image_from_path", image_path)
         if image_path is None or image_path == "":
             return
         image = Image.open(image_path)
         self.load_image_from_object(image)
     
     def load_image_from_object(self, image, is_outpaint=False, image_root_point=None):
+        print("load image from object")
         self.add_image_to_scene(image, is_outpaint=is_outpaint, image_root_point=image_root_point)
 
     def load_image(self, image_path):
@@ -690,9 +708,10 @@ def load_image(self, image_path):
         self.add_image_to_scene(image)
     
     def current_draggable_pixmap(self):
-        index = self.current_layer_index + 1
-        if index in self.layers:
-            return self.layers[index]
+        with self.layer_container_widget.current_layer() as layer:
+            index = layer + 1
+            if index in self.layers:
+                return self.layers[index]
 
     def copy_image(self, image:Image=None) -> DraggablePixmap:
         pixmap = self.current_pixmap() if image is None else QPixmap.fromImage(ImageQt(image))
@@ -704,8 +723,9 @@ def cut_image(self):
         if not draggable_pixmap:
             return
         self.scene.removeItem(draggable_pixmap)
-        if self.current_layer.id in self.layers:
-            del self.layers[self.current_layer.id]
+        with self.layer_container_widget.current_layer() as layer:
+            if layer.id in self.layers:
+                del self.layers[layer.id]
         self.update()
     
     def delete_image(self):
@@ -781,11 +801,13 @@ def switch_to_layer(self, layer_index):
         self.current_layer_index = layer_index
 
     def add_image_to_scene(self, image, is_outpaint=False, image_root_point=None):
+        print("add_image_to_scene")
         self.image_adder = ImageAdder(self, image, is_outpaint, image_root_point)
         self.image_adder.finished.connect(self.on_image_adder_finished)
         self.image_adder.start()
     
     def on_image_adder_finished(self):
+        print("on_image_adder_finished")
         pass
     
     def image_to_system_clipboard_windows(self, pixmap):
diff --git a/src/airunner/widgets/canvas_plus/standard_base_widget.py b/src/airunner/widgets/canvas_plus/standard_base_widget.py
index 821350fb2..ed303b793 100644
--- a/src/airunner/widgets/canvas_plus/standard_base_widget.py
+++ b/src/airunner/widgets/canvas_plus/standard_base_widget.py
@@ -11,6 +11,7 @@ def __init__(self, *args, **kwargs):
         self.app.load_image.connect(self.load_image_from_path)
 
     def handle_image_data(self, data):
+        print("standard base widget handle image data")
         pass
 
     def load_image_from_path(self, image_path):
diff --git a/src/airunner/widgets/canvas_plus/standard_image_widget.py b/src/airunner/widgets/canvas_plus/standard_image_widget.py
index 74289e359..c9f0177cb 100644
--- a/src/airunner/widgets/canvas_plus/standard_image_widget.py
+++ b/src/airunner/widgets/canvas_plus/standard_image_widget.py
@@ -14,6 +14,7 @@
 from airunner.widgets.slider.slider_widget import SliderWidget
 from airunner.data.models import ActionScheduler, Pipeline
 from airunner.data.session_scope import session_scope
+from airunner.aihandler.logger import Logger
 
 
 class StandardImageWidget(StandardBaseWidget):
@@ -30,7 +31,10 @@ class StandardImageWidget(StandardBaseWidget):
     @property
     def image(self):
         if self._image is None:
-            self.image = self.app.canvas_widget.current_layer.image
+            try:
+                self.image = self.app.canvas_widget.current_layer.image
+            except Exception as e:
+                Logger.error(f"Error while getting image: {e}")
         return self._image
     
     @image.setter
diff --git a/src/airunner/widgets/generator_form/generator_form_widget.py b/src/airunner/widgets/generator_form/generator_form_widget.py
index ed89e717f..d0b6ce0fc 100644
--- a/src/airunner/widgets/generator_form/generator_form_widget.py
+++ b/src/airunner/widgets/generator_form/generator_form_widget.py
@@ -54,18 +54,15 @@ def is_txt2vid(self):
 
     @property
     def generator_section(self):
-        return getattr(self.app.settings_manager, f"current_section_{self.app.settings_manager.current_image_generator}")
+        return self.app.settings_manager.settings.current_section_stablediffusion
 
     @property
     def generator_name(self):
-        return self.app.settings_manager.current_image_generator
+        return self.app.settings_manager.settings.current_image_generator
 
     @property
     def generator_settings(self):
-        return self.app.settings_manager.find_generator(
-            self.generator_section,
-            self.generator_name
-        )
+        return self.app.settings_manager.generator_settings
 
     @property
     def random_seed(self):
@@ -100,12 +97,12 @@ def image_scale(self):
     @property
     def active_rect(self):
         rect = QRect(
-            self.active_grid_settings.pos_x,
-            self.active_grid_settings.pos_y,
-            self.active_grid_settings.width,
-            self.active_grid_settings.height
+            self.app.settings_manager.active_grid_settings.pos_x,
+            self.app.settings_manager.active_grid_settings.pos_y,
+            self.app.settings_manager.active_grid_settings.width,
+            self.app.settings_manager.active_grid_settings.height
         )
-        rect.translate(-self.canvas_settings.pos_x, -self.canvas_settings.pos_y)
+        rect.translate(-self.app.settings_manager.canvas_settings.pos_x, -self.app.settings_manager.canvas_settings.pos_y)
 
         return rect
 
@@ -120,9 +117,6 @@ def controlnet_image(self):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.ui.generator_form_tabs.tabBar().hide()
-        with session_scope() as session:
-            self.active_grid_settings = session.query(ActiveGridSettings).first()
-            self.canvas_settings = session.query(CanvasSettings).first()
         self.activate_ai_mode()
     
     def activate_ai_mode(self):
@@ -164,7 +158,6 @@ def action_clicked_button_save_prompts(self):
         )
 
     def handle_prompt_changed(self):
-        print("PROMPT CHANGED")
         if not self.initialized:
             return
         self.app.settings_manager.set_value("generator.prompt", self.ui.prompt.toPlainText())
@@ -350,132 +343,130 @@ def do_generate(self, extra_options=None, seed=None, latents_seed=None, do_deter
         enable_controlnet = bool(override_data.get("enable_controlnet", self.app.settings_manager.generator.enable_controlnet))
         controlnet = override_data.get("controlnet", self.app.settings_manager.generator.controlnet)
         controlnet_conditioning_scale = float(override_data.get("controlnet_conditioning_scale", self.app.settings_manager.generator.controlnet_guidance_scale))
-        width = int(override_data.get("width", self.app.settings_manager.working_width))
-        height = int(override_data.get("height", self.app.settings_manager.working_height))
+        width = int(override_data.get("width", self.app.settings_manager.settings.working_width))
+        height = int(override_data.get("height", self.app.settings_manager.settings.working_height))
         clip_skip = int(override_data.get("clip_skip", self.app.settings_manager.generator.clip_skip))
         batch_size = int(override_data.get("batch_size", 1))
 
 
         # get the model from the database
-        model = self.app.settings_manager.models.filter_by(
-            name=model_data["name"] if "name" in model_data \
-                else self.app.settings_manager.generator.model
-        ).first()
-        if model:
-            # set the model data, first using model_data pulled from the override_data
-            model_data = dict(
-                name=model_data.get("name", model.name),
-                path=model_data.get("path", model.path),
-                branch=model_data.get("branch", model.branch),
-                version=model_data.get("version", model.version),
-                category=model_data.get("category", model.category),
-                pipeline_action=model_data.get("pipeline_action", model.pipeline_action),
-                enabled=model_data.get("enabled", model.enabled),
-                default=model_data.get("default", model.is_default)
-            )
-
-        input_image = override_data.get("input_image", None),
-        if input_image:
-            # check if input image is a tupil
-            if isinstance(input_image, tuple):
-                input_image = input_image[0]
-
-        original_model_data = {}
-        if input_image is not None:
-            if isinstance(input_image, tuple):
-                input_image_info = input_image[0].info
-            else:
-                input_image_info = input_image.info
-
-            keys = [
-                "name", 
-                "path", 
-                "branch", 
-                "version", 
-                "category", 
-                "pipeline_action", 
-                "enabled", 
-                "default",
-            ]
-            original_model_data = {
-                key: model_data.get(
-                    key, input_image_info.get(key, "")) for key in keys
-            }
-
-        # get controlnet_dropdown from active tab
-        options = dict(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            steps=steps,
-            ddim_eta=ddim_eta,  # only applies to ddim scheduler
-            n_iter=n_iter,
-            n_samples=n_samples,
-            scale=scale,
-            seed=seed,
-            latents_seed=latents_seed,
-            model=model,
-            model_data=model_data,
-            original_model_data=original_model_data,
-            scheduler=scheduler,
-            model_path=model.path,
-            model_branch=model.branch,
-            # lora=self.available_lora(action),
-            generator_section=self.generator_section,
-            width=width,
-            height=height,
-            do_nsfw_filter=self.app.settings_manager.settings.nsfw_filter,
-            pos_x=0,
-            pos_y=0,
-            outpaint_box_rect=self.active_rect,
-            hf_token=self.app.settings_manager.hf_api_key,
-            model_base_path=self.app.settings_manager.path_settings.model_base_path,
-            outpaint_model_path=self.app.settings_manager.path_settings.outpaint_model_path,
-            pix2pix_model_path=self.app.settings_manager.path_settings.pix2pix_model_path,
-            depth2img_model_path=self.app.settings_manager.path_settings.depth2img_model_path,
-            upscale_model_path=self.app.settings_manager.path_settings.upscale_model_path,
-            image_path=self.app.settings_manager.path_settings.image_path,
-            lora_path=self.app.settings_manager.lora_path,
-            embeddings_path=self.app.settings_manager.path_settings.embeddings_path,
-            video_path=self.app.settings_manager.path_settings.video_path,
-            clip_skip=clip_skip,
-            batch_size=batch_size,
-            variation=self.app.settings_manager.generator.variation,
-            deterministic_generation=False,
-            input_image=input_image,
-            enable_controlnet=enable_controlnet,
-            controlnet_conditioning_scale=controlnet_conditioning_scale,
-            controlnet=controlnet,
-        )
-
-        if self.controlnet_image:
-            options["controlnet_image"] = self.controlnet_image
-
-        if action == "superresolution":
-            options["original_image_width"] = self.app.canvas_widget.current_active_image_data.image.width
-            options["original_image_height"] = self.app.canvas_widget.current_active_image_data.image.height
-
-        if action in ["txt2img", "img2img", "outpaint", "depth2img"]:
-            options[f"strength"] = strength
-        elif action in ["pix2pix"]:
-            options[f"image_guidance_scale"] = image_guidance_scale
-
-        """
-        Emitting generate_signal with options allows us to pass more options to the dict from
-        modal windows such as the image interpolation window.
-        """
-        self.app.generate_signal.emit(options)
+        name = model_data["name"] if "name" in model_data else self.app.settings_manager.generator.model
+        with self.app.settings_manager.model_by_name(name) as model:
+            if model:
+                # set the model data, first using model_data pulled from the override_data
+                model_data = dict(
+                    name=model_data.get("name", model.name),
+                    path=model_data.get("path", model.path),
+                    branch=model_data.get("branch", model.branch),
+                    version=model_data.get("version", model.version),
+                    category=model_data.get("category", model.category),
+                    pipeline_action=model_data.get("pipeline_action", model.pipeline_action),
+                    enabled=model_data.get("enabled", model.enabled),
+                    default=model_data.get("default", model.is_default)
+                )
 
-        memory_options = self.get_memory_options()
+                input_image = override_data.get("input_image", None),
+                if input_image:
+                    # check if input image is a tupil
+                    if isinstance(input_image, tuple):
+                        input_image = input_image[0]
+
+                original_model_data = {}
+                if input_image is not None:
+                    if isinstance(input_image, tuple):
+                        input_image_info = input_image[0].info
+                    else:
+                        input_image_info = input_image.info
+
+                    keys = [
+                        "name", 
+                        "path", 
+                        "branch", 
+                        "version", 
+                        "category", 
+                        "pipeline_action", 
+                        "enabled", 
+                        "default",
+                    ]
+                    original_model_data = {
+                        key: model_data.get(
+                            key, input_image_info.get(key, "")) for key in keys
+                    }
+
+                # get controlnet_dropdown from active tab
+                options = dict(
+                    prompt=prompt,
+                    negative_prompt=negative_prompt,
+                    steps=steps,
+                    ddim_eta=ddim_eta,  # only applies to ddim scheduler
+                    n_iter=n_iter,
+                    n_samples=n_samples,
+                    scale=scale,
+                    seed=seed,
+                    latents_seed=latents_seed,
+                    model=model,
+                    model_data=model_data,
+                    original_model_data=original_model_data,
+                    scheduler=scheduler,
+                    model_path=model.path,
+                    model_branch=model.branch,
+                    # lora=self.available_lora(action),
+                    generator_section=self.generator_section,
+                    width=width,
+                    height=height,
+                    do_nsfw_filter=self.app.settings_manager.settings.nsfw_filter,
+                    pos_x=0,
+                    pos_y=0,
+                    outpaint_box_rect=self.active_rect,
+                    hf_token=self.app.settings_manager.settings.hf_api_key,
+                    model_base_path=self.app.settings_manager.path_settings.model_base_path,
+                    outpaint_model_path=self.app.settings_manager.path_settings.outpaint_model_path,
+                    pix2pix_model_path=self.app.settings_manager.path_settings.pix2pix_model_path,
+                    depth2img_model_path=self.app.settings_manager.path_settings.depth2img_model_path,
+                    upscale_model_path=self.app.settings_manager.path_settings.upscale_model_path,
+                    image_path=self.app.settings_manager.path_settings.image_path,
+                    lora_path=self.app.settings_manager.path_settings.lora_path,
+                    embeddings_path=self.app.settings_manager.path_settings.embeddings_path,
+                    video_path=self.app.settings_manager.path_settings.video_path,
+                    clip_skip=clip_skip,
+                    batch_size=batch_size,
+                    variation=self.app.settings_manager.generator.variation,
+                    deterministic_generation=False,
+                    input_image=input_image,
+                    enable_controlnet=enable_controlnet,
+                    controlnet_conditioning_scale=controlnet_conditioning_scale,
+                    controlnet=controlnet,
+                )
 
-        data = {
-            "action": action,
-            "options": {
-                **options,
-                **extra_options,
-                **memory_options
-            }
-        }
-        self.app.client.message = data
+                if self.controlnet_image:
+                    options["controlnet_image"] = self.controlnet_image
+
+                if action == "superresolution":
+                    options["original_image_width"] = self.app.canvas_widget.current_active_image_data.image.width
+                    options["original_image_height"] = self.app.canvas_widget.current_active_image_data.image.height
+
+                if action in ["txt2img", "img2img", "outpaint", "depth2img"]:
+                    options[f"strength"] = strength
+                elif action in ["pix2pix"]:
+                    options[f"image_guidance_scale"] = image_guidance_scale
+
+                """
+                Emitting generate_signal with options allows us to pass more options to the dict from
+                modal windows such as the image interpolation window.
+                """
+                self.app.generate_signal.emit(options)
+
+                memory_options = self.get_memory_options()
+
+                data = {
+                    "action": action,
+                    "options": {
+                        **options,
+                        **extra_options,
+                        **memory_options
+                    }
+                }
+                self.app.client.message = data
 
     def get_memory_options(self):
         return {
diff --git a/src/airunner/widgets/llm/templates/llm_settings.ui b/src/airunner/widgets/llm/templates/llm_settings.ui
index 3e2dacf4d..c21fc33d7 100644
--- a/src/airunner/widgets/llm/templates/llm_settings.ui
+++ b/src/airunner/widgets/llm/templates/llm_settings.ui
@@ -216,7 +216,7 @@
               <bool>true</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.repetition_penalty</string>
+              <string>llm_generator_settings.repetition_penalty</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>0</number>
@@ -262,7 +262,7 @@
               <bool>false</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.min_length</string>
+              <string>llm_generator_settings.min_length</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -312,7 +312,7 @@
               <bool>true</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.top_p</string>
+              <string>llm_generator_settings.top_p</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -358,7 +358,7 @@
               <bool>false</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.max_length</string>
+              <string>llm_generator_settings.max_length</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -445,7 +445,7 @@
               <bool>false</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.ngram_size</string>
+              <string>llm_generator_settings.ngram_size</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -491,7 +491,7 @@
               <bool>true</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.temperature</string>
+              <string>llm_generator_settings.temperature</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -541,7 +541,7 @@
               <bool>true</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.length_penalty</string>
+              <string>llm_generator_settings.length_penalty</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -587,7 +587,7 @@
               <bool>false</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.num_beams</string>
+              <string>llm_generator_settings.num_beams</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -644,7 +644,7 @@
               <bool>false</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.sequences</string>
+              <string>llm_generator_settings.sequences</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
@@ -690,7 +690,7 @@
               <bool>false</bool>
              </property>
              <property name="settings_property" stdset="0">
-              <string>llm_generator.top_k</string>
+              <string>llm_generator_settings.top_k</string>
              </property>
              <property name="slider_single_step" stdset="0">
               <number>1</number>
diff --git a/src/airunner/widgets/llm/templates/llm_settings_ui.py b/src/airunner/widgets/llm/templates/llm_settings_ui.py
index d16ea205f..ff5c5d19c 100644
--- a/src/airunner/widgets/llm/templates/llm_settings_ui.py
+++ b/src/airunner/widgets/llm/templates/llm_settings_ui.py
@@ -371,38 +371,38 @@ def retranslateUi(self, llm_settings_widget):
         self.early_stopping.setText(_translate("llm_settings_widget", "Early stopping"))
         self.do_sample.setText(_translate("llm_settings_widget", "Do sample"))
         self.groupBox_11.setTitle(_translate("llm_settings_widget", "Repetition penalty"))
-        self.repetition_penalty.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.repetition_penalty"))
+        self.repetition_penalty.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.repetition_penalty"))
         self.repetition_penalty.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_16.setTitle(_translate("llm_settings_widget", "Min length"))
-        self.min_length.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.min_length"))
+        self.min_length.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.min_length"))
         self.min_length.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_20.setTitle(_translate("llm_settings_widget", "Top P"))
-        self.top_p.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.top_p"))
+        self.top_p.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.top_p"))
         self.top_p.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_21.setTitle(_translate("llm_settings_widget", "Max length"))
-        self.max_length.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.max_length"))
+        self.max_length.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.max_length"))
         self.max_length.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.leave_in_vram.setText(_translate("llm_settings_widget", "Leave in VRAM"))
         self.move_to_cpu.setText(_translate("llm_settings_widget", "Move to CPU"))
         self.unload_model.setText(_translate("llm_settings_widget", "Unload model"))
         self.label_3.setText(_translate("llm_settings_widget", "Model management"))
         self.groupBox_17.setTitle(_translate("llm_settings_widget", "No repeat ngram size"))
-        self.ngram_size.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.ngram_size"))
+        self.ngram_size.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.ngram_size"))
         self.ngram_size.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_18.setTitle(_translate("llm_settings_widget", "Temperature"))
-        self.temperature.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.temperature"))
+        self.temperature.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.temperature"))
         self.temperature.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_24.setTitle(_translate("llm_settings_widget", "Length penalty"))
-        self.length_penalty.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.length_penalty"))
+        self.length_penalty.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.length_penalty"))
         self.length_penalty.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_25.setTitle(_translate("llm_settings_widget", "Num beams"))
-        self.num_beams.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.num_beams"))
+        self.num_beams.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.num_beams"))
         self.num_beams.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_22.setTitle(_translate("llm_settings_widget", "Sequences to generate"))
-        self.sequences.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.sequences"))
+        self.sequences.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.sequences"))
         self.sequences.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.groupBox_23.setTitle(_translate("llm_settings_widget", "Top k"))
-        self.top_k.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator.top_k"))
+        self.top_k.setProperty("settings_property", _translate("llm_settings_widget", "llm_generator_settings.top_k"))
         self.top_k.setProperty("slider_callback", _translate("llm_settings_widget", "handle_value_change"))
         self.label_4.setText(_translate("llm_settings_widget", "How to treat model when not in use"))
 from airunner.widgets.slider.slider_widget import SliderWidget
diff --git a/src/airunner/widgets/slider/slider_widget.py b/src/airunner/widgets/slider/slider_widget.py
index d46fe0fa4..8829980dd 100644
--- a/src/airunner/widgets/slider/slider_widget.py
+++ b/src/airunner/widgets/slider/slider_widget.py
@@ -123,7 +123,6 @@ def initialize_properties(self, **kwargs):
         self.divide_by = self.property("divide_by") or 1.0
 
         if settings_property is not None:
-            print("GET SETTINGS PROPERTY", settings_property)
             current_value = self.app.settings_manager.get_value(settings_property) or 0
 
         # check if slider_callback is str
@@ -169,7 +168,6 @@ def initialize_properties(self, **kwargs):
             self.ui.slider_spinbox.setDecimals(2 if decimals < 2 else decimals)
     
     def set_slider_and_spinbox_values(self, val):
-        print("VAL", val)
         self.ui.slider.blockSignals(True)
         self.ui.slider_spinbox.blockSignals(True)
 
diff --git a/src/airunner/windows/main/main_window.py b/src/airunner/windows/main/main_window.py
index 998573a82..0cbd38db2 100644
--- a/src/airunner/windows/main/main_window.py
+++ b/src/airunner/windows/main/main_window.py
@@ -60,6 +60,7 @@ def process(self):
         self.finished.emit()
     
     def process_image_data(self, message):
+        print("process_image_data 1")
         images = message["images"]
         data = message["data"]
         nsfw_content_detected = message["nsfw_content_detected"]
@@ -314,8 +315,6 @@ def handle_changed_signal(self, key, value):
             self.refresh_lora()
         elif key == "path_settings.model_base_path":
             self.generator_tab_widget.refresh_model_list()
-        elif key == "generator.seed":
-            self.prompt_builder.process_prompt()
         # elif key == "use_prompt_builder_checkbox":
         #     self.generator_tab_widget.toggle_all_prompt_builder_checkboxes(value)
         elif key == "models":