diff --git a/README.md b/README.md
index 688f14d..033e1d2 100644
--- a/README.md
+++ b/README.md
@@ -4,12 +4,21 @@
 
 AnimExtras is an addon for Blender that adds ease-of-use for animators using onion skinning. It will allow animators to preview have 3d onion skinning in the 3D View using different preview modes. Colors are fully customizable, together with the opacity. Added options allow for a convenient preview when viewing the onion skinning.
 
+NOTE OF THIS FORK: UPDATED FOR 2025 - NOW WORKING ON BLENDER 4.4.3!!!
+
+Remember, this addon calculates the skinning for all frames in the playback range that you have in Blender, to change that you'll have to set your start and end in the Timeline Editor.
+
+This add-on doesn't auto update with changes in animation yet, adapt your workflow so you update your onion skin everytime you make a change.
+
+Happy Animating!
+
 !['Preview'](https://raw.githubusercontent.com/wiki/schroef/animextras/images/anmx-v112.jpg?2021-04-21.2)
 
 ## Features
 
 * Dedicated panel
 * Easy clear / update skinning
+* Added support for multiple meshes, helpfull for animating proxy rigs.
 * 4 preview modes
   * Per-Frame
   * Per-Frame Stepped
@@ -26,8 +35,8 @@ AnimExtras is an addon for Blender that adds ease-of-use for animators using oni
 
 | **OS** | **Blender** |
 | ------------- | ------------- |
-| OSX | Blender 2.80 |
-| Windows | Blender 2.80 |
+| OSX | Blender 4.4.3 |
+| Windows | Blender 4.4.3 |
 | Linux | Not Tested |
 
 <!-- ### Blender 2.80 | Pre-release
diff --git a/__init__.py b/__init__.py
index 3af26e7..54cb2ef 100644
--- a/__init__.py
+++ b/__init__.py
@@ -24,9 +24,9 @@
 
 bl_info = {
     "name": "AnimExtras",
-    "author": "Andrew Combs, Rombout Versluijs",
-    "version": (1, 1, 2),
-    "blender": (2, 80, 0),
+    "author": "Andrew Combs, Rombout Versluijs, Sebastian Sarmiento",
+    "version": (1, 1, 6),
+    "blender": (4, 4, 3),
     "description": "True onion skinning",
     "category": "Animation",
     "wiki_url": "https://github.com/iBrushC/animextras",
diff --git a/ons/gui.py b/ons/gui.py
index 807ef30..8bb4a7c 100644
--- a/ons/gui.py
+++ b/ons/gui.py
@@ -26,7 +26,7 @@ def draw(self, context):
         layout.use_property_decorate = False
         
         # Makes sure the user can't do any operations when the onion object doesn't exist
-        if access.onion_object not in bpy.data.objects:
+        if not access.onion_group or len(access.onion_group) == 0:
             layout.operator("anim_extras.set_onion")
             return
         if context.selected_objects == []:
@@ -42,8 +42,10 @@ def draw(self, context):
             layout.separator(factor=0.2)
         
         
-        col = layout.column()
-        col.prop(access,"onion_object", text="Current", emboss=False, icon='OUTLINER_OB_MESH') #text="{}".format(access.onion_object), 
+        box = layout.box()
+        box.label(text="Onion Group:")
+        for item in access.onion_group:
+            box.label(text=item.name, icon='OUTLINER_OB_MESH')
         
         col = layout.column()
         col.prop(access, "onion_mode", text="Method")
@@ -105,5 +107,4 @@ def draw(self, context):
         if access.toggle:
             text = "Stop Drawing"
         icoOni = 'ONIONSKIN_OFF' if access.toggle else 'ONIONSKIN_ON'
-        layout.prop(access, "toggle", text=text, toggle=True, icon=icoOni)
-        
\ No newline at end of file
+        layout.prop(access, "toggle", text=text, toggle=True, icon=icoOni)
\ No newline at end of file
diff --git a/ons/ops.py b/ons/ops.py
index 06124cc..6c493d3 100644
--- a/ons/ops.py
+++ b/ons/ops.py
@@ -7,6 +7,7 @@
 from bpy.types import Operator, PropertyGroup
 import gpu
 from gpu_extras.batch import batch_for_shader
+import bmesh
 
 import numpy as np
 from mathutils import Vector, Matrix
@@ -26,157 +27,76 @@
 
 def frame_get_set(_obj, frame):
     scn = bpy.context.scene
-    anmx = scn.anmx_data
 
-    # Show from viewport > keep off this allows in_front to work
-    # if "_animextras" in scn.collection.children:
-    #     vlayer = scn.view_layers['View Layer']
-    #     vlayer.layer_collection.children['_animextras'].hide_viewport = False
-
-    if _obj.type == 'EMPTY':
-        if anmx.is_linked:
-            bpy.ops.object.duplicate_move_linked(OBJECT_OT_duplicate={"linked":True})
-            # Hide original but keep it able to render
-            _obj.hide_viewport = True
-            if "_animextras" in scn.collection.children:
-                bpy.data.collections['_animextras'].objects.link(bpy.data.objects[anmx.onion_object])
-            # bpy.ops.object.move_to_collection(collection_index=0, is_new=True, new_collection_name="_animextras")
-
-        _obj = bpy.context.active_object
-        if not "_animextras" in scn.collection.children:
-            bpy.ops.object.move_to_collection(collection_index=0, is_new=True, new_collection_name="_animextras")
-            # bpy.data.collections['_animextras'].hide_viewport = True
-            # bpy.data.scenes["Scene"].view_layers[0].layer_collection.collection.children["_animextras"].hide_viewport = False
-            bpy.data.collections['_animextras'].hide_render = True
-            _obj = bpy.context.selected_objects[0]
-        
-        # print("_obj %s" % _obj)
-        if anmx.is_linked:
-            bpy.ops.object.make_override_library()
-            for i in bpy.data.collections['_animextras'].children[0].objects:
-                if i.type == 'MESH':
-                    new_onion = i.name
-                    i.hide_render = True
-
-            scn.anmx_data.onion_object = new_onion
-            anmx.is_linked = False
-
-        # Return duplicated linked rig made local     
-        _obj =  bpy.data.objects[anmx.onion_object]
-        
-        # Make object active so panel shows
-        bpy.context.view_layer.objects.active = _obj
-        # Select active
-        # bpy.context.scene.objects["Body"].select_set(True)
-       
-	# Gets all of the data from a mesh on a certain frame
-    tmpobj = _obj
-
-    # Setting the frame to get an accurate reading of the object on the selected frame
-    scn = bpy.context.scene
+    # Set the frame to get the correct geometry
     scn.frame_set(frame)
 
-    # Getting the Depenency Graph and the evaluated object
     depsgraph = bpy.context.evaluated_depsgraph_get()
-    eval = tmpobj.evaluated_get(depsgraph)
-
-    # Making a new mesh from the object.
+    eval = _obj.evaluated_get(depsgraph)
     mesh = eval.to_mesh()
     mesh.update()
-    
-    # Getting the object's world matrix
+
     mat = Matrix(_obj.matrix_world)
-    
-    # This moves the mesh by the object's world matrix, thus making everything global space. This is much faster than getting each vertex individually and doing a matrix multiplication on it
     mesh.transform(mat)
     mesh.update()
-    
-    # loop triangles are needed to properly draw the mesh on screen
     mesh.calc_loop_triangles()
     mesh.update()
-    
-    # Creating empties so that all of the verts and indices can be gathered all at once in the next step
+
     vertices = np.empty((len(mesh.vertices), 3), 'f')
     indices = np.empty((len(mesh.loop_triangles), 3), 'i')
-    
-    # Getting all of the vertices and incices all at once (from: https://docs.blender.org/api/current/gpu.html#mesh-with-random-vertex-colors)
-    mesh.vertices.foreach_get(
-        "co", np.reshape(vertices, len(mesh.vertices) * 3))
-    mesh.loop_triangles.foreach_get(
-        "vertices", np.reshape(indices, len(mesh.loop_triangles) * 3))
-    
+
+    mesh.vertices.foreach_get("co", np.reshape(vertices, len(mesh.vertices) * 3))
+    mesh.loop_triangles.foreach_get("vertices", np.reshape(indices, len(mesh.loop_triangles) * 3))
+
     args = [vertices, indices]
-    
-    # Hide from viewport > keep off this allows in_front to work
-    # if "_animextras" in scn.collection.children:
-    #     vlayer = scn.view_layers['View Layer']
-    #     vlayer.layer_collection.children['_animextras'].hide_viewport = True
 
     return args
 
 
-def set_to_active(_obj):
-    """ Sets the object that is being used for the onion skinning """
+def set_to_active():
+    """ Sets the onion skinning group as the active source for baking/drawing """
     scn = bpy.context.scene
     anmx = scn.anmx_data
-    
-    # Clear all data > caused double drawing with mode switch
-    # Old clear method caused issues when using a rig
-    # Still see handler issue
+
+    # Clear all data
     frame_data.clear()
     batches.clear()
     extern_data.clear()
 
-    # skip clear if we are linked
-    if hasattr(anmx,"link_parent"):
-        if not anmx.link_parent == "":
-            clear_active(clrRig=False)
+    group_objs = anmx.get_onion_group()
+    if not group_objs:
+        return
 
-    anmx.onion_object = _obj.name
-    anmx.is_linked = True if _obj.type == 'EMPTY' else False
-    
-    if anmx.is_linked:
-        if hasattr(anmx,"link_parent"):
-            if not anmx.link_parent:
-                anmx.link_parent = _obj.name
 
+    # Bake and batch using the joined mesh
     bake_frames()
     make_batches()
 
 
 def clear_active(clrRig):
-    """ clrRig will do complete clear, sued with linked Rigs, allows to update it without deleting everuthing """
-    """ Clears the active object """ 
+    """ Clears all onion skinning data and the onion group """
 
-    scn = bpy.context.scene
-    anmx = scn.anmx_data
-    name = anmx.onion_object
-    
-    # Clears all the data needed to store onion skins on the previously selected object
+    # Clear all the data needed to store onion skins
     frame_data.clear()
     batches.clear()
     extern_data.clear()
-    
-    # Clear localzed rigs & overrides linked items
-    if clrRig:
-        if hasattr(anmx,"link_parent"):
-            if not anmx.link_parent == "":
-                bpy.data.collections["_animextras"].children[0].objects.unlink(bpy.data.objects[name])
-                bpy.data.collections.remove(bpy.data.collections[anmx.link_parent])
-                bpy.data.collections.remove(bpy.data.collections["_animextras"])
-                # Show original linked rig again
-                bpy.data.objects[anmx.link_parent].hide_viewport = False
-                anmx.link_parent = ""
 
-    # Gets rid of the selected object
-    anmx.onion_object = ""
+    # Clear the onion group
+    scn = bpy.context.scene
+    anmx = scn.anmx_data
+    anmx.onion_group.clear()
 
 
 def make_batches():
     # Custom OSL shader could be set here
     scn = bpy.context.scene
     anmx = scn.anmx_data
-    _obj = bpy.data.objects[anmx.onion_object]
+    group_objs = anmx.get_onion_group()
+    if not group_objs:
+        return
+    
+    _obj = join_meshes(group_objs)
+    
     
     
     for key in frame_data:
@@ -185,66 +105,62 @@ def make_batches():
         indices = arg[1]
         batch = batch_for_shader(shader, 'TRIS', {"pos": vertices}, indices=indices)
         batches[key] = batch
+
+    bpy.data.objects.remove(_obj)
+
+    
         
 
 def bake_frames():
-    # Needs to do the following:
-    # 1. Bake the data for every frame and store it in the objects "["frame_data"]" items
     scn = bpy.context.scene
     anmx = scn.anmx_data
-    _obj = bpy.data.objects[anmx.onion_object]
-    
+
+    group_objs = anmx.get_onion_group()
+    if not group_objs:
+        return
+
     curr = scn.frame_current
     step = anmx.skin_step
-    
-    # Getting the first and last frame of the animation
-    keyobj = _obj
-    
-    if _obj.parent is not None:
-        keyobj = _obj.parent
-    # Check if obj is linked rig
-    elif hasattr(_obj.instance_collection, "all_objects"):
-        keyobj = _obj.instance_collection.all_objects[_obj.name]
-        # print(keyobj)
-        # keyobj = _obj.parent
-
-    keyframes = []
-    for fc in keyobj.animation_data.action.fcurves:
-        for k in fc.keyframe_points:
-            keyframes.append(int(k.co[0]))
-            
-    keyframes = np.unique(keyframes)
 
-    start = int(np.min(keyframes))
-    end = int(np.max(keyframes)) + 1
-    
+    # Use the scene's frame range
+    start = scn.frame_start
+    end = scn.frame_end + 1
+
+    frame_data.clear()
+    extern_data.clear()
+
     if anmx.onion_mode == "PF":
-        for f in range(start, end):
-            arg = frame_get_set(_obj, f)
-            frame_data[str(f)] = arg
-        extern_data.clear()
-        
+        frames = range(start, end)
     elif anmx.onion_mode == "PFS":
-        for f in range(start, end, step):
-            arg = frame_get_set(_obj, f)
-            frame_data[str(f)] = arg
-        extern_data.clear()
-        
+        frames = range(start, end, step)
     elif anmx.onion_mode == "DC":
-        for fkey in keyframes:
-            arg = frame_get_set(_obj, fkey)
-            frame_data[str(fkey)] = arg
-        extern_data.clear()
-        
+        # Optionally, collect keyframes from all objects and their armatures
+        frames = set()
+        for obj in group_objs:
+            # Mesh keyframes
+            if obj.animation_data and obj.animation_data.action:
+                for fc in obj.animation_data.action.fcurves:
+                    for k in fc.keyframe_points:
+                        frames.add(int(k.co[0]))
+            # Armature keyframes
+            if obj.parent and obj.parent.type == 'ARMATURE':
+                arm = obj.parent
+                if arm.animation_data and arm.animation_data.action:
+                    for fc in arm.animation_data.action.fcurves:
+                        for k in fc.keyframe_points:
+                            frames.add(int(k.co[0]))
+        frames = sorted(frames) if frames else range(start, end)
     elif anmx.onion_mode == "INB":
-        for f in range(start, end):
-            arg = frame_get_set(_obj, f)
-            frame_data[str(f)] = arg
-
-        extern_data.clear()
-        for fkey in keyframes: 
-            extern_data[str(fkey)] = fkey
+        frames = range(start, end)
+    else:
+        frames = []
 
+    for f in frames:
+        scn.frame_set(f)
+        _obj = join_meshes(group_objs)
+        arg = frame_get_set(_obj, f)
+        frame_data[str(f)] = arg
+        bpy.data.objects.remove(_obj)
 
     scn.frame_set(curr)
     
@@ -261,14 +177,17 @@ def toggle_update(self, context):
             bpy.ops.anim_extras.draw_meshes('INVOKE_DEFAULT')
         return
 
-    def inFront(self,context):
+    def inFront(self, context):
         scn = bpy.context.scene
-        if self.onion_object:
-            obj = bpy.context.view_layer.objects.active = bpy.data.objects[self.onion_object]
-            obj.show_in_front = True if scn["anmx_data"]["in_front"] else False
-            if "use_xray" in scn["anmx_data"]:
-                if scn["anmx_data"]["use_xray"]:
-                    scn["anmx_data"]["use_xray"] = False if scn["anmx_data"]["in_front"] else True
+        # Set show_in_front for all objects in the onion group
+        for item in self.onion_group:
+            obj = bpy.data.objects.get(item.name)
+            if obj:
+                obj.show_in_front = self.in_front
+        # Optionally, handle use_xray logic if needed
+        if "use_xray" in scn["anmx_data"]:
+            if scn["anmx_data"]["use_xray"]:
+                scn["anmx_data"]["use_xray"] = False if scn["anmx_data"]["in_front"] else True
         return
 
     modes = [
@@ -278,19 +197,16 @@ def inFront(self,context):
         ("INB", "Inbetweening", " Inbetweening, lets you see frames with direct keyframes in a different color than interpolated frames", 4)
         ]
 
+
     # Onion Skinning Properties
     skin_count: bpy.props.IntProperty(name="Count", description="Number of frames we see in past and future", default=1, min=1)
     skin_step: bpy.props.IntProperty(name="Step", description="Number of frames to skip in conjuction with Count", default=1, min=1)
-    onion_object: bpy.props.StringProperty(name="Onion Object", default="")
     onion_mode: bpy.props.EnumProperty(name="", get=None, set=None, items=modes)
     use_xray: bpy.props.BoolProperty(name="Use X-Ray", description="Draws the onion visible through the object", default=False)
     use_flat: bpy.props.BoolProperty(name="Flat Colors", description="Colors while not use opacity showing 100% of the color", default=False)
     in_front: bpy.props.BoolProperty(name="In Front", description="Draws the selected object in front of the onion skinning", default=False, update=inFront)
     toggle: bpy.props.BoolProperty(name="Draw", description="Toggles onion skinning on or off", default=False, update=toggle_update)
     
-    # Linked settings
-    is_linked: bpy.props.BoolProperty(name="Is linked", default=False)
-    link_parent: bpy.props.StringProperty(name="Link Parent", default="")
 
     # Past settings
     past_color: bpy.props.FloatVectorProperty(name="Past Color", min=0, max=1, size=3, default=(1., .1, .1), subtype='COLOR')
@@ -304,93 +220,53 @@ def inFront(self,context):
     future_opacity_end: bpy.props.FloatProperty(name="Ending Opacity", min=0, max=1,precision=2, default=0.1)
     future_enabled: bpy.props.BoolProperty(name="Enabled?", default=True)
 
+    
+    onion_group: bpy.props.CollectionProperty(type=bpy.types.PropertyGroup)
+    # Helper to get the list of objects
+    def get_onion_group(self):
+        return [bpy.data.objects[item.name] for item in self.onion_group if item.name in bpy.data.objects]
+
 
 # ################ #
 # Operators        #
 # ################ #
 
 def check_selected(context):
-    obj = context.active_object
-    return context.selected_objects != []
-        # return True
-        # Need workaround so we can pose and still do updates
-        # return ((obj.type == 'MESH') and hasattr(obj.animation_data,"action") or (obj.type=='EMPTY') or (obj.type == 'MESH') and hasattr(obj.parent.animation_data,"action"))
-    #     if ((obj.type == 'MESH') and hasattr(obj.animation_data,"action") or (obj.type=='EMPTY')):
-    #         return True
-    # else:
-    #     return False
+    return any(obj.type == 'MESH' for obj in context.selected_objects)
 
 class ANMX_set_onion(Operator):
     bl_idname = "anim_extras.set_onion"
-    bl_label = "Set Onion To Selected"    
-    bl_description = "Sets the selected object to be the onion object"
-    bl_options = {'REGISTER', 'UNDO' }
-    
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        if context.selected_objects != []:
-            if (hasattr(obj.parent,"animation_data") and (obj.type == 'MESH')):
-                if (hasattr(obj.parent.animation_data,"action")):
-                    return True
-            if hasattr(obj.animation_data,"action"):
-                if hasattr(obj.animation_data.action,"fcurves"):
-                    return ((obj.type == 'MESH') and hasattr(obj.animation_data,"action") or (obj.type=='EMPTY'))
-            if hasattr(obj.instance_collection, "all_objects"):
-                return True
-    
-    def execute(self, context):
-        obj = context.active_object
-        scn = context.scene
-        anmx = scn.anmx_data
-
-        #Extra check for the shortcuts
-        if not check_selected(context):
-            self.report({'INFO'}, "Onion needs animated active selection ")
-            return {'CANCELLED'}  
-
-        anmx.toggle = False if anmx.toggle else True
+    bl_label = "Set Onion Group"
+    bl_description = "Set selected mesh objects as the onion skin group"
 
-        if obj == None:
-            return {"CANCELLED"}
-        
-        if obj.parent is None:
-            try:
-                obj.animation_data.action.fcurves
-            except AttributeError:
-                pass
-                # return {"CANCELLED"}
+    def execute(self, context):
+        access = context.scene.anmx_data
+        access.onion_group.clear()
+        # Track overrides for cleanup
+        if not hasattr(access, "onion_overrides"):
+            access.onion_overrides = []
         else:
-            try:
-                # This right here needs to change for allowing linked rigs
-                # obj.parent.animation_data.action.fcurves
-                dObj = bpy.data.objects[obj.name]
-                hasattr(dObj.instance_collection, "all_objects")
-            except AttributeError:
-                return {"CANCELLED"}
-        
-        # Or check if it is linked empty
-        if ((obj.type == 'MESH') or (obj.type=='EMPTY')):
-            set_to_active(obj)
-    
-        return {"FINISHED"}
-
+            access.onion_overrides.clear()
+
+        for obj in context.selected_objects:
+            if obj.type == 'MESH':
+                item = access.onion_group.add()
+                item.name = obj.name
+        if not access.onion_group:
+            self.report({'WARNING'}, "No valid mesh objects selected.")
+            return {'CANCELLED'}
+        print("Onion group set with %d objects." % len(access.onion_group))
+        return {'FINISHED'}
 
 class ANMX_clear_onion(Operator):
     bl_idname = "anim_extras.clear_onion"
-    bl_label = "Clear Selected Onion"
-    bl_description = "Clears the path of the onion object"
-    bl_options = {'REGISTER', 'UNDO' }
-   
-    def execute(self, context):
-        #Extra check for the shortcuts
-        if not check_selected(context):
-            self.report({'INFO'}, "Onion needs animated active selection")
-            return {'CANCELLED'}
+    bl_label = "Clear Onion Group"
+    bl_description = "Clear the current onion skin group"
 
-        clear_active(clrRig=True)
-
-        return {"FINISHED"}
+    def execute(self, context):
+        access = context.scene.anmx_data
+        access.onion_group.clear()
+        return {'FINISHED'}
     
 class ANMX_toggle_onion(Operator):
     """ Operator for toggling the onion object so we can shortcut it"""
@@ -409,16 +285,17 @@ class ANMX_add_clear_onion(Operator):
     bl_idname = "anim_extras.add_clear_onion"
     bl_label = "Add/Toggle Onion"
     bl_description = "Add/Toggles onion ON/OFF"
-    bl_options = {'REGISTER', 'UNDO' }
-    
+    bl_options = {'REGISTER', 'UNDO'}
+
     def execute(self, context):
-        #Extra check for the shortcuts
+        # Extra check for the shortcuts
         if not check_selected(context):
             self.report({'INFO'}, "Onion needs animated active selection")
             return {'CANCELLED'}
 
         anmx = context.scene.anmx_data
-        if anmx.onion_object=="":
+        # Check if the onion group is empty
+        if not anmx.onion_group or len(anmx.onion_group) == 0:
             bpy.ops.anim_extras.set_onion()
         else:
             bpy.ops.anim_extras.clear_onion()
@@ -428,20 +305,44 @@ def execute(self, context):
 
 class ANMX_update_onion(Operator):
     bl_idname = "anim_extras.update_onion"
-    bl_label = "Update Selected Onion"
-    bl_description = "Updates the path of the onion object"
+    bl_label = "Update Onion Group"
+    bl_description = "Updates the onion skinning data for the current group"
     bl_options = {'REGISTER', 'UNDO' }
     
     def execute(self, context):
-        #Extra check for the shortcuts
-        if not check_selected(context):
-            self.report({'INFO'}, "Onion needs active selection")
-            return {'CANCELLED'}
+        # Update the onion skinning data for the group
+        # Save current mode and selection
+        prev_mode = context.mode
+        prev_selected = [obj for obj in context.selected_objects]
+        prev_active = context.view_layer.objects.active
+
+        # Switch to Object mode
+        if prev_mode != 'OBJECT':
+            bpy.ops.object.mode_set(mode='OBJECT')
+
+        # Select all objects in the onion group
+        anmx = context.scene.anmx_data
+        group_objs = anmx.get_onion_group()
+        bpy.ops.object.select_all(action='DESELECT')
+        for obj in group_objs:
+            obj.select_set(True)
+        if group_objs:
+            context.view_layer.objects.active = group_objs[0]
+
+        # Run the update logic
+        set_to_active()
+
+        # Restore previous selection
+        bpy.ops.object.select_all(action='DESELECT')
+        for obj in prev_selected:
+            obj.select_set(True)
+        if prev_active:
+            context.view_layer.objects.active = prev_active
+
+        # Restore previous mode
+        if prev_mode != 'OBJECT':
+            bpy.ops.object.mode_set(mode=prev_mode)
 
-        # This allows to update, also pose mode
-        if context.scene.anmx_data.onion_object in bpy.data.objects:
-            set_to_active(bpy.data.objects[context.scene.anmx_data.onion_object])
-    
         return {"FINISHED"}
 
 # Uses a list formatted in the following way to draw the meshes:
@@ -451,23 +352,16 @@ class ANMX_draw_meshes(Operator):
     bl_label = "Draw"
     bl_description = "Draws a set of meshes without creating objects"
     bl_options = {'REGISTER', 'UNDO' }
-    
-    def __init__(self):
-        print("#### __INIT__ DRAW MESHES ####")
-        self.handler = None
-        self.timer = None
-        self.mode = None
-    
-    def __del__(self):
-        """ unregister when done, helps when reopening other scenes """
-        print("#### UNREGISTER HANDLERS ####")
-        self.finish(bpy.context)
-        print("#### HANDLER %s ####" % self.handler)
+
+    def execute(self, context):
+        return {'FINISHED'}
 
     def invoke(self, context, event):
+        self.handler = None
+        self.timer = None
+        self.mode = context.scene.anmx_data.onion_mode
         self.register_handlers(context)
         context.window_manager.modal_handler_add(self)
-        self.mode = context.scene.anmx_data.onion_mode
         return {'RUNNING_MODAL'}
 
     def register_handlers(self, context):
@@ -482,11 +376,13 @@ def unregister_handlers(self, context):
         self.handler = None
 
     def modal(self, context, event):
-        if context.scene.anmx_data.onion_object not in bpy.data.objects:
+        anmx = context.scene.anmx_data
+        # Cancel if the onion group is empty
+        if not anmx.onion_group or len(anmx.onion_group) == 0:
             self.unregister_handlers(context)
             return {'CANCELLED'}
 
-        if context.scene.anmx_data.toggle is False or self.mode != context.scene.anmx_data.onion_mode:
+        if anmx.toggle is False or self.mode != anmx.onion_mode:
             self.unregister_handlers(context)
             return {'CANCELLED'}
         
@@ -556,3 +452,29 @@ def draw_callback(self, context):
                 gpu.state.face_culling_set('NONE')
                 gpu.state.depth_test_set('NONE')
             override = False
+
+def join_meshes(objs, name="OnionGroupTemp"):
+    mesh = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+
+    for obj in objs:
+        if obj.type != 'MESH':
+            continue
+        eval_obj = obj.evaluated_get(depsgraph)
+        temp_mesh = eval_obj.to_mesh()
+        temp_mesh.transform(obj.matrix_world)
+        bmesh_temp = bmesh.new()
+        bmesh_temp.from_mesh(temp_mesh)
+        bm.from_mesh(temp_mesh)
+        bmesh_temp.free()
+        eval_obj.to_mesh_clear()
+
+    bm.to_mesh(mesh)
+    bm.free()
+    temp_obj = bpy.data.objects.new(name, mesh)
+    print("Joining %s objects into %s" % (len(objs), name))
+    return temp_obj
+
+
+