diff --git a/ComponentSelectorAdditions/Events/BuildCustomGenericBuilder.cs b/ComponentSelectorAdditions/Events/BuildCustomGenericBuilder.cs
new file mode 100644
index 0000000..20d2b2d
--- /dev/null
+++ b/ComponentSelectorAdditions/Events/BuildCustomGenericBuilder.cs
@@ -0,0 +1,57 @@
+using FrooxEngine;
+using FrooxEngine.UIX;
+using MonkeyLoader;
+using MonkeyLoader.Resonite.Events;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ComponentSelectorAdditions.Events
+{
+    public sealed class BuildCustomGenericBuilder : BuildUIEvent
+    {
+        internal readonly HashSet<Button> OtherAddedButtonsSet = new();
+
+        [MemberNotNullWhen(true, nameof(CreateCustomTypeButton))]
+        public bool AddsCreateCustomTypeButton => CreateCustomTypeButton is not null;
+
+        public bool AddsGenericArgumentInputs { get; set; }
+
+        /// <summary>
+        /// Gets the Type of the <see cref="FrooxEngine.Component"/>
+        /// that the custom generic builder is meant for.
+        /// </summary>
+        public Type Component { get; }
+
+        /// <summary>
+        /// Gets or sets the button that triggers creating the custom type with the defined generic arguments.<br/>
+        /// Assigning the <see cref="ComponentSelector._customGenericTypeLabel">Label</see>
+        /// and <see cref="ComponentSelector._customGenericTypeColor">Color</see>
+        /// drives is handled by the event source.
+        /// </summary>
+        public Button? CreateCustomTypeButton { get; set; }
+
+        public Type[] GenericArguments { get; }
+        public IEnumerable<Button> OtherAddedButtons => OtherAddedButtonsSet.AsSafeEnumerable();
+        public ComponentSelector Selector { get; }
+
+        public BuildCustomGenericBuilder(ComponentSelector selector, UIBuilder ui, Type component) : base(ui)
+        {
+            Selector = selector;
+            Component = component;
+            GenericArguments = component.GetGenericArguments();
+        }
+
+        public bool AddOtherButton(Button button)
+            => OtherAddedButtonsSet.Add(button);
+
+        public bool HasOtherButton(Button button)
+            => OtherAddedButtonsSet.Contains(button);
+
+        public bool RemoveOtherButton(Button button)
+            => OtherAddedButtonsSet.Remove(button);
+    }
+}
\ No newline at end of file
diff --git a/ComponentSelectorAdditions/Events/PostProcessButtonsEvent.cs b/ComponentSelectorAdditions/Events/PostProcessButtonsEvent.cs
index 02012b8..ba7aef3 100644
--- a/ComponentSelectorAdditions/Events/PostProcessButtonsEvent.cs
+++ b/ComponentSelectorAdditions/Events/PostProcessButtonsEvent.cs
@@ -40,7 +40,7 @@ public sealed class PostProcessButtonsEvent : BuildUIEvent
 
         public ComponentSelector Selector { get; }
 
-        internal PostProcessButtonsEvent(ComponentSelector selector, SelectorPath path, UIBuilder ui, Button? backButton, Button? customGenericButton, Button? cancelButton)
+        internal PostProcessButtonsEvent(ComponentSelector selector, SelectorPath path, UIBuilder ui, Button? backButton, Button? customGenericButton, Button? cancelButton, HashSet<Button>? otherAddedButtons)
             : base(ui)
         {
             Selector = selector;
@@ -51,7 +51,7 @@ internal PostProcessButtonsEvent(ComponentSelector selector, SelectorPath path,
             CancelButton = cancelButton;
 
             var buttons = selector._uiRoot.Target
-                .GetComponentsInChildren<Button>(button => button != backButton && button != cancelButton)
+                .GetComponentsInChildren<Button>(button => button != backButton && button != cancelButton && button != customGenericButton && (otherAddedButtons is null || !otherAddedButtons.Contains(button)))
                 .Select(button => (Button: button, Relay: button.Slot.GetComponent<ButtonRelay<string>>()))
                 .Where(data => data.Relay != null)
                 .ToArray();
diff --git a/ComponentSelectorAdditions/FavoritesCategories.cs b/ComponentSelectorAdditions/FavoritesCategories.cs
index 0d6b597..111ea07 100644
--- a/ComponentSelectorAdditions/FavoritesCategories.cs
+++ b/ComponentSelectorAdditions/FavoritesCategories.cs
@@ -39,9 +39,7 @@ public void Handle(EnumerateComponentsEvent eventData)
                 {
                     foreach (var element in eventData.RootCategory.Elements)
                     {
-                        var name = element.FullName;
-
-                        if (ConfigSection.Components.Contains(name) || ConfigSection.ProtoFluxNodes.Contains(name))
+                        if (ConfigSection.Components.Contains(element) || ConfigSection.ProtoFluxNodes.Contains(element))
                             eventData.AddItem(new ComponentResult(eventData.RootCategory, element), -1000, true);
                     }
                 }
@@ -50,7 +48,6 @@ public void Handle(EnumerateComponentsEvent eventData)
             }
 
             var favoriteElements = (eventData.RootCategory == _favoritesCategory ? ConfigSection.Components : ConfigSection.ProtoFluxNodes)
-                .Select(typeName => WorkerManager.ParseNiceType(typeName))
                 .Where(type => type is not null)
                 .Select(type => (Type: type, Category: WorkerInitializer.ComponentLibrary.GetSubcategory(WorkerInitializer.GetInitInfo(type).CategoryPath)));
 
@@ -123,8 +120,6 @@ public void Handle(EnumerateConcreteGenericsEvent eventData)
         {
             var concreteGenerics = ConfigSection.Components
                 .Concat(ConfigSection.ProtoFluxNodes)
-                .Where(typeName => typeName.Contains('`')) // Simple filter check as the presence of this indicates a generic type
-                .Select(typeName => WorkerManager.ParseNiceType(typeName))
                 .Where(type => type is not null && type.IsGenericType && !type.ContainsGenericParameters && type.GetGenericTypeDefinition() == eventData.Component);
 
             foreach (var concreteGeneric in concreteGenerics)
@@ -222,10 +217,10 @@ private bool IsFavoriteCategory(string name)
             => ConfigSection.Categories.Contains(name);
 
         private bool IsFavoriteComponent(string name)
-            => ConfigSection.Components.Contains(name);
+            => ConfigSection.Components.Contains(WorkerManager.ParseNiceType(name));
 
         private bool IsFavoriteProtoFluxNode(string name)
-            => ConfigSection.ProtoFluxNodes.Contains(name);
+            => ConfigSection.ProtoFluxNodes.Contains(WorkerManager.ParseNiceType(name));
 
         private bool IsProtoFluxFavoriteCategory(string name)
             => ConfigSection.ProtoFluxCategories.Contains(name);
@@ -234,10 +229,10 @@ private bool ToggleFavoriteCategory(string name)
             => ToggleHashSetContains(ConfigSection.Categories, name);
 
         private bool ToggleFavoriteComponent(string name)
-            => ToggleHashSetContains(ConfigSection.Components, name);
+            => ToggleHashSetContains(ConfigSection.Components, WorkerManager.ParseNiceType(name));
 
         private bool ToggleFavoriteProtoFluxNode(string name)
-            => ToggleHashSetContains(ConfigSection.ProtoFluxNodes, name);
+            => ToggleHashSetContains(ConfigSection.ProtoFluxNodes, WorkerManager.ParseNiceType(name));
 
         private bool ToggleProtoFluxFavoriteCategory(string name)
             => ToggleHashSetContains(ConfigSection.ProtoFluxCategories, name);
diff --git a/ComponentSelectorAdditions/FavoritesConfig.cs b/ComponentSelectorAdditions/FavoritesConfig.cs
index 6c3831c..45d5256 100644
--- a/ComponentSelectorAdditions/FavoritesConfig.cs
+++ b/ComponentSelectorAdditions/FavoritesConfig.cs
@@ -1,4 +1,5 @@
-using MonkeyLoader.Configuration;
+using FrooxEngine;
+using MonkeyLoader.Configuration;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -9,20 +10,20 @@ namespace ComponentSelectorAdditions
 {
     internal sealed class FavoritesConfig : ConfigSection
     {
-        private static readonly DefiningConfigKey<HashSet<string>> _categoriesKey = new("FavoriteCategories", "Favorited Categories", () => new HashSet<string>() { "/Data/Dynamic" }, true);
-        private static readonly DefiningConfigKey<HashSet<string>> _componentsKey = new("FavoriteComponents", "Favorited Components", () => new HashSet<string>() { "FrooxEngine.ValueMultiDriver`1", "FrooxEngine.ReferenceMultiDriver`1" }, true);
-        private static readonly DefiningConfigKey<HashSet<string>> _protoFluxCategoriesKey = new("FavoriteProtoFluxCategories", "Favorited ProtoFlux Categories", () => new HashSet<string>() { }, true);
-        private static readonly DefiningConfigKey<HashSet<string>> _protoFluxNodesKey = new("FavoriteProtoFluxNodes", "Favorited ProtoFlux Nodes", () => new HashSet<string>() { }, true);
+        private static readonly DefiningConfigKey<HashSet<string>> _categoriesKey = new("FavoriteCategories", "Favorited Categories", () => new HashSet<string> { "/Data/Dynamic" }, true);
+        private static readonly DefiningConfigKey<HashSet<Type>> _componentsKey = new("FavoriteComponents", "Favorited Components", () => new HashSet<Type> { typeof(ValueMultiDriver<>), typeof(ReferenceMultiDriver<>) }, true);
+        private static readonly DefiningConfigKey<HashSet<string>> _protoFluxCategoriesKey = new("FavoriteProtoFluxCategories", "Favorited ProtoFlux Categories", () => new HashSet<string> { }, true);
+        private static readonly DefiningConfigKey<HashSet<Type>> _protoFluxNodesKey = new("FavoriteProtoFluxNodes", "Favorited ProtoFlux Nodes", () => new HashSet<Type> { }, true);
         private static readonly DefiningConfigKey<bool> _sortFavoriteCategoriesToTop = new("SortFavoriteCategoriesToTop", "Sort favorited Categories above unfavorited ones.", () => false);
         private static readonly DefiningConfigKey<bool> _sortFavoriteComponentsToTop = new("SortFavoriteComponentsToTop", "Sort favorited Components / Nodes above unfavorited ones.", () => true);
         private static readonly DefiningConfigKey<bool> _sortFavoriteConcreteGenericsToTop = new("SortFavoriteConcreteGenericsToTop", "Sort favorited concrete generic Components / Nodes above unfavorited ones.", () => true);
         public HashSet<string> Categories => _categoriesKey.GetValue()!;
 
-        public HashSet<string> Components => _componentsKey.GetValue()!;
+        public HashSet<Type> Components => _componentsKey.GetValue()!;
         public override string Description => "Contains the favorited categories and components.";
         public override string Id => "Favorites";
         public HashSet<string> ProtoFluxCategories => _protoFluxCategoriesKey.GetValue()!;
-        public HashSet<string> ProtoFluxNodes => _protoFluxNodesKey.GetValue()!;
+        public HashSet<Type> ProtoFluxNodes => _protoFluxNodesKey.GetValue()!;
         public bool SortFavoriteCategoriesToTop => _sortFavoriteCategoriesToTop.GetValue();
         public bool SortFavoriteComponentsToTop => _sortFavoriteComponentsToTop.GetValue();
         public bool SortFavoriteConcreteGenericsToTop => _sortFavoriteConcreteGenericsToTop.GetValue();
diff --git a/ComponentSelectorAdditions/GenericPresetsConfig.cs b/ComponentSelectorAdditions/GenericPresetsConfig.cs
new file mode 100644
index 0000000..c901930
--- /dev/null
+++ b/ComponentSelectorAdditions/GenericPresetsConfig.cs
@@ -0,0 +1,18 @@
+using FrooxEngine;
+using MonkeyLoader;
+using MonkeyLoader.Configuration;
+using System;
+using System.Collections.Generic;
+
+namespace ComponentSelectorAdditions
+{
+    internal sealed class GenericPresetsConfig : ConfigSection
+    {
+        private static readonly DefiningConfigKey<HashSet<Sequence<Type>>> _presetsKey = new("Presets", "Generic argument presets to attempt to add as concrete types to the generic Component / Node selection.", () => new HashSet<Sequence<Type>> { new[] { typeof(User) }, new[] { typeof(Slot) } }, true);
+        public override string Description => "Contains options for adding more concrete versions of generic Components / Nodes to the selection.";
+        public HashSet<Sequence<Type>> GenericArgumentPresets => _presetsKey.GetValue()!;
+        public override string Id => "GenericPresets";
+        public override bool InternalAccessOnly => true;
+        public override Version Version { get; } = new Version(1, 0, 0);
+    }
+}
\ No newline at end of file
diff --git a/ComponentSelectorAdditions/GenericPresetsHandler.cs b/ComponentSelectorAdditions/GenericPresetsHandler.cs
new file mode 100644
index 0000000..cd8b835
--- /dev/null
+++ b/ComponentSelectorAdditions/GenericPresetsHandler.cs
@@ -0,0 +1,160 @@
+using ComponentSelectorAdditions.Events;
+using Elements.Core;
+using FrooxEngine;
+using FrooxEngine.UIX;
+using MonkeyLoader;
+using MonkeyLoader.Events;
+using MonkeyLoader.Patching;
+using MonkeyLoader.Resonite;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ComponentSelectorAdditions
+{
+    internal sealed class GenericPresetsHandler : ConfiguredResoniteMonkey<GenericPresetsHandler, GenericPresetsConfig>,
+        IEventHandler<BuildCustomGenericBuilder>, IEventHandler<EnumerateConcreteGenericsEvent>
+    {
+        public override bool CanBeDisabled => true;
+        public int Priority => HarmonyLib.Priority.Normal;
+
+        public void Handle(EnumerateConcreteGenericsEvent eventData)
+        {
+            if (!Enabled)
+                return;
+
+            var parameters = eventData.Component.GetGenericArguments().Length;
+            var concreteOptions = ConfigSection.GenericArgumentPresets
+                .Where(preset => preset.Length == parameters)
+                .Select(preset => MakeGenericType(eventData.Component, preset))
+                .Where(type => type is not null && type.IsValidGenericType(true));
+
+            foreach (var concreteOption in concreteOptions)
+                eventData.AddItem(concreteOption!);
+        }
+
+        public void Handle(BuildCustomGenericBuilder eventData)
+        {
+            if (!Enabled)
+                return;
+
+            var ui = eventData.UI;
+            var selector = eventData.Selector;
+
+            ui.PushStyle();
+            ui.Style.FlexibleWidth = 1;
+            ui.Style.ForceExpandHeight = true;
+
+            ui.HorizontalLayout(4, 0, Alignment.MiddleLeft);
+            ui.FitContent(SizeFit.Disabled, SizeFit.PreferredSize);
+            ui.VerticalLayout(8, 0);
+
+            foreach (var genericArgument in eventData.GenericArguments)
+            {
+                var textField = ui.HorizontalElementWithLabel(genericArgument.Name, .05f, () =>
+                {
+                    var textField = ui.TextField(null, false, null, false);
+                    textField.Text.NullContent.AssignLocaleString(Mod.GetLocaleString("EnterType"));
+
+                    return textField;
+                }, out var label);
+
+                label.HorizontalAlign.Value = Elements.Assets.TextHorizontalAlignment.Center;
+
+                if (selector.GenericArgumentPrefiller.Target != null)
+                    textField.TargetString = selector.GenericArgumentPrefiller.Target(eventData.Component, genericArgument);
+
+                selector._customGenericArguments.Add(textField);
+            }
+
+            ui.NestOut();
+            ui.Style.FlexibleWidth = -1;
+
+            ui.Style.PreferredHeight = 32;
+            ui.Style.PreferredWidth = 32;
+            var addPresetButton = ui.Button(OfficialAssets.Graphics.Icons.World_Categories.FeaturedRibbon, RadiantUI_Constants.BUTTON_COLOR, RadiantUI_Constants.Neutrals.DARKLIGHT);
+            var icon = addPresetButton.Slot.GetComponentsInChildren<Image>().Last();
+
+            addPresetButton.Slot.DestroyWhenLocalUserLeaves();
+            addPresetButton.StartTask(UpdatePresetButtonAsync);
+            addPresetButton.LocalPressed += (btn, btnEvent) => ToggleSavedPreset(selector.GetCustomGenericType());
+
+            eventData.AddsGenericArgumentInputs = true;
+            ui.PopStyle();
+            ui.NestOut();
+
+            async Task UpdatePresetButtonAsync()
+            {
+                while (addPresetButton.FilterWorldElement() is not null)
+                {
+                    await default(NextUpdate);
+
+                    var concreteType = selector.GetCustomGenericType();
+
+                    addPresetButton.Enabled = IsValidConcreteType(concreteType);
+                    icon.Tint.Value = addPresetButton.Enabled && IsPreset(concreteType.GenericTypeArguments) ?
+                        RadiantUI_Constants.Hero.YELLOW : RadiantUI_Constants.Neutrals.DARKLIGHT;
+                }
+            }
+        }
+
+        protected override IEnumerable<IFeaturePatch> GetFeaturePatches() => Enumerable.Empty<IFeaturePatch>();
+
+        protected override bool OnEngineReady()
+        {
+            Mod.RegisterEventHandler<BuildCustomGenericBuilder>(this);
+            Mod.RegisterEventHandler<EnumerateConcreteGenericsEvent>(this);
+
+            return base.OnEngineReady();
+        }
+
+        protected override bool OnShutdown(bool applicationExiting)
+        {
+            if (!applicationExiting)
+            {
+                Mod.UnregisterEventHandler<BuildCustomGenericBuilder>(this);
+                Mod.RegisterEventHandler<EnumerateConcreteGenericsEvent>(this);
+            }
+
+            return base.OnShutdown(applicationExiting);
+        }
+
+        private static bool IsPreset(Sequence<Type> arguments)
+            => ConfigSection.GenericArgumentPresets.Contains(arguments);
+
+        private static bool IsValidConcreteType([NotNullWhen(true)] Type? concreteType)
+            => concreteType is not null && concreteType.IsValidGenericType(true);
+
+        private static Type? MakeGenericType(Type genericType, Type[] arguments)
+        {
+            try
+            {
+                return genericType.MakeGenericType(arguments);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static void ToggleSavedPreset(Type? concreteType)
+        {
+            if (!IsValidConcreteType(concreteType))
+                return;
+
+            var arguments = concreteType.GenericTypeArguments;
+
+            if (ConfigSection.GenericArgumentPresets.Add(arguments))
+            {
+                Config.Save();
+                return;
+            }
+
+            ConfigSection.GenericArgumentPresets.Remove(arguments);
+            Config.Save();
+        }
+    }
+}
\ No newline at end of file
diff --git a/ComponentSelectorAdditions/Injector.cs b/ComponentSelectorAdditions/Injector.cs
index ce8dda8..076a8c8 100644
--- a/ComponentSelectorAdditions/Injector.cs
+++ b/ComponentSelectorAdditions/Injector.cs
@@ -13,6 +13,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Reflection.Emit;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
@@ -25,12 +26,14 @@ internal sealed class Injector : ResoniteMonkey<Injector>,
         IEventSource<BuildSelectorHeaderEvent>, IEventSource<BuildSelectorFooterEvent>,
         ICancelableEventSource<EnumerateCategoriesEvent>, ICancelableEventSource<EnumerateComponentsEvent>,
         ICancelableEventSource<BuildCategoryButtonEvent>, ICancelableEventSource<BuildGroupButtonEvent>, ICancelableEventSource<BuildComponentButtonEvent>,
-        IEventSource<EnumerateConcreteGenericsEvent>, IEventSource<PostProcessButtonsEvent>
+        IEventSource<BuildCustomGenericBuilder>, IEventSource<EnumerateConcreteGenericsEvent>,
+        IEventSource<PostProcessButtonsEvent>
     {
         private static readonly ConditionalWeakTable<ComponentSelector, SelectorData> _selectorData = new();
 
         private static CancelableEventDispatching<BuildCategoryButtonEvent>? _buildCategoryButton;
         private static CancelableEventDispatching<BuildComponentButtonEvent>? _buildComponentButton;
+        private static EventDispatching<BuildCustomGenericBuilder>? _buildCustomGenericBuilder;
         private static EventDispatching<BuildSelectorFooterEvent>? _buildFooter;
         private static CancelableEventDispatching<BuildGroupButtonEvent>? _buildGroupButton;
         private static EventDispatching<BuildSelectorHeaderEvent>? _buildHeader;
@@ -38,7 +41,6 @@ internal sealed class Injector : ResoniteMonkey<Injector>,
         private static CancelableEventDispatching<EnumerateComponentsEvent>? _enumerateComponents;
         private static EventDispatching<EnumerateConcreteGenericsEvent>? _enumerateConcreteGenerics;
         private static EventDispatching<PostProcessButtonsEvent>? _postProcessButtons;
-
         public override bool CanBeDisabled => true;
 
         protected override IEnumerable<IFeaturePatch> GetFeaturePatches() => Enumerable.Empty<IFeaturePatch>();
@@ -52,6 +54,8 @@ protected override bool OnEngineReady()
             Mod.RegisterEventSource<EnumerateComponentsEvent>(this);
             Mod.RegisterEventSource<EnumerateConcreteGenericsEvent>(this);
 
+            Mod.RegisterEventSource<BuildCustomGenericBuilder>(this);
+
             Mod.RegisterEventSource<BuildCategoryButtonEvent>(this);
             Mod.RegisterEventSource<BuildGroupButtonEvent>(this);
             Mod.RegisterEventSource<BuildComponentButtonEvent>(this);
@@ -72,6 +76,8 @@ protected override bool OnShutdown(bool applicationExiting)
                 Mod.UnregisterEventSource<EnumerateComponentsEvent>(this);
                 Mod.UnregisterEventSource<EnumerateConcreteGenericsEvent>(this);
 
+                Mod.RegisterEventSource<BuildCustomGenericBuilder>(this);
+
                 Mod.UnregisterEventSource<BuildCategoryButtonEvent>(this);
                 Mod.UnregisterEventSource<BuildGroupButtonEvent>(this);
                 Mod.UnregisterEventSource<BuildComponentButtonEvent>(this);
@@ -153,7 +159,7 @@ private static void BuildCategoryUI(ComponentSelector selector, UIBuilder ui, Se
             }
         }
 
-        private static void BuildGenericTypeUI(ComponentSelector selector, UIBuilder ui, SelectorPath path, bool doNotGenerateBack, out Button? backButton, out Button? customGenericButton)
+        private static void BuildGenericTypeUI(ComponentSelector selector, UIBuilder ui, SelectorPath path, bool doNotGenerateBack, out Button? backButton, out Button? customGenericButton, out HashSet<Button> otherAddedButtons)
         {
             backButton = null;
 
@@ -165,38 +171,33 @@ private static void BuildGenericTypeUI(ComponentSelector selector, UIBuilder ui,
 
             ui.Text("ComponentSelector.CustomGenericArguments".AsLocaleKey());
 
-            var genericArguments = type.GetGenericArguments();
-            foreach (var genericArgument in genericArguments)
-            {
-                var textField = ui.HorizontalElementWithLabel(genericArgument.Name, .05f, () => ui.TextField(string.Empty, undo: false, null, parseRTF: false));
-
-                if (selector.GenericArgumentPrefiller.Target != null)
-                    textField.TargetString = selector.GenericArgumentPrefiller.Target(type, genericArgument);
-
-                selector._customGenericArguments.Add(textField);
-            }
+            var customGenericBuilderData = OnBuildCustomGenericBuilder(selector, ui, type);
+            customGenericButton = customGenericBuilderData.CreateCustomTypeButton!;
+            otherAddedButtons = customGenericBuilderData.OtherAddedButtonsSet;
 
-            customGenericButton = ui.Button((LocaleString)string.Empty, RadiantUI_Constants.BUTTON_COLOR, selector.OnCreateCustomType, .35f);
-            selector._customGenericTypeLabel.Target = customGenericButton.Label.Content;
-            selector._customGenericTypeColor.Target = customGenericButton.BaseColor;
+            ui.Panel();
+            ui.NestOut();
 
             var concreteGenericsEventData = OnEnumerateConcreteGenerics(selector, type);
 
-            ui.Text("ComponentSelector.CustomGenericArguments".AsLocaleKey());
-
-            foreach (var concreteType in concreteGenericsEventData.Items)
+            if (concreteGenericsEventData.Items.Any())
             {
-                try
+                ui.Text("ComponentSelector.CommonGenericTypes".AsLocaleKey());
+
+                foreach (var concreteType in concreteGenericsEventData.Items)
                 {
-                    if (concreteType.IsValidGenericType(true))
+                    try
                     {
-                        ui.Button(concreteType.GetNiceName(), RadiantUI_Constants.Sub.CYAN, selector.OnAddComponentPressed,
-                            TypeHelper.TryGetAlias(concreteType) ?? concreteType.FullName, .35f).Label.ParseRichText.Value = false;
+                        if (concreteType.IsValidGenericType(true))
+                        {
+                            ui.Button(concreteType.GetNiceName(), RadiantUI_Constants.Sub.CYAN, selector.OnAddComponentPressed,
+                                TypeHelper.TryGetAlias(concreteType) ?? concreteType.FullName, .35f).Label.ParseRichText.Value = false;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        UniLog.Warning(ex.Format("Exception checking validity of a generic type: " + concreteType?.ToString() + " for " + type?.ToString()));
                     }
-                }
-                catch (Exception ex)
-                {
-                    UniLog.Warning(ex.Format("Exception checking validity of a generic type: " + concreteType?.ToString() + " for " + type?.ToString()));
                 }
             }
         }
@@ -231,23 +232,20 @@ private static bool BuildUIPrefix(ComponentSelector __instance, string path, boo
             Button? backButton;
             Button? customGenericButton = null;
             Button? cancelButton = null;
+            HashSet<Button>? otherAddedButtons = null;
 
             if (genericType)
-            {
-                BuildGenericTypeUI(__instance, ui, selectorPath, doNotGenerateBack, out backButton, out customGenericButton);
-            }
+                BuildGenericTypeUI(__instance, ui, selectorPath, doNotGenerateBack, out backButton, out customGenericButton, out otherAddedButtons);
             else
-            {
                 BuildCategoryUI(__instance, ui, selectorData, doNotGenerateBack, out backButton);
 
-                if (!selectorData.HasCancelButton)
-                {
-                    cancelButton = ui.Button("General.Cancel".AsLocaleKey(), RadiantUI_Constants.Sub.RED, __instance.OnCancelPressed, 0.35f);
-                    cancelButton.Slot.OrderOffset = 1000000L;
-                }
+            if (!selectorData.HasCancelButton)
+            {
+                cancelButton = ui.Button("General.Cancel".AsLocaleKey(), RadiantUI_Constants.Sub.RED, __instance.OnCancelPressed, 0.35f);
+                cancelButton.Slot.OrderOffset = 1000000L;
             }
 
-            OnPostProcessButtons(__instance, selectorData.CurrentPath, ui, backButton, customGenericButton, cancelButton);
+            OnPostProcessButtons(__instance, selectorData.CurrentPath, ui, backButton, customGenericButton, cancelButton, otherAddedButtons);
 
             return false;
         }
@@ -335,6 +333,8 @@ private static void OnBuildCategoryButton(ComponentSelector selector, UIBuilder
 
             _buildCategoryButton?.Invoke(eventData);
 
+            ui.NestInto(root);
+
             if (!eventData.Canceled)
             {
                 ui.Button(
@@ -342,8 +342,6 @@ private static void OnBuildCategoryButton(ComponentSelector selector, UIBuilder
                     RadiantUI_Constants.Sub.YELLOW, selector.OnOpenCategoryPressed, subCategory.GetPath(),
                     0.35f).Label.ParseRichText.Value = false;
             }
-
-            ui.NestInto(root);
         }
 
         private static void OnBuildComponentButton(ComponentSelector selector, UIBuilder ui, SelectorPath path, CategoryNode<Type> rootCategory, ComponentResult component)
@@ -353,6 +351,8 @@ private static void OnBuildComponentButton(ComponentSelector selector, UIBuilder
 
             _buildComponentButton?.Invoke(eventData);
 
+            ui.NestInto(root);
+
             if (!eventData.Canceled)
             {
                 var category = GetPrettyPath(component.Category, rootCategory);
@@ -366,12 +366,54 @@ private static void OnBuildComponentButton(ComponentSelector selector, UIBuilder
             ui.NestInto(root);
         }
 
+        private static BuildCustomGenericBuilder OnBuildCustomGenericBuilder(ComponentSelector selector, UIBuilder ui, Type component)
+        {
+            var root = ui.Root;
+            var eventData = new BuildCustomGenericBuilder(selector, ui, component);
+
+            _buildCustomGenericBuilder?.Invoke(eventData);
+
+            ui.NestInto(root);
+
+            if (!eventData.AddsGenericArgumentInputs)
+            {
+                foreach (var genericArgument in eventData.GenericArguments)
+                {
+                    var textField = ui.HorizontalElementWithLabel(genericArgument.Name, .05f, () =>
+                    {
+                        var textField = ui.TextField(null, false, null, false);
+                        textField.Text.NullContent.AssignLocaleString(Mod.GetLocaleString("EnterType"));
+
+                        return textField;
+                    }, out var label);
+
+                    label.HorizontalAlign.Value = Elements.Assets.TextHorizontalAlignment.Center;
+
+                    if (selector.GenericArgumentPrefiller.Target != null)
+                        textField.TargetString = selector.GenericArgumentPrefiller.Target(component, genericArgument);
+
+                    selector._customGenericArguments.Add(textField);
+                }
+            }
+
+            if (!eventData.AddsCreateCustomTypeButton)
+                eventData.CreateCustomTypeButton = ui.Button((LocaleString)string.Empty, RadiantUI_Constants.BUTTON_COLOR, selector.OnCreateCustomType, .35f);
+
+            selector._customGenericTypeLabel.Target = eventData.CreateCustomTypeButton.Label.Content;
+            selector._customGenericTypeColor.Target = eventData.CreateCustomTypeButton.BaseColor;
+
+            return eventData;
+        }
+
         private static BuildSelectorFooterEvent OnBuildFooter(ComponentSelector selector, UIBuilder ui, SelectorSearchBar? searchBar, bool hasBackButton, bool hasCancelButton)
         {
+            var root = ui.Root;
             var eventData = new BuildSelectorFooterEvent(selector, ui, searchBar, hasBackButton, hasCancelButton);
 
             _buildFooter?.Invoke(eventData);
 
+            ui.NestInto(root);
+
             return eventData;
         }
 
@@ -382,6 +424,8 @@ private static void OnBuildGroupButton(ComponentSelector selector, UIBuilder ui,
 
             _buildGroupButton?.Invoke(eventData);
 
+            ui.NestInto(root);
+
             if (!eventData.Canceled)
             {
                 var category = GetPrettyPath(groupComponent.Category, rootCategory);
@@ -396,10 +440,13 @@ private static void OnBuildGroupButton(ComponentSelector selector, UIBuilder ui,
 
         private static BuildSelectorHeaderEvent OnBuildHeader(ComponentSelector selector, UIBuilder ui)
         {
+            var root = ui.Root;
             var eventData = new BuildSelectorHeaderEvent(selector, ui);
 
             _buildHeader?.Invoke(eventData);
 
+            ui.NestInto(root);
+
             return eventData;
         }
 
@@ -446,7 +493,7 @@ private static EnumerateConcreteGenericsEvent OnEnumerateConcreteGenerics(Compon
         }
 
         private static void OnPostProcessButtons(ComponentSelector selector, SelectorPath path,
-            UIBuilder ui, Button? backButton, Button? customGenericButton, Button? cancelButton)
+            UIBuilder ui, Button? backButton, Button? customGenericButton, Button? cancelButton, HashSet<Button>? otherAddedButtons)
         {
             // Lock in UI Order through the Offsets
             var index = 0;
@@ -454,7 +501,7 @@ private static void OnPostProcessButtons(ComponentSelector selector, SelectorPat
                 child.OrderOffset = 10 * index++;
 
             var root = ui.Root;
-            var eventData = new PostProcessButtonsEvent(selector, path, ui, backButton, customGenericButton, cancelButton);
+            var eventData = new PostProcessButtonsEvent(selector, path, ui, backButton, customGenericButton, cancelButton, otherAddedButtons);
 
             _postProcessButtons?.Invoke(eventData);
 
@@ -581,6 +628,12 @@ event EventDispatching<PostProcessButtonsEvent>? IEventSource<PostProcessButtons
             remove => _postProcessButtons -= value;
         }
 
+        event EventDispatching<BuildCustomGenericBuilder>? IEventSource<BuildCustomGenericBuilder>.Dispatching
+        {
+            add => _buildCustomGenericBuilder += value;
+            remove => _buildCustomGenericBuilder -= value;
+        }
+
         private sealed class SelectorData
         {
             public Action<SelectorPath, bool>? BackButtonChanged { get; }
diff --git a/ComponentSelectorAdditions/Locale/de.json b/ComponentSelectorAdditions/Locale/de.json
index 9d62c56..89684c1 100644
--- a/ComponentSelectorAdditions/Locale/de.json
+++ b/ComponentSelectorAdditions/Locale/de.json
@@ -5,11 +5,13 @@
     "ComponentSelectorAdditions.Description": "Dieser MonkeyLoader Mod für Resonite strukturiert Komponenten-Selektoren und ProtoFlux Nodebrowser neu und fügt eine Suchfunktion sowie Kategorien für zuletzt genutzte und favorisierte Komponenten / Nodes hinzu.",
 
     "ComponentSelectorAdditions.Search": "<i>Suchen ...</i>",
+    "ComponentSelectorAdditions.EnterType": "<i>Typ eingeben...</i>",
 
     "ComponentSelectorAdditions.CurrentPathIndicator.Description": "Fügt eine Anzeige für den Pfad der aktuellen Kategorie (und des generischen Typs) zu Komponenten-Selektoren hinzu.",
     "ComponentSelectorAdditions.FavoritesCategories.Description": "Fügt 'Favorites' Kategorien zu den Wurzelkategorien von Komponenten-Selektoren und ProtoFlux Nodebrowsern hinzu und macht Kategorien und Komponenten / Nodes favorisierbar.",
     "ComponentSelectorAdditions.FixedBackButton.Description": "Platziert den 'Zurück' Knopf bei Komponent-Selektoren außerhalb des scrollbaren Bereichs.",
     "ComponentSelectorAdditions.FixedCancelButton.Description": "Platziert den 'Abbrechen' Knopf bei Komponent-Selektoren außerhalb des scrollbaren Bereichs.",
+    "ComponentSelectorAdditions.GenericPresetsHandler.Description": "Erlaubt es benutzerdefinierte generische Argumente als Muster zu speichern, welche dann zur Liste der häufig verwendeten generischen Typen für alle validen Komponenten / Nodes hinzugefügt werden.",
     "ComponentSelectorAdditions.Injector.Description": "Macht die Komponenten-Selektor-Generation und -Auflistung modular indem sie durch Events ausgeführt werden.",
     "ComponentSelectorAdditions.RecentsCategories.Description": "Fügt 'Recents' Kategorien zu den Wurzelkategorien von Komponenten-Selektoren und ProtoFlux Nodebrowsern hinzu, welche die zuletzt Genutzten auflisten.",
     "ComponentSelectorAdditions.SearchBar.Description": "Fügt eine Suchleiste zu Komponenten-Selektoren hinzu, welche es erlaubt Komponenten und ProtoFlux Nodes zu suchen.",
diff --git a/ComponentSelectorAdditions/Locale/en.json b/ComponentSelectorAdditions/Locale/en.json
index d6070ad..5dbf6b6 100644
--- a/ComponentSelectorAdditions/Locale/en.json
+++ b/ComponentSelectorAdditions/Locale/en.json
@@ -3,11 +3,13 @@
   "authors": [ "Banane9" ],
   "messages": {
     "ComponentSelectorAdditions.Search": "<i>Search ...</i>",
+    "ComponentSelectorAdditions.EnterType": "<i>Enter Type ...</i>",
 
     "ComponentSelectorAdditions.CurrentPathIndicator.Description": "Adds an indicator for the current category (and generic Type) path to component attachers.",
     "ComponentSelectorAdditions.FavoritesCategories.Description": "Adds 'Favorites' categories to component attachers and ProtoFlux node selector roots and makes categories and components / nodes favoritable.",
     "ComponentSelectorAdditions.FixedBackButton.Description": "Places the 'Back' button on component attachers outside of the scrollable area.",
     "ComponentSelectorAdditions.FixedCancelButton.Description": "Places the 'Cancel' button on component attachers outside of the scrollable area.",
+    "ComponentSelectorAdditions.GenericPresetsHandler.Description": "Allows saving custom generic Type arguments as presets, which will be added to the list of Common Generic Types on any valid Component / Node.",
     "ComponentSelectorAdditions.Injector.Description": "Makes the component selector generation and listing modular by handling it through events.",
     "ComponentSelectorAdditions.RecentsCategories.Description": "Adds 'Recents' categories to the component attacher and ProtoFlux node browser roots which display the latest used ones.",
     "ComponentSelectorAdditions.SearchBar.Description": "Adds a searchbar to component selectors which allows searching components or ProtoFlux nodes."
diff --git a/ComponentSelectorAdditions/RecentsCategories.cs b/ComponentSelectorAdditions/RecentsCategories.cs
index 974a237..c6174a5 100644
--- a/ComponentSelectorAdditions/RecentsCategories.cs
+++ b/ComponentSelectorAdditions/RecentsCategories.cs
@@ -2,7 +2,6 @@
 using Elements.Core;
 using FrooxEngine;
 using FrooxEngine.ProtoFlux;
-using FrooxEngine.UIX;
 using HarmonyLib;
 using MonkeyLoader.Events;
 using MonkeyLoader.Patching;
@@ -41,7 +40,6 @@ public void Handle(EnumerateComponentsEvent eventData)
                 return;
 
             var recentElements = (eventData.RootCategory == _recentsCategory ? ConfigSection.Components : ConfigSection.ProtoFluxNodes)
-                .Select(typeName => WorkerManager.ParseNiceType(typeName))
                 .Where(type => type is not null)
                 .Select(type => (Type: type, Category: WorkerInitializer.ComponentLibrary.GetSubcategory(WorkerInitializer.GetInitInfo(type).CategoryPath)));
 
@@ -63,8 +61,6 @@ public void Handle(EnumerateConcreteGenericsEvent eventData)
         {
             var concreteGenerics = ConfigSection.Components
                 .Concat(ConfigSection.ProtoFluxNodes)
-                .Where(typeName => typeName.Contains('`')) // Simple filter check as the presence of this indicates a generic type
-                .Select(typeName => WorkerManager.ParseNiceType(typeName))
                 .Where(type => type is not null && type.IsGenericType && !type.ContainsGenericParameters && type.GetGenericTypeDefinition() == eventData.Component);
 
             foreach (var concreteGeneric in concreteGenerics)
@@ -109,6 +105,12 @@ protected override bool OnShutdown(bool applicationExiting)
             return base.OnShutdown(applicationExiting);
         }
 
+        private static void AddRecent(List<Type> recents, Type type)
+        {
+            recents.RemoveAll(recentType => recentType == type);
+            recents.Add(type);
+        }
+
         [HarmonyPostfix]
         [HarmonyPatch(nameof(ComponentSelector.OnAddComponentPressed))]
         private static void OnAddComponentPressedPostfix(ComponentSelector __instance, string typename)
@@ -143,22 +145,13 @@ private static void OnCreateCustomTypePostfix(ComponentSelector __instance)
                 UpdateRecents(ConfigSection.Components, type);
         }
 
-        private static bool ToggleHashSetContains<T>(ISet<T> set, T value)
-        {
-            if (set.Add(value))
-                return true;
-
-            set.Remove(value);
-            return false;
-        }
-
-        private static void UpdateRecents(List<string> recents, Type type)
+        private static void UpdateRecents(List<Type> recents, Type type)
         {
             if (type.IsGenericType && ConfigSection.TrackGenericComponents)
-                recents.Add(type.GetGenericTypeDefinition().FullName);
+                AddRecent(recents, type.GetGenericTypeDefinition());
 
             if (!type.IsGenericType || ConfigSection.TrackConcreteComponents)
-                recents.Add(type.FullName);
+                AddRecent(recents, type);
 
             if (recents.Count > ConfigSection.RecentCap)
                 recents.RemoveRange(0, recents.Count - ConfigSection.RecentCap);
diff --git a/ComponentSelectorAdditions/RecentsConfig.cs b/ComponentSelectorAdditions/RecentsConfig.cs
index ac9e1b1..7398b5e 100644
--- a/ComponentSelectorAdditions/RecentsConfig.cs
+++ b/ComponentSelectorAdditions/RecentsConfig.cs
@@ -1,4 +1,5 @@
-using MonkeyLoader.Configuration;
+using FrooxEngine;
+using MonkeyLoader.Configuration;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -10,8 +11,8 @@ namespace ComponentSelectorAdditions
     internal sealed class RecentsConfig : ConfigSection
     {
         private static readonly DefiningConfigKey<bool> _addRecentConcreteComponentsToSelection = new("AddRecentConcreteComponentsToSelection", "Ensure that recent concrete versions of generic Components / Nodes appear in the selection.", () => true);
-        private static readonly DefiningConfigKey<List<string>> _componentsKey = new("RecentComponents", "Recent Components", () => new List<string>() { "FrooxEngine.ValueMultiDriver`1", "FrooxEngine.ReferenceMultiDriver`1" }, true);
-        private static readonly DefiningConfigKey<List<string>> _protoFluxNodesKey = new("RecentProtoFluxNodes", "Recent ProtoFlux Nodes", () => new List<string>() { }, true);
+        private static readonly DefiningConfigKey<List<Type>> _componentsKey = new("RecentComponents", "Recent Components", () => new List<Type> { typeof(ValueMultiDriver<>), typeof(ReferenceMultiDriver<>) }, true);
+        private static readonly DefiningConfigKey<List<Type>> _protoFluxNodesKey = new("RecentProtoFluxNodes", "Recent ProtoFlux Nodes", () => new List<Type> { }, true);
 
         private static readonly DefiningConfigKey<int> _recentCapKey = new("TrackedCapacity", "How many recent components / nodes to save and show.", () => 32)
         {
@@ -22,11 +23,11 @@ internal sealed class RecentsConfig : ConfigSection
         private static readonly DefiningConfigKey<bool> _trackGenericComponentsKey = new("TrackGenericComponents", "Whether the generic version of a recent Component / Node gets saved.", () => true);
 
         public bool AddRecentConcreteComponentsToSelection => _addRecentConcreteComponentsToSelection.GetValue();
-        public List<string> Components => _componentsKey.GetValue()!;
+        public List<Type> Components => _componentsKey.GetValue()!;
         public override string Description => "Contains the recent components.";
         public override string Id => "Recents";
 
-        public List<string> ProtoFluxNodes => _protoFluxNodesKey.GetValue()!;
+        public List<Type> ProtoFluxNodes => _protoFluxNodesKey.GetValue()!;
 
         public int RecentCap => _recentCapKey.GetValue();
         public bool TrackConcreteComponents => _trackConcreteComponentsKey.GetValue();