diff --git a/BepisModSettings/ConfigAttributes/ActionConfig.cs b/BepisModSettings/ConfigAttributes/ActionConfig.cs
new file mode 100644
index 0000000..ab5a6e5
--- /dev/null
+++ b/BepisModSettings/ConfigAttributes/ActionConfig.cs
@@ -0,0 +1,30 @@
+using System;
+
+namespace BepisModSettings.ConfigAttributes;
+
+public class ActionConfig(Delegate action)
+{
+    public Delegate Action { get; } = action ?? throw new ArgumentNullException(nameof(action));
+
+    public object Invoke(params object[] args) => Action.DynamicInvoke(args);
+}
+
+public class ActionConfig<T>(Action<T> action) : ActionConfig(action)
+{
+    public void Invoke(T arg) => ((Action<T>)Action)(arg);
+}
+
+public class ActionConfig<T1, T2>(Action<T1, T2> action) : ActionConfig(action)
+{
+    public void Invoke(T1 arg1, T2 arg2) => ((Action<T1, T2>)Action)(arg1, arg2);
+}
+
+public class FuncConfig<TResult>(Func<TResult> func) : ActionConfig(func)
+{
+    public TResult Invoke() => ((Func<TResult>)Action)();
+}
+
+public class FuncConfig<T, TResult>(Func<T, TResult> func) : ActionConfig(func)
+{
+    public TResult Invoke(T arg) => ((Func<T, TResult>)Action)(arg);
+}
\ No newline at end of file
diff --git a/BepisModSettings/ConfigAttributes/CustomDataFeed.cs b/BepisModSettings/ConfigAttributes/CustomDataFeed.cs
new file mode 100644
index 0000000..b5dff62
--- /dev/null
+++ b/BepisModSettings/ConfigAttributes/CustomDataFeed.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using FrooxEngine;
+
+namespace BepisModSettings.ConfigAttributes;
+
+public delegate IAsyncEnumerable<DataFeedItem> DataFeedMethod(IReadOnlyList<string> path, IReadOnlyList<string> groupKeys);
+
+public sealed class CustomDataFeed(DataFeedMethod action)
+{
+    private readonly DataFeedMethod _action = action ?? throw new ArgumentNullException(nameof(action));
+
+    public IAsyncEnumerable<DataFeedItem> Build(IReadOnlyList<string> path, IReadOnlyList<string> groupKeys)
+    {
+        ArgumentNullException.ThrowIfNull(path);
+        
+        return _action(path, groupKeys);
+    }
+}
\ No newline at end of file
diff --git a/BepisModSettings/ConfigAttributes/HiddenConfig.cs b/BepisModSettings/ConfigAttributes/HiddenConfig.cs
new file mode 100644
index 0000000..7c351b4
--- /dev/null
+++ b/BepisModSettings/ConfigAttributes/HiddenConfig.cs
@@ -0,0 +1,3 @@
+namespace BepisModSettings.ConfigAttributes;
+
+public class HiddenConfig { }
\ No newline at end of file
diff --git a/BepisModSettings/ConfigAttributes/ProtectedConfig.cs b/BepisModSettings/ConfigAttributes/ProtectedConfig.cs
new file mode 100644
index 0000000..74ce550
--- /dev/null
+++ b/BepisModSettings/ConfigAttributes/ProtectedConfig.cs
@@ -0,0 +1,8 @@
+namespace BepisModSettings.ConfigAttributes;
+
+public class ProtectedConfig(string maskString)
+{
+    public ProtectedConfig() : this("*") { }
+
+    public string MaskString { get; } = maskString;
+}
\ No newline at end of file
diff --git a/BepisModSettings/DataFeeds/BepisNestedCategoryPage.cs b/BepisModSettings/DataFeeds/BepisNestedCategoryPage.cs
index 4afbc17..f6a8287 100644
--- a/BepisModSettings/DataFeeds/BepisNestedCategoryPage.cs
+++ b/BepisModSettings/DataFeeds/BepisNestedCategoryPage.cs
@@ -21,9 +21,9 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         }
         else
         {
-            DataFeedLabel noConfigs = new DataFeedLabel();
-            noConfigs.InitBase("InvalidCategory", path, null, "Settings.BepInEx.Plugins.Error".AsLocaleKey());
-            yield return noConfigs;
+            DataFeedLabel invalidCategory = new DataFeedLabel();
+            invalidCategory.InitBase("InvalidCategory", path, null, "Settings.BepInEx.Plugins.Error".AsLocaleKey());
+            yield return invalidCategory;
         }
     }
 }
\ No newline at end of file
diff --git a/BepisModSettings/DataFeeds/BepisPluginPage.cs b/BepisModSettings/DataFeeds/BepisPluginPage.cs
index 62e2064..1a38854 100644
--- a/BepisModSettings/DataFeeds/BepisPluginPage.cs
+++ b/BepisModSettings/DataFeeds/BepisPluginPage.cs
@@ -9,6 +9,7 @@
 using BepInEx.NET.Common;
 using BepInExResoniteShim;
 using BepisLocaleLoader;
+using BepisModSettings.ConfigAttributes;
 using Elements.Core;
 using FrooxEngine;
 using FrooxEngine.UIX;
@@ -73,7 +74,7 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         modGroup.InitBase("Metadata", path, null, "Settings.BepInEx.Plugins.Metadata".AsLocaleKey());
         yield return modGroup;
 
-        string[] metadataGroup = new[] { "Metadata" };
+        string[] metadataGroup = ["Metadata"];
 
         DataFeedIndicator<string> idIndicator = new DataFeedIndicator<string>();
         idIndicator.InitBase("Id", path, metadataGroup, "Settings.BepInEx.Plugins.Guid".AsLocaleKey());
@@ -119,6 +120,8 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
             List<string> added = new List<string>();
             foreach (ConfigEntryBase config in configFile.Values)
             {
+                if (!Plugin.ShowHidden.Value && config.Description.Tags.Any(x => x is HiddenConfig)) continue;
+                
                 Type valueType = config.SettingType;
 
                 string section = config.Definition.Section;
@@ -147,22 +150,24 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
                 string initKey = section + "." + config.Definition.Key;
                 string key = added.Contains(initKey) ? initKey + added.Count : initKey;
 
-                // TODO: Figure out how to actually Localize config keys.
-                // TODO: Add Key for SubCategories
+                // 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}";
 
-                string defaultKey = $"{config.Definition.Key} : {valueType}";       // "Settings.BepInEx.Plugins.Configs.Default".AsLocaleKey(("name", config.Definition.Key), ("type", valueType));
-                string valueKey = $"{config.Definition.Key} : {config.BoxedValue}"; // "Settings.BepInEx.Plugins.Configs.Value".AsLocaleKey(("name", config.Definition.Key), ("value", config.BoxedValue));
-                string nameKey = config.Definition.Key;                             // "Settings.BepInEx.Plugins.Configs.Name".AsLocaleKey(("name", config.Definition.Key));
-                string descKey = config.Description.Description;                    // "Settings.BepInEx.Plugins.Configs.Description".AsLocaleKey(("description", config.Description.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;
 
-                // if (SettingsLocaleHelper.PluginsWithLocales.Any(x => x.Metadata.GUID == metaData.ID))
-                // {
-                //     nameKey = config.Definition.Key.AsLocaleKey();
-                //     descKey = config.Description.Description.AsLocaleKey();
-                //     
-                //     defaultKey = $"Settings.{metaData.ID}.Configs.Default".AsLocaleKey(("name", nameKey.content), ("type", valueType));
-                //     valueKey = $"Settings.{metaData.ID}.Configs.Value".AsLocaleKey(("name", nameKey.content), ("value", config.BoxedValue));
-                // }
+                    string formatted = localeString.Name.content.GetFormattedLocaleString();
+                    defaultKey = $"{formatted} : {valueType}";
+                    valueKey = $"{formatted} : {config.BoxedValue}";
+                }
+                
+                InternalLocale internalLocale = new InternalLocale(nameKey, descKey);
 
                 added.Add(key);
 
@@ -172,7 +177,7 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
                 {
                     DataFeedItem dummyField = null;
 
-                    if (config.Description.Tags.Contains("Action") && config.Description.Tags.FirstOrDefault(x => x is Delegate) is Delegate del)
+                    if (config.Description.Tags.FirstOrDefault(x => x is ActionConfig) is ActionConfig action)
                     {
                         DataFeedAction actionField = new DataFeedAction();
                         actionField.InitBase(key, path, groupingKeys, nameKey, descKey);
@@ -181,23 +186,37 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
                             Button btn = syncDelegate.Slot.GetComponent<Button>();
                             if (btn == null) return;
 
-                            btn.LocalPressed += (_, _) => del.DynamicInvoke();
+                            btn.LocalPressed += (_, _) => action.Invoke();
                         });
 
                         dummyField = actionField;
                     }
 
-                    if (dummyField == null)
+                    bool customUi = false;
+                    if (config.Description.Tags.FirstOrDefault(x => x is CustomDataFeed) is CustomDataFeed customDataFeed)
+                    {
+                        customUi = true;
+                        IAsyncEnumerable<DataFeedItem> datafeed = customDataFeed.Build(path, groupingKeys);
+                        await foreach (DataFeedItem item in datafeed)
+                        {
+                            yield return item;
+                        }
+                    }
+
+                    if (dummyField == null && !customUi)
                     {
                         dummyField = new DataFeedValueField<dummy>();
                         dummyField.InitBase(key, path, groupingKeys, nameKey, descKey);
                     }
-
-                    yield return dummyField;
+                    
+                    if (!customUi)
+                    {
+                        yield return dummyField;
+                    }
                 }
                 else if (valueType == typeof(bool))
                 {
-                    yield return DataFeedHelpers.GenerateToggle(key, path, groupingKeys, config);
+                    yield return DataFeedHelpers.GenerateToggle(key, path, groupingKeys, internalLocale, config);
                 }
                 else if (valueType.IsEnum)
                 {
@@ -215,7 +234,7 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
                         }
                         else
                         {
-                            enumItem = (DataFeedItem)DataFeedHelpers.GenerateEnumItemsAsync.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, config]);
+                            enumItem = (DataFeedItem)DataFeedHelpers.GenerateEnumItemsAsync.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
                         }
                     }
                     catch (Exception e)
@@ -236,7 +255,7 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
 
                         try
                         {
-                            nullableEnumItems = (IAsyncEnumerable<DataFeedItem>)DataFeedHelpers.GenerateNullableEnumItemsAsync.MakeGenericMethod(nullableType).Invoke(null, [key, path, groupingKeys, config]);
+                            nullableEnumItems = (IAsyncEnumerable<DataFeedItem>)DataFeedHelpers.GenerateNullableEnumItemsAsync.MakeGenericMethod(nullableType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
                         }
                         catch (Exception e)
                         {
@@ -261,11 +280,11 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
                     {
                         if (!config.SettingType.IsTypeInjectable() && TomlTypeConverter.CanConvert(config.SettingType))
                         {
-                            valueItem = DataFeedHelpers.GenerateProxyField(key, path, groupingKeys, config);
+                            valueItem = DataFeedHelpers.GenerateProxyField(key, path, groupingKeys, internalLocale, config);
                         }
                         else
                         {
-                            valueItem = (DataFeedItem)DataFeedHelpers.GenerateValueField.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, config]);
+                            valueItem = (DataFeedItem)DataFeedHelpers.GenerateValueField.MakeGenericMethod(valueType).Invoke(null, [key, path, groupingKeys, internalLocale, config]);
                         }
                     }
                     catch (Exception e)
@@ -292,7 +311,7 @@ private static async IAsyncEnumerable<DataFeedItem> EnumerateConfigs(ConfigFile
         {
             Button btn = syncDelegate.Slot.GetComponent<Button>();
             if (btn == null) return;
-        
+
             btn.LocalPressed += (_, _) => LoadConfigs(metaData.ID);
         });
         yield return loadAct;
@@ -348,6 +367,7 @@ private static async IAsyncEnumerable<DataFeedItem> GetDummyAsync(DataFeedItem i
 
         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 c83e8d7..f6e378f 100644
--- a/BepisModSettings/DataFeeds/BepisSettingsPage.cs
+++ b/BepisModSettings/DataFeeds/BepisSettingsPage.cs
@@ -23,7 +23,7 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         pluginsGrid.InitBase("PluginsGrid", path, ["BepInExPlugins"], "Settings.BepInEx.LoadedPlugins".AsLocaleKey());
         yield return pluginsGrid;
 
-        string[] loadedPluginsGroup = new[] { "BepInExPlugins", "PluginsGrid" };
+        string[] loadedPluginsGroup = ["BepInExPlugins", "PluginsGrid"];
 
         if (NetChainloader.Instance.Plugins.Count > 0)
         {
@@ -65,7 +65,7 @@ internal static async IAsyncEnumerable<DataFeedItem> Enumerate(IReadOnlyList<str
         coreGroup.InitBase("BepInExCore", path, null, "Settings.BepInEx.Core".AsLocaleKey());
         yield return coreGroup;
 
-        string[] coreGroupParam = new[] { "BepInExCore" };
+        string[] coreGroupParam = ["BepInExCore"];
 
         DataFeedCategory bepisCategory = new DataFeedCategory();
         bepisCategory.InitBase("BepInEx.Core.Config", path, coreGroupParam, "Settings.BepInEx.Core.Config".AsLocaleKey());
diff --git a/BepisModSettings/DataFeeds/DataFeedHelpers.cs b/BepisModSettings/DataFeeds/DataFeedHelpers.cs
index ad1d0be..1140556 100644
--- a/BepisModSettings/DataFeeds/DataFeedHelpers.cs
+++ b/BepisModSettings/DataFeeds/DataFeedHelpers.cs
@@ -15,6 +15,7 @@
 using System.Reflection;
 using System.Threading.Tasks;
 using BepInEx.Configuration;
+using BepisModSettings.ConfigAttributes;
 using Elements.Assets;
 using Elements.Core;
 using FrooxEngine;
@@ -54,27 +55,27 @@ private static RootCategoryView RootCategoryView
     public static readonly MethodInfo GenerateValueField = AccessTools.Method(typeof(DataFeedHelpers), nameof(GenerateValueFieldMethod));
     public static readonly MethodInfo HandleFlagsEnumCategory = AccessTools.Method(typeof(DataFeedHelpers), nameof(HandleFlagsEnumCategoryMethod));
 
-    public static DataFeedToggle GenerateToggle(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, ConfigEntryBase configKey)
+    public 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, configKey.Definition.Key, configKey.Description.Description);
+        toggle.InitBase($"{key}.Toggle", path, groupKeys, internalLocale.Key, internalLocale.Description);
         toggle.InitSetupValue(field => field.SyncWithConfigKey(configKey));
 
         return toggle;
     }
 
-    public static DataFeedValueField<T> GenerateValueFieldMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, ConfigEntryBase configKey)
+    public 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, configKey.Definition.Key, configKey.Description.Description);
+        valueField.InitBase($"{key}.{configKey.SettingType}", path, groupKeys, internalLocale.Key, internalLocale.Description);
         valueField.InitSetupValue(field =>
         {
-            if (configKey.Description.Tags.Contains("Protected") && !Plugin.ShowProtected.Value)
+            if (!Plugin.ShowProtected.Value && configKey.Description.Tags.FirstOrDefault(x => x is ProtectedConfig) is ProtectedConfig protectedConfig)
             {
                 TextField textField = field.FindNearestParent<Slot>().FindParent(x => x.Name == "DataFeedValueField<string>", 5).GetComponentInChildren<TextField>();
                 textField.Text.ParseRichText.Value = false;
                 textField.Editor.Target.Undo.Value = false;
-                textField.Text.MaskPattern.Value = "*";
+                textField.Text.MaskPattern.Value = protectedConfig.MaskString;
             }
             
             field.SyncWithConfigKey(configKey);
@@ -90,10 +91,10 @@ public static DataFeedValueField<T> GenerateValueFieldMethod<T>(string key, IRea
         return valueField;
     }
 
-    public static DataFeedValueField<string> GenerateProxyField(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, ConfigEntryBase configKey)
+    public 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, configKey.Definition.Key, configKey.Description.Description);
+        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)
@@ -104,7 +105,7 @@ public static DataFeedValueField<string> GenerateProxyField(string key, IReadOnl
         return valueField;
     }
 
-    private static async IAsyncEnumerable<DataFeedItem> GenerateNullableEnumItemsAsyncMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, ConfigEntryBase configKey)
+    private static async IAsyncEnumerable<DataFeedItem> GenerateNullableEnumItemsAsyncMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
             where T : unmanaged, Enum
     {
         await Task.CompletedTask;
@@ -131,7 +132,7 @@ private static async IAsyncEnumerable<DataFeedItem> GenerateNullableEnumItemsAsy
         });
         yield return nullableToggle;
 
-        IAsyncEnumerable<DataFeedItem> enumItems = (IAsyncEnumerable<DataFeedItem>)GenerateEnumItemsAsync.MakeGenericMethod(typeof(T)).Invoke(null, [path, nullableGroupKeys, configKey]);
+        IAsyncEnumerable<DataFeedItem> enumItems = (IAsyncEnumerable<DataFeedItem>)GenerateEnumItemsAsync.MakeGenericMethod(typeof(T)).Invoke(null, [path, nullableGroupKeys, internalLocale, configKey]);
         if (enumItems != null)
         {
             await foreach (DataFeedItem item in enumItems)
@@ -199,11 +200,11 @@ void KeyChanged(object sender, SettingChangedEventArgs e)
         }
     }
 
-    private static DataFeedItem GenerateEnumItemsAsyncMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, ConfigEntryBase configKey)
+    private static DataFeedEnum<T> GenerateEnumItemsAsyncMethod<T>(string key, IReadOnlyList<string> path, IReadOnlyList<string> groupKeys, InternalLocale internalLocale, ConfigEntryBase configKey)
             where T : unmanaged, Enum
     {
         DataFeedEnum<T> enumField = new DataFeedEnum<T>();
-        enumField.InitBase($"{key}.Enum", path, groupKeys, configKey.Definition.Key, configKey.Description.Description);
+        enumField.InitBase($"{key}.Enum", path, groupKeys, internalLocale.Key, internalLocale.Description);
         enumField.InitSetupValue(field => field.SyncWithConfigKey(configKey));
 
         return enumField;
@@ -267,13 +268,13 @@ void ParentDestroyedHandler(IDestroyable _)
         }
     }
 
-    internal static async IAsyncEnumerable<DataFeedItem> HandleFlagsEnumCategoryMethod<T>(IReadOnlyList<string> path, ConfigEntryBase key) where T : Enum
+    internal static async IAsyncEnumerable<DataFeedItem> HandleFlagsEnumCategoryMethod<T>(IReadOnlyList<string> path, ConfigEntryBase configKey) where T : Enum
     {
         await Task.CompletedTask;
 
         const string groupId = "FlagsGroup";
         DataFeedGroup group = new DataFeedGroup();
-        group.InitBase(groupId, path, null, key.Definition.Section + "." + key.Definition.Key);
+        group.InitBase(groupId, path, null, configKey.Definition.Section + "." + configKey.Definition.Key);
         yield return group;
         string[] groupKeys = [groupId];
 
@@ -291,9 +292,9 @@ internal static async IAsyncEnumerable<DataFeedItem> HandleFlagsEnumCategoryMeth
             {
                 bool skipNextChange = false;
 
-                field.Value = ((T)(key.BoxedValue ?? default(T)!)).HasFlag(e);
+                field.Value = ((T)(configKey.BoxedValue ?? default(T)!)).HasFlag(e);
 
-                field.SetupChangedHandlers(FieldChanged, key, KeyChanged);
+                field.SetupChangedHandlers(FieldChanged, configKey, KeyChanged);
 
                 return;
 
@@ -305,18 +306,18 @@ void FieldChanged(IChangeable _)
                         return;
                     }
 
-                    long current = Convert.ToInt64(key.BoxedValue ?? default(T));
+                    long current = Convert.ToInt64(configKey.BoxedValue ?? default(T));
                     long newValue = field.Value
                             ? current | intValue
                             : current & ~intValue;
-                    key.BoxedValue = Enum.ToObject(enumType, newValue);
+                    configKey.BoxedValue = Enum.ToObject(enumType, newValue);
 
-                    field.World.RunSynchronously(() => { field.Value = ((T)(key.BoxedValue ?? default(T)!)).HasFlag(e); });
+                    field.World.RunSynchronously(() => { field.Value = ((T)(configKey.BoxedValue ?? default(T)!)).HasFlag(e); });
                 }
 
                 void KeyChanged(object sender, SettingChangedEventArgs ev)
                 {
-                    if (ev.ChangedSetting != key) return;
+                    if (ev.ChangedSetting != configKey) return;
 
                     bool thingy = ((T)(ev.ChangedSetting.BoxedValue ?? default(T)!)).HasFlag(e);
 
diff --git a/BepisModSettings/DataFeeds/InternalLocale.cs b/BepisModSettings/DataFeeds/InternalLocale.cs
new file mode 100644
index 0000000..f23988e
--- /dev/null
+++ b/BepisModSettings/DataFeeds/InternalLocale.cs
@@ -0,0 +1,5 @@
+using Elements.Core;
+
+namespace BepisModSettings.DataFeeds;
+
+public record InternalLocale(LocaleString Key, LocaleString Description);
\ No newline at end of file
diff --git a/BepisModSettings/Plugin.cs b/BepisModSettings/Plugin.cs
index 14c3f21..c1e50cb 100644
--- a/BepisModSettings/Plugin.cs
+++ b/BepisModSettings/Plugin.cs
@@ -12,6 +12,8 @@
 using System.Threading.Tasks;
 using BepInEx.Configuration;
 using BepInEx.NET.Common;
+using BepisLocaleLoader;
+using BepisModSettings.ConfigAttributes;
 using BepisModSettings.DataFeeds;
 using BepisResoniteWrapper;
 
@@ -30,14 +32,24 @@ public class Plugin : BasePlugin
     internal static ConfigEntry<bool> ShowHidden;
     internal static ConfigEntry<bool> ShowProtected;
 
+    internal static ConfigEntry<dummy> TestAction;
+    internal static ConfigEntry<string> TestProtected;
+    internal static ConfigEntry<string> TestHidden;
+    internal static ConfigEntry<dummy> TestCustomDataFeed;
+
     public override void Load()
     {
         // Plugin startup logic
         Log = base.Log;
 
-        ShowHidden = Config.Bind("General", "ShowHidden", false, "Whether to show hidden Configs - Not Implemented");
+        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");
 
+        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()));
+        TestHidden = Config.Bind("Tests", "TestHidden", "AWAWAWAWA THIS IS A TEST MESSAGE", new ConfigDescription("TestHidden", null, new HiddenConfig()));
+        TestCustomDataFeed = Config.Bind("Tests", "TestCustomDataFeed", default(dummy), new ConfigDescription("TestCustomDataFeed", null, new CustomDataFeed(CustomDateFeedEnumerate)));
+
         HarmonyInstance.PatchAll();
 
         ResoniteHooks.OnEngineReady += () =>
@@ -94,4 +106,35 @@ private static bool Prefix(string pathSegment, int depth, ref LocaleString __res
             return false;
         }
     }
+
+    private static async IAsyncEnumerable<DataFeedItem> CustomDateFeedEnumerate(IReadOnlyList<string> path, IReadOnlyList<string> groupingKeys)
+    {
+        await Task.CompletedTask;
+
+        DataFeedGroup group = new DataFeedGroup();
+        group.InitBase("Test", path, groupingKeys, "Test");
+        yield return group;
+
+        string[] groupingKeysArray = groupingKeys.Concat(["Test"]).ToArray();
+
+        DataFeedIndicator<string> indicator = new DataFeedIndicator<string>();
+        indicator.InitBase("Test1", path, groupingKeysArray, "Test1");
+        indicator.InitSetupValue(field => field.Value = "Test1");
+        yield return indicator;
+
+        DataFeedIndicator<string> indicator2 = new DataFeedIndicator<string>();
+        indicator2.InitBase("Test2", path, groupingKeysArray, "Test2");
+        indicator2.InitSetupValue(field => field.Value = "Test2");
+        yield return indicator2;
+
+        DataFeedIndicator<string> indicator3 = new DataFeedIndicator<string>();
+        indicator3.InitBase("Test3", path, groupingKeysArray, "Test3");
+        indicator3.InitSetupValue(field => field.Value = "Test3");
+        yield return indicator3;
+
+        DataFeedIndicator<string> indicator4 = new DataFeedIndicator<string>();
+        indicator4.InitBase("Test4", path, groupingKeysArray, "Test4");
+        indicator4.InitSetupValue(field => field.Value = "Test4");
+        yield return indicator4;
+    }
 }
\ No newline at end of file