diff --git a/FrostyEditor/Windows/MainWindow.xaml b/FrostyEditor/Windows/MainWindow.xaml
index c782b8cba..eb8c8029e 100644
--- a/FrostyEditor/Windows/MainWindow.xaml
+++ b/FrostyEditor/Windows/MainWindow.xaml
@@ -20,13 +20,42 @@
     <ctrl2:FrostyWindow.Resources>
         <conv:BooleanToVisibilityConverter x:Key="booleanToVisibilityConverter"/>
         <cmd:ExportModMenuItemCommand x:Key="exportModMenuItemCommand"/>
+        <cmd:ExportModMenuItemCommand x:Key="exportModMenuItemCommand_dos" />
         <ContextMenu x:Key="bookmarksContextMenu">
             <MenuItem Header="Open asset" Click="contextMenuBookmarkItemOpen_Click">
                 <MenuItem.Icon>
-                    <Image Source="/FrostyEditor;component/Images/OpenAsset.png" Opacity="0.5"/>
+                    <Image Source="/FrostyEditor;component/Images/OpenAsset.png" RenderOptions.BitmapScalingMode="Fant"
+                        Opacity="0.5" />
+                </MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Find in explorer" Click="contextMenuBookmarkItemFind_Click">
+                <MenuItem.Icon>
+                    <Image Source="/FrostyEditor;component/Images/Open.png"
+                        RenderOptions.BitmapScalingMode="Fant"
+                        Opacity="0.5" />
+                </MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Open in Blueprint Editor" Click="contextMenuBookmarkItemOpenBlueprintEditor_Click">
+                <MenuItem.Icon>
+                    <Image Source="/FrostyCore;component/Images/Assets/BlueprintFileType.png"
+                        RenderOptions.BitmapScalingMode="Fant"
+                        Opacity="0.5" />
+                </MenuItem.Icon>
+            </MenuItem>
+            <!-- <MenuItem Header="Copy file GUID" Click="contextMenuBookmarkItemCopyGUID_Click">
+                <MenuItem.Icon>
+                    <Image Source="/FrostyCore;component/Images/Copy.png"
+                        RenderOptions.BitmapScalingMode="Fant"
+                        Opacity="0.5" />
+                </MenuItem.Icon>
+            </MenuItem> -->
+            <MenuItem Header="Copy file path" Click="contextMenuBookmarkItemCopyPath_Click">
+                <MenuItem.Icon>
+                    <Image Source="/FrostyCore;component/Images/Copy.png"
+                        RenderOptions.BitmapScalingMode="Fant"
+                        Opacity="0.5" />
                 </MenuItem.Icon>
             </MenuItem>
-            <MenuItem Header="Find in explorer" Click="contextMenuBookmarkItemFind_Click"/>
         </ContextMenu>
     </ctrl2:FrostyWindow.Resources>
 
@@ -67,7 +96,7 @@
                         </MenuItem.Icon>
                     </MenuItem>
                     <Separator/>
-                    <MenuItem x:Name="ExportModMenuItem" Header="Export to Mod" Height="22" Command="{StaticResource exportModMenuItemCommand}" CommandParameter="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}}">
+                    <MenuItem x:Name="ExportModMenuItem" Header="Export to Mod" Height="22" Command="{StaticResource exportModMenuItemCommand_dos}" CommandParameter="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}}">
                         <MenuItem.Icon>
                             <Image Source="/FrostyEditor;component/Images/Compile.png"/>
                         </MenuItem.Icon>
diff --git a/FrostyEditor/Windows/MainWindow.xaml.cs b/FrostyEditor/Windows/MainWindow.xaml.cs
index 7222a2c60..6cc5e9798 100644
--- a/FrostyEditor/Windows/MainWindow.xaml.cs
+++ b/FrostyEditor/Windows/MainWindow.xaml.cs
@@ -24,10 +24,11 @@
 using FrostyCore;
 using FrostySdk;
 using FrostySdk.IO;
-using FrostySdk.Managers;
 using FrostySdk.Managers.Entries;
 using Microsoft.Win32;
 using Bookmarks = Frosty.Core.Bookmarks;
+using Frosty.Core.Attributes;
+using Frosty.Core.Misc;
 
 namespace FrostyEditor.Windows
 {
@@ -1142,7 +1143,62 @@ private void contextMenuBookmarkItemFind_Click(object sender, RoutedEventArgs e)
             target.Target.NavigateTo(false);
         }
 
-#endregion
+        private IBlueprintEditorHandler blueprintEditorHandler = App.PluginManager.BlueprintEditorOpenAction.Count() == 0 ? new DefaultBlueprintEditorHandler() : App.PluginManager.BlueprintEditorOpenAction.First();
+
+        private void contextMenuBookmarkItemOpenBlueprintEditor_Click(object sender, RoutedEventArgs e)
+        {
+            if (BookmarkTreeView.SelectedItem == null)
+                return;
+            Bookmarks.BookmarkItem target = BookmarkTreeView.SelectedItem as Bookmarks.BookmarkItem;
+            if (target.Target is Bookmarks.AssetBookmarkTarget assetTarget)
+            {
+                if (assetTarget.Asset is EbxAssetEntry entry)
+                {
+                    if (entry != null)
+                    {
+                        blueprintEditorHandler.OpenAssetAsGraph(entry);
+                    }
+                }
+            }
+        }
+
+        private void contextMenuBookmarkItemCopyGUID_Click(object sender, RoutedEventArgs e)
+        {
+            if (BookmarkTreeView.SelectedItem == null)
+                return;
+            Bookmarks.BookmarkItem target = BookmarkTreeView.SelectedItem as Bookmarks.BookmarkItem;
+            if (target.Target is Bookmarks.AssetBookmarkTarget assetTarget)
+            {
+                if (assetTarget.Asset is EbxAssetEntry entry)
+                {
+                    if (entry != null)
+                    {
+                        EbxAsset asset = App.AssetManager.GetEbx(entry.Name);
+                        App.Logger.Log(asset.FileGuid.ToString());
+                        Clipboard.SetText(asset.FileGuid.ToString());
+                    }
+                }
+            }
+        }
+
+        private void contextMenuBookmarkItemCopyPath_Click(object sender, RoutedEventArgs e)
+        {
+            if (BookmarkTreeView.SelectedItem == null)
+                return;
+            Bookmarks.BookmarkItem target = BookmarkTreeView.SelectedItem as Bookmarks.BookmarkItem;
+            if (target.Target is Bookmarks.AssetBookmarkTarget assetTarget)
+            {
+                if (assetTarget.Asset is EbxAssetEntry entry)
+                {
+                    if (entry != null)
+                    {
+                        Clipboard.SetText(entry.Name);
+                    }
+                }
+            }
+        }
+
+        #endregion
 
         #region -- Bookmarks --
 
diff --git a/FrostyPlugin/Attributes/RegisterBlueprintEditorHandlerAttribute.cs b/FrostyPlugin/Attributes/RegisterBlueprintEditorHandlerAttribute.cs
new file mode 100644
index 000000000..ebac5fcc5
--- /dev/null
+++ b/FrostyPlugin/Attributes/RegisterBlueprintEditorHandlerAttribute.cs
@@ -0,0 +1,27 @@
+using FrostySdk.Ebx;
+using FrostySdk.Managers.Entries;
+using System;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace Frosty.Core.Attributes
+{
+    /// <summary>
+    /// This attribute registers the method for opening files in the Blueprint Editor.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true, Inherited = true)]
+    public class RegisterBlueprintEditorHandlerAttribute : Attribute
+    {
+        public Type classToHandle { get; set; }
+
+        public RegisterBlueprintEditorHandlerAttribute(Type type)
+        {
+            classToHandle = type;
+        }
+    }
+
+    public interface IBlueprintEditorHandler
+    {
+        void OpenAssetAsGraph(EbxAssetEntry asset);
+    }
+}
diff --git a/FrostyPlugin/Controls/Editors/FrostyPointerRefEditor.cs b/FrostyPlugin/Controls/Editors/FrostyPointerRefEditor.cs
index dbc04776c..bfeb9265f 100644
--- a/FrostyPlugin/Controls/Editors/FrostyPointerRefEditor.cs
+++ b/FrostyPlugin/Controls/Editors/FrostyPointerRefEditor.cs
@@ -18,6 +18,9 @@
 using System.Windows.Input;
 using FrostySdk.Managers.Entries;
 
+using Frosty.Core.Attributes;
+using Frosty.Core.Misc;
+
 //using System.IO;
 
 namespace Frosty.Core.Controls.Editors
@@ -270,6 +273,7 @@ private void Popup_DropDownOpened(object sender, EventArgs e)
             Button clearButton = (popupMenu.FindName("PART_ClearButton") as Button);
             Button openButton = (popupMenu.FindName("PART_OpenButton") as Button);
             Button findButton = (popupMenu.FindName("PART_FindButton") as Button);
+            Button blueprintEditorButton = (popupMenu.FindName("PART_BlueprintEditorButton") as Button);
             Button createButton = (popupMenu.FindName("PART_CreateButton") as Button);
             TextBlock textBlock = (popupMenu.FindName("PART_TextBlock") as TextBlock);
             Border separator = (popupMenu.FindName("PART_Separator") as Border);
@@ -278,11 +282,13 @@ private void Popup_DropDownOpened(object sender, EventArgs e)
 
             clearButton.Click -= ClearButton_Click;
             findButton.Click -= FindButton_Click;
+            blueprintEditorButton.Click -= BlueprintEditorButton_Click;
             openButton.Click -= OpenButton_Click;
             createButton.Click -= CreateButton_Click;
 
             clearButton.Click += ClearButton_Click;
             findButton.Click += FindButton_Click;
+            blueprintEditorButton.Click += BlueprintEditorButton_Click;
             openButton.Click += OpenButton_Click;
             createButton.Click += CreateButton_Click;
             filter.TextChanged += Filter_TextChanged;
@@ -290,6 +296,7 @@ private void Popup_DropDownOpened(object sender, EventArgs e)
             PointerRef ptrRef = (PointerRef)Value;
             clearButton.IsEnabled = ptrRef.Type != PointerRefType.Null;
             findButton.IsEnabled = !(ptrRef.Type == PointerRefType.Internal || ptrRef.Type == PointerRefType.Null);
+            blueprintEditorButton.IsEnabled = !(ptrRef.Type == PointerRefType.Internal || ptrRef.Type == PointerRefType.Null);
             openButton.IsEnabled = !(ptrRef.Type == PointerRefType.Internal || ptrRef.Type == PointerRefType.Null);
             createButton.IsEnabled = canCreate;
             textBlock.Text = "Assign from " + ((isInternal) ? "self" : App.AssetManager.GetEbxEntry(assignFileGuid).Name);
@@ -383,6 +390,23 @@ private void FindButton_Click(object sender, RoutedEventArgs e)
             popup.IsDropDownOpen = false;
         }
 
+        private void BlueprintEditorButton_Click(object sender, RoutedEventArgs e)
+        {
+            IEnumerable<IBlueprintEditorHandler> handlerEnumerable = App.PluginManager.BlueprintEditorOpenAction;
+            IBlueprintEditorHandler handlerClass = handlerEnumerable.Count() == 0 ? new DefaultBlueprintEditorHandler() : handlerEnumerable.First();
+            PointerRef ptr = (PointerRef)Value;
+            if (ptr.Type == PointerRefType.External)
+            {
+                EbxAssetEntry asset = App.AssetManager.GetEbxEntry(ptr.External.FileGuid);
+                if (asset == null)
+                {
+                    return;
+                }
+                handlerClass.OpenAssetAsGraph(asset);
+            }
+            popup.IsDropDownOpen = false;
+        }
+
         /// <summary>
         /// Performs the actual assinging for either internal or external selection
         /// </summary>
diff --git a/FrostyPlugin/Controls/FrostyAssetEditor.cs b/FrostyPlugin/Controls/FrostyAssetEditor.cs
index 02d0b02ee..613514d79 100644
--- a/FrostyPlugin/Controls/FrostyAssetEditor.cs
+++ b/FrostyPlugin/Controls/FrostyAssetEditor.cs
@@ -1,13 +1,18 @@
-using Frosty.Core.Windows;
+using Frosty.Core.Attributes;
+using Frosty.Core.Misc;
+using Frosty.Core.Windows;
 using FrostySdk;
+using FrostySdk.Ebx;
 using FrostySdk.Interfaces;
 using FrostySdk.IO;
 using FrostySdk.Managers;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
 using System.Windows.Media;
 using FrostySdk.Managers.Entries;
 using Frosty.Controls;
@@ -199,7 +204,14 @@ public virtual void Closed()
 
         public virtual List<ToolbarItem> RegisterToolbarItems()
         {
-            return new List<ToolbarItem>() { new ToolbarItem("View Instances", "View class instances", null, new RelayCommand(ViewInstances_Click, ViewInstances_CanClick)) };
+            return new List<ToolbarItem>() {
+                new ToolbarItem($"View Instances ({asset.RootObjects.Count()})", "View class instances", "Images/Database.png", new RelayCommand(ViewInstances_Click, ViewInstances_CanClick)),
+                new ToolbarItem("Open in Blueprint Editor", "Open this file in the graph editor (if available)", "Images/Grid.png", new RelayCommand((_) => {
+                    IEnumerable<IBlueprintEditorHandler> handlerEnumerable = App.PluginManager.BlueprintEditorOpenAction;
+                    IBlueprintEditorHandler handlerClass = handlerEnumerable.Count() == 0 ? new DefaultBlueprintEditorHandler() : handlerEnumerable.First();
+                    handlerClass.OpenAssetAsGraph(AssetEntry as EbxAssetEntry);
+                }, (_) => AssetEntry is EbxAssetEntry))
+            };
         }
 
         private void ViewInstances_Click(object state)
diff --git a/FrostyPlugin/FrostyCore.csproj b/FrostyPlugin/FrostyCore.csproj
index 764bab647..4dc21ae7c 100644
--- a/FrostyPlugin/FrostyCore.csproj
+++ b/FrostyPlugin/FrostyCore.csproj
@@ -122,6 +122,7 @@
     <Compile Include="Attributes\RegisterExecutionAction.cs" />
     <Compile Include="Attributes\RegisterCustomHandlerAttribute.cs" />
     <Compile Include="Attributes\RegisterDataExplorerContextMenuAttribute.cs" />
+    <Compile Include="Attributes\RegisterBlueprintEditorHandlerAttribute.cs" />
     <Compile Include="Attributes\RegisterGlobalTypeEditorAttribute.cs" />
     <Compile Include="Attributes\RegisterLocalizedStringDatabaseAttribute.cs" />
     <Compile Include="Attributes\RegisterMenuExtensionAttribute.cs" />
@@ -150,6 +151,7 @@
     <Compile Include="FrostyLogger.cs" />
     <Compile Include="FrostyProfileTaskWindowLogger.cs" />
     <Compile Include="FrostyTaskLogger.cs" />
+    <Compile Include="Misc\DefaultBlueprintEditorHandler.cs" />
     <Compile Include="Legacy\LegacyFileManagerV2.cs" />
     <Compile Include="Managers\NotificationManager.cs" />
     <Compile Include="Managers\UndoManager.cs" />
diff --git a/FrostyPlugin/Managers/PluginManager.cs b/FrostyPlugin/Managers/PluginManager.cs
index 1eb8a11af..ecc4d25f3 100644
--- a/FrostyPlugin/Managers/PluginManager.cs
+++ b/FrostyPlugin/Managers/PluginManager.cs
@@ -170,6 +170,10 @@ public sealed class PluginManager
         public PluginManagerType ManagerType => m_managerType;
 
         public IEnumerable<string> CustomAssetHandlers => m_customAssetHandlers.Keys;
+		
+        private List<IBlueprintEditorHandler> m_blueprintEditorOpenAction = new List<IBlueprintEditorHandler>();
+
+        public IEnumerable<IBlueprintEditorHandler> BlueprintEditorOpenAction => m_blueprintEditorOpenAction;
 
         private readonly Dictionary<string, AssetDefinition> m_definitions = new Dictionary<string, AssetDefinition>();
         private readonly List<MenuExtension> m_menuExtensions = new List<MenuExtension>();
@@ -670,6 +674,11 @@ private void LoadDefinitionsFromAssembly(PluginLoadType loadType, Assembly assem
                     {
                         App.AssetManager.RegisterCustomAssetManager(attr12.CustomAssetManagerType, attr12.CustomAssetManagerClassType);
                     }
+
+                    else if (tmpAttr is RegisterBlueprintEditorHandlerAttribute attr13)
+                    {
+                        m_blueprintEditorOpenAction.Add((IBlueprintEditorHandler)Activator.CreateInstance(attr13.classToHandle));
+                    }
                 }
             }
         }
diff --git a/FrostyPlugin/Misc/DefaultBlueprintEditorHandler.cs b/FrostyPlugin/Misc/DefaultBlueprintEditorHandler.cs
new file mode 100644
index 000000000..b3c2fe91f
--- /dev/null
+++ b/FrostyPlugin/Misc/DefaultBlueprintEditorHandler.cs
@@ -0,0 +1,19 @@
+using Frosty.Controls;
+using Frosty.Core.Attributes;
+using FrostySdk.Managers.Entries;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Frosty.Core.Misc
+{
+    public class DefaultBlueprintEditorHandler : IBlueprintEditorHandler
+    {
+        public void OpenAssetAsGraph(EbxAssetEntry asset)
+        {
+            FrostyMessageBox.Show("Missing valid handler for opening blueprint editor. Please make sure you have a version of the blueprint editor that supports this feature.", "Open in Blueprint Editor");
+        }
+    }
+}
diff --git a/FrostyPlugin/Themes/Generic.xaml b/FrostyPlugin/Themes/Generic.xaml
index bb4a5f05d..634a3d970 100644
--- a/FrostyPlugin/Themes/Generic.xaml
+++ b/FrostyPlugin/Themes/Generic.xaml
@@ -808,6 +808,7 @@
                                                         <Button x:Name="PART_ClearButton" Content="Clear assigned object" Style="{StaticResource MenuButtonStyle}" FontFamily="MS Reference Sans Serif" Height="22"/>
                                                         <Button x:Name="PART_OpenButton" Content="Open asset" Style="{StaticResource MenuButtonStyle}" FontFamily="MS Reference Sans Serif" Height="22"/>
                                                         <Button x:Name="PART_FindButton" Content="Find in data explorer" Style="{StaticResource MenuButtonStyle}" FontFamily="MS Reference Sans Serif" Height="22"/>
+                                                        <Button x:Name="PART_BlueprintEditorButton" Content="Open in Blueprint Editor" Style="{StaticResource MenuButtonStyle}" FontFamily="MS Reference Sans Serif" Height="22"/>
                                                         <Button x:Name="PART_CreateButton" Content="Create new ..." Style="{StaticResource MenuButtonStyle}" FontFamily="MS Reference Sans Serif" Height="22"/>
                                                         
                                                         <Border x:Name="PART_Separator" Height="22">
diff --git a/FrostySdk/Managers/AssetManager.cs b/FrostySdk/Managers/AssetManager.cs
index 181af38c0..c1601cc3c 100644
--- a/FrostySdk/Managers/AssetManager.cs
+++ b/FrostySdk/Managers/AssetManager.cs
@@ -461,9 +461,9 @@ public void DoEbxIndexing()
 
         public uint GetModifiedCount()
         {
-            uint modifiedEbx = (uint)m_ebxList.Values.Count((EbxAssetEntry entry) => entry.IsModified);
-            uint modifiedRes = (uint)m_resList.Values.Count((ResAssetEntry entry) => entry.IsModified);
-            uint modifiedChunks = (uint)m_chunkList.Values.Count((ChunkAssetEntry entry) => entry.IsModified);
+            uint modifiedEbx = (uint)m_ebxList.Values.ToList().Count((EbxAssetEntry entry) => entry.IsModified);
+            uint modifiedRes = (uint)m_resList.Values.ToList().Count((ResAssetEntry entry) => entry.IsModified);
+            uint modifiedChunks = (uint)m_chunkList.Values.ToList().Count((ChunkAssetEntry entry) => entry.IsModified);
             uint modifiedCustom = 0;
             foreach (ICustomAssetManager mgr in m_customAssetManagers.Values)
             {
diff --git a/Plugins/BundleEditorPlugin/BundleTabItem.cs b/Plugins/BundleEditorPlugin/BundleTabItem.cs
index fef839cc0..5ae6bd135 100644
--- a/Plugins/BundleEditorPlugin/BundleTabItem.cs
+++ b/Plugins/BundleEditorPlugin/BundleTabItem.cs
@@ -85,6 +85,18 @@ public void RefreshBundles(EbxAssetEntry entry)
             bundlesListTextBox.Text = sb1.ToString();
             if (sb2.Length > 0)
                 bundlesListTextBox.Text += "\r\nAdded to bundles:\r\n" + sb2.ToString();
+
+            foreach (var item in App.EditorWindow.MiscTabControl.Items)
+            {
+                if (item is FrostyTabItem)
+                {
+                    FrostyTabItem tab = item as FrostyTabItem;
+                    if (tab.Header.ToString().Contains("Bundles"))
+                    {
+                        tab.Header = $"Bundles ({sb1.ToString().Split("\n".ToCharArray()).Length - 1} + {sb2.ToString().Split("\n".ToCharArray()).Length - 1})";
+                    }
+                }
+            }
         }
     }
 }
diff --git a/Plugins/ReferencesPlugin/Extensions/CacheMenuExtension.cs b/Plugins/ReferencesPlugin/Extensions/CacheMenuExtension.cs
new file mode 100644
index 000000000..410a7d4d1
--- /dev/null
+++ b/Plugins/ReferencesPlugin/Extensions/CacheMenuExtension.cs
@@ -0,0 +1,134 @@
+using Frosty.Core;
+using Frosty.Core.Windows;
+using FrostySdk;
+using FrostySdk.IO;
+using FrostySdk.Managers.Entries;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Media;
+
+namespace ReferencesPlugin.Extensions
+{
+    public class CreateCacheMenuExtension : MenuExtension
+    {
+        public override string TopLevelMenuName => "Tools";
+
+        public override string SubLevelMenuName => "Generate Cache";
+
+        public override string MenuItemName => "Reference Plugin Cache";
+
+        public override ImageSource Icon => new ImageSourceConverter().ConvertFromString("pack://application:,,,/FrostyEditor;component/Images/Database.png") as ImageSource;
+
+        public override RelayCommand MenuItemClicked => new RelayCommand((o) =>
+        {
+
+            FrostyTaskWindow.Show("Creating Cache", "", (task) =>
+            {
+                CreateCache(task);
+            });
+        });
+        public static string CacheDirectory = System.AppDomain.CurrentDomain.BaseDirectory + @"Plugins\Caches\";
+        public static string CacheFileDir = CacheDirectory + Enum.GetName(typeof(ProfileVersion), ProfilesLibrary.DataVersion) + "_ReferencePlugin_Cache.cache";
+        private void CreateCache(FrostyTaskWindow task)
+        {
+            Dictionary<Guid, Guid> TextureGuidsToLog = new Dictionary<Guid, Guid>();
+            AssetManager AM = App.AssetManager;
+            int textureassetcount = AM.EnumerateEbx(type: "TextureAsset").ToList().Count;
+            int idx = 0;
+            TextureGuidsToLog.Clear();
+            Dictionary<UInt32, List<Tuple<string, int>>> metadataList = new Dictionary<UInt32, List<Tuple<string, int>>>();
+            foreach (EbxAssetEntry refEntry in AM.EnumerateEbx(type: "UIMetaDataAsset"))
+            {
+                if (!refEntry.IsAdded)
+                {
+                    EbxAsset refAsset = AM.GetEbx(refEntry, true);
+                    dynamic refRoot = refAsset.RootObject;
+                    int idx2 = 0;
+                    foreach (dynamic item in refRoot.Items)
+                    {
+                        UInt32 TypeFNV = FNVConvertMetadata(item.Internal.GetType().Name);
+                        foreach (UInt32 Identifier in item.Internal.Identifiers)
+                        {
+                            UInt32 newIden = TypeFNV ^ Identifier;
+                            if (metadataList.ContainsKey(newIden))
+                                metadataList[newIden].Add(new Tuple<string, int>(refEntry.Name, idx2));
+                            else
+                                metadataList.Add(newIden, new List<Tuple<string, int>>() { new Tuple<string, int>(refEntry.Name, idx2) });
+                        }
+                        idx2++;
+                    }
+                }
+            }
+            foreach (EbxAssetEntry refEntry in AM.EnumerateEbx(type: "TextureAsset"))
+            {
+                task.Update("Logging Texture Assets", ((idx++ / (double)textureassetcount) * 100.0d));
+                if (!refEntry.IsAdded)
+                {
+                    EbxAsset refAsset = AM.GetEbx(refEntry, true);
+                    TextureGuidsToLog.Add(refAsset.FileGuid, refAsset.RootInstanceGuid);
+                }
+            }
+            if (!Directory.Exists(CacheDirectory))
+                Directory.CreateDirectory(CacheDirectory);
+            using (NativeWriter writer = new NativeWriter(new FileStream(CacheFileDir, FileMode.Create)))
+            {
+                writer.Write(TextureGuidsToLog.Keys.Count);
+                writer.Write(metadataList.Keys.Count);
+                foreach (Guid TexFileGuid in TextureGuidsToLog.Keys)
+                {
+                    writer.Write(TexFileGuid);
+                    writer.Write(TextureGuidsToLog[TexFileGuid]);
+                }
+                foreach (UInt32 key in metadataList.Keys)
+                {
+                    writer.Write(key);
+                    writer.Write(metadataList[key].Count);
+                    foreach (Tuple<string, int> tup in metadataList[key])
+                    {
+                        writer.WriteNullTerminatedString(tup.Item1);
+                        writer.Write(tup.Item2);
+                    }
+                }
+            }
+        }
+        public static UInt32 FNVConvertMetadata(string FNVInput)
+        {
+            int FNV_offset_basis = 5381;
+            int FNV_prime = 33;
+            for (int i = 0; i < FNVInput.Length; i++)
+            {
+                byte b = (byte)FNVInput[i];
+                FNV_offset_basis = (FNV_offset_basis * FNV_prime) ^ b;
+            }
+            String Output = "";
+            Int64 FNV_offset_basis_Temp = Convert.ToInt64(FNV_offset_basis);
+            if (FNV_offset_basis < 0)
+            {
+                FNV_offset_basis = FNV_offset_basis * -1;
+                string Original = Convert.ToString(FNV_offset_basis, 2).PadLeft(32, '0');
+                string Zero = "0";
+                for (int i = 0; i < Original.Length; i++)
+                {
+                    if (Original[i] == Zero[0])
+                    {
+                        Output = Output + "1";
+                    }
+                    else
+                    {
+                        Output = Output + "0";
+                    }
+                }
+                FNV_offset_basis_Temp = Convert.ToInt64(Output, 2) + 2;
+            }
+            else
+            {
+                FNV_offset_basis_Temp = FNV_offset_basis_Temp + 1;
+            }
+            return Convert.ToUInt32(FNV_offset_basis_Temp);
+        }
+    }
+}
diff --git a/Plugins/ReferencesPlugin/Extensions/ReferencesOptions.cs b/Plugins/ReferencesPlugin/Extensions/ReferencesOptions.cs
new file mode 100644
index 000000000..e638fac27
--- /dev/null
+++ b/Plugins/ReferencesPlugin/Extensions/ReferencesOptions.cs
@@ -0,0 +1,28 @@
+using Frosty.Controls;
+using Frosty.Core;
+using FrostySdk.Attributes;
+using FrostySdk.IO;
+
+namespace ReferencesPlugin.Extensions
+{
+    [DisplayName("References Options")]
+    public class ReferencesOptions : OptionsExtension
+    {
+        [Category("References")]
+        [DisplayName("Show NetRegs")]
+        [Description("If `false`, NetworkRegistryAssets will be hidden from the \"References to ___\" tab.")]
+        [EbxFieldMeta(EbxFieldType.Boolean)]
+        public bool ShowNetRegs { get; set; } = true;
+
+        public override void Load()
+        {
+            ShowNetRegs = Config.Get<bool>("References.ShowNetRegs", true);
+        }
+
+        public override void Save()
+        {
+            Config.Add("References.ShowNetRegs", ShowNetRegs);
+            Config.Save();
+        }
+    }
+}
diff --git a/Plugins/ReferencesPlugin/Properties/AssemblyInfo.cs b/Plugins/ReferencesPlugin/Properties/AssemblyInfo.cs
index a44549b0f..e2381c2ee 100644
--- a/Plugins/ReferencesPlugin/Properties/AssemblyInfo.cs
+++ b/Plugins/ReferencesPlugin/Properties/AssemblyInfo.cs
@@ -24,7 +24,10 @@
 [assembly: Guid("4b612468-9b6a-4304-88a5-055c3575eb3d")]
 
 [assembly: PluginDisplayName("References Plugin")]
-[assembly: PluginAuthor("Cade")]
-[assembly: PluginVersion("1.0.1.0")]
+[assembly: PluginAuthor("Cade, Mophead, AdamRaichu")]
+[assembly: PluginVersion("1.0.1.8")]
 
-[assembly: RegisterTabExtension(typeof(ReferenceTabExtension))]
\ No newline at end of file
+[assembly: RegisterTabExtension(typeof(ReferenceTabExtension))]
+[assembly: RegisterMenuExtension(typeof(CreateCacheMenuExtension))]
+
+[assembly: RegisterOptionsExtension(typeof(ReferencesOptions))]
\ No newline at end of file
diff --git a/Plugins/ReferencesPlugin/ReferenceTabItem.cs b/Plugins/ReferencesPlugin/ReferenceTabItem.cs
index bd2c2016d..253377c11 100644
--- a/Plugins/ReferencesPlugin/ReferenceTabItem.cs
+++ b/Plugins/ReferencesPlugin/ReferenceTabItem.cs
@@ -1,6 +1,8 @@
 using Frosty.Controls;
 using Frosty.Core;
 using Frosty.Core.Controls;
+using Frosty.Core.Attributes;
+using Frosty.Core.Misc;
 using FrostySdk.Managers;
 using System;
 using System.Collections.Generic;
@@ -10,6 +12,13 @@
 using System.Windows;
 using System.Windows.Controls;
 using FrostySdk.Managers.Entries;
+using Frosty.Core.Windows;
+using FrostySdk;
+using FrostySdk.Ebx;
+using FrostySdk.IO;
+using System.IO;
+using System.Windows.Media;
+using ReferencesPlugin.Extensions;
 
 namespace ReferencesPlugin
 {
@@ -28,6 +37,20 @@ public class ReferenceTabItem : FrostyTabItem
 
         private const string PART_RefExplorerToFindItem = "PART_RefExplorerToFindItem";
         private const string PART_RefExplorerFromFindItem = "PART_RefExplorerFromFindItem";
+		
+        // AdamRaichu
+        private const string PART_RefExplorerToOpenBlueprintEditor = "PART_RefExplorerToOpenBlueprintEditor";
+        private const string PART_RefExplorerFromOpenBlueprintEditor = "PART_RefExplorerFromOpenBlueprintEditor";
+        private const string PART_RefExplorerToCopyGUID = "PART_RefExplorerToCopyGUID";
+        private const string PART_RefExplorerFromCopyGUID = "PART_RefExplorerFromCopyGUID";
+        private const string PART_RefExplorerToCopyFilePath = "PART_RefExplorerToCopyFilePath";
+        private const string PART_RefExplorerFromCopyFilePath = "PART_RefExplorerFromCopyFilePath";
+
+        // Mophead
+        private const string PART_RefExplorerToDisplayInfo = "PART_RefExplorerToDisplayInfo";
+        private const string PART_RefExplorerFromDisplayInfo = "PART_RefExplorerFromDisplayInfo";
+        private const string PART_RefExplorerToTextBlockInfo = "PART_RefExplorerToTextBlockInfo";
+        private const string PART_RefExplorerFromTextBlockInfo = "PART_RefExplorerFromTextBlockInfo";
 
         private FrostyAssetListView refExplorerToList;
         private FrostyAssetListView refExplorerFromList;
@@ -39,6 +62,22 @@ public class ReferenceTabItem : FrostyTabItem
         private MenuItem refExplorerToFindItem;
         private MenuItem refExplorerFromFindItem;
 
+        // AdamRaichu
+        private MenuItem refExplorerToOpenBlueprintEditor;
+        private MenuItem refExplorerFromOpenBlueprintEditor;
+        private MenuItem refExplorerToCopyGUID;
+        private MenuItem refExplorerFromCopyGUID;
+        private MenuItem refExplorerToCopyFilePath;
+        private MenuItem refExplorerFromCopyFilePath;
+
+        // Mophead
+        private MenuItem refExplorerToDisplayInfo;
+        private MenuItem refExplorerFromDisplayInfo;
+        private TextBlock refExplorerToTextBlockInfo;
+        private TextBlock refExplorerFromTextBlockInfo;
+
+        private IBlueprintEditorHandler blueprintEditorHandler = App.PluginManager.BlueprintEditorOpenAction.Count() == 0 ? new DefaultBlueprintEditorHandler() : App.PluginManager.BlueprintEditorOpenAction.First();
+
         static ReferenceTabItem()
         {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(ReferenceTabItem), new FrameworkPropertyMetadata(typeof(ReferenceTabItem)));
@@ -60,6 +99,10 @@ public override void OnApplyTemplate()
             refExplorerToText = GetTemplateChild(PART_RefExplorerToTextBlock) as TextBlock;
             refExplorerFromText = GetTemplateChild(PART_RefExplorerFromTextBlock) as TextBlock;
 
+            // Bind References Textblock Info Elements
+            refExplorerToTextBlockInfo = GetTemplateChild(PART_RefExplorerToTextBlockInfo) as TextBlock;
+            refExplorerFromTextBlockInfo = GetTemplateChild(PART_RefExplorerFromTextBlockInfo) as TextBlock;
+
             // Bind Open Asset Elements
             refExplorerToOpenItem = GetTemplateChild(PART_RefExplorerToOpenItem) as MenuItem;
             refExplorerFromOpenItem = GetTemplateChild(PART_RefExplorerFromOpenItem) as MenuItem;
@@ -67,6 +110,22 @@ public override void OnApplyTemplate()
             // Bind Find Asset Elements
             refExplorerToFindItem = GetTemplateChild(PART_RefExplorerToFindItem) as MenuItem;
             refExplorerFromFindItem = GetTemplateChild(PART_RefExplorerFromFindItem) as MenuItem;
+			
+            // Bind Open Blueprint Editor Elements
+            refExplorerToOpenBlueprintEditor = GetTemplateChild(PART_RefExplorerToOpenBlueprintEditor) as MenuItem;
+            refExplorerFromOpenBlueprintEditor = GetTemplateChild(PART_RefExplorerFromOpenBlueprintEditor) as MenuItem;
+
+            // Bind Copy GUID Elements
+            refExplorerToCopyGUID = GetTemplateChild(PART_RefExplorerToCopyGUID) as MenuItem;
+            refExplorerFromCopyGUID = GetTemplateChild(PART_RefExplorerFromCopyGUID) as MenuItem;
+
+            // Bind Copy File Path Elements
+            refExplorerToCopyFilePath = GetTemplateChild(PART_RefExplorerToCopyFilePath) as MenuItem;
+            refExplorerFromCopyFilePath = GetTemplateChild(PART_RefExplorerFromCopyFilePath) as MenuItem;
+
+            // Bind Display Asset Info Elements
+            refExplorerToDisplayInfo = GetTemplateChild(PART_RefExplorerToDisplayInfo) as MenuItem;
+            refExplorerFromDisplayInfo = GetTemplateChild(PART_RefExplorerFromDisplayInfo) as MenuItem;
 
             // Double Click Asset to Open
             refExplorerToList.SelectedAssetDoubleClick += ReferenceExplorerList_SelectedAssetDoubleClick;
@@ -79,12 +138,104 @@ public override void OnApplyTemplate()
             // Find Item in Data Explorer
             refExplorerToFindItem.Click += contextMenuRefExplorerToFind_Click;
             refExplorerFromFindItem.Click += contextMenuRefExplorerFromFind_Click;
+			
+            // Open Blueprint Editor
+            refExplorerToOpenBlueprintEditor.Click += contextMenuRefExplorerToOpenBlueprintEditor_Click;
+            refExplorerFromOpenBlueprintEditor.Click += contextMenuRefExplorerFromOpenBlueprintEditor_Click;
+
+            // Copy GUID
+            refExplorerToCopyGUID.Click += contextMenuRefExplorerToCopyGUID_Click;
+            refExplorerFromCopyGUID.Click += contextMenuRefExplorerFromCopyGUID_Click;
+
+            // Copy file path
+            refExplorerToCopyFilePath.Click += RefExplorerToCopyFilePath_Click;
+            refExplorerFromCopyFilePath.Click += RefExplorerFromCopyFilePath_Click;
+
+            // Display Asset Info
+            refExplorerToDisplayInfo.Click += RefExplorerToDisplayInfo_Click;
+            refExplorerFromDisplayInfo.Click += RefExplorerFromDisplayInfo_Click;
 
             Loaded += ReferenceTabItem_Loaded;
 
             App.EditorWindow.DataExplorer.SelectionChanged += dataExplorer_SelectionChanged;
         }
 
+        private Dictionary<EbxAssetEntry, string> SpecialInfoTo = new Dictionary<EbxAssetEntry, string>();
+        private Dictionary<EbxAssetEntry, string> SpecialInfoFrom = new Dictionary<EbxAssetEntry, string>();
+
+        private void RefExplorerFromCopyFilePath_Click(object sender, EventArgs e)
+        {
+            EbxAssetEntry entry = refExplorerFromList.SelectedItem as EbxAssetEntry;
+            if (entry == null)
+                return;
+            Clipboard.SetText(entry.Name);
+        }
+
+        private void RefExplorerToCopyFilePath_Click(object sender, EventArgs e)
+        {
+            EbxAssetEntry entry = refExplorerToList.SelectedItem as EbxAssetEntry;
+            if (entry == null)
+                return;
+            Clipboard.SetText(entry.Name);
+        }
+
+        private void RefExplorerFromDisplayInfo_Click(object sender, RoutedEventArgs e)
+        {
+            EbxAssetEntry entry = refExplorerFromList.SelectedItem as EbxAssetEntry;
+            if (entry == null)
+                return;
+            refExplorerFromTextBlockInfo.Text = SpecialInfoFrom[entry];
+        }
+
+        private void RefExplorerToDisplayInfo_Click(object sender, RoutedEventArgs e)
+        {
+            EbxAssetEntry entry = refExplorerToList.SelectedItem as EbxAssetEntry;
+            if (entry == null)
+                return;
+            refExplorerToTextBlockInfo.Text = SpecialInfoTo[entry];
+        }
+
+        private void contextMenuRefExplorerToCopyGUID_Click(object sender, RoutedEventArgs e)
+        {
+            if (refExplorerToList.SelectedItem == null)
+                return;
+            if (refExplorerToList.SelectedItem is EbxAssetEntry entry)
+            {
+                Clipboard.SetText(entry.Guid.ToString());
+            }
+        }
+        private void contextMenuRefExplorerFromCopyGUID_Click(object sender, RoutedEventArgs e)
+        {
+            if (refExplorerFromList.SelectedItem == null)
+                return;
+            if (refExplorerFromList.SelectedItem is EbxAssetEntry entry)
+            {
+                Clipboard.SetText(entry.Guid.ToString());
+            }
+        }
+
+        private void contextMenuRefExplorerToOpenBlueprintEditor_Click(object sender, RoutedEventArgs e)
+        {
+            if (refExplorerToList.SelectedItem == null)
+                return;
+
+            if (refExplorerToList.SelectedItem is EbxAssetEntry) {
+                App.Logger.Log("Opening blueprint editor (debug test)");
+                blueprintEditorHandler.OpenAssetAsGraph((EbxAssetEntry)refExplorerToList.SelectedItem);
+            }
+        }
+        private void contextMenuRefExplorerFromOpenBlueprintEditor_Click(object sender, RoutedEventArgs e)
+        {
+            if (refExplorerFromList.SelectedItem == null)
+                return;
+
+            if (refExplorerFromList.SelectedItem is EbxAssetEntry)
+            {
+                App.Logger.Log("Opening blueprint editor (debug test)");
+                blueprintEditorHandler.OpenAssetAsGraph((EbxAssetEntry)refExplorerFromList.SelectedItem);
+            }
+        }
+
         private void ReferenceTabItem_Loaded(object sender, RoutedEventArgs e)
         {
             EbxAssetEntry selectedEntry = App.SelectedAsset;
@@ -138,9 +289,11 @@ private void contextMenuRefExplorerFromFind_Click(object sender, RoutedEventArgs
 
         private void RefreshReferences(EbxAssetEntry entry)
         {
-            //if (!ReferencesTabItem.IsSelected)
-            //    return;
-
+            LoadCache();
+            SpecialInfoTo.Clear();
+            SpecialInfoFrom.Clear();
+            refExplorerToTextBlockInfo.Text = "";
+            refExplorerFromTextBlockInfo.Text = "";
             if (entry == null)
             {
                 refExplorerFromText.Text = "";
@@ -159,13 +312,334 @@ private void RefreshReferences(EbxAssetEntry entry)
             foreach (EbxAssetEntry subEntry in App.AssetManager.EnumerateEbx())
             {
                 if (subEntry.ContainsDependency(entry.Guid))
+                {
                     refToItems.Add(subEntry);
+                    if (!SpecialInfoTo.ContainsKey(subEntry))
+                        SpecialInfoTo.Add(subEntry, string.Format("{0} directly references {1}", subEntry.Name, entry.Filename));
+                }
             }
             foreach (Guid guid in entry.EnumerateDependencies())
+            {
                 refFromItems.Add(App.AssetManager.GetEbxEntry(guid));
+                if (!SpecialInfoFrom.ContainsKey(App.AssetManager.GetEbxEntry(guid)))
+                    SpecialInfoFrom.Add(App.AssetManager.GetEbxEntry(guid), string.Format("{0} directly references {1}", entry.Filename, App.AssetManager.GetEbxEntry(guid).Name));
+            }
+            if (entry.Type == "ShaderGraph")
+            {
+                foreach (ResAssetEntry resBlockEntry in App.AssetManager.EnumerateRes(resType: (uint)ResourceType.ShaderBlockDepot))
+                {
+                    if (resBlockEntry.Name == entry.Name.ToLower() + "_graph/blocks")
+                    {
+                        using (NativeReader reader = new NativeReader(App.AssetManager.GetRes(resBlockEntry)))
+                        {
+                            for (int idx = 72; idx < Convert.ToInt32(reader.BaseStream.Length - 12); idx = idx + 4)
+                            {
+                                reader.BaseStream.Position = idx;
+                                Guid ReadGuid = reader.ReadGuid();
+                                if (TextureGuids.ContainsKey(ReadGuid))
+                                {
+                                    if (!refFromItems.Contains(App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid])))
+                                    {
+                                        refFromItems.Add(App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid]));
+                                        SpecialInfoFrom.Add(App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid]), string.Format("{0} references {1} through res file", entry.Filename, App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid]).Filename));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else if (TypeLibrary.IsSubClassOf(entry.Type, "MeshAsset"))
+            {
+                foreach (EbxAssetEntry refEntry in entry.EnumerateDependencies().Select(o => App.AssetManager.GetEbxEntry(o)))
+                {
+                    foreach (ResAssetEntry resBlockEntry in App.AssetManager.EnumerateRes(resType: (uint)ResourceType.ShaderBlockDepot))
+                    {
+                        if (resBlockEntry.Name == refEntry.Name.ToLower() + "_graph/blocks")
+                        {
+                            using (NativeReader reader = new NativeReader(App.AssetManager.GetRes(resBlockEntry)))
+                            {
+                                for (int idx = 72; idx < Convert.ToInt32(reader.BaseStream.Length - 12); idx = idx + 4)
+                                {
+                                    reader.BaseStream.Position = idx;
+                                    Guid ReadGuid = reader.ReadGuid();
+                                    if (TextureGuids.ContainsKey(ReadGuid))
+                                    {
+                                        if (!refFromItems.Contains(App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid])))
+                                        {
+                                            refFromItems.Add(App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid]));
+                                            SpecialInfoFrom.Add(App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid]), string.Format("{0} references {1} through shadergraph {2} res file", entry.DisplayName, App.AssetManager.GetEbxEntry(TextureGuids[ReadGuid]).DisplayName, refEntry.DisplayName));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (metadataList.Count != 0 & entry.GetType().Name != "UIMetaDataAsset")
+            {
+                GetModifiedMetadata();
+                EbxAsset refAsset = App.AssetManager.GetEbx(entry);
+                Dictionary<UInt32, string> assetIdens = new Dictionary<uint, string>();
+                dynamic refRoot = refAsset.RootObject;
+                if (refRoot.GetType().GetProperty("Identifier") != null)
+                    assetIdens.Add(refRoot.Identifier, "Identifier");
+                UInt32 guidIden = FNVConvertGUID(refAsset.RootInstanceGuid.ToString());
+                if (!assetIdens.ContainsKey(guidIden))
+                    assetIdens.Add(guidIden, "Root Instance GUID");
+                else
+                    assetIdens[guidIden] = "Identifier & Root Instance GUID";
+                if (refRoot.GetType().Name == "VisualUnlockRootAsset")
+                {
+                    Dictionary<EbxAssetEntry, string> bpbsToRef = new Dictionary<EbxAssetEntry, string>();
+                    foreach (dynamic bpbRef in refRoot.ThirdPersonBundles)
+                    {
+                        EbxAssetEntry primBpbEntry = App.AssetManager.GetEbxEntry(bpbRef.Name);
+                        if (primBpbEntry != null)
+                        {
+                            if (!bpbsToRef.ContainsKey(primBpbEntry))
+                                bpbsToRef.Add(primBpbEntry, "Third Person Bpb");
+                        }
+                        foreach (dynamic par in bpbRef.Parents)
+                        {
+                            EbxAssetEntry bpbEntry = App.AssetManager.GetEbxEntry(par.Name);
+                            if (bpbEntry != null)
+                            {
+                                if (!bpbsToRef.ContainsKey(bpbEntry))
+                                    bpbsToRef.Add(bpbEntry, "Third Person Bpb Parent");
+                            }
+                        }
+
+                    }
+                    foreach (dynamic bpbRef in refRoot.FirstPersonBundles)
+                    {
+                        EbxAssetEntry primBpbEntry = App.AssetManager.GetEbxEntry(bpbRef.Name);
+                        if (primBpbEntry != null)
+                        {
+                            if (!bpbsToRef.ContainsKey(primBpbEntry))
+                                bpbsToRef.Add(primBpbEntry, "First Person Bpb");
+                        }
+                        foreach (dynamic par in bpbRef.Parents)
+                        {
+                            EbxAssetEntry bpbEntry = App.AssetManager.GetEbxEntry(par.Name);
+                            if (bpbEntry != null)
+                            {
+                                if (!bpbsToRef.ContainsKey(bpbEntry))
+                                    bpbsToRef.Add(bpbEntry, "First Person Bpb Parent");
+                            }
+                        }
+
+                    }
+                    foreach (dynamic skinInfo in refRoot.SkinInfos)
+                    {
+                        if (!assetIdens.ContainsKey(skinInfo.Identifier))
+                            assetIdens.Add(skinInfo.Identifier, "SkinInfos Identifiers");
+                        foreach (EbxAssetEntry bpbEntry in new List<string> { skinInfo.ThirdPersonBundle.Name, skinInfo.FirstPersonBundle.Name }.Select(o => App.AssetManager.GetEbxEntry(o)))
+                        {
+                            if (bpbEntry != null)
+                            {
+                                if (!bpbsToRef.ContainsKey(bpbEntry))
+                                    bpbsToRef.Add(bpbEntry, "SkinInfo Bpbs");
+                            }
+
+                        }
+                    }
+                    foreach (EbxAssetEntry bpbEntry in bpbsToRef.Keys)
+                    {
+                        if (!refFromItems.Contains(bpbEntry))
+                        {
+                            refFromItems.Add(bpbEntry);
+                            SpecialInfoFrom.Add(bpbEntry, string.Format("{0} references {1} through {2}", entry.DisplayName, bpbEntry.DisplayName, bpbsToRef[bpbEntry]));
+                        }
+                    }
+                }
+                foreach (UInt32 assetIden in assetIdens.Keys)
+                {
+                    if (modifiedMetadataList.ContainsKey(assetIden))
+                    {
+                        foreach (Tuple<string, int> tup in modifiedMetadataList[assetIden])
+                        {
+                            if (!refToItems.Contains(App.AssetManager.GetEbxEntry(tup.Item1)))
+                            {
+                                refToItems.Add(App.AssetManager.GetEbxEntry(tup.Item1));
+                                if (!SpecialInfoTo.ContainsKey(App.AssetManager.GetEbxEntry(tup.Item1)))
+                                    SpecialInfoTo.Add(App.AssetManager.GetEbxEntry(tup.Item1), string.Format("{0}[{2}] references {1} through metadata identifier using the asset {3}", App.AssetManager.GetEbxEntry(tup.Item1).Filename, entry.Filename, tup.Item2, assetIdens[assetIden]));
+                            }
+                        }
+                    }
+                    if (metadataList.ContainsKey(assetIden))
+                    {
+                        foreach (Tuple<string, int> tup in metadataList[assetIden])
+                        {
+                            if (!refToItems.Contains(App.AssetManager.GetEbxEntry(tup.Item1)) & !modifiedMetadataFiles.Contains(tup.Item1))
+                            {
+                                refToItems.Add(App.AssetManager.GetEbxEntry(tup.Item1));
+                                if (!SpecialInfoTo.ContainsKey(App.AssetManager.GetEbxEntry(tup.Item1)))
+                                    SpecialInfoTo.Add(App.AssetManager.GetEbxEntry(tup.Item1), string.Format("{0}[{2}] references {1} through metadata identifier using the asset {3}", App.AssetManager.GetEbxEntry(tup.Item1).Filename, entry.Filename, tup.Item2, assetIdens[assetIden]));
+                            }
+                        }
+                    }
+                }
+            }
 
-            refExplorerToList.ItemsSource = refToItems;
+            refExplorerToTextBlockInfo.Text = "";
+            int hiddenNetRegs = 0;
+            refExplorerToList.ItemsSource = refToItems.Where((entryWhere) => {
+                ReferencesOptions options = new ReferencesOptions();
+                options.Load();
+                if (!options.ShowNetRegs)
+                {
+                    if (entryWhere.Type == "NetworkRegistryAsset")
+                    {
+                        hiddenNetRegs++;
+                        return false;
+                    }
+                }
+                return true;
+            });
+            if (hiddenNetRegs > 0)
+                refExplorerToTextBlockInfo.Text = $"(Hiding {hiddenNetRegs} NetworkRegistryAsset{(hiddenNetRegs > 1 ? "s" : "")})";
             refExplorerFromList.ItemsSource = refFromItems;
         }
+
+        private void LoadCache()
+        {
+            if (TextureGuids.Count == 0)
+            {
+                if (File.Exists(CacheFileDir))
+                {
+                    using (NativeReader reader = new NativeReader(new FileStream(CacheFileDir, FileMode.Open)))
+                    {
+                        int texGuidCount = reader.ReadInt();
+                        int metaDataCount = reader.ReadInt();
+                        for (int i = 0; i < texGuidCount; i++)
+                        {
+                            Guid texFileGuid = reader.ReadGuid();
+                            Guid texRootGuid = reader.ReadGuid();
+                            TextureGuids.Add(texRootGuid, texFileGuid);
+                        }
+                        for (int i = 0; i < metaDataCount; i++)
+                        {
+                            UInt32 key = reader.ReadUInt();
+                            int keycount = reader.ReadInt();
+                            List<Tuple<string, int>> tuples = new List<Tuple<string, int>>();
+                            for (int i2 = 0; i2 < keycount; i2++)
+                                tuples.Add(new Tuple<string, int>(reader.ReadNullTerminatedString(), reader.ReadInt()));
+                            metadataList.Add(key, tuples);
+                        }
+                    }
+                }
+                else
+                    App.Logger.Log(string.Format("Cannot find cache file {0}, please generate one through \"Tools>Generate Cache>Reference Plugin Cache\"", CacheFileDir));
+            }
+        }
+		
+        private void GetModifiedMetadata()
+        {
+            modifiedMetadataFiles.Clear();
+            modifiedMetadataList.Clear();
+            AssetManager AM = App.AssetManager;
+            foreach (EbxAssetEntry refEntry in AM.EnumerateEbx(type: "UIMetaDataAsset"))
+            {
+                if (refEntry.HasModifiedData)
+                {
+                    modifiedMetadataFiles.Add(refEntry.Name);
+                    EbxAsset refAsset = AM.GetEbx(refEntry);
+                    dynamic refRoot = refAsset.RootObject;
+                    int idx2 = 0;
+                    foreach (dynamic item in refRoot.Items)
+                    {
+                        if (item.Type == PointerRefType.Internal)
+                        {
+                            UInt32 TypeFNV = FNVConvertMetadata(item.Internal.GetType().Name);
+                            foreach (UInt32 Identifier in item.Internal.Identifiers)
+                            {
+                                UInt32 newIden = TypeFNV ^ Identifier;
+                                if (modifiedMetadataList.ContainsKey(newIden))
+                                    modifiedMetadataList[newIden].Add(new Tuple<string, int>(refEntry.Name, idx2));
+                                else
+                                    modifiedMetadataList.Add(newIden, new List<Tuple<string, int>>() { new Tuple<string, int>(refEntry.Name, idx2) });
+                            }
+                        }
+                        idx2++;
+                    }
+                }
+            }
+        }
+		
+        List<string> modifiedMetadataFiles = new List<string>();
+        Dictionary<UInt32, List<Tuple<string, int>>> modifiedMetadataList = new Dictionary<UInt32, List<Tuple<string, int>>>();
+		
+        static UInt32 FNVConvertMetadata(string FNVInput)
+        {
+            int FNV_offset_basis = 5381;
+            int FNV_prime = 33;
+            for (int i = 0; i < FNVInput.Length; i++)
+            {
+                byte b = (byte)FNVInput[i];
+                FNV_offset_basis = (FNV_offset_basis * FNV_prime) ^ b;
+            }
+            String Output = "";
+            Int64 FNV_offset_basis_Temp = Convert.ToInt64(FNV_offset_basis);
+            if (FNV_offset_basis < 0)
+            {
+                FNV_offset_basis = FNV_offset_basis * -1;
+                string Original = Convert.ToString(FNV_offset_basis, 2).PadLeft(32, '0');
+                string Zero = "0";
+                for (int i = 0; i < Original.Length; i++)
+                {
+                    if (Original[i] == Zero[0])
+                    {
+                        Output = Output + "1";
+                    }
+                    else
+                    {
+                        Output = Output + "0";
+                    }
+                }
+                FNV_offset_basis_Temp = Convert.ToInt64(Output, 2) + 2;
+            }
+            else
+            {
+                FNV_offset_basis_Temp = FNV_offset_basis_Temp + 1;
+            }
+            return Convert.ToUInt32(FNV_offset_basis_Temp);
+        }
+        static UInt32 FNVConvertGUID(string FNVInput)
+        {
+            int FNV_offset_basis = 5381;
+            int FNV_prime = 33;
+            for (int i = 0; i < FNVInput.Length; i++)
+            {
+                byte b = (byte)FNVInput[i];
+                FNV_offset_basis = (FNV_offset_basis * FNV_prime) ^ b;
+            }
+            String Output = "";
+            Int64 FNV_offset_basis_Temp = Convert.ToInt64(FNV_offset_basis);
+            if (FNV_offset_basis < 0)
+            {
+                FNV_offset_basis = FNV_offset_basis * -1;
+                string Original = Convert.ToString(FNV_offset_basis, 2).PadLeft(32, '0');
+                string Zero = "0";
+                for (int i = 0; i < Original.Length; i++)
+                {
+                    if (Original[i] == Zero[0])
+                    {
+                        Output = Output + "1";
+                    }
+                    else
+                    {
+                        Output = Output + "0";
+                    }
+                }
+                FNV_offset_basis_Temp = Convert.ToInt64(Output, 2) + 1;
+            }
+            return Convert.ToUInt32(FNV_offset_basis_Temp);
+        }
+		
+        Dictionary<Guid, Guid> TextureGuids = new Dictionary<Guid, Guid>();
+        Dictionary<UInt32, List<Tuple<string, int>>> metadataList = new Dictionary<UInt32, List<Tuple<string, int>>>();
+        public static string CacheFileDir = System.AppDomain.CurrentDomain.BaseDirectory + @"Plugins\Caches\" + Enum.GetName(typeof(ProfileVersion), ProfilesLibrary.DataVersion) + "_ReferencePlugin_Cache.cache";
     }
 }
diff --git a/Plugins/ReferencesPlugin/Themes/Generic.xaml b/Plugins/ReferencesPlugin/Themes/Generic.xaml
index 4c3c8d6eb..cbb0ad8f2 100644
--- a/Plugins/ReferencesPlugin/Themes/Generic.xaml
+++ b/Plugins/ReferencesPlugin/Themes/Generic.xaml
@@ -24,11 +24,13 @@
                         <Grid.RowDefinitions>
                             <RowDefinition Height="26"/>
                             <RowDefinition/>
+                            <RowDefinition Height="26"/>
                         </Grid.RowDefinitions>
 
                         <!-- Backgrounds -->
-                        <Border  Grid.ColumnSpan="2" Grid.RowSpan="2" Background="{StaticResource ListBackground}" RenderOptions.EdgeMode="Aliased"/>
-                        <Border Grid.ColumnSpan="2" Background="{StaticResource ControlBackground}" RenderOptions.EdgeMode="Aliased"/>
+                        <Border  Grid.ColumnSpan="2" Grid.RowSpan="2" Background="{StaticResource ListBackground}"/>
+                        <Border Grid.ColumnSpan="2" Background="{StaticResource ControlBackground}"/>
+                        <Border  Grid.ColumnSpan="2" Grid.RowSpan="3" Background="{StaticResource ControlBackground}"/>
 
                         <!-- Titles -->
                         <TextBlock x:Name="PART_RefExplorerToTextBlock" FontFamily="Global User Interface" Foreground="{StaticResource FontColor}" Text="" VerticalAlignment="Center" Margin="2 0 3 0" TextTrimming="CharacterEllipsis"/>
@@ -43,7 +45,31 @@
                                             <Image Source="/FrostyEditor;component/Images/OpenAsset.png" Opacity="0.5"/>
                                         </MenuItem.Icon>
                                     </MenuItem>
-                                    <MenuItem x:Name="PART_RefExplorerToFindItem" Header="Find in data explorer"/>
+                                    <MenuItem x:Name="PART_RefExplorerToFindItem" Header="Find in data explorer">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyEditor;component/Images/Open.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerToOpenBlueprintEditor" Header="Open in Blueprint Editor">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyCore;component/Images/Assets/BlueprintFileType.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerToCopyGUID" Header="Copy file GUID">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyCore;component/Images/Copy.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerToCopyFilePath" Header="Copy file path">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyCore;component/Images/Copy.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerToDisplayInfo" Header="Display reference details">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyEditor;component/Images/Key.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
                                 </ContextMenu>
                             </core:FrostyAssetListView.AssetContextMenu>
                         </core:FrostyAssetListView>
@@ -55,10 +81,36 @@
                                             <Image Source="/FrostyEditor;component/Images/OpenAsset.png" Opacity="0.5"/>
                                         </MenuItem.Icon>
                                     </MenuItem>
-                                    <MenuItem x:Name="PART_RefExplorerFromFindItem" Header="Find in data explorer"/>
+                                    <MenuItem x:Name="PART_RefExplorerFromFindItem" Header="Find in data explorer">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyEditor;component/Images/Open.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerFromOpenBlueprintEditor" Header="Open in Blueprint Editor">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyCore;component/Images/Assets/BlueprintFileType.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerFromCopyGUID" Header="Copy file GUID">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyCore;component/Images/Copy.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerFromCopyFilePath" Header="Copy file path">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyCore;component/Images/Copy.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
+                                    <MenuItem x:Name="PART_RefExplorerFromDisplayInfo" Header="Display reference details">
+                                        <MenuItem.Icon>
+                                            <Image Source="/FrostyEditor;component/Images/Key.png" Opacity="0.5"/>
+                                        </MenuItem.Icon>
+                                    </MenuItem>
                                 </ContextMenu>
                             </core:FrostyAssetListView.AssetContextMenu>
                         </core:FrostyAssetListView>
+                        <TextBlock x:Name="PART_RefExplorerToTextBlockInfo" FontFamily="Global User Interface" Foreground="{StaticResource FontColor}" Text="" VerticalAlignment="Center" Margin="2 0 3 0" Grid.Row="2" TextTrimming="CharacterEllipsis"/>
+                        <TextBlock x:Name="PART_RefExplorerFromTextBlockInfo" FontFamily="Global User Interface"  Foreground="{StaticResource FontColor}" Text="" VerticalAlignment="Center" Margin="2 0 0 0" Grid.Row="2" Grid.Column="1" TextTrimming="CharacterEllipsis"/>
 
                         <!-- Divider -->
                         <GridSplitter VerticalAlignment="Stretch" Width="3" HorizontalAlignment="Right" Grid.RowSpan="2" Background="{StaticResource ControlBackground}"/>
diff --git a/Plugins/TypeExplorerPlugin/FrostyTypeExplorer.cs b/Plugins/TypeExplorerPlugin/FrostyTypeExplorer.cs
index ceb866361..549020a5a 100644
--- a/Plugins/TypeExplorerPlugin/FrostyTypeExplorer.cs
+++ b/Plugins/TypeExplorerPlugin/FrostyTypeExplorer.cs
@@ -11,6 +11,8 @@
 using System.Windows.Media;
 using FrostySdk;
 using FrostySdk.Attributes;
+using Frosty.Controls;
+using Frosty.Core.Windows;
 
 namespace TypeExplorerPlugin
 {
@@ -18,6 +20,7 @@ namespace TypeExplorerPlugin
     [TemplatePart(Name = PART_TypeFilter, Type = typeof(TextBox))]
     [TemplatePart(Name = PART_TypeFieldsTextBox, Type = typeof(RichTextBox))]
     [TemplatePart(Name = PART_HideEmptyCheckBox, Type = typeof(CheckBox))]
+    [TemplatePart(Name = PART_ExportButton, Type = typeof(Button))]
     public class FrostyTypeExplorer : FrostyBaseEditor
     {
         public override ImageSource Icon => TypeExplorerMenuExtension.imageSource;
@@ -28,11 +31,13 @@ public class FrostyTypeExplorer : FrostyBaseEditor
         private const string PART_TypeFilter = "PART_TypeFilter";
         private const string PART_TypeFieldsTextBox = "PART_TypeFieldsTextBox";
         private const string PART_HideEmptyCheckBox = "PART_HideEmptyCheckBox";
+        private const string PART_ExportButton = "PART_ExportButton";
 
         private ListBox typesListBox;
         private TextBox typeFilterTextBox;
         private RichTextBox typeFieldsTextBox;
         private CheckBox hideEmptyCheckBox;
+        private Button exportButton;
 
         private static readonly SolidColorBrush TextColor = new SolidColorBrush(Color.FromRgb(0xDC, 0xDC, 0xDC));
         private static readonly SolidColorBrush EnumColor = new SolidColorBrush(Color.FromRgb(0xB8, 0xD7, 0xA3));
@@ -74,6 +79,7 @@ public override void OnApplyTemplate()
             typeFilterTextBox = GetTemplateChild(PART_TypeFilter) as TextBox;
             typeFieldsTextBox = GetTemplateChild(PART_TypeFieldsTextBox) as RichTextBox;
             hideEmptyCheckBox = GetTemplateChild(PART_HideEmptyCheckBox) as CheckBox;
+            exportButton = GetTemplateChild(PART_ExportButton) as Button;
 
             Loaded += FrostyTypeExplorer_Loaded;
             typesListBox.SelectionChanged += TypesListBox_SelectionChanged;
@@ -81,6 +87,7 @@ public override void OnApplyTemplate()
             typeFilterTextBox.KeyUp += TypeFilterTextBox_KeyUp;
             hideEmptyCheckBox.Checked += HideEmptyCheckBox_Checked;
             hideEmptyCheckBox.Unchecked += HideEmptyCheckBox_Unchecked;
+            exportButton.Click += ExportButton_Click;
         }
 
         private void TypeFilterTextBox_KeyUp(object sender, KeyEventArgs e)
@@ -110,99 +117,7 @@ private void TypesListBox_SelectionChanged(object sender, RoutedEventArgs e)
             {
                 Type type = typeItem.Type;
 
-                FlowDocument document = new FlowDocument();
-                Paragraph paragraph = new Paragraph();
-
-                paragraph.Inlines.Add(new Run(type.Name) { Foreground = GetTypeColor(type) });
-
-                // enums
-                if (type.IsEnum)
-                {
-                    paragraph.Inlines.Add(new Run("\n{\n") { Foreground = TextColor });
-
-                    var underlyingType = Enum.GetUnderlyingType(type);
-                    var values = type.GetEnumValues();
-
-                    // enum members
-                    for (int i = 0; i < values.Length; i++)
-                    {
-                        paragraph.Inlines.Add(new Run($"    {values.GetValue(i)} = ") { Foreground = TextColor });
-                        paragraph.Inlines.Add(new Run(Convert.ChangeType(values.GetValue(i), underlyingType).ToString()) { Foreground = LiteralColor });
-                        paragraph.Inlines.Add(new Run(i != values.Length - 1 ? ",\n" : "\n") { Foreground = TextColor });
-                    }
-
-                    paragraph.Inlines.Add(new Run("}") { Foreground = TextColor });
-                    document.Blocks.Add(paragraph);
-
-                    typeFieldsTextBox.Document = document;
-                    return;
-                }
-
-                // base types
-                if (type.BaseType != null && type.BaseType.Name != "Object")
-                {
-                    paragraph.Inlines.Add(new Run(" : ") { Foreground = TextColor });
-                    paragraph.Inlines.Add(new Run(type.BaseType.Name) { Foreground = ClassColor });
-                }
-
-                paragraph.Inlines.Add(new Run("\n{\n") { Foreground = TextColor });
-
-                var props = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
-
-                // class properties
-                foreach (var pi in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly))
-                {
-                    if (pi.Name.StartsWith("_"))
-                        continue;
-                    
-                    string propName = pi.PropertyType.Name;
-                    paragraph.Inlines.Add(new Run("    "));
-
-                    // use ebx field type names
-                    if (propName == "Single")
-                        propName = "Float32";
-                    else if (propName == "Double")
-                        propName = "Float64";
-
-                    // get the generic/ref type
-                    if (propName == "List`1" || propName == "PointerRef")
-                    {
-                        paragraph.Inlines.Add(new Run(propName == "List`1" ? "List" : "PointerRef") { Foreground = ClassColor });
-                        paragraph.Inlines.Add(new Run("<") { Foreground = TextColor });
-
-                        if (propName == "List`1")
-                        {
-                            Type listType = pi.PropertyType.GetGenericArguments()[0];
-
-                            // list of pointerrefs
-                            if (listType.Name == "PointerRef")
-                            {
-                                paragraph.Inlines.Add(new Run("PointerRef") { Foreground = ClassColor });
-                                paragraph.Inlines.Add(new Run("<") { Foreground = TextColor });
-                                paragraph.Inlines.Add(new Run(pi.GetCustomAttribute<EbxFieldMetaAttribute>().BaseType?.Name) { Foreground = ClassColor });
-                                paragraph.Inlines.Add(new Run(">") { Foreground = TextColor });
-                            }
-                            else
-                                paragraph.Inlines.Add(new Run(listType.Name) {Foreground = GetTypeColor(listType) });
-                        }
-                        else
-                        {
-                            paragraph.Inlines.Add(new Run(pi.GetCustomAttribute<EbxFieldMetaAttribute>().BaseType?.Name) {Foreground = ClassColor});
-                        }
-
-                        paragraph.Inlines.Add(new Run(">") { Foreground = TextColor });
-                    }
-                    else
-                    {
-                        paragraph.Inlines.Add(new Run(propName) { Foreground = GetTypeColor(pi.PropertyType) });
-                    }
-
-                    paragraph.Inlines.Add(new Run($" {pi.Name};\n") { Foreground = TextColor });
-                }
-
-                paragraph.Inlines.Add(new Run("}") { Foreground = TextColor });
-                document.Blocks.Add(paragraph);
-                typeFieldsTextBox.Document = document;
+                typeFieldsTextBox.Document = getDocForType(type);
             }
             else
             {
@@ -269,5 +184,131 @@ private void FrostyTypeExplorer_Loaded(object sender, RoutedEventArgs e)
             typesListBox.Items.SortDescriptions.Add(new System.ComponentModel.SortDescription("Name", System.ComponentModel.ListSortDirection.Ascending));
             typesListBox.Items.Refresh();
         }
+
+        private void ExportButton_Click(object sender, RoutedEventArgs e) {
+            bool shouldCancel = false;
+            FrostyTaskWindow.Show("Exporting types to clipboard...", "Loading...", (taskWindow) => {
+                TypeItem[] types = TypeItems.ToArray();
+                int length = types.Length;
+                string output = "";
+                taskWindow.Progress = 0;
+                for (var i = 0; i < length; i++)
+                {
+                    taskWindow.Progress = (i + 1) / length;
+                    taskWindow.Status = $"{i}/{length}";
+                    TypeItem _type = types[i];
+                    FlowDocument doc = getDocForType(_type.Type);
+                    string text = new TextRange(doc.ContentStart, doc.ContentEnd).Text;
+                    output += text;
+                    output += "\n";
+                    if (shouldCancel)
+                    {
+                        return;
+                    }
+                }
+                Application.Current.Dispatcher.Invoke(() => {
+                    Clipboard.SetText(output);
+                    FrostyMessageBox.Show("Saved types to clipboard.");
+                });
+            }, true, (taskWindow) => {
+                taskWindow.Status = "Cancelling...";
+                shouldCancel = true;
+            });
+        }
+
+        private FlowDocument getDocForType(Type type) {
+            FlowDocument document = new FlowDocument();
+            Paragraph paragraph = new Paragraph();
+
+            paragraph.Inlines.Add(new Run(type.Name) { Foreground = GetTypeColor(type) });
+
+            // enums
+            if (type.IsEnum)
+            {
+                paragraph.Inlines.Add(new Run("\n{\n") { Foreground = TextColor });
+
+                var underlyingType = Enum.GetUnderlyingType(type);
+                var values = type.GetEnumValues();
+
+                // enum members
+                for (int i = 0; i < values.Length; i++)
+                {
+                    paragraph.Inlines.Add(new Run($"    {values.GetValue(i)} = ") { Foreground = TextColor });
+                    paragraph.Inlines.Add(new Run(Convert.ChangeType(values.GetValue(i), underlyingType).ToString()) { Foreground = LiteralColor });
+                    paragraph.Inlines.Add(new Run(i != values.Length - 1 ? ",\n" : "\n") { Foreground = TextColor });
+                }
+
+                paragraph.Inlines.Add(new Run("}") { Foreground = TextColor });
+                document.Blocks.Add(paragraph);
+
+                return document;
+            }
+
+            // base types
+            if (type.BaseType != null && type.BaseType.Name != "Object")
+            {
+                paragraph.Inlines.Add(new Run(" : ") { Foreground = TextColor });
+                paragraph.Inlines.Add(new Run(type.BaseType.Name) { Foreground = ClassColor });
+            }
+
+            paragraph.Inlines.Add(new Run("\n{\n") { Foreground = TextColor });
+
+            var props = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
+
+            // class properties
+            foreach (var pi in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly))
+            {
+                if (pi.Name.StartsWith("_"))
+                    continue;
+
+                string propName = pi.PropertyType.Name;
+                paragraph.Inlines.Add(new Run("    "));
+
+                // use ebx field type names
+                if (propName == "Single")
+                    propName = "Float32";
+                else if (propName == "Double")
+                    propName = "Float64";
+
+                // get the generic/ref type
+                if (propName == "List`1" || propName == "PointerRef")
+                {
+                    paragraph.Inlines.Add(new Run(propName == "List`1" ? "List" : "PointerRef") { Foreground = ClassColor });
+                    paragraph.Inlines.Add(new Run("<") { Foreground = TextColor });
+
+                    if (propName == "List`1")
+                    {
+                        Type listType = pi.PropertyType.GetGenericArguments()[0];
+
+                        // list of pointerrefs
+                        if (listType.Name == "PointerRef")
+                        {
+                            paragraph.Inlines.Add(new Run("PointerRef") { Foreground = ClassColor });
+                            paragraph.Inlines.Add(new Run("<") { Foreground = TextColor });
+                            paragraph.Inlines.Add(new Run(pi.GetCustomAttribute<EbxFieldMetaAttribute>().BaseType?.Name) { Foreground = ClassColor });
+                            paragraph.Inlines.Add(new Run(">") { Foreground = TextColor });
+                        }
+                        else
+                            paragraph.Inlines.Add(new Run(listType.Name) { Foreground = GetTypeColor(listType) });
+                    }
+                    else
+                    {
+                        paragraph.Inlines.Add(new Run(pi.GetCustomAttribute<EbxFieldMetaAttribute>().BaseType?.Name) { Foreground = ClassColor });
+                    }
+
+                    paragraph.Inlines.Add(new Run(">") { Foreground = TextColor });
+                }
+                else
+                {
+                    paragraph.Inlines.Add(new Run(propName) { Foreground = GetTypeColor(pi.PropertyType) });
+                }
+
+                paragraph.Inlines.Add(new Run($" {pi.Name};\n") { Foreground = TextColor });
+            }
+
+            paragraph.Inlines.Add(new Run("}") { Foreground = TextColor });
+            document.Blocks.Add(paragraph);
+            return document;
+        }
     }
 }
diff --git a/Plugins/TypeExplorerPlugin/Properties/AssemblyInfo.cs b/Plugins/TypeExplorerPlugin/Properties/AssemblyInfo.cs
index ea0bb8173..a427c0c21 100644
--- a/Plugins/TypeExplorerPlugin/Properties/AssemblyInfo.cs
+++ b/Plugins/TypeExplorerPlugin/Properties/AssemblyInfo.cs
@@ -21,7 +21,7 @@
 [assembly: Guid("4b612468-9b6a-4304-88a5-055c3575eb3d")]
 
 [assembly: PluginDisplayName("Type Explorer")]
-[assembly: PluginAuthor("derwangler")]
-[assembly: PluginVersion("1.0.0.0")]
+[assembly: PluginAuthor("derwangler, AdamRaichu")]
+[assembly: PluginVersion("1.0.1.0")]
 
 [assembly: RegisterMenuExtension(typeof(TypeExplorerMenuExtension))]
diff --git a/Plugins/TypeExplorerPlugin/Themes/Generic.xaml b/Plugins/TypeExplorerPlugin/Themes/Generic.xaml
index 2d26be25f..13538f99b 100644
--- a/Plugins/TypeExplorerPlugin/Themes/Generic.xaml
+++ b/Plugins/TypeExplorerPlugin/Themes/Generic.xaml
@@ -29,6 +29,7 @@
                                     <Grid.ColumnDefinitions>
                                         <ColumnDefinition Width="*"/>
                                         <ColumnDefinition Width="Auto"/>
+                                        <ColumnDefinition Width="Auto"/>
                                     </Grid.ColumnDefinitions>
                                     <TextBox Grid.Column="0" x:Name="PART_TypeFilter" Background="{StaticResource WindowBackground}" Margin="1" VerticalContentAlignment="Center" />
                                     <CheckBox Grid.Column="1" x:Name="PART_HideEmptyCheckBox" Foreground="{StaticResource FontColor}" ToolTip="Hide types with no fields" Margin="4,2,4,2" VerticalContentAlignment="Center" >
@@ -36,6 +37,18 @@
                                             <TextBlock Text=" Hide empty types" Foreground="{StaticResource FontColor}" VerticalAlignment="Center" />
                                         </CheckBox.Content>
                                     </CheckBox>
+                                    <Button x:Name="PART_ExportButton" ToolTip="Export all types" Margin="6,0,0,0" Grid.Column="2">
+                                        <Button.Content>
+                                            <Grid>
+                                                <Grid.ColumnDefinitions>
+                                                    <ColumnDefinition Width="22"/>
+                                                    <ColumnDefinition Width="*"/>
+                                                </Grid.ColumnDefinitions>
+                                                <Image Grid.Column="0" Width="14" Source="/FrostyEditor;component/Images/Export.png"/>
+                                                <TextBlock Grid.Column="1" Text="Export Types" Margin="0,0,4,0"/>
+                                            </Grid>
+                                        </Button.Content>
+                                    </Button>
                                 </Grid>
 
                                 <ListBox Grid.Row="1" x:Name="PART_TypesListBox" Tag="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:FrostyTypeExplorer}}}">