diff --git a/.vscode/settings.json b/.vscode/settings.json
index 444722ff71..f5bc003aa2 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -8,10 +8,10 @@
   },
   "omnisharp.enableEditorConfigSupport": true,
   "omnisharp.enableRoslynAnalyzers": true,
-  "omnisharp.defaultLaunchSolution": "SDK.slnf",
   "[dotnet][xml]": {
     "editor.defaultFormatter": "ms-dotnettools.csharp",
     "editor.tabSize": 2
   },
-  "xml.format.spaceBeforeEmptyCloseTag": false
+  "xml.format.spaceBeforeEmptyCloseTag": false,
+  "dotnet.defaultSolution": "SDK.slnf"
 }
diff --git a/ConnectorRhino/ConnectorRhino/ConnectorRhinoShared/UI/MappingBindingsRhino.cs b/ConnectorRhino/ConnectorRhino/ConnectorRhinoShared/UI/MappingBindingsRhino.cs
index 7f032e2d07..fe2319801a 100644
--- a/ConnectorRhino/ConnectorRhino/ConnectorRhinoShared/UI/MappingBindingsRhino.cs
+++ b/ConnectorRhino/ConnectorRhino/ConnectorRhinoShared/UI/MappingBindingsRhino.cs
@@ -73,7 +73,10 @@ private List<Schema> GetObjectSchemas(RhinoObject obj)
         result.Add(existingSchema);
 
       if (obj is InstanceObject)
+      {
+        result.Add(new BlockDefinitionViewModel());
         result.Add(new RevitFamilyInstanceViewModel());
+      }
       else
         switch (obj.Geometry)
         {
diff --git a/DesktopUI2/DesktopUI2/ViewModels/MappingTool/MappingsViewModel.cs b/DesktopUI2/DesktopUI2/ViewModels/MappingTool/MappingsViewModel.cs
index 60fc80505c..8434ff27bd 100644
--- a/DesktopUI2/DesktopUI2/ViewModels/MappingTool/MappingsViewModel.cs
+++ b/DesktopUI2/DesktopUI2/ViewModels/MappingTool/MappingsViewModel.cs
@@ -315,6 +315,7 @@ private void AddRevitInfoToSchema(List<Schema> schemas)
         //no need to do extra stuff
         if (
           schema is DirectShapeFreeformViewModel
+          || schema is BlockDefinitionViewModel
           || schema is RevitTopographyViewModel
           || schema is RevitDefaultWallViewModel
           || schema is RevitDefaultFloorViewModel
diff --git a/DesktopUI2/DesktopUI2/ViewModels/MappingTool/Schemas.cs b/DesktopUI2/DesktopUI2/ViewModels/MappingTool/Schemas.cs
index 92bfcdfbb4..99e52e0b2b 100644
--- a/DesktopUI2/DesktopUI2/ViewModels/MappingTool/Schemas.cs
+++ b/DesktopUI2/DesktopUI2/ViewModels/MappingTool/Schemas.cs
@@ -4,6 +4,7 @@
 using System.Runtime.Serialization;
 using Objects.BuiltElements;
 using Objects.BuiltElements.Revit;
+using Objects.Other;
 using Objects.BuiltElements.Revit.RevitRoof;
 using ReactiveUI;
 using Speckle.Core.Api;
@@ -378,7 +379,6 @@ public DirectShapeFreeformViewModel()
       .Select(x => x.ToString())
       .OrderBy(x => x)
       .ToList();
-    ;
   }
 
   public override string Name => "DirectShape";
@@ -437,6 +437,57 @@ public override string GetSerializedSchema()
   }
 }
 
+public class BlockDefinitionViewModel : Schema
+{
+  private List<string> _categories;
+
+  private string _selectedCategory = RevitCategory.GenericModel.ToString();
+
+  public BlockDefinitionViewModel()
+  {
+    Categories = Enum.GetValues(typeof(RevitCategory))
+      .Cast<RevitCategory>()
+      .Select(x => x.ToString())
+      .OrderBy(x => x)
+      .ToList();
+    ;
+  }
+
+  public override string Name => "New Revit Family";
+
+  public List<string> Categories
+  {
+    get => _categories;
+    set => this.RaiseAndSetIfChanged(ref _categories, value);
+  }
+
+  [DataMember]
+  public string SelectedCategory
+  {
+    get => _selectedCategory;
+    set
+    {
+      this.RaiseAndSetIfChanged(ref _selectedCategory, value);
+      this.RaisePropertyChanged(nameof(IsValid));
+    }
+  }
+  public override string Summary => $"New Revit Family - {SelectedCategory}";
+
+  public override bool IsValid => !string.IsNullOrEmpty(SelectedCategory);
+
+  public override string GetSerializedSchema()
+  {
+    var res = Enum.TryParse(SelectedCategory, out RevitCategory cat);
+    if (!res)
+      cat = RevitCategory.GenericModel;
+
+    var ds = new MappedBlockWrapper(); //don't use the constructor
+    ds.category = cat.ToString();
+
+    return Operations.Serialize(ds);
+  }
+}
+
 public class RevitDefaultWallViewModel : Schema
 {
   public override string Name => "Default Wall";
diff --git a/DesktopUI2/DesktopUI2/Views/MappingsControl.xaml b/DesktopUI2/DesktopUI2/Views/MappingsControl.xaml
index d160f47e97..6054bc9214 100644
--- a/DesktopUI2/DesktopUI2/Views/MappingsControl.xaml
+++ b/DesktopUI2/DesktopUI2/Views/MappingsControl.xaml
@@ -347,17 +347,25 @@
                               IsChecked="{Binding Freeform}" />-->
                             </StackPanel>
                           </DataTemplate>
-
+                          <DataTemplate DataType="{x:Type s:BlockDefinitionViewModel}">
+                            <StackPanel Orientation="Vertical" Spacing="5">
+                              <ComboBox
+                                assists:ComboBoxAssist.Label="Category"
+                                Classes="Outline"
+                                Items="{Binding Categories}"
+                                SelectedItem="{Binding SelectedCategory, Mode=TwoWay}" />
+                            </StackPanel>
+                          </DataTemplate>
 
                         </ContentControl.DataTemplates>
                       </ContentControl>
 
                       <!--  APPLY MAPPINGS  -->
                       <Button
-                        Command="{Binding SetMappingsCommand}"
-                        Content="Apply Mappings"
-                        IsEnabled="{Binding SelectedSchema.IsValid}"
-                        ToolTip.Tip="Apply mappings to all the selected elements" />
+                                                                                                            Command="{Binding SetMappingsCommand}"
+                                                                                                            Content="Apply Mappings"
+                                                                                                            IsEnabled="{Binding SelectedSchema.IsValid}"
+                                                                                                            ToolTip.Tip="Apply mappings to all the selected elements" />
 
 
 
diff --git a/Objects/Converters/ConverterRevit/ConverterRevitShared/ConversionUtils.cs b/Objects/Converters/ConverterRevit/ConverterRevitShared/ConversionUtils.cs
index a57e0899fd..179380c87f 100644
--- a/Objects/Converters/ConverterRevit/ConverterRevitShared/ConversionUtils.cs
+++ b/Objects/Converters/ConverterRevit/ConverterRevitShared/ConversionUtils.cs
@@ -634,21 +634,20 @@ private Phase GetRevitPhase(DB.Document document, string phaseName)
       if (applicationId == null || ReceiveMode == Speckle.Core.Kits.ReceiveMode.Create)
         return null;
 
-      var cachedIds = PreviouslyReceivedObjectIds.GetCreatedIdsFromConvertedId(applicationId);
+      var cachedIds = PreviouslyReceivedObjectIds?.GetCreatedIdsFromConvertedId(applicationId);
       // TODO: we may not want just the first one
-      return Doc.GetElement(cachedIds.First());
+      return  cachedIds == null ? null : Doc.GetElement(cachedIds.First());
     }
 
     public IEnumerable<DB.Element?> GetExistingElementsByApplicationId(string applicationId)
     {
-      if (applicationId == null || ReceiveMode == Speckle.Core.Kits.ReceiveMode.Create)
+      if (applicationId == null || ReceiveMode == ReceiveMode.Create)
         yield break;
 
-      var cachedIds = PreviouslyReceivedObjectIds.GetCreatedIdsFromConvertedId(applicationId);
+      var cachedIds = PreviouslyReceivedObjectIds?.GetCreatedIdsFromConvertedId(applicationId);
+      if (cachedIds == null) yield break;
       foreach (var id in cachedIds)
-      {
         yield return Doc.GetElement(id);
-      }
     }
 
     /// <summary>
diff --git a/Objects/Converters/ConverterRevit/ConverterRevitShared/ConverterRevit.cs b/Objects/Converters/ConverterRevit/ConverterRevitShared/ConverterRevit.cs
index a622062f36..fb7b98927f 100644
--- a/Objects/Converters/ConverterRevit/ConverterRevitShared/ConverterRevit.cs
+++ b/Objects/Converters/ConverterRevit/ConverterRevitShared/ConverterRevit.cs
@@ -5,6 +5,7 @@
 using Objects.BuiltElements.Revit;
 using Objects.GIS;
 using Objects.Organization;
+using Objects.Other;
 using Objects.Structural.Properties.Profiles;
 using RevitSharedResources.Helpers;
 using RevitSharedResources.Helpers.Extensions;
@@ -51,7 +52,7 @@ public partial class ConverterRevit : ISpeckleConverter
 
     private const double TOLERANCE = 0.0164042; // 5mm in ft
 
-    public static Document Doc { get; private set; }
+    public Document Doc { get; private set; }
 
     /// <summary>
     /// <para>To know which other objects are being converted, in order to sort relationships between them.
@@ -444,6 +445,13 @@ private Base SwapGeometrySchemaObject(Base @object)
         // item in the list.
         ds.baseGeometries = new List<Base> { @object };
       }
+      else if (speckleSchema is MappedBlockWrapper mbw)
+      {
+        if (@object is not BlockInstance bi)
+          throw new Exception($"{nameof(MappedBlockWrapper)} can only be used with {nameof(BlockInstance)} objects.");
+
+        mbw.instance = bi;
+      }
       else
       {
         // find self referential prop and set value to @object if it is null (happens when sent from gh)
@@ -468,11 +476,11 @@ public object ConvertToNative(Base @base)
         case ApplicationObject appObject:
           if (appObject.Converted.Cast<Element>().ToList() is List<Element> typedList && typedList.Count >= 1)
           {
-            receivedObjectsCache.AddConvertedObjects(@base, typedList);
+            receivedObjectsCache?.AddConvertedObjects(@base, typedList);
           }
           break;
         case Element element:
-          receivedObjectsCache.AddConvertedObjects(@base, new List<Element> { element });
+          receivedObjectsCache?.AddConvertedObjects(@base, new List<Element> { element });
           break;
       }
 
@@ -502,9 +510,9 @@ public object ConvertToNativeObject(Base @object)
           case ICurve o:
             return ModelCurveToNative(o);
           case Geometry.Brep o:
-            return FreeformElementToNativeFamily(o);
+            return TryDirectShapeToNative(o, ToNativeMeshSettingEnum.Default);
           case Geometry.Mesh o:
-            return FreeformElementToNativeFamily(o);
+            return TryDirectShapeToNative(o, ToNativeMeshSettingEnum.Default);
           case BER.FreeformElement o:
             return FreeformElementToNative(o);
           default:
@@ -694,6 +702,8 @@ public object ConvertToNativeObject(Base @object)
         case Other.BlockInstance o:
           return BlockInstanceToNative(o);
 
+        case Other.MappedBlockWrapper o:
+          return MappedBlockWrapperToNative(o);
         // gis
         case PolygonElement o:
           return PolygonElementToNative(o);
@@ -846,6 +856,7 @@ public bool CanConvertToNative(Base @object)
         STR.Geometry.Element1D _ => true,
         STR.Geometry.Element2D _ => true,
         Other.BlockInstance _ => true,
+        Other.MappedBlockWrapper => true,
         Organization.DataTable _ => true,
         // GIS
         PolygonElement _ => true,
diff --git a/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertBlock.cs b/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertBlock.cs
index 725bb4da4f..66e421c06d 100644
--- a/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertBlock.cs	
+++ b/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertBlock.cs	
@@ -1,190 +1,403 @@
-#nullable enable
+#nullable enable
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
-using Autodesk.Revit.DB;
-using DB = Autodesk.Revit.DB;
-using Speckle.Core.Models;
+using System.DoubleNumerics;
+using ConverterRevitShared.Revit;
+using Objects.BuiltElements.Revit;
 using Objects.Geometry;
+using Speckle.Core.Models;
 using Speckle.Core.Models.Extensions;
-using BlockInstance = Objects.Other.BlockInstance;
-using Transform = Objects.Other.Transform;
-using Mesh = Objects.Geometry.Mesh;
+using Objects.Other;
+using Serilog.Core;
+using Speckle.Core.Kits;
+using Speckle.Core.Logging;
+using Speckle.netDxf.Blocks;
+using DB = Autodesk.Revit.DB;
 
-namespace Objects.Converter.Revit
+namespace Objects.Converter.Revit;
+
+public partial class ConverterRevit
 {
-  public partial class ConverterRevit
+  /// <summary>
+  /// Same as <see cref="BlockInstanceToNative"/> but the result will have a user-specified category
+  /// coming form our mapping tool.
+  /// </summary>
+  /// <param name="blockWrapper">The block wrapper that contains the user-defined category and the block instance</param>
+  /// <returns></returns>
+  public ApplicationObject MappedBlockWrapperToNative(MappedBlockWrapper blockWrapper)
   {
-    public ApplicationObject? BlockInstanceToNative(BlockInstance instance, Transform? transform = null)
-    {
-      var docObj = GetExistingElementByApplicationId(instance.applicationId);
-      var appObj = new ApplicationObject(instance.id, instance.speckle_type) { applicationId = instance.applicationId };
+    blockWrapper.instance.typedDefinition["category"] = blockWrapper.category;
+    if (blockWrapper.nameOverride != null)
+      blockWrapper.instance.typedDefinition.name = blockWrapper.nameOverride;
+    return BlockInstanceToNative(blockWrapper.instance);
+  }
 
-      // skip if element already exists in doc & receive mode is set to ignore
-      if (IsIgnore(docObj, appObj))
-        return appObj;
+  /// <summary>
+  /// Top-level block to native conversion. Handles conversion from block to family, as well as
+  /// updating behaviour and appObject creation.
+  /// </summary>
+  /// <param name="instance">The block instance to convert.</param>
+  /// <returns></returns>
+  public ApplicationObject BlockInstanceToNative(BlockInstance instance)
+  {
+    var docObj = GetExistingElementByApplicationId(instance.applicationId);
+    var appObj = new ApplicationObject(instance.id, instance.speckle_type) { applicationId = instance.applicationId };
 
-      var isUpdate = false;
-      if (docObj != null && ReceiveMode == Speckle.Core.Kits.ReceiveMode.Update)
+    // skip if element already exists in doc & receive mode is set to ignore
+    if (IsIgnore(docObj, appObj))
+      return appObj;
+
+    var isUpdate = false;
+    if (docObj != null && ReceiveMode == ReceiveMode.Update)
+    {
+      try
       {
-        try
-        {
-          Doc.Delete(docObj.Id);
-          isUpdate = true;
-        }
-        catch
-        {
-          //something went wrong, re-create it
-        }
+        isUpdate = true;
+        Doc.Delete(docObj.Id);
+      }
+      catch (Exception e)
+      {
+        SpeckleLog.Logger.Warning(
+          e,
+          "Unexpected issue when deleting existing BlockInstance, proceeding with new Block creation."
+        );
       }
+    }
 
-      // need to combine the two transforms, but i'm stupid and did it wrong so leaving like this for now
-      if (transform != null)
-        transform *= instance.transform;
-      else
-        transform = instance.transform;
+    try
+    {
+      var familyInstance = ConvertBlockInstanceToFamilyInstance(instance);
+      var state = isUpdate ? ApplicationObject.State.Updated : ApplicationObject.State.Created;
+      appObj.Update(
+        status: state,
+        createdId: familyInstance.UniqueId,
+        convertedItem: familyInstance,
+        logItem: $"Assigned name: {familyInstance.Symbol.Name}"
+      );
+    }
+    catch (Exception e)
+    {
+      var errMsg = "An unexpected error occured when converting a BlockInstance to Native";
+      SpeckleLog.Logger.Error(e, errMsg);
+      appObj.Update(status: ApplicationObject.State.Failed, logItem: $"{errMsg}: {e.ToFormattedString()}");
+    }
 
-      // convert definition geometry to native
-      var breps = new List<Brep>();
-      var meshes = new List<Mesh>();
-      var curves = new List<DB.Curve>();
-      var blocks = new List<BlockInstance>();
+    return appObj;
+  }
 
-      foreach (var geometry in instance.typedDefinition.geometry)
-      {
-        switch (geometry)
-        {
-          case Brep brep:
-            var success = brep.TransformTo(transform, out Brep tbrep);
-            if (success)
-              breps.Add(tbrep);
-            else
-            {
-              appObj.Update(logItem: $"Could not convert block brep to native, using mesh fallback value instead");
-              meshes.AddRange(tbrep.displayValue);
-            }
-
-            break;
-          case Mesh mesh:
-            mesh.TransformTo(transform, out Mesh tmesh);
-            meshes.Add(tmesh);
-            break;
-          case ICurve curve:
-            try
-            {
-              if (curve is ITransformable tCurve)
-              {
-                tCurve.TransformTo(transform, out tCurve);
-                curve = (ICurve)tCurve;
-              }
-
-              var modelCurves = CurveToNative(curve);
-              curves.AddRange(modelCurves.Cast<DB.Curve>());
-            }
-            catch (Exception e)
-            {
-              appObj.Update(logItem: $"Could not convert block curve to native: {e.Message}");
-            }
-
-            break;
-          case BlockInstance blk:
-            blocks.Add(blk);
-            break;
-          case { }:
-            var displayValue = geometry.GetDetachedProp("displayValue") as IList ?? Array.Empty<object>();
-            foreach (var d in displayValue)
-            {
-              if (d is Mesh m)
-              {
-                m.TransformTo(transform, out Mesh tm);
-                meshes.Add(tm);
-              }
-              //TODO: Ideally, we'd support more geometry types here too, but this switch statement is getting messy!
-            }
-            break;
-        }
-      }
+  /// <summary>
+  /// Converts a Speckle Block instance into a Revit family instance. This includes finding or creating it's
+  /// corresponding family, as well as properly locating that instance in space.
+  /// The resulting family instance will be "Work Plane-based" and placed correctly in 3D space.
+  /// </summary>
+  /// <param name="instance">The instance to convert to a family in Revit.</param>
+  /// <returns>A new instance of the Revit family, located in the same place as the input block instance.</returns>
+  private DB.FamilyInstance ConvertBlockInstanceToFamilyInstance(BlockInstance instance)
+  {
+    using var revitTransform = TransformToNative(instance.transform);
+    instance.transform.Decompose(out var s, out var r, out var t);
 
-      var ids = new List<ElementId>();
-      int skippedBreps = breps.Count;
-      breps.ForEach(o =>
-      {
-        var ds =
-          TryDirectShapeToNative(o, ToNativeMeshSettingEnum.Default).Converted.FirstOrDefault() as DB.DirectShape;
-        if (ds != null)
-        {
-          ids.Add(ds.Id);
-          skippedBreps--;
-        }
-      });
+    var axisMirrorCheck = (s.X < 0, s.Y < 0, s.Z < 0);
+    using DB.Plane pln = GetLocationPlaneForTransform(revitTransform);
 
-      int skippedMeshes = meshes.Count;
-      meshes.ForEach(o =>
-      {
-        var ds =
-          TryDirectShapeToNative(o, ToNativeMeshSettingEnum.Default).Converted.FirstOrDefault() as DB.DirectShape;
-        if (ds != null)
-        {
-          ids.Add(ds.Id);
-          skippedMeshes--;
-        }
-      });
+    // Get the symbol for this instance's block definition
+    var symbol = ConvertBlockDefinitionToFamilySymbol(instance.typedDefinition);
+
+    // Create instance with the correct mode depending if it's nested or not.
+    // For now we usually call this at the model level only
+    var refPlane = Doc.Create.NewReferencePlane2(
+      pln.Origin,
+      pln.Origin + pln.XVec,
+      pln.Origin + pln.YVec,
+      Doc.ActiveView
+    );
+
+    var familyInstance = Doc.Create.NewFamilyInstance(refPlane.GetReference(), pln.Origin, pln.XVec, symbol);
+    ApplyMirroringToElement(familyInstance.Id, pln, axisMirrorCheck);
+
+    return familyInstance;
+  }
+
+  /// <summary>
+  /// Top-level logic to convert from a Speckle BlockDefinition to a Revit Family.
+  /// It handles finding existing family for the block, as well as creating a new one if none exists.
+  /// Ensures that the first symbol of the family is active in the document and returns it.
+  /// </summary>
+  /// <param name="definition">The block definition that will be converted to a revit family.</param>
+  /// <returns>The family symbol representing that block definition.</returns>
+  private DB.FamilySymbol ConvertBlockDefinitionToFamilySymbol(BlockDefinition definition)
+  {
+    // TODO: Geometry update of existing family is not implemented yet.
+    using var family = FindBlockDefinitionFamily(definition) ?? CreateBlockDefinitionFamily(definition);
+
+    // TODO: We're still picking the first one here. New symbol creation for other scales is not yet supported
+    var symbol =
+      FindBlockDefinitionFamilySymbol(definition, family) ?? CreateBlockDefinitionFamilySymbol(definition, family);
+
+    return symbol;
+  }
+
+  /// <summary>
+  /// Creates a new family for the given block definition. The family will not contain any sub-families,
+  /// and all nested blocks will be flattened to the top-level.
+  /// </summary>
+  /// <param name="definition">The block definition to create a family out of.</param>
+  /// <returns>A family instance of the newly created family loaded into the doc.</returns>
+  private DB.Family CreateBlockDefinitionFamily(BlockDefinition definition)
+  {
+    var famDoc = CreateNewFamilyTemplateDoc();
+
+    // Get the flat list of geometry and scale using transform to get it to the right size.
+    var flatGeometry = GetBlockDefinitionGeometry(definition).Select(bt => bt as Base);
+
+    // Grab all geometry from the definition, convert and add to family symbol.
+    PopulateFamilyWithBlockDefinitionGeometry(famDoc, flatGeometry);
+    // Change the category of this definition
+    AssignCategoryToFamilyDoc(famDoc, definition["category"] as string);
+
+    string tempFamilyPath = Path.Combine(Path.GetTempPath(), GetFamilyNameFor(definition) + ".rfa");
+    using var so = new DB.SaveAsOptions();
+    so.OverwriteExistingFile = true;
+
+    // Save and close the doc
+    famDoc.SaveAs(tempFamilyPath, so);
+    famDoc.Close();
+
+    // Load the new document into the model doc
+    Doc.LoadFamily(tempFamilyPath, new FamilyLoadOption(), out var family);
+    return family;
+  }
+
+  /// <summary>
+  /// Assigns a category to a family document based on a given name. If the category of the given name does not exist,
+  /// "Generic Model" will be used as the default.
+  /// This method is intended to be used in family documents only.
+  /// </summary>
+  /// <param name="famDoc">The Revit family document to change category of.</param>
+  /// <param name="categoryName">The category name. Must be one of <see cref="RevitCategory"/> converted to string.</param>
+  private static void AssignCategoryToFamilyDoc(DB.Document famDoc, string? categoryName)
+  {
+    // Get the RevitCategory from a string value
+    var success = Enum.TryParse(categoryName, out RevitCategory cat);
+    if (!success)
+      cat = RevitCategory.GenericModel;
+
+    // Get the BuiltInCategory corresponding to the RevitCategory
+    var catName = Categories.GetBuiltInFromSchemaBuilderCategory(cat);
+    success = Enum.TryParse(catName, out DB.BuiltInCategory bic);
+    if (!success)
+      bic = DB.BuiltInCategory.OST_GenericModel;
 
-      int skippedCurves = curves.Count;
-      curves.ForEach(o =>
+    // Get the actual category from the document
+    DB.Category familyCategory = famDoc.Settings.Categories.get_Item(bic);
+
+    using var t = new DB.Transaction(famDoc, "Change family category");
+
+    try
+    {
+      t.Start();
+      // Swap the family category for the one we want
+      famDoc.OwnerFamily.FamilyCategory = familyCategory;
+      t.Commit();
+    }
+    catch (Exception e)
+    {
+      SpeckleLog.Logger.Warning(e, "Document category could not be modified");
+      t.RollBack();
+    }
+  }
+
+  /// <summary>
+  /// Re-creates the BlockDefinition geometry into the provided document.
+  /// This will return every geometry (including nested families) at the top-level.
+  /// Creation of sub-families is currently not supported.
+  /// </summary>
+  /// <param name="definition">The BlockDefinition to extract the geometry from</param>
+  /// <param name="famDoc">The revit document where the geometry will be added</param>
+  private static void PopulateFamilyWithBlockDefinitionGeometry(DB.Document famDoc, IEnumerable<Base?> geometry)
+  {
+    // Start up a local converter to isolate conversions for this particular family document.
+    // This prevents other conversions from being polluted by multi-document environments.
+    var converter = new ConverterRevit();
+    converter.SetContextDocument(famDoc); // Always remember to set the doc 🙂
+
+    // Using the family document, add all geometry of the instance at the root level (no nesting)
+    using DB.Transaction t = new(famDoc, $"Create geometry for block definition");
+    t.Start();
+    foreach (var o in geometry)
+      converter.ConvertToNativeObject(o);
+    t.Commit();
+  }
+
+  /// <summary>
+  /// Attempts to find the corresponding family symbol for a given block definition.
+  /// In general, since we're converting from a block to a family, we expect it to only have one symbol.
+  /// For this reason, current implementation will return the first symbol of the family.
+  /// </summary>
+  /// <param name="definition">The block definition to find a symbol for.</param>
+  /// <param name="family">The family that corresponds to th is block definition.</param>
+  /// <returns>The first family symbol of the family (as it is currently implemented).</returns>
+  private DB.FamilySymbol? FindBlockDefinitionFamilySymbol(BlockDefinition definition, DB.Family family)
+  {
+    // The loaded family contains all the possible symbols (variations)
+    // We must pick the right one and return.
+    // TODO: For now, we're just picking the first.
+    var element = Doc.GetElement(family.GetFamilySymbolIds().First());
+    if (element is not DB.FamilySymbol symbol)
+      return null;
+    if (!symbol.IsActive)
+      symbol.Activate();
+    return symbol;
+  }
+
+  /// <summary>
+  /// Creates a family symbol for the given block definition.
+  /// THIS IS NOT SUPPORTED YET
+  /// </summary>
+  /// <param name="definition">The block definition to create a symbol out of</param>
+  /// <param name="family">The family where the symbol will be created</param>
+  /// <returns>The new family symbol instance.</returns>
+  /// <exception cref="NotImplementedException">Throws always, as this is not implemented yet.</exception>
+  private DB.FamilySymbol CreateBlockDefinitionFamilySymbol(BlockDefinition definition, DB.Family family)
+  {
+    throw new NotImplementedException("Creating family symbols is not supported yet");
+  }
+
+  /// <summary>
+  ///   Creates a new family document as a duplicate of the specified template.
+  /// </summary>
+  /// <param name="name">The name of the template to use to create the family document.</param>
+  /// <returns>A new family document based based on the specified template.</returns>
+  /// <exception cref="System.IO.FileNotFoundException">When the file corresponding to the provided template name could not be found</exception>
+  /// <exception cref="Autodesk.Revit.Exceptions.InvalidOperationException">When the document could not be opened</exception>
+  private DB.Document CreateNewFamilyTemplateDoc(string name = "Block")
+  {
+    var templatePath = GetTemplatePath(name);
+    if (!File.Exists(templatePath))
+      throw new FileNotFoundException($"Could not find '{name}.rft' template file - {templatePath}");
+    return Doc.Application.NewFamilyDocument(templatePath);
+  }
+
+  /// <summary>
+  /// Returns the <see cref="DB.Family"/> instance for a given <see cref="BlockDefinition"/> if it exists.
+  /// The family is found by looking up on the current context document for any family that
+  /// matches the BlockDefinition name.
+  /// </summary>
+  /// <param name="definition">The <see cref="BlockDefinition"/> to find a Family for.</param>
+  /// <returns>The <see cref="DB.Family"/> instance if it was found, null otherwise.</returns>
+  private DB.Family? FindBlockDefinitionFamily(BlockDefinition definition)
+  {
+    return FindFamilyByName(Doc, GetFamilyNameFor(definition));
+  }
+
+  /// <summary>
+  /// Attempts to find a <see cref="DB.Family"/> instance in the given document.
+  /// This will only succeed if it finds an exact match.
+  /// </summary>
+  /// <param name="doc">The document to search in.</param>
+  /// <param name="familyName">The name of the family to search for.</param>
+  /// <returns>The <see cref="DB.Family"/> instance if found, null otherwise.</returns>
+  private static DB.Family? FindFamilyByName(DB.Document doc, string familyName)
+  {
+    // Filter for family elements
+    using DB.FilteredElementCollector collector = new(doc);
+    var families = collector.OfClass(typeof(DB.Family)).ToElements();
+
+    foreach (DB.Element elem in families)
+      if (elem is DB.Family fam && fam.Name == familyName)
+        return fam; // Cast to Family and return if the names match
+
+    return null; // Return null if not found
+  }
+
+  /// <summary>
+  /// Utility function to consolidate the naming pattern for <see cref="BlockDefinition"/> instances in Revit.
+  /// The current pattern will return the name of the block, followed by the prefix '_SpeckleBlock'
+  /// </summary>
+  /// <param name="definition">The block definition we want to extract the family name from.</param>
+  /// <returns>The corresponding family name in Revit for the given block definition.</returns>
+  /// <remarks>This is done to prevent naming conflicts with existing families in the document.</remarks>
+  /// <example>For a block named "Chair", it's Revit family name would be "Chair_SpeckleBlock"</example>
+  private static string GetFamilyNameFor(BlockDefinition definition)
+  {
+    return definition.name;
+  }
+
+  /// <summary>
+  /// Gets the geometric representation of a given block definition. This will 'flatten' all inner instances so that
+  /// all that remains is the geometric entities, properly translated into this <see cref="BlockDefinition"/>'s transform space.
+  /// </summary>
+  /// <param name="definition">The definition to extract</param>
+  /// <param name="scaleTransform"></param>
+  /// <returns></returns>
+  private static IEnumerable<ITransformable?> GetBlockDefinitionGeometry(BlockDefinition definition)
+  {
+    return definition.geometry
+      .SelectMany(
+        b =>
+          b switch
+          {
+            // This cast to Base is safe. Compiler just can't safely know ITransformable is only applied to Base objects.
+            Instance i => i.GetTransformedGeometry(), // Flattening inner instances here.
+            ITransformable bt => new List<ITransformable> { bt },
+            _
+              => (b.GetDetachedProp("displayValue") as IList)?.OfType<ITransformable>()
+                ?? Enumerable.Empty<ITransformable>()
+          }
+      )
+      .Where(bt => bt != null);
+  }
+
+  /// <summary>
+  /// Converts a Revit Transform into a Revit Plane.
+  /// </summary>
+  /// <param name="transform">The transform to convert.</param>
+  /// <returns>A new plane instance representing the input transform.</returns>
+  private static DB.Plane GetLocationPlaneForTransform(DB.Transform transform)
+  {
+    // Get the position of the instance in the current document
+    var position = transform.OfPoint(DB.XYZ.Zero);
+    // Apply XY mirroring to instance
+    var instanceXAxis = transform.OfVector(DB.XYZ.BasisX);
+    var instanceYAxis = transform.OfVector(DB.XYZ.BasisY);
+    return DB.Plane.CreateByOriginAndBasis(position, instanceXAxis, instanceYAxis);
+  }
+
+  /// <summary>
+  /// Mirrors an element across all axes of a given plane.
+  /// All mirror operations are optional and controlled by the mirrorCheck input parameter.
+  /// </summary>
+  /// <param name="elementId">The ID of the element to mirror.</param>
+  /// <param name="plane">The location of the mirroring planes</param>
+  /// <param name="mirrorCheck">A tuple to determine which axis to mirror</param>
+  private void ApplyMirroringToElement(
+    DB.ElementId elementId,
+    DB.Plane plane,
+    (bool IsMirorredX, bool IsMirroredY, bool IsMirroredZ) mirrorCheck
+  )
+  {
+    new List<(string name, bool shouldMirror, DB.Plane mirrorPlane)>
+    {
+      ("YZ", mirrorCheck.IsMirorredX, DB.Plane.CreateByOriginAndBasis(plane.Origin, plane.YVec, plane.Normal)),
+      ("XZ", mirrorCheck.IsMirroredY, DB.Plane.CreateByOriginAndBasis(plane.Origin, plane.XVec, plane.Normal)),
+      ("XY", mirrorCheck.IsMirroredZ, DB.Plane.CreateByOriginAndBasis(plane.Origin, plane.XVec, plane.YVec))
+    }
+      .Where(i => i.shouldMirror)
+      .ToList()
+      .ForEach(item =>
       {
-        var mc = Doc.Create.NewModelCurve(o, NewSketchPlaneFromCurve(o, Doc));
-        if (mc != null)
+        try
         {
-          ids.Add(mc.Id);
-          skippedCurves--;
+          Doc.Regenerate();
+          DB.ElementTransformUtils.MirrorElements(Doc, new List<DB.ElementId> { elementId }, item.mirrorPlane, false);
         }
-      });
-
-      int skippedBlocks = blocks.Count;
-      blocks.ForEach(o =>
-      {
-        var block = BlockInstanceToNative(o, transform);
-        if (block != null)
+        catch (Exception e)
         {
-          var nestedBlock = block.Converted.FirstOrDefault() as Group;
-          ids.Add(nestedBlock.Id);
-          skippedBlocks--;
+          SpeckleLog.Logger.Warning(e, "Failed to mirror element on {name} plane", item.name);
         }
       });
-
-      if (!ids.Any())
-      {
-        appObj.Update(status: ApplicationObject.State.Failed, logItem: $"No geometry could be created");
-        Report.Log(appObj);
-        return null;
-      }
-
-      Group group = null;
-      try
-      {
-        group = Doc.Create.NewGroup(ids);
-        group.GroupType.Name =
-          $"SpeckleBlock_{RemoveProhibitedCharacters(instance.typedDefinition.name)}_{instance.applicationId ?? instance.id}";
-        string skipped =
-          $"{(skippedBreps > 0 ? $"{skippedBreps} breps " : "")}{(skippedMeshes > 0 ? $"{skippedMeshes} meshes " : "")}{(skippedCurves > 0 ? $"{skippedCurves} curves " : "")}{(skippedBlocks > 0 ? $"{skippedBlocks} blocks " : "")}";
-        if (!string.IsNullOrEmpty(skipped))
-          appObj.Update(logItem: $"Skipped {skipped}");
-        var state = isUpdate ? ApplicationObject.State.Updated : ApplicationObject.State.Created;
-        appObj.Update(
-          status: state,
-          createdId: group.UniqueId,
-          convertedItem: group,
-          logItem: $"Assigned name: {group.GroupType.Name}"
-        );
-      }
-      catch
-      {
-        appObj.Update(status: ApplicationObject.State.Failed, logItem: $"Group could not be created");
-      }
-
-      return appObj;
-    }
   }
 }
diff --git a/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertFreeformElement.cs b/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertFreeformElement.cs
index ddb44cc86c..9dd73a1c46 100644
--- a/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertFreeformElement.cs	
+++ b/Objects/Converters/ConverterRevit/ConverterRevitShared/Partial Classes/ConvertFreeformElement.cs	
@@ -97,7 +97,7 @@ public ApplicationObject FreeformElementToNativeFamily(Brep brep, Category cat =
         var form = DB.FreeFormElement.Create(Doc, s);
         if (cat != null)
           form.Subcategory = cat;
-        appObj.Update(createdId: form.UniqueId, convertedItem: s);
+        appObj.Update(createdId: form.UniqueId, convertedItem: form);
       }
 
       return appObj;
@@ -108,9 +108,9 @@ public ApplicationObject FreeformElementToNativeFamily(Geometry.Mesh mesh)
       var appObj = new ApplicationObject(mesh.id, mesh.speckle_type) { applicationId = mesh.applicationId };
       var solids = new List<DB.Solid>();
       var d = MeshToNative(mesh, DB.TessellatedShapeBuilderTarget.Solid);
-      var revitMmesh =
+      var revitMesh =
           d.Select(m => m as DB.Solid);
-      solids.AddRange(revitMmesh);
+      solids.AddRange(revitMesh);
 
       foreach (var s in solids)
       {
@@ -123,9 +123,12 @@ public ApplicationObject FreeformElementToNativeFamily(Geometry.Mesh mesh)
 
     private IEnumerable<Solid> GetSolidMeshes(IEnumerable<Mesh> meshes)
     {
-      return meshes
-        .SelectMany(m => MeshToNative(m, DB.TessellatedShapeBuilderTarget.Solid, DB.TessellatedShapeBuilderFallback.Abort))
-        .Select(m => m as DB.Solid);
+      var allMeshes = meshes
+        .SelectMany(
+        m => MeshToNative(m, DB.TessellatedShapeBuilderTarget.Solid, DB.TessellatedShapeBuilderFallback.Abort) ?? new List<GeometryObject>());
+      var notNull = allMeshes.Where(m => m != null);
+       var solids = notNull.Select(m => m as DB.Solid);
+       return solids;
     }
 
     private ApplicationObject FreeformElementToNative(Brep brep)
diff --git a/Objects/Converters/ConverterRevit/Templates/2020/Block - Imperial.rft b/Objects/Converters/ConverterRevit/Templates/2020/Block - Imperial.rft
new file mode 100755
index 0000000000..23c40af6c0
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2020/Block - Imperial.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2020/Block - Metric.rft b/Objects/Converters/ConverterRevit/Templates/2020/Block - Metric.rft
new file mode 100755
index 0000000000..27ad7fbb47
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2020/Block - Metric.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2021/Block - Imperial.rft b/Objects/Converters/ConverterRevit/Templates/2021/Block - Imperial.rft
new file mode 100755
index 0000000000..ae43b758ee
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2021/Block - Imperial.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2021/Block - Metric.rft b/Objects/Converters/ConverterRevit/Templates/2021/Block - Metric.rft
new file mode 100755
index 0000000000..d93a5477c2
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2021/Block - Metric.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2022/Block - Imperial.rft b/Objects/Converters/ConverterRevit/Templates/2022/Block - Imperial.rft
new file mode 100644
index 0000000000..3a4fe020ff
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2022/Block - Imperial.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2022/Block - Metric.rft b/Objects/Converters/ConverterRevit/Templates/2022/Block - Metric.rft
new file mode 100644
index 0000000000..14ee9128f9
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2022/Block - Metric.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2023/Block - Imperial.rft b/Objects/Converters/ConverterRevit/Templates/2023/Block - Imperial.rft
new file mode 100644
index 0000000000..d3f1a64125
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2023/Block - Imperial.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2023/Block - Metric.rft b/Objects/Converters/ConverterRevit/Templates/2023/Block - Metric.rft
new file mode 100644
index 0000000000..5dd1a184a3
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2023/Block - Metric.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2024/Block - Imperial.rft b/Objects/Converters/ConverterRevit/Templates/2024/Block - Imperial.rft
new file mode 100644
index 0000000000..0d74d992c8
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2024/Block - Imperial.rft differ
diff --git a/Objects/Converters/ConverterRevit/Templates/2024/Block - Metric.rft b/Objects/Converters/ConverterRevit/Templates/2024/Block - Metric.rft
new file mode 100644
index 0000000000..5e82cf475e
Binary files /dev/null and b/Objects/Converters/ConverterRevit/Templates/2024/Block - Metric.rft differ
diff --git a/Objects/Converters/ConverterRhinoGh/ConverterRhinoGhShared/ConverterRhinoGh.Mappings.cs b/Objects/Converters/ConverterRhinoGh/ConverterRhinoGhShared/ConverterRhinoGh.Mappings.cs
index e18a5651ee..e23ef59ee1 100644
--- a/Objects/Converters/ConverterRhinoGh/ConverterRhinoGhShared/ConverterRhinoGh.Mappings.cs
+++ b/Objects/Converters/ConverterRhinoGh/ConverterRhinoGhShared/ConverterRhinoGh.Mappings.cs
@@ -11,6 +11,7 @@
 using Objects.BuiltElements;
 using Objects.BuiltElements.Revit;
 using Objects.Geometry;
+using Objects.Other;
 using Plane = Objects.Geometry.Plane;
 
 namespace Objects.Converter.RhinoGh;
@@ -160,6 +161,12 @@ private Base MappingToSpeckle(string mapping, RhinoObject @object, List<string>
             var angle = RH.Vector3d.VectorAngle(RH.Vector3d.XAxis, VectorToNative(plane.xdir), RH.Plane.WorldXY);
             o.rotation = angle;
           }
+          break;
+        case MappedBlockWrapper o:
+          if (@object is InstanceObject instance)
+          {
+            o.instance = BlockInstanceToSpeckle(instance);
+          }
 
           break;
       }
diff --git a/Objects/Objects/Other/MappedBlockWrapper.cs b/Objects/Objects/Other/MappedBlockWrapper.cs
new file mode 100644
index 0000000000..3609bfb8de
--- /dev/null
+++ b/Objects/Objects/Other/MappedBlockWrapper.cs
@@ -0,0 +1,19 @@
+using Objects.BuiltElements.Revit;
+using Speckle.Core.Models;
+
+namespace Objects.Other;
+
+public class MappedBlockWrapper : Base
+{
+  public string category { get; set; } = RevitCategory.GenericModel.ToString();
+  public string? nameOverride { get; set; }
+  public BlockInstance instance { get; set; }
+
+  public MappedBlockWrapper() { }
+
+  public MappedBlockWrapper(BlockInstance instance, RevitCategory category)
+  {
+    this.instance = instance;
+    this.category = category.ToString();
+  }
+}
diff --git a/Objects/Objects/Other/Transform.cs b/Objects/Objects/Other/Transform.cs
index 45c6625bc7..3ca5938e07 100644
--- a/Objects/Objects/Other/Transform.cs
+++ b/Objects/Objects/Other/Transform.cs
@@ -119,10 +119,20 @@ public void Decompose(out Vector3 scale, out Quaternion rotation, out Vector4 tr
 
     // scale
     // this should account for non-uniform scaling
-    var scaleX = new Vector4(matrix.M11, matrix.M21, matrix.M31, matrix.M41).Length();
-    var scaleY = new Vector4(matrix.M12, matrix.M22, matrix.M32, matrix.M42).Length();
-    var scaleZ = new Vector4(matrix.M13, matrix.M23, matrix.M33, matrix.M43).Length();
-    scale = new Vector3(scaleX, scaleY, scaleZ);
+    Vector4 basis4dX = new(matrix.M11, matrix.M21, matrix.M31, matrix.M41);
+    Vector4 basis4dY = new(matrix.M12, matrix.M22, matrix.M32, matrix.M42);
+    Vector4 basis4dZ = new(matrix.M13, matrix.M23, matrix.M33, matrix.M43);
+
+    // Check for mirroring
+    Vector3 basisX = new(matrix.M11, matrix.M21, matrix.M31);
+    Vector3 basisY = new(matrix.M12, matrix.M22, matrix.M32);
+    Vector3 basisZ = new(matrix.M13, matrix.M23, matrix.M33);
+    // Negative determinant means flip on Z.
+    // TODO: Add tests and figure out exactly why this is. Jedd and myself have some theories but it would be nice to document this properly
+    double determinant = Vector3.Dot(Vector3.Cross(basisX, basisY), basisZ) < 0 ? -1 : 1;
+
+    // Compute the scale, but only multiply the Z scale by the determinant to flag negative scaling on Z axis (see todo above)
+    scale = new Vector3(basis4dX.Length(), basis4dY.Length(), basis4dZ.Length() * determinant);
 
     // rotation
     // this is using a z-up convention for basis vectors
@@ -151,43 +161,23 @@ private static Quaternion LookRotation(Vector3 forward, Vector3 up)
     {
       var num = Math.Sqrt(num8 + 1d);
       num = 0.5d / num;
-      return new Quaternion(
-        (m12 - m21) * num,
-        (m20 - m02) * num,
-        (m01 - m10) * num,
-        num * 0.5d
-      );
+      return new Quaternion((m12 - m21) * num, (m20 - m02) * num, (m01 - m10) * num, num * 0.5d);
     }
     if (m00 >= m11 && m00 >= m22)
     {
       var num7 = Math.Sqrt(1d + m00 - m11 - m22);
       var num4 = 0.5d / num7;
-      return new Quaternion(
-        0.5d * num7,
-        (m01 + m10) * num4,
-        (m02 + m20) * num4,
-        (m12 - m21) * num4
-      );
+      return new Quaternion(0.5d * num7, (m01 + m10) * num4, (m02 + m20) * num4, (m12 - m21) * num4);
     }
     if (m11 > m22)
     {
       var num6 = Math.Sqrt(1d + m11 - m00 - m22);
       var num3 = 0.5d / num6;
-      return new Quaternion(
-        (m10 + m01) * num3,
-        0.5d * num6,
-        (m21 + m12) * num3,
-        (m20 - m02) * num3
-      );
+      return new Quaternion((m10 + m01) * num3, 0.5d * num6, (m21 + m12) * num3, (m20 - m02) * num3);
     }
     var num5 = Math.Sqrt(1d + m22 - m00 - m11);
     var num2 = 0.5d / num5;
-    return new Quaternion(
-      (m20 + m02) * num2,
-      (m21 + m12) * num2,
-      0.5d * num5,
-      (m01 - m10) * num2
-    );
+    return new Quaternion((m20 + m02) * num2, (m21 + m12) * num2, 0.5d * num5, (m01 - m10) * num2);
   }
 
   /// <summary>