diff --git a/BepisModSettings/BepisModSettings.csproj b/BepisModSettings/BepisModSettings.csproj
index d45ee03..b10dd63 100644
--- a/BepisModSettings/BepisModSettings.csproj
+++ b/BepisModSettings/BepisModSettings.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <Version>1.1.1</Version>
+        <Version>1.2.0</Version>
         <Authors>ResoniteModding</Authors>
         <TargetFramework>net9.0</TargetFramework>
         <Product>Bepis Mod Settings</Product>
diff --git a/BepisModSettings/ConfigAttributes/CustomDataFeed.cs b/BepisModSettings/ConfigAttributes/CustomDataFeed.cs
index 978ddb1..4586130 100644
--- a/BepisModSettings/ConfigAttributes/CustomDataFeed.cs
+++ b/BepisModSettings/ConfigAttributes/CustomDataFeed.cs
@@ -14,17 +14,19 @@ public sealed class CustomDataFeed(DataFeedMethod action)
     public static DataFeedMethod GetCustomFeedMethod(ConfigEntryBase config)
     {
         if (config?.Description?.Tags == null) return null;
-        foreach (var tag in config.Description.Tags)
+        foreach (object tag in config.Description.Tags)
         {
-            if(tag is CustomDataFeed customDataFeed)
+            if (tag is CustomDataFeed customDataFeed)
             {
                 return customDataFeed._action;
             }
-            if(tag is Func<IReadOnlyList<string>, IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>> func)
+
+            if (tag is Func<IReadOnlyList<string>, IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>> func)
             {
-                return (DataFeedMethod) Delegate.CreateDelegate(typeof(DataFeedMethod), func.Target, func.Method);
+                return (DataFeedMethod)Delegate.CreateDelegate(typeof(DataFeedMethod), func.Target, func.Method);
             }
         }
+
         return null;
     }
 }
\ No newline at end of file
diff --git a/BepisModSettings/ConfigAttributes/HiddenConfig.cs b/BepisModSettings/ConfigAttributes/HiddenConfig.cs
index 2d71914..2bc424d 100644
--- a/BepisModSettings/ConfigAttributes/HiddenConfig.cs
+++ b/BepisModSettings/ConfigAttributes/HiddenConfig.cs
@@ -3,7 +3,7 @@
 
 namespace BepisModSettings.ConfigAttributes;
 
-public class HiddenConfig 
+public class HiddenConfig
 {
     public static bool IsHidden(ConfigEntryBase config)
     {
diff --git a/BepisModSettings/ConfigAttributes/ProtectedConfig.cs b/BepisModSettings/ConfigAttributes/ProtectedConfig.cs
index d039f90..4cddd17 100644
--- a/BepisModSettings/ConfigAttributes/ProtectedConfig.cs
+++ b/BepisModSettings/ConfigAttributes/ProtectedConfig.cs
@@ -12,17 +12,19 @@ public ProtectedConfig() : this("*") { }
     public static string GetMask(ConfigEntryBase config)
     {
         if (config?.Description?.Tags == null) return null;
-        foreach (var tag in config.Description.Tags)
+        foreach (object tag in config.Description.Tags)
         {
-            if(tag is ProtectedConfig protectedConfig)
+            if (tag is ProtectedConfig protectedConfig)
             {
                 return protectedConfig.MaskString;
             }
-            else if(tag as string == "Protected")
+
+            if (tag as string == "Protected")
             {
                 return "*";
             }
         }
+
         return null;
     }
 }
\ No newline at end of file
diff --git a/BepisModSettings/DataFeeds/BepisPluginPage.cs b/BepisModSettings/DataFeeds/BepisPluginPage.cs
index ec83421..95dd328 100644
--- a/BepisModSettings/DataFeeds/BepisPluginPage.cs
+++ b/BepisModSettings/DataFeeds/BepisPluginPage.cs
@@ -21,12 +21,32 @@ public static class BepisPluginPage
 {
     internal static readonly Dictionary<string, Func<IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>>> CategoryHandlers = new Dictionary<string, Func<IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>>>();
 
+    public static event Func<IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>> CustomPluginConfigsPages;
+
     internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<string> path)
     {
         await Task.CompletedTask;
 
         string pluginId = path[1];
 
+        if (NetChainloader.Instance.Plugins.Values.All(x => x.Metadata.GUID != pluginId) && pluginId != "BepInEx.Core.Config")
+        {
+            if (CustomPluginConfigsPages != null)
+            {
+                foreach (Delegate del in CustomPluginConfigsPages.GetInvocationList())
+                {
+                    if (del is not Func<IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>> handler) continue;
+
+                    await foreach (DataFeedItem item in handler(path))
+                    {
+                        yield return item;
+                    }
+                }
+            }
+
+            yield break;
+        }
+
         ConfigFile configFile;
         ModMeta metadata;
 
@@ -43,10 +63,8 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
             BepInPlugin pMetadata = MetadataHelper.GetMetadata(plugin);
             ResonitePlugin resonitePlugin = pMetadata as ResonitePlugin;
 
-            var assCo = resonitePlugin?.Author ??
-                plugin.GetType().Assembly.GetCustomAttribute<AssemblyCompanyAttribute>()?.Company;
-            var assUrl = resonitePlugin?.Link ??
-                plugin.GetType().Assembly.GetCustomAttributes<AssemblyMetadataAttribute>()?.FirstOrDefault(a => a.Key.ToLower().Contains("url"))?.Value;
+            string assCo = resonitePlugin?.Author ?? plugin.GetType().Assembly.GetCustomAttribute<AssemblyCompanyAttribute>()?.Company;
+            string assUrl = resonitePlugin?.Link ?? plugin.GetType().Assembly.GetCustomAttributes<AssemblyMetadataAttribute>().FirstOrDefault(a => a.Key.Contains("url", StringComparison.CurrentCultureIgnoreCase))?.Value;
 
             configFile = plugin.Config;
             metadata = new ModMeta(pMetadata.Name, pMetadata.Version.ToString(), pluginId, assCo, assUrl);
@@ -102,7 +120,7 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         if (!string.IsNullOrWhiteSpace(metadata.Link) && Uri.TryCreate(metadata.Link, UriKind.Absolute, out var uri))
         {
             var modHyperlink = new DataFeedAction();
-            modHyperlink.InitBase("Link", path, metadataGroup, "Settings.BepInEx.Plugins.ModPage".AsLocaleKey());
+            modHyperlink.InitBase("Link", path, metadataGroup, "Settings.BepInEx.Plugins.ModPage".AsLocaleKey(), metadata.Link);
             modHyperlink.InitAction(syncDelegate =>
             {
                 var slot = syncDelegate?.Slot;
@@ -119,191 +137,189 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
         // Used for enum config keys. basically you can define a function which will display a subcategory of this category.
         CategoryHandlers.Clear();
 
-        if (configFile.Count > 0)
+        HashSet<string> sections = new HashSet<string>();
+        List<string> added = new List<string>();
+        foreach (ConfigEntryBase config in configFile.Values)
         {
-            HashSet<string> sections = new HashSet<string>();
-            List<string> added = new List<string>();
-            foreach (ConfigEntryBase config in configFile.Values)
-            {
-                if (!Plugin.ShowHidden.Value && HiddenConfig.IsHidden(config)) continue;
+            if (!Plugin.ShowHidden.Value && HiddenConfig.IsHidden(config)) continue;
 
-                Type valueType = config.SettingType;
+            Type valueType = config.SettingType;
 
-                string section = config.Definition.Section;
-                if (sections.Add(section))
+            string section = config.Definition.Section;
+            if (sections.Add(section))
+            {
+                DataFeedResettableGroup configs = new DataFeedResettableGroup();
+                configs.InitBase(section, path, null, section);
+                configs.InitResetAction(a =>
                 {
-                    DataFeedResettableGroup configs = new DataFeedResettableGroup();
-                    configs.InitBase(section, path, null, section);
-                    configs.InitResetAction(a =>
+                    Button but = a.Slot.GetComponentInChildren<Button>();
+                    if (but == null) return;
+
+                    but.LocalPressed += (b, _) =>
                     {
-                        Button but = a.Slot.GetComponentInChildren<Button>();
-                        if (but == null) return;
-
-                        but.LocalPressed += (b, _) =>
-                        {
-                            Slot resetBtn = b.Slot.FindParent(x => x.Name == "Reset Button");
-                            var store = resetBtn?.GetComponentInChildren<DataModelValueFieldStore<bool>.Store>();
-                            if (store == null) return;
-
-                            if (!store.Value.Value) return;
-                            ResetConfigSection(metaData.ID, section);
-                        };
-                    });
-                    yield return configs;
-                }
+                        Slot resetBtn = b.Slot.FindParent(x => x.Name == "Reset Button");
+                        var store = resetBtn?.GetComponentInChildren<DataModelValueFieldStore<bool>.Store>();
+                        if (store == null) return;
+
+                        if (!store.Value.Value) return;
+                        ResetConfigSection(metaData.ID, section);
+                    };
+                });
+                yield return configs;
+            }
 
-                string initKey = section + "." + config.Definition.Key;
-                string key = added.Contains(initKey) ? initKey + added.Count : initKey;
+            string initKey = section + "." + config.Definition.Key;
+            string key = added.Contains(initKey) ? initKey + added.Count : initKey;
 
-                // TODO: Somehow support subcategories
-                LocaleString nameKey = config.Definition.Key;
-                LocaleString descKey = config.Description.Description;
-                LocaleString defaultKey = $"{config.Definition.Key} : {valueType}";
-                LocaleString valueKey = $"{config.Definition.Key} : {config.BoxedValue}";
+            // TODO: Somehow support subcategories
+            LocaleString nameKey = config.Definition.Key;
+            LocaleString descKey = config.Description.Description;
+            LocaleString defaultKey = $"{config.Definition.Key} : {valueType}";
+            LocaleString valueKey = $"{config.Definition.Key} : {config.BoxedValue}";
 
-                bool hasLocale = LocaleLoader.PluginsWithLocales.Any(x => x.Metadata.GUID == metaData.ID);
-                if (hasLocale && config.Description.Tags.FirstOrDefault(x => x is ConfigLocale) is ConfigLocale localeString)
-                {
-                    nameKey = localeString.Name;
-                    descKey = localeString.Description;
+            bool hasLocale = LocaleLoader.PluginsWithLocales.Any(x => x.Metadata.GUID == metaData.ID);
+            if (hasLocale && config.Description.Tags.FirstOrDefault(x => x is ConfigLocale) is ConfigLocale localeString)
+            {
+                nameKey = localeString.Name;
+                descKey = localeString.Description;
 
-                    string formatted = localeString.Name.content.GetFormattedLocaleString();
-                    defaultKey = $"{formatted} : {valueType}";
-                    valueKey = $"{formatted} : {config.BoxedValue}";
-                }
+                string formatted = localeString.Name.content.GetFormattedLocaleString();
+                defaultKey = $"{formatted} : {valueType}";
+                valueKey = $"{formatted} : {config.BoxedValue}";
+            }
 
-                InternalLocale internalLocale = new InternalLocale(nameKey, descKey);
+            InternalLocale internalLocale = new InternalLocale(nameKey, descKey);
 
-                added.Add(key);
+            added.Add(key);
 
-                string[] groupingKeys = [section];
+            string[] groupingKeys = [section];
 
-                if (valueType == typeof(dummy))
-                {
-                    DataFeedItem dummyField = null;
+            if (valueType == typeof(dummy))
+            {
+                DataFeedItem dummyField = null;
 
-                    var firstAction = config.Description.Tags.FirstOrDefault(x => x is ActionConfig || x is Action);
-                    if (firstAction != null)
+                object firstAction = config.Description.Tags.FirstOrDefault(x => x is ActionConfig or Action);
+                if (firstAction != null)
+                {
+                    DataFeedAction actionField = new DataFeedAction();
+                    actionField.InitBase(key, path, groupingKeys, nameKey, descKey);
+                    actionField.InitAction(syncDelegate =>
                     {
-                        DataFeedAction actionField = new DataFeedAction();
-                        actionField.InitBase(key, path, groupingKeys, nameKey, descKey);
-                        actionField.InitAction(syncDelegate =>
-                        {
-                            Button btn = syncDelegate.Slot.GetComponent<Button>();
-                            if (btn == null) return;
-                            if(firstAction is ActionConfig actionCofnig)
-                                btn.LocalPressed += (_, _) => actionCofnig.Invoke();
-                            else if (firstAction is Action action)
-                                btn.LocalPressed += (_, _) => action.Invoke();
-                        });
-
-                        dummyField = actionField;
-                    }
+                        Button btn = syncDelegate.Slot.GetComponent<Button>();
+                        if (btn == null) return;
 
-                    bool customUi = false;
-                    if (CustomDataFeed.GetCustomFeedMethod(config) is DataFeedMethod customDataFeed)
+                        if (firstAction is ActionConfig actionConfig)
+                            btn.LocalPressed += (_, _) => actionConfig.Invoke();
+                        else if (firstAction is Action action)
+                            btn.LocalPressed += (_, _) => action.Invoke();
+                    });
+
+                    dummyField = actionField;
+                }
+
+                bool customUi = false;
+                if (CustomDataFeed.GetCustomFeedMethod(config) is DataFeedMethod customDataFeed)
+                {
+                    customUi = true;
+                    IAsyncEnumerable<DataFeedItem> datafeed = customDataFeed(path, groupingKeys);
+                    await foreach (DataFeedItem item in datafeed)
                     {
-                        customUi = true;
-                        IAsyncEnumerable<DataFeedItem> datafeed = customDataFeed(path, groupingKeys);
-                        await foreach (DataFeedItem item in datafeed)
-                        {
-                            yield return item;
-                        }
+                        yield return item;
                     }
+                }
+
+                if (dummyField == null && !customUi)
+                {
+                    dummyField = new DataFeedValueField<dummy>();
+                    dummyField.InitBase(key, path, groupingKeys, nameKey, descKey);
+                }
 
-                    if (dummyField == null && !customUi)
+                if (!customUi)
+                {
+                    yield return dummyField;
+                }
+            }
+            else if (valueType == typeof(bool))
+            {
+                yield return DataFeedHelpers.GenerateToggle(key, path, groupingKeys, internalLocale, config);
+            }
+            else if (valueType.IsEnum)
+            {
+                DataFeedItem enumItem;
+
+                try
+                {
+                    if (valueType.GetCustomAttribute<FlagsAttribute>() != null)
                     {
-                        dummyField = new DataFeedValueField<dummy>();
-                        dummyField.InitBase(key, path, groupingKeys, nameKey, descKey);
-                    }
+                        LocaleLoader.AddLocaleString($"Settings.{key}.Breadcrumb", initKey, authors: PluginMetadata.AUTHORS);
 
-                    if (!customUi)
+                        CategoryHandlers.Add(key, path2 => (IAsyncEnumerable<DataFeedItem>)DataFeedHelpers.HandleFlagsEnumCategory.MakeGenericMethod(valueType).Invoke(null, [path2, config]));
+                        enumItem = new DataFeedCategory();
+                        enumItem.InitBase(key, path, groupingKeys, valueKey, descKey);
+                    }
+                    else
                     {
-                        yield return dummyField;
+                        enumItem = (DataFeedItem)DataFeedHelpers.GenerateEnumItemsAsync.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
                     }
                 }
-                else if (valueType == typeof(bool))
+                catch (Exception e)
                 {
-                    yield return DataFeedHelpers.GenerateToggle(key, path, groupingKeys, internalLocale, config);
+                    Plugin.Log.LogError(e);
+                    enumItem = new DataFeedValueField<dummy>();
+                    enumItem.InitBase(key, path, groupingKeys, defaultKey, descKey);
                 }
-                else if (valueType.IsEnum)
+
+                yield return enumItem;
+            }
+            else if (valueType.IsNullable())
+            {
+                Type nullableType = valueType.GetGenericArguments()[0];
+                if (nullableType.IsEnum)
                 {
-                    DataFeedItem enumItem;
+                    IAsyncEnumerable<DataFeedItem> nullableEnumItems;
 
                     try
                     {
-                        if (valueType.GetCustomAttribute<FlagsAttribute>() != null)
-                        {
-                            LocaleLoader.AddLocaleString($"Settings.{key}.Breadcrumb", initKey, authors: PluginMetadata.AUTHORS);
-
-                            CategoryHandlers.Add(key, path2 => (IAsyncEnumerable<DataFeedItem>)DataFeedHelpers.HandleFlagsEnumCategory.MakeGenericMethod(valueType).Invoke(null, [path2, config]));
-                            enumItem = new DataFeedCategory();
-                            enumItem.InitBase(key, path, groupingKeys, valueKey, descKey);
-                        }
-                        else
-                        {
-                            enumItem = (DataFeedItem)DataFeedHelpers.GenerateEnumItemsAsync.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
-                        }
+                        nullableEnumItems = (IAsyncEnumerable<DataFeedItem>)DataFeedHelpers.GenerateNullableEnumItemsAsync.MakeGenericMethod(nullableType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
                     }
                     catch (Exception e)
                     {
                         Plugin.Log.LogError(e);
-                        enumItem = new DataFeedValueField<dummy>();
-                        enumItem.InitBase(key, path, groupingKeys, defaultKey, descKey);
+                        DataFeedValueField<dummy> dummyField = new DataFeedValueField<dummy>();
+                        dummyField.InitBase(key, path, groupingKeys, defaultKey, descKey);
+
+                        nullableEnumItems = dummyField.AsAsyncEnumerable();
                     }
 
-                    yield return enumItem;
-                }
-                else if (valueType.IsNullable())
-                {
-                    Type nullableType = valueType.GetGenericArguments()[0];
-                    if (nullableType.IsEnum)
+                    await foreach (DataFeedItem item in nullableEnumItems)
                     {
-                        IAsyncEnumerable<DataFeedItem> nullableEnumItems;
-
-                        try
-                        {
-                            nullableEnumItems = (IAsyncEnumerable<DataFeedItem>)DataFeedHelpers.GenerateNullableEnumItemsAsync.MakeGenericMethod(nullableType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
-                        }
-                        catch (Exception e)
-                        {
-                            Plugin.Log.LogError(e);
-                            DataFeedValueField<dummy> dummyField = new DataFeedValueField<dummy>();
-                            dummyField.InitBase(key, path, groupingKeys, defaultKey, descKey);
-
-                            nullableEnumItems = GetDummyAsync(dummyField);
-                        }
-
-                        await foreach (DataFeedItem item in nullableEnumItems)
-                        {
-                            yield return item;
-                        }
+                        yield return item;
                     }
                 }
-                else
-                {
-                    DataFeedItem valueItem;
+            }
+            else
+            {
+                DataFeedItem valueItem;
 
-                    try
+                try
+                {
+                    if (!config.SettingType.IsTypeInjectable() && TomlTypeConverter.CanConvert(config.SettingType))
                     {
-                        if (!config.SettingType.IsTypeInjectable() && TomlTypeConverter.CanConvert(config.SettingType))
-                        {
-                            valueItem = DataFeedHelpers.GenerateProxyField(key, path, groupingKeys, internalLocale, config);
-                        }
-                        else
-                        {
-                            valueItem = (DataFeedItem)DataFeedHelpers.GenerateValueField.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
-                        }
+                        valueItem = DataFeedHelpers.GenerateProxyField(key, path, groupingKeys, internalLocale, config);
                     }
-                    catch (Exception e)
+                    else
                     {
-                        Plugin.Log.LogError(e);
-                        valueItem = new DataFeedValueField<dummy>();
-                        valueItem.InitBase(key, path, groupingKeys, defaultKey, descKey);
+                        valueItem = (DataFeedItem)DataFeedHelpers.GenerateValueField.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
                     }
-
-                    yield return valueItem;
                 }
+                catch (Exception e)
+                {
+                    Plugin.Log.LogError(e);
+                    valueItem = new DataFeedValueField<dummy>();
+                    valueItem.InitBase(key, path, groupingKeys, defaultKey, descKey);
+                }
+
+                yield return valueItem;
             }
         }
 
@@ -369,13 +385,6 @@ void SetColor(int index, colorX color)
         yield return resetAct;
     }
 
-    private static async IAsyncEnumerable<DataFeedItem> GetDummyAsync(DataFeedItem item)
-    {
-        await Task.CompletedTask;
-
-        yield return item;
-    }
-
     private static void LoadConfigs(string pluginId)
     {
         Plugin.Log.LogDebug($"Loading Configs for {pluginId}");
diff --git a/BepisModSettings/DataFeeds/BepisSettingsPage.cs b/BepisModSettings/DataFeeds/BepisSettingsPage.cs
index f6e378f..d2c5dae 100644
--- a/BepisModSettings/DataFeeds/BepisSettingsPage.cs
+++ b/BepisModSettings/DataFeeds/BepisSettingsPage.cs
@@ -1,20 +1,46 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using BepInEx;
 using BepInEx.NET.Common;
+using BepInExResoniteShim;
 using BepisLocaleLoader;
 using Elements.Core;
 using FrooxEngine;
+using FrooxEngine.UIX;
 
 namespace BepisModSettings.DataFeeds;
 
 public static class BepisSettingsPage
 {
+    public static event Func<IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>> CustomPluginsPages;
+
+    public static string SearchString { get; set; } = "";
+
     internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<string> path)
     {
         await Task.CompletedTask;
 
+        DataFeedGroup searchGroup = new DataFeedGroup();
+        searchGroup.InitBase("SearchGroup", path, null, "Settings.BepInEx.Search".AsLocaleKey());
+        yield return searchGroup;
+
+        string[] searchGroupParam = ["SearchGroup"];
+
+        DataFeedValueField<string> searchField = new DataFeedValueField<string>();
+        searchField.InitBase("SearchField", path, searchGroupParam, "Settings.BepInEx.SearchField".AsLocaleKey());
+        searchField.InitSetupValue(field =>
+        {
+            Slot slot = field.FindNearestParent<Slot>();
+            if (slot == null) return;
+
+            field.Value = SearchString;
+            field.Changed += _ => SearchString = field.Value;
+            slot.GetComponentInParents<TextEditor>().LocalEditingFinished += _ => DataFeedHelpers.RefreshSettingsScreen();
+        });
+        yield return searchField;
+
         DataFeedGroup plguinsGroup = new DataFeedGroup();
         plguinsGroup.InitBase("BepInExPlugins", path, null, "Settings.BepInEx.Plugins".AsLocaleKey());
         yield return plguinsGroup;
@@ -29,36 +55,66 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         {
             List<PluginInfo> sortedPlugins = new List<PluginInfo>(NetChainloader.Instance.Plugins.Values);
             sortedPlugins.Sort((a, b) => string.Compare(a.Metadata.Name, b.Metadata.Name, StringComparison.OrdinalIgnoreCase));
-            foreach (PluginInfo plugin in sortedPlugins)
+
+            List<PluginInfo> filteredPlugins = FilterPlugins(sortedPlugins, SearchString).ToList();
+            if (filteredPlugins.Count > 0)
             {
-                BepInPlugin metaData = plugin.Metadata;
+                foreach (PluginInfo pluginInfo in filteredPlugins)
+                {
+                    BepInPlugin pMetadata = MetadataHelper.GetMetadata(pluginInfo.Instance) ?? pluginInfo.Metadata;
+                    ResonitePlugin resonitePlugin = pMetadata as ResonitePlugin;
 
-                string pluginname = metaData.Name;
-                string pluginGuid = metaData.GUID;
+                    ModMeta metaData = new ModMeta(pMetadata.Name, pMetadata.Version.ToString(), pMetadata.GUID, resonitePlugin?.Author, resonitePlugin?.Link);
 
-                LocaleString nameKey = pluginname;
-                LocaleString description = $"{pluginname}\n{pluginGuid}\n({metaData.Version})"; // "Settings.BepInEx.Plugin.Description".AsLocaleKey(("name", pluginname), ("guid", metaData.GUID), ("version", metaData.Version));
+                    string pluginName = metaData.Name;
+                    string pluginGuid = metaData.ID;
+                    string pluginAuthor = metaData.Author;
 
-                if (LocaleLoader.PluginsWithLocales.Contains(plugin))
-                {
-                    nameKey = $"Settings.{pluginGuid}".AsLocaleKey();
-                    description = $"Settings.{pluginGuid}.Description".AsLocaleKey();
-                }
-                else
-                {
-                    LocaleLoader.AddLocaleString($"Settings.{pluginGuid}.Breadcrumb", pluginname, authors: PluginMetadata.AUTHORS);
-                }
+                    LocaleString nameKey = pluginName;
+                    LocaleString description = $"{pluginName} ({metaData.Version}){(!string.IsNullOrEmpty(pluginAuthor) ? $"\nby \"{pluginAuthor}\"" : "")}\n\n{pluginGuid}";
+
+                    if (LocaleLoader.PluginsWithLocales.Contains(pluginInfo))
+                    {
+                        nameKey = $"Settings.{pluginGuid}".AsLocaleKey();
+                        description = $"Settings.{pluginGuid}.Description".AsLocaleKey();
+                    }
+                    else
+                    {
+                        LocaleLoader.AddLocaleString($"Settings.{pluginGuid}.Breadcrumb", pluginName, authors: PluginMetadata.AUTHORS);
+                    }
 
-                DataFeedCategory loadedPlugin = new DataFeedCategory();
-                loadedPlugin.InitBase(pluginGuid, path, loadedPluginsGroup, nameKey, description);
-                yield return loadedPlugin;
+                    DataFeedCategory loadedPlugin = new DataFeedCategory();
+                    loadedPlugin.InitBase(pluginGuid, path, loadedPluginsGroup, nameKey, description);
+                    yield return loadedPlugin;
+                }
+            }
+            else if (!string.IsNullOrWhiteSpace(SearchString))
+            {
+                DataFeedLabel noResults = new DataFeedLabel();
+                noResults.InitBase("NoSearchResults", path, loadedPluginsGroup, "Settings.BepInEx.Plugins.NoSearchResults".AsLocaleKey());
+                yield return noResults;
+            }
+            else
+            {
+                yield return CreateNoPluginsLabel(path, loadedPluginsGroup);
             }
         }
         else
         {
-            DataFeedLabel noPlugins = new DataFeedLabel();
-            noPlugins.InitBase("NoPlugins", path, loadedPluginsGroup, "Settings.BepInEx.Plugins.NoPlugins".AsLocaleKey());
-            yield return noPlugins;
+            yield return CreateNoPluginsLabel(path, loadedPluginsGroup);
+        }
+
+        if (CustomPluginsPages != null)
+        {
+            foreach (Delegate del in CustomPluginsPages.GetInvocationList())
+            {
+                if (del is not Func<IReadOnlyList<string>, IAsyncEnumerable<DataFeedItem>> handler) continue;
+
+                await foreach (DataFeedItem item in handler(path))
+                {
+                    yield return item;
+                }
+            }
         }
 
         DataFeedGroup coreGroup = new DataFeedGroup();
@@ -71,4 +127,47 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         bepisCategory.InitBase("BepInEx.Core.Config", path, coreGroupParam, "Settings.BepInEx.Core.Config".AsLocaleKey());
         yield return bepisCategory;
     }
+
+    private static DataFeedLabel CreateNoPluginsLabel(IReadOnlyList<string> path, string[] loadedPluginsGroup)
+    {
+        DataFeedLabel noPlugins = new DataFeedLabel();
+        noPlugins.InitBase("NoPlugins", path, loadedPluginsGroup, "Settings.BepInEx.Plugins.NoPlugins".AsLocaleKey());
+        return noPlugins;
+    }
+
+    private static IEnumerable<PluginInfo> FilterPlugins(List<PluginInfo> plugins, string searchString)
+    {
+        searchString = searchString.Trim();
+
+        return plugins.Where(plugin =>
+        {
+            if (!Plugin.ShowEmptyPages.Value)
+            {
+                if (plugin.Instance is BasePlugin plug && plug.Config.Count == 0)
+                    return false;
+            }
+
+            if (string.IsNullOrWhiteSpace(searchString))
+                return true;
+
+            BepInPlugin pMetadata = MetadataHelper.GetMetadata(plugin.Instance) ?? plugin.Metadata;
+            ResonitePlugin resonitePlugin = pMetadata as ResonitePlugin;
+
+            ModMeta metadata = new ModMeta(pMetadata.Name, pMetadata.Version.ToString(), pMetadata.GUID, resonitePlugin?.Author, resonitePlugin?.Link);
+
+            if (metadata.Name.Contains(searchString, StringComparison.InvariantCultureIgnoreCase))
+                return true;
+
+            if (metadata.ID.Contains(searchString, StringComparison.InvariantCultureIgnoreCase))
+                return true;
+
+            if (metadata.Version.Contains(searchString, StringComparison.InvariantCultureIgnoreCase))
+                return true;
+
+            if (!string.IsNullOrEmpty(metadata.Author) && metadata.Author.Contains(searchString, StringComparison.InvariantCultureIgnoreCase))
+                return true;
+
+            return false;
+        });
+    }
 }
\ No newline at end of file
diff --git a/BepisModSettings/DataFeeds/DataFeedHelpers.cs b/BepisModSettings/DataFeeds/DataFeedHelpers.cs
index 41e1eca..262f6b1 100644
--- a/BepisModSettings/DataFeeds/DataFeedHelpers.cs
+++ b/BepisModSettings/DataFeeds/DataFeedHelpers.cs
@@ -1,13 +1,13 @@
 /*
-* This file is based on code from:
-* https://github.com/ResoniteModdingGroup/MonkeyLoader.GamePacks.Resonite/blob/master/MonkeyLoader.Resonite.Integration/DataFeeds/Settings/ConfigSectionSettingsItems.cs
-*
-* Original code licensed under the GNU Lesser General Public License v3.0.
-* In accordance with the LGPL v3.0, this file is redistributed under
-* the terms of the GNU General Public License v3.0, as permitted by LGPL v3.0.
-*
-* Modifications: Edited by NepuShiro and ResoniteModding contributors.
-*/
+ * This file is based on code from:
+ * https://github.com/ResoniteModdingGroup/MonkeyLoader.GamePacks.Resonite/blob/master/MonkeyLoader.Resonite.Integration/DataFeeds/Settings/ConfigSectionSettingsItems.cs
+ *
+ * Original code licensed under the GNU Lesser General Public License v3.0.
+ * In accordance with the LGPL v3.0, this file is redistributed under
+ * the terms of the GNU General Public License v3.0, as permitted by LGPL v3.0.
+ *
+ * Modifications: Edited by NepuShiro and ResoniteModding contributors.
+ */
 
 using System;
 using System.Collections.Generic;
@@ -26,16 +26,7 @@ namespace BepisModSettings.DataFeeds;
 
 public static class DataFeedHelpers
 {
-    private static GridContainerScreen _settingsScreen;
-
-    private static GridContainerScreen SettingsScreen
-    {
-        get
-        {
-            _settingsScreen = _settingsScreen?.FilterWorldElement() ?? Userspace.UserspaceWorld.RootSlot.GetComponentInChildren<GridContainerScreen>(x => x.Label.Value == "Settings");
-            return _settingsScreen;
-        }
-    }
+    internal static SettingsDataFeed SettingsDataFeed { get; set; }
 
     private static RootCategoryView _rootCategoryView;
 
@@ -43,19 +34,19 @@ private static RootCategoryView RootCategoryView
     {
         get
         {
-            _rootCategoryView = _rootCategoryView?.FilterWorldElement() ?? SettingsScreen.Slot.GetComponentInChildren<RootCategoryView>();
+            _rootCategoryView = _rootCategoryView?.FilterWorldElement() ?? SettingsDataFeed.Slot.GetComponent<RootCategoryView>();
             return _rootCategoryView;
         }
     }
 
     private static DataFeedItemMapper Mapper => RootCategoryView?.ItemsManager.TemplateMapper.Target.FilterWorldElement();
 
-    public static readonly MethodInfo GenerateEnumItemsAsync = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateEnumItemsAsyncMethod));
-    public static readonly MethodInfo GenerateNullableEnumItemsAsync = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateNullableEnumItemsAsyncMethod));
-    public static readonly MethodInfo GenerateValueField = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateValueFieldMethod));
-    public static readonly MethodInfo HandleFlagsEnumCategory = AccessTools.Method(typeof(DataFeedHelpers), nameof(HandleFlagsEnumCategoryMethod));
+    internal static readonly MethodInfo GenerateEnumItemsAsync = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateEnumItemsAsyncMethod));
+    internal static readonly MethodInfo GenerateNullableEnumItemsAsync = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateNullableEnumItemsAsyncMethod));
+    internal static readonly MethodInfo GenerateValueField = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateValueFieldMethod));
+    internal static readonly MethodInfo HandleFlagsEnumCategory = AccessTools.Method(typeof(DataFeedHelpers), nameof(HandleFlagsEnumCategoryMethod));
 
-    public static DataFeedToggle GenerateToggle(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
+    internal static DataFeedToggle GenerateToggle(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
     {
         DataFeedToggle toggle = new DataFeedToggle();
         toggle.InitBase($"{key}.Toggle", path, groupKeys, internalLocale.Key, internalLocale.Description);
@@ -64,7 +55,7 @@ public static DataFeedToggle GenerateToggle(string key, IReadOnlyList<string> pa
         return toggle;
     }
 
-    public static DataFeedValueField<T> GenerateValueFieldMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
+    internal static DataFeedValueField<T> GenerateValueFieldMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
     {
         DataFeedValueField<T> valueField = new DataFeedValueField<T>();
         valueField.InitBase($"{key}.{configKey.SettingType}", path, groupKeys, internalLocale.Key, internalLocale.Description);
@@ -77,29 +68,24 @@ public static DataFeedValueField<T> GenerateValueFieldMethod<T>(string key, IRea
                 textField.Editor.Target.Undo.Value = false;
                 textField.Text.MaskPattern.Value = mask;
             }
-            
+
             field.SyncWithConfigKey(configKey);
         });
-        
-        
 
-        if (configKey.SettingType.IsTypeInjectable() && SettingsScreen?.Slot != null)
-        {
-            SettingsScreen.Slot.RunSynchronously(() => InjectNewTemplateType(configKey.SettingType));
-        }
+        TryInjectNewTemplateType(configKey.SettingType);
 
         return valueField;
     }
 
-    public static DataFeedValueField<string> GenerateProxyField(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
+    internal static DataFeedValueField<string> GenerateProxyField(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
     {
         DataFeedValueField<string> valueField = new DataFeedValueField<string>();
         valueField.InitBase($"{key}.{configKey.SettingType}", path, groupKeys, internalLocale.Key, internalLocale.Description);
         valueField.InitSetupValue(field => field.SyncProxyWithConfigKey(configKey));
 
-        if (TomlTypeConverter.CanConvert(configKey.SettingType) && SettingsScreen?.Slot != null)
+        if (TomlTypeConverter.CanConvert(configKey.SettingType) && SettingsDataFeed != null)
         {
-            SettingsScreen.Slot.RunSynchronously(() => InjectNewTemplateType(typeof(string)));
+            SettingsDataFeed.Slot.RunSynchronously(() => InjectNewTemplateType(typeof(string)));
         }
 
         return valueField;
@@ -192,7 +178,7 @@ void FieldChanged(IChangeable _)
         void KeyChanged(object sender, SettingChangedEventArgs e)
         {
             if (e.ChangedSetting != configKey) return;
-            var valAsStr = TomlTypeConverter.ConvertToString(e.ChangedSetting.BoxedValue ?? configKey.SettingType.GetDefault(), configKey.SettingType);
+            string valAsStr = TomlTypeConverter.ConvertToString(e.ChangedSetting.BoxedValue ?? configKey.SettingType.GetDefault(), configKey.SettingType);
             if (Equals(field.Value, valAsStr))
                 return;
 
@@ -335,7 +321,72 @@ void KeyChanged(object sender, SettingChangedEventArgs ev)
         }
     }
 
-    internal static bool IsTypeInjectable(this Type type) => type.Name != nameof(dummy) && (type.IsEnginePrimitive() || type == typeof(Type));
+    // TODO: find a better way of doing this non-destructively
+    /*internal static void EnsureBetterInnerContainerItem()
+    {
+        try
+        {
+            Slot templatesRoot = Mapper.Slot.Parent?.FindChild("Templates");
+            if (templatesRoot == null) return;
+
+            Slot betterInnterInterfaceSlot = templatesRoot.FindChild("Injected - InnerContainerItem");
+            if (betterInnterInterfaceSlot == null)
+            {
+                templatesRoot.RunSynchronously(() =>
+                {
+                    Slot innerInterfaceSlot = templatesRoot.FindChild("InnerContainerItem");
+                    if (innerInterfaceSlot != null)
+                    {
+                        betterInnterInterfaceSlot = innerInterfaceSlot.Duplicate();
+                        betterInnterInterfaceSlot.Name = "Injected - InnerContainerItem";
+                        betterInnterInterfaceSlot.ActiveSelf = false;
+                        betterInnterInterfaceSlot.PersistentSelf = false;
+
+                        betterInnterInterfaceSlot.FindChildInHierarchy("Button")?.Parent.Destroy();
+                        
+                        FeedItemInterface injectedInnerContainerItem = betterInnterInterfaceSlot.GetComponent<FeedItemInterface>();
+                        templatesRoot.ForeachComponentInChildren<FeedItemInterface>(interface2 =>
+                        {
+                            if (interface2 == null) return;
+                            if (interface2.ParentContainer.Target != null) return;
+
+                            interface2.ParentContainer.Target = injectedInnerContainerItem;
+                        });
+                    }
+                    else
+                    {
+                        Plugin.Log.LogError("InnerContainerItem slot is null in EnsureBetterInnerContainerItem!");
+                    }
+                });
+            }
+
+            while (templatesRoot.FindChild("Injected - InnerContainerItem") == null)
+            {
+                Task.Delay(10).Wait();
+            }
+        }
+        catch (Exception e)
+        {
+            Plugin.Log.LogError($"Error in EnsureBetterInnerContainerItem: {e}");
+        }
+    }*/
+
+    public static async IAsyncEnumerable<DataFeedItem> AsAsyncEnumerable(this DataFeedItem item)
+    {
+        await Task.CompletedTask;
+
+        yield return item;
+    }
+
+    public static bool IsTypeInjectable(this Type type) => type.Name != nameof(dummy) && (type.IsEnginePrimitive() || type == typeof(Type));
+
+    public static bool TryInjectNewTemplateType(Type typeToInject)
+    {
+        if (!typeToInject.IsTypeInjectable() || SettingsDataFeed == null) return false;
+
+        SettingsDataFeed.Slot.RunSynchronously(() => InjectNewTemplateType(typeToInject));
+        return true;
+    }
 
     private static void InjectNewTemplateType(Type typeToInject)
     {
@@ -453,4 +504,129 @@ private static void InjectNewTemplateType(Type typeToInject)
             Plugin.Log.LogError("Could not find Templates slot in DoInject!");
         }
     }
+
+    private static bool _isUpdatingSettings;
+
+    public static bool GoUpOneSetting()
+    {
+        try
+        {
+            RootCategoryView rcv = GetRootCategoryView();
+            if (rcv == null || rcv.Path.Count <= 1) return false;
+
+            rcv.MoveUpInCategory();
+            return true;
+        }
+        catch (Exception e)
+        {
+            Plugin.Log.LogError($"Error navigating up one setting: {e}");
+            return false;
+        }
+    }
+
+    public static bool GoToSettingPath(string path)
+    {
+        if (string.IsNullOrEmpty(path)) return false;
+        return GoToSettingPath(new[] { path });
+    }
+
+    public static bool GoToSettingPath(string[] path)
+    {
+        if (path == null || path.Length == 0) return false;
+
+        try
+        {
+            RootCategoryView rcv = GetRootCategoryView();
+            return rcv != null && SetCategoryPathSafe(rcv, path);
+        }
+        catch (Exception e)
+        {
+            Plugin.Log.LogError($"Error navigating to path [{string.Join("/", path)}]: {e}");
+            return false;
+        }
+    }
+
+    public static bool RefreshSettingsScreen()
+    {
+        if (_isUpdatingSettings) return false;
+
+        try
+        {
+            _isUpdatingSettings = true;
+            RootCategoryView rcv = GetRootCategoryView();
+            if (rcv == null)
+            {
+                _isUpdatingSettings = false;
+                return false;
+            }
+
+            // Store the current path
+            string[] currentPath = rcv.Path.ToArray();
+
+            // Navigate to empty path to trigger refresh
+            if (!SetCategoryPathSafe(rcv, new[] { string.Empty }))
+            {
+                Plugin.Log.LogError("Failed to navigate to empty path during refresh");
+                _isUpdatingSettings = false;
+                return false;
+            }
+
+            rcv.RunInUpdates(3, () =>
+            {
+                try
+                {
+                    // Go back to the original path
+                    SetCategoryPathSafe(rcv, currentPath);
+                }
+                catch (Exception e)
+                {
+                    Plugin.Log.LogError($"Error returning to original path after refresh: {e}");
+                }
+                finally
+                {
+                    _isUpdatingSettings = false;
+                }
+            });
+
+            return true;
+        }
+        catch (Exception e)
+        {
+            Plugin.Log.LogError($"Error refreshing settings screen: {e}");
+            _isUpdatingSettings = false;
+            return false;
+        }
+    }
+
+    private static bool SetCategoryPathSafe(RootCategoryView rcv, string[] path)
+    {
+        if (rcv == null || path == null) return false;
+
+        try
+        {
+            rcv.SetCategoryPath(path);
+            return true;
+        }
+        catch (Exception e)
+        {
+            Plugin.Log.LogError($"SetCategoryPathSafe [{string.Join("/", path)}] failed: {e}");
+            return false;
+        }
+    }
+
+    private static RootCategoryView GetRootCategoryView()
+    {
+        try
+        {
+            RootCategoryView rcv = RootCategoryView ?? Userspace.UserspaceWorld?.RootSlot?.GetComponentInChildren<SettingsDataFeed>()?.Slot?.GetComponent<RootCategoryView>(); // <- just for safety :)
+
+            if (rcv?.Path == null) throw new Exception("Path is null or empty");
+            return rcv;
+        }
+        catch (Exception e)
+        {
+            Plugin.Log.LogError($"Error getting RootCategoryView: {e}");
+            return null;
+        }
+    }
 }
\ No newline at end of file
diff --git a/BepisModSettings/Locale/en.json b/BepisModSettings/Locale/en.json
index cd44786..3fd3290 100644
--- a/BepisModSettings/Locale/en.json
+++ b/BepisModSettings/Locale/en.json
@@ -9,6 +9,9 @@
     "Settings.BepInEx": "BepInEx",
     "Settings.BepInEx.Breadcrumb": "BepInEx",
     
+    "Settings.BepInEx.Search": "Search",
+    "Settings.BepInEx.SearchField": "Search Field",
+    
     "Settings.BepInEx.Warning": "Warning",
     "Settings.BepInEx.NotUserspace": "This menu is only available in userspace!",
     
@@ -21,6 +24,7 @@
 	"Settings.BepInEx.Plugins.LoadedPlugins": "Loaded Plugins",
 	"Settings.BepInEx.Plugins.NoConfigs": "This Plugin has No Configs",
 	"Settings.BepInEx.Plugins.NoPlugins": "There is no Plugins Loaded",
+	"Settings.BepInEx.Plugins.NoSearchResults": "No Plugins found",
     
     "Settings.BepInEx.Plugins.Config.FlagsEnum": "PlaceHolder",
     "Settings.BepInEx.Plugins.Config.FlagsEnum.Description": "Toggles the '{name}' enum flag.",
@@ -46,7 +50,6 @@
 	"Settings.ResoniteModding.BepisModSettings.Breadcrumb": "Bepis Mod Settings",
 	"Settings.ResoniteModding.BepisModSettings.Description": "Lets you edit your mod settings in settings tab of the dashboard.",
 
-    // TODO: Add a way to read these
 	"Settings.ResoniteModding.BepisModSettings.Configs.ShowHidden": "Show Hidden Configs", 
 	"Settings.ResoniteModding.BepisModSettings.Configs.ShowHidden.Description": "Whether to show hidden Configs"
   }
diff --git a/BepisModSettings/Plugin.cs b/BepisModSettings/Plugin.cs
index 1dcbba9..6a6179c 100644
--- a/BepisModSettings/Plugin.cs
+++ b/BepisModSettings/Plugin.cs
@@ -29,8 +29,9 @@ public class Plugin : BasePlugin
     // TODO: Add configs for specific things, like internal only etc
     // basically try to get feature parity with ResoniteModSettings
 
-    internal static ConfigEntry<bool> ShowHidden;
-    internal static ConfigEntry<bool> ShowProtected;
+    public static ConfigEntry<bool> ShowHidden;
+    public static ConfigEntry<bool> ShowProtected;
+    public static ConfigEntry<bool> ShowEmptyPages;
 
     internal static ConfigEntry<dummy> TestAction;
     internal static ConfigEntry<string> TestProtected;
@@ -44,6 +45,7 @@ public override void Load()
 
         ShowHidden = Config.Bind("General", "ShowHidden", false, new ConfigDescription("Whether to show hidden Configs", null, new ConfigLocale("Settings.ResoniteModding.BepisModSettings.Configs.ShowHidden", "Settings.ResoniteModding.BepisModSettings.Configs.ShowHidden.Description")));
         ShowProtected = Config.Bind("General", "ShowProtected", false, "Whether to show protected Configs");
+        ShowEmptyPages = Config.Bind("General", "ShowEmptyPages", true, "Whether to show category buttons for pages which would have no content");
 
         TestAction = Config.Bind("Tests", "TestAction", default(dummy), new ConfigDescription("TestAction", null, new ActionConfig(() => Log.LogError("OneOfThem"))));
         TestProtected = Config.Bind("Tests", "TestProtected", "AWAWAWAWA THIS IS A TEST MESSAGE", new ConfigDescription("TestProtected", null, new ProtectedConfig()));
@@ -70,7 +72,7 @@ public override void Load()
             Engine.Current.OnShutdown += () =>
             {
                 Plugin.Log.LogInfo("Running shutdown, saving configs...");
-                
+
                 Plugin.Log.LogDebug("Saving Config for BepInEx.Core");
                 ConfigFile.CoreConfig?.Save();
 
@@ -92,12 +94,16 @@ public override void Load()
     private static class EnumeratorPostfix
     {
         [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
-        private static IAsyncEnumerable<DataFeedItem> Postfix(IAsyncEnumerable<DataFeedItem> __result, SettingsDataFeed __instance, IReadOnlyList<string> path /*, IReadOnlyList<string> groupingKeys, string searchPhrase, object viewData*/)
+        private static IAsyncEnumerable<DataFeedItem> Postfix(IAsyncEnumerable<DataFeedItem> __result, SettingsDataFeed __instance, IReadOnlyList<string> path)
         {
             try
             {
                 if (!path.Contains("BepInEx")) return __result;
 
+                DataFeedHelpers.SettingsDataFeed = __instance;
+                // TODO: Find a way to do this non-destructively
+                // DataFeedHelpers.EnsureBetterInnerContainerItem();
+
                 return __instance.World.IsUserspace() ? DataFeedInjector.ReplaceEnumerable(__result, path) : DataFeedInjector.NotUserspaceEnumerator(path);
             }
             catch (Exception ex)
diff --git a/README.md b/README.md
index 6373b4a..0133ea8 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Configuration page footer:<img width="1358" height="480" alt="image" src="https:
 
 ## Installation (Manual)
 1. Install [BepisLoader](https://github.com/ResoniteModding/BepisLoader) for Resonite.
-2. Download the latest release ZIP file (e.g., `NepuShiro-BepisModSettings-0.0.3.zip`) from the [Releases](https://github.com/ResoniteModding/BepisModSettings/releases) page.
+2. Download the latest release ZIP file (e.g., `ResoniteModding-BepisModSettings-1.2.0.zip`) from the [Releases](https://github.com/ResoniteModding/BepisModSettings/releases) page.
 3. Extract the ZIP and copy the `plugins` folder to your BepInEx folder in your Resonite installation directory:
    - **Default location:** `C:\Program Files (x86)\Steam\steamapps\common\Resonite\BepInEx\`
 4. Start the game. If you want to verify that the mod is working you can check your BepInEx logs.
diff --git a/thunderstore.toml b/thunderstore.toml
index 98145a6..8eba6ab 100644
--- a/thunderstore.toml
+++ b/thunderstore.toml
@@ -6,14 +6,14 @@ schemaVersion = "0.0.1"
 [package]
 namespace = "ResoniteModding"
 name = "BepisModSettings"
-versionNumber = "1.1.1"
+versionNumber = "1.2.0"
 description = "Lets you edit your mod settings in the settings tab of the dashboard"
 websiteUrl = "https://github.com/ResoniteModding/BepisModSettings"
 containsNsfwContent = false
 
 [package.dependencies]
 ResoniteModding-BepisLoader = "1.4.1"
-ResoniteModding-BepisLocaleLoader = "1.0.0"
+ResoniteModding-BepisLocaleLoader = "1.1.0"
 ResoniteModding-BepisResoniteWrapper = "1.0.0"
 
 [build]
@@ -33,11 +33,6 @@ target = "plugins/BepisModSettings/"
 source = "./BepisModSettings/Locale"
 target = "plugins/BepisModSettings/Locale"
 
-# Uncomment the following lines to include CHANGELOG file in your mod package. https://wiki.thunderstore.io/mods/updating-a-package#changelog
-# [[build.copy]]
-# source = "./CHANGELOG.md"
-# target = "/"
-
 [[build.copy]]
 source = "./LICENSE"
 target = "/"
@@ -50,4 +45,4 @@ communities = ["resonite"]
 resonite = [
   "dashboard",
   "misc",
-] # TODO: Change this to your mod's categories, see https://thunderstore.io/api/experimental/community/resonite/category/ for a list of available categories
+]
\ No newline at end of file