diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGenerationContext.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGenerationContext.cs
new file mode 100644
index 000000000..60811553f
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGenerationContext.cs
@@ -0,0 +1,10 @@
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolGenerationContext : RegistrableGeneratorContext
+    {
+        public LuaSolGenerationContext()
+            : base()
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGenerator.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGenerator.cs
new file mode 100644
index 000000000..ddb2faeeb
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGenerator.cs
@@ -0,0 +1,30 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolGenerator : RegistrableGenerator<LuaSolGeneratorOptions, LuaSolHeaders, LuaSolSources>
+    {
+        public const string Id = "Lua::Sol";
+        public static readonly GeneratorKind Kind = new(Id, "lua::sol", typeof(LuaSolGenerator), typeof(LuaSolTypePrinter), new[] { "lua::sol" });
+
+        public LuaSolGenerator(BindingContext context) : base(context)
+        {
+        }
+
+        protected override LuaSolGeneratorOptions CreateOptions()
+        {
+            return new LuaSolGeneratorOptions(this);
+        }
+
+        protected override LuaSolHeaders CreateHeader(IEnumerable<TranslationUnit> units)
+        {
+            return new LuaSolHeaders(this, units);
+        }
+
+        protected override LuaSolSources CreateSource(IEnumerable<TranslationUnit> units)
+        {
+            return new LuaSolSources(this, units);
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGeneratorOptions.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGeneratorOptions.cs
new file mode 100644
index 000000000..32531c212
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolGeneratorOptions.cs
@@ -0,0 +1,24 @@
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolGeneratorOptions : TRegistrableGeneratorOptions<LuaSolGenerator>
+    {
+        public LuaSolNamingStrategy NamingStrategy;
+
+        public LuaSolGeneratorOptions(LuaSolGenerator generator) : base(generator)
+        {
+            NamingStrategy = new LuaSolNamingStrategy(generator);
+        }
+
+        public override string DefaultRootContextType => "::sol::state_view&";
+
+        public override string DefaultRootContextName => "state";
+
+        public override string DefaultTemplateContextDefaultType => "::sol::table";
+
+        public override string DefaultTemplateContextDefaultValue => "::sol::nil";
+
+        public override string DefaultCmakeVariableHeader => "LUA_SOL_BINDINGS_HEADER";
+
+        public override string DefaultCmakeVariableSource => "LUA_SOL_BINDINGS_SOURCE";
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolHeaders.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolHeaders.cs
new file mode 100644
index 000000000..acc9fe919
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolHeaders.cs
@@ -0,0 +1,82 @@
+using System.Collections.Generic;
+using CppSharp.AST;
+
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolHeaders : LuaSolSources
+    {
+        public LuaSolHeaders(LuaSolGenerator generator, IEnumerable<TranslationUnit> units)
+            : base(generator, units)
+        {
+        }
+
+        public override string FileExtension => "h";
+
+        protected override bool TemplateAllowed { get { return true; } }
+
+        public override void Process()
+        {
+            GenerateFilePreamble(CommentKind.BCPL);
+
+            PushBlock();
+            WriteLine("#pragma once");
+            PopBlock(NewLineKind.BeforeNextBlock);
+
+            TranslationUnit.Visit(this);
+        }
+
+        #region TranslationUnit
+
+        public virtual void GenerateTranslationUnitRegistrationFunctionDeclaration(TranslationUnit translationUnit)
+        {
+            NewLine();
+            GenerateTranslationUnitRegistrationFunctionSignature(translationUnit);
+            WriteLine(";");
+            NewLine();
+        }
+
+        public override void GenerateTranslationUnit(TranslationUnit translationUnit)
+        {
+            GenerateTranslationUnitNamespaceBegin(translationUnit);
+            GenerateTranslationUnitRegistrationFunctionBody(translationUnit);
+            GenerateTranslationUnitRegistrationFunctionDeclaration(translationUnit);
+            GenerateTranslationUnitNamespaceEnd(translationUnit);
+        }
+
+        public override bool CanGenerateTranslationUnit(TranslationUnit unit)
+        {
+            if (AlreadyVisited(unit))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        public override bool VisitTranslationUnit(TranslationUnit unit)
+        {
+            if (!CanGenerateTranslationUnit(unit))
+            {
+                return false;
+            }
+
+            GenerateTranslationUnit(unit);
+
+            return true;
+        }
+
+        #endregion
+
+        public virtual void GenerateMain()
+        {
+            VisitNamespace(TranslationUnit);
+        }
+
+        public virtual void GenerateIncludes()
+        {
+            if (Generator.GeneratorOptions.BaseInclude != null)
+            {
+                WriteLineIndent(Generator.GeneratorOptions.BaseInclude.ToString());
+            }
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolNamingStrategy.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolNamingStrategy.cs
new file mode 100644
index 000000000..2f26269ba
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolNamingStrategy.cs
@@ -0,0 +1,10 @@
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolNamingStrategy : RegistrableNamingStrategy<LuaSolGenerator>
+    {
+        public LuaSolNamingStrategy(LuaSolGenerator generator)
+            : base(generator)
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolSources.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolSources.cs
new file mode 100644
index 000000000..f1a15576b
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolSources.cs
@@ -0,0 +1,2068 @@
+using CppSharp.AST;
+using CppSharp.Generators.C;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolSources : RegistrableSources<LuaSolGenerator>
+    {
+        protected LuaSolGenerationContext GenerationContext { get; }
+        protected LuaSolNamingStrategy NamingStrategy => Generator.GeneratorOptions.NamingStrategy;
+
+        public LuaSolSources(LuaSolGenerator generator, IEnumerable<TranslationUnit> units)
+            : base(generator, units)
+        {
+            GenerationContext = new LuaSolGenerationContext();
+        }
+
+        public override string FileExtension { get { return "cpp"; } }
+
+        protected virtual bool TemplateAllowed { get { return false; } }
+
+        protected bool NonTemplateAllowed { get { return !TemplateAllowed || GenerationContext.PeekTemplateLevel() != 0; } }
+
+        public override void Process()
+        {
+            GenerateFilePreamble(CommentKind.BCPL);
+
+            PushBlock(BlockKind.Includes);
+            var file = Context.Options.GetIncludePath(TranslationUnit);
+            WriteLine($"#include \"{file}\"");
+
+            NewLine();
+            PopBlock();
+
+            TranslationUnit.Visit(this);
+
+            PushBlock(BlockKind.Footer);
+            PopBlock();
+        }
+
+        public virtual void GenerateDeclarationGlobalStateRegistration(Declaration declaration)
+        {
+            if (declaration.Access != AccessSpecifier.Protected)
+            {
+                if (declaration.OriginalNamespace is not Class)
+                {
+                    Write(NamingStrategy.GetBindingContext(declaration, GenerationContext));
+                }
+                else
+                {
+                    Write($"{NamingStrategy.GetRootContextName(GenerationContext)}[{NamingStrategy.GetBindingIdValue(declaration.Namespace, GenerationContext)}]");
+                }
+                Write($"[{NamingStrategy.GetRegistrationNameQuoted(declaration)}] = ");
+                Write($"{NamingStrategy.GetRootContextName(GenerationContext)}[{NamingStrategy.GetBindingIdName(declaration)}];");
+                NewLine();
+            }
+        }
+
+        public virtual void GenerateDeclarationContainerList(DeclarationContext declaration)
+        {
+            List<Declaration> containerList = declaration.Declarations.Where(declaration =>
+            {
+                if (declaration is Namespace || declaration is Enumeration)
+                {
+                    return true;
+                }
+                else if (declaration is Class)
+                {
+                    return Utils.FindDescribedTemplate(declaration) == null;
+                }
+                return false;
+            }).ToList();
+            containerList.Sort((x, y) => x.LineNumberStart.CompareTo(y.LineNumberStart));
+            foreach (var item in containerList)
+            {
+                item.Visit(this);
+            };
+
+            if (NonTemplateAllowed)
+            {
+                List<ClassTemplate> classTemplateList = declaration.Templates.Where(template => template is ClassTemplate).Cast<ClassTemplate>().ToList();
+                classTemplateList.Sort((x, y) => x.LineNumberStart.CompareTo(y.LineNumberStart));
+                foreach (var classTemplate in classTemplateList)
+                {
+                    if (Utils.IsDefaultTemplateParameterList(classTemplate.Parameters))
+                    {
+                        Write(string.Format("{0}<>{{}}({1}",
+                            NamingStrategy.GetClassTemplateName(classTemplate),
+                            NamingStrategy.GetRootContextName(GenerationContext)
+                        ));
+                        if (classTemplate.OriginalName != classTemplate.Name)
+                        {
+                            Write(", ");
+                            Write(NamingStrategy.GetRootContextName(GenerationContext));
+                            Write(", ");
+                            Write(classTemplate.Name);
+                        }
+                        WriteLine(");");
+                    }
+
+                    foreach (var classTemplateSpecialization in classTemplate.Specializations)
+                    {
+                        if (classTemplateSpecialization is not ClassTemplatePartialSpecialization)
+                        {
+                            if (classTemplateSpecialization.SpecializationKind == TemplateSpecializationKind.ExplicitSpecialization)
+                            {
+                                Write(string.Format("{0}<{1}>{{}}({2}",
+                                    NamingStrategy.GetClassTemplateName(classTemplateSpecialization),
+                                    NamingStrategy.PrintClassTemplateSpecializationArguments(classTemplateSpecialization.Arguments, false),
+                                    NamingStrategy.GetRootContextName(GenerationContext)
+                                ));
+                                if (classTemplateSpecialization.OriginalName != classTemplateSpecialization.Name)
+                                {
+                                    Write(", ");
+                                    Write(NamingStrategy.GetRootContextName(GenerationContext));
+                                    Write(", ");
+                                    Write(classTemplateSpecialization.Name);
+                                }
+                                WriteLine(");");
+                            }
+                        }
+                    }
+                };
+            }
+        }
+
+        public virtual void GenerateDeclarationTemplateList(DeclarationContext declaration)
+        {
+            if (!TemplateAllowed)
+            {
+                return;
+            }
+
+            List<Declaration> containerList = declaration.Declarations.Where(declaration =>
+            {
+                if (declaration is Namespace || declaration is Enumeration)
+                {
+                    return true;
+                }
+                else if (declaration is Class)
+                {
+                    return Utils.FindDescribedTemplate(declaration) == null;
+                }
+                return false;
+            }).ToList();
+            containerList.Sort((x, y) => x.LineNumberStart.CompareTo(y.LineNumberStart));
+            foreach (var item in containerList)
+            {
+                if (item.Access == AccessSpecifier.Protected)
+                {
+                    item.Visit(this);
+                }
+                else
+                {
+                    GenerateDeclarationTemplateList((DeclarationContext)item);
+                }
+            };
+
+            List<ClassTemplate> classTemplateList = declaration.Templates.Where(template => template is ClassTemplate).Cast<ClassTemplate>().ToList();
+            classTemplateList.Sort((x, y) => x.LineNumberStart.CompareTo(y.LineNumberStart));
+            foreach (var classTemplate in classTemplateList)
+            {
+                classTemplate.Visit(this);
+                foreach (var classTemplateSpecialization in classTemplate.Specializations)
+                {
+                    classTemplateSpecialization.Visit(this);
+                }
+            };
+
+            //List<Template> functionTemplateList = declaration.Templates.Where(template => template is FunctionTemplate).ToList();
+            //functionTemplateList.Sort((x, y) => x.LineNumberStart.CompareTo(y.LineNumberStart));
+            //foreach (var item in functionTemplateList)
+            //{
+            //    item.Visit(this);
+            //};
+        }
+
+        #region TranslationUnit
+
+        public virtual void GenerateTranslationUnitRegistrationFunctionSignature(TranslationUnit translationUnit)
+        {
+            var generatorOptions = Generator.GeneratorOptions;
+            Write("void ");
+            Write(generatorOptions.NamingStrategy.GetRegistrationFunctionName(translationUnit));
+            Write($"({generatorOptions.RootContextType} {generatorOptions.RootContextName})");
+        }
+
+        public virtual void GenerateTranslationUnitNamespaceBegin(TranslationUnit translationUnit)
+        {
+            PushBlock(BlockKind.Namespace);
+            WriteLine($"namespace {TranslationUnit.Module.OutputNamespace} {{");
+        }
+
+        public virtual void GenerateTranslationUnitNamespaceEnd(TranslationUnit translationUnit)
+        {
+            WriteLine($"}}  // namespace {TranslationUnit.Module.OutputNamespace}");
+            PopBlock();
+        }
+
+        public virtual void GenerateTranslationUnitRegistrationFunctionBegin(TranslationUnit translationUnit)
+        {
+            PushBlock(BlockKind.Function);
+            NewLine();
+            GenerateTranslationUnitRegistrationFunctionSignature(translationUnit);
+            WriteLine(" {");
+            Indent();
+        }
+
+        public virtual void GenerateTranslationUnitRegistrationFunctionBody(TranslationUnit translationUnit)
+        {
+            GenerateDeclarationTemplateList(translationUnit);
+            GenerateDeclarationContainerList(translationUnit);
+
+            GenerationContext.Scoped(RegistrableGeneratorContext.IsDetach, DetachmentOption.On, () =>
+            {
+                foreach (var variable in translationUnit.Variables)
+                {
+                    variable.Visit(this);
+                }
+
+                var methods = translationUnit.Functions.Where(method => !(method.IsOperator));
+                var overloads = methods.GroupBy(m => m.Name);
+                foreach (var overload in overloads)
+                {
+                    GenerateFunctions(translationUnit, overload.ToList());
+                }
+
+                foreach (var typedef in translationUnit.Typedefs)
+                {
+                    typedef.Visit(this);
+                }
+            });
+        }
+
+        public virtual void GenerateTranslationUnitRegistrationFunctionEnd(TranslationUnit translationUnit)
+        {
+            Unindent();
+            WriteLine("}");
+            NewLine();
+            PopBlock(NewLineKind.BeforeNextBlock);
+        }
+
+        public virtual void GenerateTranslationUnit(TranslationUnit translationUnit)
+        {
+            GenerateTranslationUnitNamespaceBegin(translationUnit);
+            GenerateTranslationUnitRegistrationFunctionBegin(translationUnit);
+            GenerateTranslationUnitRegistrationFunctionBody(translationUnit);
+            GenerateTranslationUnitRegistrationFunctionEnd(translationUnit);
+            GenerateTranslationUnitNamespaceEnd(translationUnit);
+        }
+
+        public virtual bool CanGenerateTranslationUnit(TranslationUnit unit)
+        {
+            if (AlreadyVisited(unit))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        public override bool VisitTranslationUnit(TranslationUnit unit)
+        {
+            if (!CanGenerateTranslationUnit(unit))
+            {
+                return false;
+            }
+
+            GenerateTranslationUnit(unit);
+
+            return true;
+        }
+
+        #endregion
+
+        #region Namespace
+
+        public virtual void GenerateNamespaceDebugName(Namespace @namespace)
+        {
+            WriteLine($"/* {NamingStrategy.GetFullyQualifiedName(@namespace, FQNOption.IgnoreNone)} */");
+        }
+
+        public virtual void GenerateNamespaceHeader(Namespace @namespace)
+        {
+            WriteLine("{");
+            Indent();
+        }
+
+        public virtual void GenerateNamespaceBegin(Namespace @namespace)
+        {
+            Write($"auto {NamingStrategy.GetBindingName(@namespace)} = ");
+            Write(NamingStrategy.GetBindingContextNamespacePredicate(
+                NamingStrategy.GetBindingContext(@namespace, GenerationContext),
+                @namespace.Name)
+            );
+            WriteLine(";");
+        }
+
+        public virtual void GenerateNamespaceBody(Namespace @namespace)
+        {
+            GenerateNamespaceDeclarationList(@namespace, DetachmentOption.Off);
+        }
+
+        public virtual void GenerateNamespaceDeclarationList(Namespace @namespace, DetachmentOption detachment)
+        {
+            GenerateNamespaceContainerList(@namespace);
+            GenerateNamespaceTemplates(@namespace);
+            GenerateNamespaceTypedefs(@namespace);
+            GenerationContext.Scoped(RegistrableGeneratorContext.IsDetach, DetachmentOption.On, () =>
+            {
+                GenerateNamespaceFunctions(@namespace);
+                GenerateNamespaceVariables(@namespace);
+
+                var methods = @namespace.Functions.Where(method => !(method.IsOperator));
+                var overloads = methods.GroupBy(m => m.Name);
+                foreach (var overload in overloads)
+                {
+                    GenerateFunctions(@namespace, overload.ToList());
+                }
+
+                foreach (var typedef in @namespace.Typedefs)
+                {
+                    typedef.Visit(this);
+                }
+            });
+        }
+
+        public virtual void GenerateNamespaceContainerList(Namespace @namespace)
+        {
+            GenerateDeclarationContainerList(@namespace);
+        }
+
+        public virtual void GenerateNamespaceTemplates(Namespace @namespace)
+        {
+        }
+
+        public virtual void GenerateNamespaceTypedefs(Namespace @namespace)
+        {
+        }
+
+        public virtual void GenerateNamespaceFunctions(Namespace @namespace)
+        {
+        }
+
+        public virtual void GenerateNamespaceVariables(Namespace @namespace)
+        {
+            foreach (var variable in @namespace.Variables)
+            {
+                variable.Visit(this);
+            }
+        }
+
+        public virtual void GenerateNamespaceEnd(Namespace @namespace)
+        {
+            //GenerateNamespaceDeclarationList(@namespace, DetachmentOption.On);
+        }
+
+        public virtual void GenerateNamespaceGlobalStateRegistration(Namespace @namespace)
+        {
+        }
+
+        public virtual void GenerateNamespaceFooter(Namespace @namespace)
+        {
+            Unindent();
+            WriteLine("}");
+        }
+
+        public virtual void GenerateNamespace(Namespace @namespace)
+        {
+            GenerateNamespaceDebugName(@namespace);
+            GenerateNamespaceHeader(@namespace);
+            GenerateNamespaceBegin(@namespace);
+            GenerateNamespaceBody(@namespace);
+            GenerateNamespaceEnd(@namespace);
+            GenerateNamespaceGlobalStateRegistration(@namespace);
+            GenerateNamespaceFooter(@namespace);
+        }
+
+        public virtual bool CanGenerateNamespace(Namespace @namespace)
+        {
+            if (AlreadyVisited(@namespace))
+            {
+                return false;
+            }
+            else if (@namespace.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            return @namespace.IsGenerated;
+        }
+
+        public override bool VisitNamespace(Namespace @namespace)
+        {
+            if (!CanGenerateNamespace(@namespace))
+            {
+                return false;
+            }
+
+            GenerateNamespace(@namespace);
+
+            return true;
+        }
+
+        #endregion
+
+        #region Enumeration
+
+        public virtual void GenerateEnumDeclItem(Enumeration enumeration, Enumeration.Item item)
+        {
+            Write(",");
+            NewLine();
+            Write($"\"{item.Name}\", {NamingStrategy.GetFullyQualifiedName(item, FQNOption.IgnoreNone)}");
+        }
+
+        public virtual void GenerateEnumDeclItemList(Enumeration enumeration, List<Enumeration.Item> items)
+        {
+            foreach (var item in items)
+            {
+                GenerateEnumDeclItem(enumeration, item);
+            }
+        }
+
+        #region Enumeration Anonymous
+
+        public virtual void GenerateEnumDeclAnonymousItem(Enumeration enumeration, Enumeration.Item item)
+        {
+            WriteLine($"{NamingStrategy.GetRootContextName(GenerationContext)}[\"{item.Name}\"] = {item.OriginalName};");
+        }
+
+        public virtual void GenerateEnumDeclAnonymousItemList(Enumeration enumeration, List<Enumeration.Item> items)
+        {
+            foreach (var item in items)
+            {
+                GenerateEnumDeclAnonymousItem(enumeration, item);
+            }
+        }
+
+        public virtual void GenerateEnumDeclAnonymous(Enumeration enumeration)
+        {
+            GenerateEnumDeclAnonymousItemList(enumeration, enumeration.Items);
+        }
+
+        #endregion
+
+        #region Enumeration Non Scoped
+
+        public virtual void GenerateEnumDeclNonScoped(Enumeration enumeration)
+        {
+            GenerateEnumDeclScoped(enumeration);
+            GenerateEnumDeclAnonymous(enumeration);
+        }
+
+        #endregion
+
+        #region Enumeration Scoped
+
+        public virtual void GenerateEnumDeclScopedDebugName(Enumeration enumeration)
+        {
+            WriteLine($"/* {NamingStrategy.GetFullyQualifiedName(enumeration, FQNOption.IgnoreNone)} */");
+        }
+
+        public virtual void GenerateEnumDeclScopedHeader(Enumeration enumeration)
+        {
+            WriteLine("{");
+            Indent();
+        }
+
+        public virtual void GenerateEnumDeclScopedBindingIdName(Enumeration enumeration)
+        {
+            WriteLine($"auto {NamingStrategy.GetBindingIdName(enumeration)} = {NamingStrategy.GetBindingIdValue(enumeration, GenerationContext)};");
+        }
+
+        public virtual void GenerateEnumDeclScopedBegin(Enumeration enumeration)
+        {
+            WriteLine($"auto {NamingStrategy.GetBindingName(enumeration)} = {NamingStrategy.GetRootContextName(GenerationContext)}.new_enum<>(");
+            Indent();
+            Write(NamingStrategy.GetBindingIdName(enumeration));
+        }
+
+        public virtual void GenerateEnumDeclScopedItemList(Enumeration enumeration)
+        {
+            GenerateEnumDeclItemList(enumeration, enumeration.Items);
+        }
+
+        public virtual void GenerateEnumDeclScopedBody(Enumeration enumeration)
+        {
+            GenerateEnumDeclScopedItemList(enumeration);
+            GenerateEnumDeclScopedDeclarationList(enumeration, DetachmentOption.Off);
+        }
+
+        public virtual void GenerateEnumDeclScopedDeclarationList(Enumeration enumeration, DetachmentOption detachment)
+        {
+            if (detachment == DetachmentOption.Off)
+            {
+                GenerateEnumDeclScopedFunctions(enumeration);
+                GenerateEnumDeclScopedVariables(enumeration);
+            }
+            else
+            {
+                GenerateEnumDeclScopedContainerList(enumeration);
+                GenerateEnumDeclScopedTemplates(enumeration);
+                GenerateEnumDeclScopedTypedefs(enumeration);
+                GenerateEnumDeclScopedFunctions(enumeration);
+                GenerateEnumDeclScopedVariables(enumeration);
+            }
+        }
+
+        public virtual void GenerateEnumDeclScopedContainerList(Enumeration enumeration)
+        {
+            GenerateDeclarationContainerList(enumeration);
+        }
+
+        public virtual void GenerateEnumDeclScopedTemplates(Enumeration enumeration)
+        {
+        }
+
+        public virtual void GenerateEnumDeclScopedTypedefs(Enumeration enumeration)
+        {
+        }
+
+        public virtual void GenerateEnumDeclScopedFunctions(Enumeration enumeration)
+        {
+        }
+
+        public virtual void GenerateEnumDeclScopedVariables(Enumeration enumeration)
+        {
+        }
+
+        public virtual void GenerateEnumDeclScopedEnd(Enumeration enumeration)
+        {
+            Unindent();
+            NewLine();
+            WriteLine(");");
+            GenerateEnumDeclScopedDeclarationList(enumeration, DetachmentOption.On);
+        }
+
+        public virtual void GenerateEnumDeclScopedGlobalStateRegistration(Enumeration enumeration)
+        {
+            GenerateDeclarationGlobalStateRegistration(enumeration);
+        }
+
+        public virtual void GenerateEnumDeclScopedFooter(Enumeration enumeration)
+        {
+            Unindent();
+            WriteLine("}");
+        }
+
+        public virtual void GenerateEnumDeclScoped(Enumeration enumeration)
+        {
+            GenerateEnumDeclScopedDebugName(enumeration);
+            GenerateEnumDeclScopedHeader(enumeration);
+            GenerateEnumDeclScopedBindingIdName(enumeration);
+            GenerateEnumDeclScopedBegin(enumeration);
+            GenerateEnumDeclScopedBody(enumeration);
+            GenerateEnumDeclScopedEnd(enumeration);
+            GenerateEnumDeclScopedGlobalStateRegistration(enumeration);
+            GenerateEnumDeclScopedFooter(enumeration);
+        }
+
+        #endregion
+
+        public virtual void GenerateEnumDecl(Enumeration enumeration)
+        {
+            if (enumeration.IsScoped)
+            {
+                GenerateEnumDeclScoped(enumeration);
+            }
+            else
+            {
+                if (string.IsNullOrEmpty(enumeration.OriginalName))
+                {
+                    GenerateEnumDeclAnonymous(enumeration);
+                }
+                else
+                {
+                    GenerateEnumDeclNonScoped(enumeration);
+                }
+            }
+        }
+
+        public virtual bool CanGenerateEnumDecl(Enumeration enumeration)
+        {
+            if (AlreadyVisited(enumeration))
+            {
+                return false;
+            }
+            else if (enumeration.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            return enumeration.IsGenerated;
+        }
+
+        public override bool VisitEnumDecl(Enumeration enumeration)
+        {
+            if (!CanGenerateEnumDecl(enumeration))
+            {
+                return false;
+            }
+
+            GenerateEnumDecl(enumeration);
+
+            return true;
+        }
+
+        #endregion
+
+        #region Class
+
+        public virtual void GenerateClassDeclDebugName(Class @class)
+        {
+            WriteLine($"/* {NamingStrategy.GetFullyQualifiedName(@class, FQNOption.IgnoreNone)} */");
+        }
+
+        public virtual void GenerateClassDeclHeader(Class @class)
+        {
+            WriteLine("{");
+            Indent();
+        }
+
+        public virtual void GenerateClassDeclBindingIdName(Class @class)
+        {
+            WriteLine($"auto {NamingStrategy.GetBindingIdName(@class)} = {NamingStrategy.GetBindingIdValue(@class, GenerationContext)};");
+        }
+
+        public virtual void GenerateClassDeclBegin(Class @class)
+        {
+            Write($"auto {NamingStrategy.GetBindingName(@class)} = {NamingStrategy.GetRootContextName(GenerationContext)}.");
+            if (TemplateAllowed)
+            {
+                Write("template ");
+            }
+            WriteLine($"new_usertype<{NamingStrategy.GetContextualName(@class, GenerationContext, FQNOption.IgnoreNone)}>(");
+            Indent();
+            Write(NamingStrategy.GetBindingIdName(@class));
+        }
+
+        public virtual void GenerateClassDeclBody(Class @class)
+        {
+            GenerateClassDeclDeclarationList(@class, DetachmentOption.Off);
+        }
+
+        public virtual void GenerateClassDeclDeclarationList(Class @class, DetachmentOption detachment)
+        {
+            if (detachment == DetachmentOption.Off)
+            {
+                GenerateConstructors(@class, @class.Constructors);
+
+                var methods = @class.Methods.Where(method => !(method.IsConstructor || method.IsDestructor || method.IsOperator));
+                var overloads = methods.GroupBy(m => m.Name);
+                foreach (var overload in overloads)
+                {
+                    GenerateMethods(@class, overload.ToList());
+                }
+
+                GenerateClassDeclFunctions(@class);
+                GenerateClassDeclVariables(@class);
+            }
+            else
+            {
+                GenerateClassDeclContainerList(@class);
+                GenerateClassDeclTemplates(@class);
+                GenerateClassDeclTypedefs(@class);
+                GenerateClassDeclFunctions(@class);
+                GenerateClassDeclVariables(@class);
+            }
+        }
+
+        public virtual void GenerateClassDeclContainerList(Class @class)
+        {
+            GenerateDeclarationContainerList(@class);
+        }
+
+        public virtual void GenerateClassDeclTemplates(Class @class)
+        {
+        }
+
+        public virtual void GenerateClassDeclTypedefs(Class @class)
+        {
+        }
+
+        public virtual void GenerateClassDeclFunctions(Class @class)
+        {
+        }
+
+        public virtual void GenerateClassDeclVariables(Class @class)
+        {
+            foreach (var field in @class.Fields)
+            {
+                field.Visit(this);
+            }
+            foreach (var variable in @class.Variables)
+            {
+                variable.Visit(this);
+            }
+        }
+
+        public virtual void GenerateClassDeclEnd(Class @class)
+        {
+            Unindent();
+            NewLine();
+            WriteLine(");");
+            GenerateClassDeclDeclarationList(@class, DetachmentOption.On);
+        }
+
+        public virtual void GenerateClassDeclGlobalStateRegistration(Class @class)
+        {
+            GenerateDeclarationGlobalStateRegistration(@class);
+        }
+
+        public virtual void GenerateClassDeclFooter(Class @class)
+        {
+            Unindent();
+            WriteLine("}");
+        }
+
+        public virtual void GenerateClassDecl(Class @class)
+        {
+            GenerateClassDeclDebugName(@class);
+            GenerateClassDeclHeader(@class);
+            GenerateClassDeclBindingIdName(@class);
+            GenerateClassDeclBegin(@class);
+            GenerateClassDeclBody(@class);
+            GenerateClassDeclEnd(@class);
+            GenerateClassDeclGlobalStateRegistration(@class);
+            GenerateClassDeclFooter(@class);
+        }
+
+        public virtual bool CanGenerateClassDecl(Class @class)
+        {
+            if (AlreadyVisited(@class))
+            {
+                return false;
+            }
+            else if (@class.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (@class.IsIncomplete)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            else if (Utils.FindDescribedTemplate(@class) != null)
+            {
+                return false;
+            }
+            return @class.IsGenerated;
+        }
+
+        public override bool VisitClassDecl(Class @class)
+        {
+            if (IsClassDeclImported(@class))
+            {
+                if (!CanGenerateClassDeclImported(@class))
+                {
+                    return false;
+                }
+
+                GenerateClassDeclImported(@class);
+            }
+            else
+            {
+                if (!CanGenerateClassDecl(@class))
+                {
+                    return false;
+                }
+
+                GenerateClassDecl(@class);
+            }
+
+            return true;
+        }
+
+        #endregion
+
+        #region Field
+
+        #region Field
+
+        public virtual bool CanGenerateFieldDecl(Field field)
+        {
+            if (AlreadyVisited(field))
+            {
+                return false;
+            }
+            else if (field.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            return field.IsGenerated;
+        }
+
+        public virtual bool GenerateFieldDecl(Field field)
+        {
+            var isDetach = GenerationContext.PeekIsDetach(DetachmentOption.Off);
+
+            if (isDetach == DetachmentOption.Forced || isDetach == Utils.FindDetachmentOption(field))
+            {
+                string fieldName = field.Name;
+                string fieldNameQuoted = $"\"{fieldName}\"";
+                string fieldContextualName = NamingStrategy.GetContextualName(field, GenerationContext, FQNOption.IgnoreNone);
+
+                if (isDetach != DetachmentOption.Off)
+                {
+                    Write($"{NamingStrategy.GetBindingContext(field, GenerationContext)}[{fieldNameQuoted}] = ");
+                }
+                else
+                {
+                    WriteLine(",");
+                    Write($"{fieldNameQuoted}, ");
+                }
+                // TODO : check for typemaps!!!
+                {
+                    Write($"&{fieldContextualName}");
+                }
+                if (isDetach != DetachmentOption.Off)
+                {
+                    WriteLine(";");
+                }
+            }
+
+            return true;
+        }
+
+        #endregion
+
+        #region Bitfield
+
+        public virtual bool CanGenerateFieldDeclBitfield(Field field)
+        {
+            if (AlreadyVisited(field))
+            {
+                return false;
+            }
+            else if (field.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            return field.IsGenerated;
+        }
+
+        public virtual bool GenerateFieldDeclBitfield(Field field)
+        {
+            var isDetach = GenerationContext.PeekIsDetach(DetachmentOption.Off);
+
+            if (isDetach == DetachmentOption.Forced || isDetach == Utils.FindDetachmentOption(field))
+            {
+                string bitfieldOriginalName = field.OriginalName;
+                string bitfieldName = field.Name;
+                string bitfieldNameQuoted = $"\"{bitfieldName}\"";
+                string bitfieldCppContext = NamingStrategy.GetCppContext(field, GenerationContext, FQNOption.IgnoreNone);
+                string bitfieldType = field.Type.Visit(new CppTypePrinter(Context));
+
+                if (isDetach != DetachmentOption.Off)
+                {
+                    Write($"{NamingStrategy.GetBindingContext(field, GenerationContext)}[{bitfieldNameQuoted}] = ");
+                }
+                else
+                {
+                    WriteLine(",");
+                    Write($"{bitfieldNameQuoted}, ");
+                }
+                WriteLine("::sol::property(");
+                Indent();
+                WriteLine($"[]({bitfieldCppContext}& self) {{");
+                Indent();
+                WriteLine($"return self.{bitfieldOriginalName};");
+                Unindent();
+                WriteLine("}, ");
+                WriteLine($"[]({bitfieldCppContext}& self, {bitfieldType} value) {{");
+                Indent();
+                WriteLine($"self.{bitfieldOriginalName} = value;");
+                Unindent();
+                WriteLine("}");
+                Unindent();
+                Write(")");
+                if (isDetach != DetachmentOption.Off)
+                {
+                    WriteLine(";");
+                }
+            }
+
+            return true;
+        }
+
+        #endregion
+
+        public override bool VisitFieldDecl(Field field)
+        {
+            if (field.IsBitField)
+            {
+                if (!CanGenerateFieldDeclBitfield(field))
+                {
+                    return false;
+                }
+
+                return GenerateFieldDeclBitfield(field);
+            }
+            else
+            {
+                if (!CanGenerateFieldDecl(field))
+                {
+                    return false;
+                }
+
+                return GenerateFieldDecl(field);
+            }
+            return false;
+        }
+
+        #endregion
+
+        #region Variable
+
+        public virtual bool CanGenerateVariableDecl(Variable variable)
+        {
+            if (AlreadyVisited(variable))
+            {
+                return false;
+            }
+            else if (variable.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            return variable.IsGenerated;
+        }
+
+        public virtual bool GenerateVariableDecl(Variable variable)
+        {
+            var isDetach = GenerationContext.PeekIsDetach(DetachmentOption.Off);
+
+            if (isDetach == DetachmentOption.Forced || isDetach == Utils.FindDetachmentOption(variable))
+            {
+                string variableName = variable.Name;
+                string variableNameQuoted = $"\"{variableName}\"";
+                string variableBindingContext = NamingStrategy.GetBindingContext(variable, GenerationContext);
+                string variableContextualName = NamingStrategy.GetContextualName(variable, GenerationContext, FQNOption.IgnoreNone);
+                // TODO: Bug in sol until it gets resolved: we can only bind static class variable by reference.
+                if (variable.OriginalNamespace is Class)
+                {
+                    variableContextualName = $"::std::ref({variableContextualName})";
+                }
+
+                // TODO: check for typemaps!!!
+                if (isDetach != DetachmentOption.Off)
+                {
+                    WriteLine($"{variableBindingContext}[{variableNameQuoted}] = ::sol::var({variableContextualName});");
+                }
+                else
+                {
+                    WriteLine(",");
+                    Write($"{variableNameQuoted}, ::sol::var({variableContextualName})");
+                }
+            }
+
+            return true;
+        }
+
+        public override bool VisitVariableDecl(Variable variable)
+        {
+            if (!CanGenerateVariableDecl(variable))
+            {
+                return false;
+            }
+
+            return GenerateVariableDecl(variable);
+        }
+
+        #endregion
+
+        #region Constructor
+
+        public virtual bool NeedExpansionForConstructors(Class @class, IEnumerable<Method> constructors)
+        {
+            return false;
+        }
+
+        public virtual void GenerateConstructors(Class @class, IEnumerable<Method> constructors)
+        {
+            var isDetach = GenerationContext.PeekIsDetach();
+
+            List<Method> filteredConstructors = constructors.Where((method) => CanGenerateConstructor(method)).ToList();
+            if (filteredConstructors.Any())
+            {
+                Method constructor = filteredConstructors.First();
+                string constructorBindingContext = NamingStrategy.GetBindingContext(constructor, GenerationContext);
+                string constructorContextualName = NamingStrategy.GetContextualName(constructor, GenerationContext, FQNOption.IgnoreNone);
+
+                if (isDetach == DetachmentOption.Forced || isDetach == Utils.FindDetachmentOption(constructor))
+                {
+
+                    if (isDetach != DetachmentOption.Off)
+                    {
+                        Write($"{constructorBindingContext}[\"new\"] = ");
+                    }
+                    else
+                    {
+                        WriteLine(",");
+                        Write($"\"new\", ");
+                    }
+                    if (NeedExpansionForConstructors(@class, constructors))
+                    {
+                        Write("::sol::factories(");
+                        Indent();
+                        for (int i = 0; i < filteredConstructors.Count; i++)
+                        {
+                            if (i > 0)
+                            {
+                                Write(",");
+                            }
+                            NewLine();
+                            GenerateConstructor(@class, filteredConstructors[i], true);
+                        }
+                        Unindent();
+                        WriteLine(")");
+                    }
+                    else
+                    {
+                        Write("::sol::constructors<");
+                        Indent();
+                        for (int i = 0; i < filteredConstructors.Count; i++)
+                        {
+                            if (i > 0)
+                            {
+                                Write(",");
+                            }
+                            NewLine();
+                            GenerateConstructor(@class, filteredConstructors[i], false);
+                        }
+                        Unindent();
+                        NewLine();
+                        Write(">()");
+                    }
+                    if (isDetach != DetachmentOption.Off)
+                    {
+                        WriteLine(";");
+                    }
+                }
+            }
+        }
+
+        public virtual bool CanGenerateConstructor(Method constructor)
+        {
+            if (AlreadyVisited(constructor))
+            {
+                return false;
+            }
+            else if (constructor.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            else if (Utils.FindDescribedTemplate(constructor) != null)
+            {
+                return false;
+            }
+            return constructor.IsGenerated;
+        }
+
+        public virtual void GenerateConstructor(Class @class, Method constructor, bool doExpand)
+        {
+            if (doExpand)
+            {
+                // TODO: Implement when ready
+            }
+            else
+            {
+                Write(NamingStrategy.GetCppContext(constructor, GenerationContext, FQNOption.IgnoreNone));
+                Write("(");
+                var needsComma = false;
+                foreach (var parameter in constructor.Parameters)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    else
+                    {
+                        needsComma = true;
+                    }
+                    Write(parameter.Type.Visit(new CppTypePrinter(Context)));
+                }
+                if (constructor.IsVariadic)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    Write("...");
+                }
+                Write(")");
+            }
+        }
+
+        #endregion
+
+        #region Function
+
+        public virtual bool NeedExpansionForFunctions(Declaration declaration, IEnumerable<Function> functions)
+        {
+            return false;
+        }
+
+        public virtual void GenerateFunctions(Declaration declaration, IEnumerable<Function> functions)
+        {
+            var isDetach = GenerationContext.PeekIsDetach();
+
+            List<Function> filteredFunctions = functions.Where((function) => CanGenerateFunction(function)).ToList();
+            if (filteredFunctions.Any())
+            {
+                Function function = filteredFunctions.First();
+                string functionName = function.Name;
+                string functionNameQuoted = $"\"{functionName}\"";
+                string functionBindingContext = NamingStrategy.GetBindingContext(function, GenerationContext);
+                string functionContextualName = NamingStrategy.GetContextualName(function, GenerationContext, FQNOption.IgnoreNone);
+
+                if (isDetach == DetachmentOption.Forced || isDetach == Utils.FindDetachmentOption(function))
+                {
+
+                    if (isDetach != DetachmentOption.Off)
+                    {
+                        Write($"{functionBindingContext}[{functionNameQuoted}] = ");
+                    }
+                    else
+                    {
+                        WriteLine(",");
+                        Write($"{functionNameQuoted}, ");
+                    }
+                    if (filteredFunctions.Count == 1)
+                    {
+                        GenerateFunction(declaration, filteredFunctions.First());
+                    }
+                    else
+                    {
+                        Write("::sol::overload(");
+                        Indent();
+                        for (int i = 0; i < filteredFunctions.Count; i++)
+                        {
+                            if (i > 0)
+                            {
+                                Write(",");
+                            }
+                            NewLine();
+                            GenerateFunction(declaration, filteredFunctions[i]);
+                        }
+                        Unindent();
+                        NewLine();
+                        Write(")");
+                    }
+                    if (isDetach != DetachmentOption.Off)
+                    {
+                        WriteLine(";");
+                    }
+                }
+            }
+        }
+
+        public virtual bool CanGenerateFunction(Function function)
+        {
+            if (AlreadyVisited(function))
+            {
+                return false;
+            }
+            else if (function.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            else if (Utils.FindDescribedTemplate(function) != null)
+            {
+                return false;
+            }
+            return function.IsGenerated;
+        }
+
+        public virtual void GenerateFunction(Declaration declaration, Function function)
+        {
+            if (Utils.HasPossibleTemplateOverload(function))
+            {
+                Write("static_cast<");
+                Write(function.ReturnType.Visit(new CppTypePrinter(Context)));
+                Write("(");
+                Write("*)");
+                Write("(");
+                var needsComma = false;
+                foreach (var parameter in function.Parameters)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    else
+                    {
+                        needsComma = true;
+                    }
+                    Write(parameter.Type.Visit(new CppTypePrinter(Context)));
+                }
+                if (function.IsVariadic)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    Write("...");
+                }
+                Write(")");
+                Write(">(&");
+                Write(NamingStrategy.GetContextualName(function, GenerationContext, FQNOption.IgnoreNone));
+                Write(")");
+            }
+            else if (Utils.HasPossibleOverload(function))
+            {
+                Write("::sol::resolve<");
+                Write(function.ReturnType.Visit(new CppTypePrinter(Context)));
+                Write("(");
+                var needsComma = false;
+                foreach (var parameter in function.Parameters)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    else
+                    {
+                        needsComma = true;
+                    }
+                    Write(parameter.Type.Visit(new CppTypePrinter(Context)));
+                }
+                if (function.IsVariadic)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    Write("...");
+                }
+                Write(")");
+                Write(">(&");
+                Write(NamingStrategy.GetContextualName(function, GenerationContext, FQNOption.IgnoreNone));
+                Write(")");
+            }
+            else
+            {
+                Write(string.Format("&{0}",
+                    NamingStrategy.GetContextualName(function, GenerationContext, FQNOption.IgnoreNone)
+                ));
+            }
+        }
+
+        #endregion
+
+        #region Method
+
+        public virtual bool NeedExpansionForMethods(Class @class, IEnumerable<Method> methods)
+        {
+            return false;
+        }
+
+        public virtual void GenerateMethods(Class @class, IEnumerable<Method> methods)
+        {
+            var isDetach = GenerationContext.PeekIsDetach();
+
+            List<Method> filteredMethods = methods.Where((method) => CanGenerateMethod(method)).ToList();
+            if (filteredMethods.Any())
+            {
+                Method method = filteredMethods.First();
+                string methodName = method.Name;
+                string methodNameQuoted = $"\"{methodName}\"";
+                string methodBindingContext = NamingStrategy.GetBindingContext(method, GenerationContext);
+                string methodContextualName = NamingStrategy.GetContextualName(method, GenerationContext, FQNOption.IgnoreNone);
+
+                if (isDetach == DetachmentOption.Forced || isDetach == Utils.FindDetachmentOption(method))
+                {
+
+                    if (isDetach != DetachmentOption.Off)
+                    {
+                        Write($"{methodBindingContext}[{methodNameQuoted}] = ");
+                    }
+                    else
+                    {
+                        WriteLine(",");
+                        Write($"{methodNameQuoted}, ");
+                    }
+                    if (filteredMethods.Count == 1)
+                    {
+                        GenerateMethod(@class, filteredMethods.First());
+                    }
+                    else
+                    {
+                        Write("::sol::overload(");
+                        Indent();
+                        for (int i = 0; i < filteredMethods.Count; i++)
+                        {
+                            if (i > 0)
+                            {
+                                Write(",");
+                            }
+                            NewLine();
+                            GenerateMethod(@class, filteredMethods[i]);
+                        }
+                        Unindent();
+                        NewLine();
+                        Write(")");
+                    }
+                    if (isDetach != DetachmentOption.Off)
+                    {
+                        WriteLine(";");
+                    }
+                }
+            }
+        }
+
+        public virtual bool CanGenerateMethod(Method method)
+        {
+            if (AlreadyVisited(method))
+            {
+                return false;
+            }
+            else if (method.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            else if (Utils.FindDescribedTemplate(method) != null)
+            {
+                return false;
+            }
+            return method.IsGenerated;
+        }
+
+        public virtual void GenerateMethod(Class @class, Method method)
+        {
+            if (Utils.HasPossibleTemplateOverload(method))
+            {
+                Write("static_cast<");
+                Write(method.ReturnType.Visit(new CppTypePrinter(Context)));
+                Write("(");
+                Write($"{NamingStrategy.GetMembershipScopeName(method, GenerationContext)}*)");
+                Write("(");
+                var needsComma = false;
+                foreach (var parameter in method.Parameters)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    else
+                    {
+                        needsComma = true;
+                    }
+                    Write(parameter.Type.Visit(new CppTypePrinter(Context)));
+                }
+                if (method.IsVariadic)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    Write("...");
+                }
+                Write(")");
+                Write(">(&");
+                Write(NamingStrategy.GetContextualName(method, GenerationContext, FQNOption.IgnoreNone));
+                Write(")");
+            }
+            else if (Utils.HasPossibleOverload(method))
+            {
+                Write("::sol::resolve<");
+                Write(method.ReturnType.Visit(new CppTypePrinter(Context)));
+                Write("(");
+                var needsComma = false;
+                foreach (var parameter in method.Parameters)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    else
+                    {
+                        needsComma = true;
+                    }
+                    Write(parameter.Type.Visit(new CppTypePrinter(Context)));
+                }
+                if (method.IsVariadic)
+                {
+                    if (needsComma)
+                    {
+                        Write(", ");
+                    }
+                    Write("...");
+                }
+                Write(")");
+                Write(">(&");
+                Write(NamingStrategy.GetContextualName(method, GenerationContext, FQNOption.IgnoreNone));
+                Write(")");
+            }
+            else
+            {
+                Write(string.Format("&{0}",
+                    NamingStrategy.GetContextualName(method, GenerationContext, FQNOption.IgnoreNone)
+                ));
+            }
+        }
+
+        #endregion
+
+        #region Typedef
+
+        public virtual bool CanGenerateTypedefNameDecl(TypedefNameDecl typedef)
+        {
+            if (AlreadyVisited(typedef))
+            {
+                return false;
+            }
+            else if (typedef.Access != AccessSpecifier.Public)
+            {
+                return false;
+            }
+            else if (!NonTemplateAllowed)
+            {
+                return false;
+            }
+            return typedef.IsGenerated;
+        }
+
+        public virtual void GenerateTypedefNameDecl(TypedefNameDecl typedef)
+        {
+            var type = typedef.Type;
+            if (type is TemplateSpecializationType templateSpecializationType)
+            {
+                string typedefName = typedef.Name;
+                string typedefNameQuoted = $"\"{typedefName}\"";
+                string typedefRegistrationFunctionName = NamingStrategy.GetFullyQualifiedName(templateSpecializationType.GetClassTemplateSpecialization(), new FQNOption()
+                {
+                    IgnoreTemplateTypenameKeyword = true
+                });
+                string typedefBindingContext = NamingStrategy.GetBindingContext(typedef, GenerationContext);
+                string typedefRootContextName = NamingStrategy.GetRootContextName(GenerationContext);
+
+                WriteLine($"//TODO: global{typedefRegistrationFunctionName}{{}}({typedefRootContextName}, {typedefBindingContext}, {typedefNameQuoted}); /* directly */");
+            }
+        }
+
+        public override bool VisitTypedefNameDecl(TypedefNameDecl typedef)
+        {
+            if (!CanGenerateTypedefNameDecl(typedef))
+            {
+                return false;
+            }
+
+            GenerateTypedefNameDecl(typedef);
+
+            return true;
+        }
+
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
+        {
+            return VisitTypedefNameDecl(typedef);
+        }
+
+        public override bool VisitTypeAliasDecl(TypeAlias typeAlias)
+        {
+            return VisitTypedefNameDecl(typeAlias);
+        }
+
+        #endregion
+
+        #region Template
+
+        #region ClassDeclImported
+
+        public virtual string GetClassDeclImportedClassType(Class @class)
+        {
+            return "auto";
+        }
+
+        public virtual void GenerateClassDeclImportedClassValueType(Class @class)
+        {
+            var classContextualName = NamingStrategy.GetContextualName(@class, GenerationContext, FQNOption.IgnoreNone);
+            WriteLine($"using value_type = ::sol::usertype<{classContextualName}>;");
+        }
+
+        public virtual void GenerateClassDeclImportedClassBegin(Class @class)
+        {
+            WriteLine($"template <typename Importer>");
+            WriteLine($"struct {NamingStrategy.GetClassTemplateName(@class)} {{");
+            Indent();
+            GenerateClassDeclImportedClassValueType(@class);
+            GenerateDeclarationTemplateList(@class);
+            WriteLine(string.Format("template <typename {0}, typename {1} = {2}>",
+                Generator.GeneratorOptions.TemplateTypenameState,
+                Generator.GeneratorOptions.TemplateTypenameContext,
+                Generator.GeneratorOptions.TemplateContextDefaultType
+            ));
+            WriteLine(string.Format("{0} operator()({1}&& {2}, {3}&& {4} = {5}, const ::std::string& {6} = {{}}) {{",
+                GetClassDeclImportedClassType(@class),
+                Generator.GeneratorOptions.TemplateTypenameState,
+                Generator.GeneratorOptions.TemplateIdentifierState,
+                Generator.GeneratorOptions.TemplateTypenameContext,
+                Generator.GeneratorOptions.TemplateIdentifierContext,
+                Generator.GeneratorOptions.TemplateContextDefaultValue,
+                "name"
+            ));
+            Indent();
+        }
+
+        public virtual void GenerateClassDeclImportedClassEnd(Class @class)
+        {
+            Unindent();
+            WriteLine("}");
+            Unindent();
+            WriteLine("};");
+        }
+
+        public virtual void GenerateClassDeclImportedClassBody(Class @class)
+        {
+            var bindingName = NamingStrategy.GetBindingName(@class);
+            var contextualName = NamingStrategy.GetContextualName(@class, GenerationContext, FQNOption.IgnoreNone);
+            var fullyQualifiedName = NamingStrategy.GetFullyQualifiedName(@class, FQNOption.IgnoreNone);
+            var templateIdentifierContext = Generator.GeneratorOptions.TemplateIdentifierContext;
+            var templateIdentifierState = Generator.GeneratorOptions.TemplateIdentifierState;
+
+            WriteLine(string.Format("const char* {0} = typeid({1}).name();",
+                "__typeid_name",
+                contextualName
+            ));
+            WriteLine(string.Format("if ({0}[{1}] == ::sol::nil) {{",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+            Indent();
+
+            WriteLine(string.Format("/* FullyQualifiedName: {0} */",
+                fullyQualifiedName
+            ));
+            WriteLine(string.Format("auto {0} = {1}.template new_usertype<{2}>(",
+                bindingName,
+                templateIdentifierState,
+                contextualName
+            ));
+            Indent();
+            Write("__typeid_name");
+            GenerateClassDeclDeclarationList(@class, DetachmentOption.Off);
+            Unindent();
+            NewLine();
+            WriteLine(");");
+
+            Unindent();
+            WriteLine("}");
+            WriteLine(string.Format("if (!{0}.empty()) {{",
+                "name"
+            ));
+            Indent();
+            WriteLine(string.Format("{0}[{1}] = {2}[{3}];",
+                templateIdentifierContext,
+                "name",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+            Unindent();
+            WriteLine("}");
+            WriteLine(string.Format("return {0}[{1}];",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+        }
+
+        public virtual void GenerateClassDeclImportedClassPushContext(Class @class)
+        {
+            GenerationContext.PushTemplateLevel(1);
+            GenerationContext.PushRootContextName(Generator.GeneratorOptions.TemplateIdentifierState);
+            GenerationContext.PushCppContext(new CppContext()
+            {
+                FullyQualifiedName = string.Format("Importer::template {0}",
+                    NamingStrategy.GetQualifiedName(@class, FQNOption.IgnoreNone)
+                ),
+                Option = FQNOption.IgnoreNone
+            });
+        }
+
+        public virtual void GenerateClassDeclImportedClassPopContext(Class @class)
+        {
+            GenerationContext.PopCppContext();
+            GenerationContext.PopRootContextName();
+            GenerationContext.PopTemplateLevel();
+        }
+
+        public virtual bool IsClassDeclImported(Class @class)
+        {
+            return @class.Access == AccessSpecifier.Protected;
+        }
+
+        public virtual bool CanGenerateClassDeclImported(Class @class)
+        {
+            if (AlreadyVisited(@class))
+            {
+                return false;
+            }
+            else if (@class.Access != AccessSpecifier.Protected)
+            {
+                return false;
+            }
+            else if (@class.IsIncomplete)
+            {
+                return false;
+            }
+            else if (@class.IsUnion)
+            {
+                return false;
+            }
+            else if (!TemplateAllowed)
+            {
+                return false;
+            }
+            else if (Utils.FindDescribedTemplate(@class) != null)
+            {
+                return false;
+            }
+            return @class.IsGenerated;
+        }
+
+        public virtual void GenerateClassDeclImported(Class @class)
+        {
+            GenerateClassDeclImportedClassPushContext(@class);
+
+            GenerateClassDeclImportedClassBegin(@class);
+            GenerateClassDeclImportedClassBody(@class);
+            GenerateClassDeclImportedClassEnd(@class);
+
+            GenerateClassDeclImportedClassPopContext(@class);
+        }
+
+        #endregion
+
+        #region ClassTemplate
+
+        public virtual string GetClassTemplateDeclFunctorReturnType(ClassTemplate template)
+        {
+            return "auto";
+        }
+
+        public virtual void GenerateClassTemplateDeclFunctorValueType(ClassTemplate template)
+        {
+            var contextualName = NamingStrategy.GetContextualName(template, GenerationContext, FQNOption.IgnoreNone);
+
+            WriteLine(string.Format("using value_type = ::sol::usertype<{0}>;",
+                contextualName
+            ));
+        }
+
+        public virtual void GenerateClassTemplateDeclBegin(ClassTemplate template)
+        {
+            Write("template <");
+            if (template.Access == AccessSpecifier.Protected)
+            {
+                Write("typename Importer>");
+                if (template.Parameters.Count > 0)
+                {
+                    Write(", ");
+                }
+            }
+            Write(NamingStrategy.PrintClassTemplateParameters(template.Parameters, false, TemplateParameterOption.AsParameter));
+            WriteLine(">");
+            WriteLine($"struct {NamingStrategy.GetClassTemplateName(template)} {{");
+            Indent();
+            GenerateClassTemplateDeclFunctorValueType(template);
+            GenerateDeclarationTemplateList(template.TemplatedClass);
+            WriteLine(string.Format("template <typename {0}, typename {1} = {2}>",
+                Generator.GeneratorOptions.TemplateTypenameState,
+                Generator.GeneratorOptions.TemplateTypenameContext,
+                Generator.GeneratorOptions.TemplateContextDefaultType
+            ));
+            WriteLine(string.Format("{0} operator()({1}&& {2}, {3}&& {4} = {5}, const ::std::string& {6} = {{}}) {{",
+                GetClassTemplateDeclFunctorReturnType(template),
+                Generator.GeneratorOptions.TemplateTypenameState,
+                Generator.GeneratorOptions.TemplateIdentifierState,
+                Generator.GeneratorOptions.TemplateTypenameContext,
+                Generator.GeneratorOptions.TemplateIdentifierContext,
+                Generator.GeneratorOptions.TemplateContextDefaultValue,
+                "name"
+            ));
+            Indent();
+        }
+
+        public virtual void GenerateClassTemplateDeclEnd(ClassTemplate template)
+        {
+            Unindent();
+            WriteLine("}");
+            Unindent();
+            WriteLine("};");
+        }
+
+        public virtual void GenerateClassTemplateDeclBody(ClassTemplate template)
+        {
+            var bindingName = NamingStrategy.GetBindingName(template);
+            var contextualName = NamingStrategy.GetContextualName(template, GenerationContext, FQNOption.IgnoreNone);
+            var fullyQualifiedName = NamingStrategy.GetFullyQualifiedName(template, FQNOption.IgnoreNone);
+            var templateIdentifierContext = Generator.GeneratorOptions.TemplateIdentifierContext;
+            var templateIdentifierState = Generator.GeneratorOptions.TemplateIdentifierState;
+
+            WriteLine(string.Format("const char* {0} = typeid({1}).name();",
+                "__typeid_name",
+                contextualName
+            ));
+            WriteLine(string.Format("if ({0}[{1}] == ::sol::nil) {{",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+            Indent();
+
+            WriteLine(string.Format("/* FullyQualifiedName: {0} */",
+                fullyQualifiedName
+            ));
+            WriteLine(string.Format("auto {0} = {1}.template new_usertype<{2}>(",
+                bindingName,
+                templateIdentifierState,
+                contextualName
+            ));
+            Indent();
+            Write("__typeid_name");
+            GenerateClassDeclDeclarationList(template.TemplatedClass, DetachmentOption.Off);
+            Unindent();
+            NewLine();
+            WriteLine(");");
+
+            Unindent();
+            WriteLine("}");
+            WriteLine(string.Format("if (!{0}.empty()) {{",
+                "name"
+            ));
+            Indent();
+            WriteLine(string.Format("{0}[{1}] = {2}[{3}];",
+                templateIdentifierContext,
+                "name",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+            Unindent();
+            WriteLine("}");
+            WriteLine(string.Format("return {0}[{1}];",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+        }
+
+        public virtual void GenerateClassTemplateDeclPushContext(ClassTemplate template)
+        {
+            GenerationContext.PushTemplateLevel(1);
+            GenerationContext.PushRootContextName(Generator.GeneratorOptions.TemplateIdentifierState);
+            if (template.Access == AccessSpecifier.Protected)
+            {
+                if (Generator.GeneratorOptions.ImportedTemplateMode == ImportedClassTemplateMode.Indirect)
+                {
+                    GenerationContext.PushCppContext(new CppContext()
+                    {
+                        FullyQualifiedName = string.Format("Temp_{0}",
+                            NamingStrategy.GetQualifiedName(template, FQNOption.IgnoreNone)
+                        )
+                    });
+                }
+                else
+                {
+                    GenerationContext.PushCppContext(new CppContext()
+                    {
+                        FullyQualifiedName = string.Format("Importer::template {0}",
+                            NamingStrategy.GetQualifiedName(template, FQNOption.IgnoreNone)
+                        )
+                    });
+                }
+            }
+        }
+
+        public virtual void GenerateClassTemplateDeclPopContext(ClassTemplate template)
+        {
+            if (template.Access == AccessSpecifier.Protected)
+            {
+                GenerationContext.PopCppContext();
+            }
+            GenerationContext.PopRootContextName();
+            GenerationContext.PopTemplateLevel();
+        }
+
+        public virtual bool CanGenerateClassTemplateDecl(ClassTemplate template)
+        {
+            if (AlreadyVisited(template))
+            {
+                return false;
+            }
+            else if (template.Access == AccessSpecifier.Private)
+            {
+                return false;
+            }
+            else if (template.IsIncomplete)
+            {
+                return false;
+            }
+            else if (!TemplateAllowed)
+            {
+                return false;
+            }
+            return template.IsGenerated;
+        }
+
+        public virtual void GenerateClassTemplateDecl(ClassTemplate template)
+        {
+            GenerateClassTemplateDeclPushContext(template);
+
+            GenerateClassTemplateDeclBegin(template);
+            GenerateClassTemplateDeclBody(template);
+            GenerateClassTemplateDeclEnd(template);
+
+            GenerateClassTemplateDeclPopContext(template);
+        }
+
+        public override bool VisitClassTemplateDecl(ClassTemplate template)
+        {
+            if (!CanGenerateClassTemplateDecl(template))
+            {
+                return false;
+            }
+
+            GenerateClassTemplateDecl(template);
+
+            return true;
+        }
+
+        #endregion
+
+        #region ClassTemplateSpecialization
+
+        public virtual string GetClassTemplateSpecializationDeclFunctorReturnType(ClassTemplateSpecialization specialization)
+        {
+            return "auto";
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDeclFunctorValueType(ClassTemplateSpecialization specialization)
+        {
+            var contextualName = NamingStrategy.GetContextualName(specialization, GenerationContext, FQNOption.IgnoreNone);
+
+            WriteLine(string.Format("using value_type = ::sol::usertype<{0}>;",
+                contextualName
+            ));
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDeclBegin(ClassTemplateSpecialization specialization)
+        {
+            ClassTemplatePartialSpecialization classTemplatePartialSpecialization = specialization as ClassTemplatePartialSpecialization;
+            Write("template <");
+            if (specialization.Access == AccessSpecifier.Protected)
+            {
+                Write("typename Importer>");
+                if (classTemplatePartialSpecialization != null)
+                {
+                    if (classTemplatePartialSpecialization.Parameters.Count > 0)
+                    {
+                        Write(", ");
+                    }
+                }
+            }
+            if (classTemplatePartialSpecialization != null)
+            {
+                Write(NamingStrategy.PrintClassTemplateParameters(classTemplatePartialSpecialization.Parameters, false, TemplateParameterOption.AsParameter));
+            }
+            WriteLine(">");
+            WriteLine(string.Format("struct {0}{1} {{",
+                NamingStrategy.GetClassTemplateName(specialization),
+                NamingStrategy.PrintClassTemplateSpecializationArguments(specialization.Arguments, true)
+            ));
+            Indent();
+            GenerateClassTemplateSpecializationDeclFunctorValueType(specialization);
+            GenerateDeclarationTemplateList(specialization);
+            WriteLine(string.Format("template <typename {0}, typename {1} = {2}>",
+                Generator.GeneratorOptions.TemplateTypenameState,
+                Generator.GeneratorOptions.TemplateTypenameContext,
+                Generator.GeneratorOptions.TemplateContextDefaultType
+            ));
+            WriteLine(string.Format("{0} operator()({1}&& {2}, {3}&& {4} = {5}, const ::std::string& {6} = {{}}) {{",
+                GetClassTemplateSpecializationDeclFunctorReturnType(specialization),
+                Generator.GeneratorOptions.TemplateTypenameState,
+                Generator.GeneratorOptions.TemplateIdentifierState,
+                Generator.GeneratorOptions.TemplateTypenameContext,
+                Generator.GeneratorOptions.TemplateIdentifierContext,
+                Generator.GeneratorOptions.TemplateContextDefaultValue,
+                "name"
+            ));
+            Indent();
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDeclEnd(ClassTemplateSpecialization specialization)
+        {
+            Unindent();
+            WriteLine("}");
+            Unindent();
+            WriteLine("};");
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDeclBody(ClassTemplateSpecialization specialization)
+        {
+            var bindingName = NamingStrategy.GetBindingName(specialization);
+            var contextualName = NamingStrategy.GetContextualName(specialization, GenerationContext, FQNOption.IgnoreNone);
+            var fullyQualifiedName = NamingStrategy.GetFullyQualifiedName(specialization, FQNOption.IgnoreNone);
+            var templateIdentifierContext = Generator.GeneratorOptions.TemplateIdentifierContext;
+            var templateIdentifierState = Generator.GeneratorOptions.TemplateIdentifierState;
+
+            WriteLine(string.Format("const char* {0} = typeid({1}).name();",
+                "__typeid_name",
+                contextualName
+            ));
+            WriteLine(string.Format("if ({0}[{1}] == ::sol::nil) {{",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+            Indent();
+
+            WriteLine(string.Format("/* FullyQualifiedName: {0} */",
+                fullyQualifiedName
+            ));
+            WriteLine(string.Format("auto {0} = {1}.template new_usertype<{2}>(",
+                bindingName,
+                templateIdentifierState,
+                contextualName
+            ));
+            Indent();
+            Write("__typeid_name");
+            GenerateClassDeclDeclarationList(specialization, DetachmentOption.Off);
+            Unindent();
+            NewLine();
+            WriteLine(");");
+
+            Unindent();
+            WriteLine("}");
+            WriteLine(string.Format("if (!{0}.empty()) {{",
+                "name"
+            ));
+            Indent();
+            WriteLine(string.Format("{0}[{1}] = {2}[{3}];",
+                templateIdentifierContext,
+                "name",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+            Unindent();
+            WriteLine("}");
+            WriteLine(string.Format("return {0}[{1}];",
+                templateIdentifierState,
+                "__typeid_name"
+            ));
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDeclPushContext(ClassTemplateSpecialization specialization)
+        {
+            GenerationContext.PushTemplateLevel(1);
+            GenerationContext.PushRootContextName(Generator.GeneratorOptions.TemplateIdentifierState);
+            if (specialization.Access == AccessSpecifier.Protected)
+            {
+                if (Generator.GeneratorOptions.ImportedTemplateMode == ImportedClassTemplateMode.Indirect)
+                {
+                    GenerationContext.PushCppContext(new CppContext()
+                    {
+                        FullyQualifiedName = string.Format("Temp_{0}",
+                            NamingStrategy.GetQualifiedName(specialization, FQNOption.IgnoreNone)
+                        )
+                    });
+                }
+                else
+                {
+                    GenerationContext.PushCppContext(new CppContext()
+                    {
+                        FullyQualifiedName = string.Format("Importer::template {0}",
+                            NamingStrategy.GetQualifiedName(specialization, FQNOption.IgnoreNone)
+                        )
+                    });
+                }
+            }
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDeclPopContext(ClassTemplateSpecialization specialization)
+        {
+            if (specialization.Access == AccessSpecifier.Protected)
+            {
+                GenerationContext.PopCppContext();
+            }
+            GenerationContext.PopRootContextName();
+            GenerationContext.PopTemplateLevel();
+        }
+
+        public virtual bool CanGenerateClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
+        {
+            if (AlreadyVisited(specialization))
+            {
+                return false;
+            }
+            else if (specialization.Access == AccessSpecifier.Private)
+            {
+                return false;
+            }
+            else if (specialization.IsIncomplete)
+            {
+                return false;
+            }
+            else if (!TemplateAllowed)
+            {
+                return false;
+            }
+            return specialization.IsGenerated;
+        }
+
+        public virtual void GenerateClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
+        {
+            GenerateClassTemplateSpecializationDeclPushContext(specialization);
+
+            GenerateClassTemplateSpecializationDeclBegin(specialization);
+            GenerateClassTemplateSpecializationDeclBody(specialization);
+            GenerateClassTemplateSpecializationDeclEnd(specialization);
+
+            GenerateClassTemplateSpecializationDeclPopContext(specialization);
+        }
+
+        public override bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
+        {
+            if (!CanGenerateClassTemplateSpecializationDecl(specialization))
+            {
+                return false;
+            }
+
+            GenerateClassTemplateSpecializationDecl(specialization);
+
+            return true;
+        }
+
+        #endregion
+
+        #endregion
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Lua/Sol/LuaSolTypePrinter.cs b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolTypePrinter.cs
new file mode 100644
index 000000000..c6c5b51b3
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Lua/Sol/LuaSolTypePrinter.cs
@@ -0,0 +1,12 @@
+using CppSharp.Generators;
+using CppSharp.Generators.C;
+
+namespace CppSharp.Generators.Registrable.Lua.Sol
+{
+    public class LuaSolTypePrinter : CppTypePrinter
+    {
+        public LuaSolTypePrinter(BindingContext context) : base(context)
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableCodeGenerator.cs b/src/Generator/Generators/Registrable/RegistrableCodeGenerator.cs
new file mode 100644
index 000000000..b537d9fe7
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableCodeGenerator.cs
@@ -0,0 +1,16 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable
+{
+    public abstract class RegistrableCodeGenerator<TGenerator> : CodeGenerator
+        where TGenerator : Generator
+    {
+        public TGenerator Generator { get; set; }
+
+        public RegistrableCodeGenerator(TGenerator generator, IEnumerable<TranslationUnit> units) : base(generator.Context, units)
+        {
+            Generator = generator;
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableGenerator.cs b/src/Generator/Generators/Registrable/RegistrableGenerator.cs
new file mode 100644
index 000000000..00017d80b
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableGenerator.cs
@@ -0,0 +1,64 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+using System.IO;
+
+namespace CppSharp.Generators.Registrable
+{
+    public abstract class RegistrableGenerator<TOptions, THeader, TSource> : Generator
+        where TOptions : RegistrableGeneratorOptions
+        where THeader : CodeGenerator
+        where TSource : CodeGenerator
+    {
+        public TOptions GeneratorOptions { get; }
+
+        public TranslationUnit GlobalTranslationUnit { get; private set; }
+
+        public TranslationUnit InheritanceTranslationUnit { get; private set; }
+
+        // TODO: Implement when Generator interface is cleaner
+        // public CodeGenerator ModuleHeaderCodeGenerator { get; private set; }
+
+        // TODO: Implement when Generator interface is cleaner
+        //public CodeGenerator ModuleSourceCodeGenerator { get; private set; }
+
+        public RegistrableGenerator(BindingContext context) : base(context)
+        {
+            GeneratorOptions = CreateOptions();
+        }
+
+        protected abstract TOptions CreateOptions();
+
+        protected abstract THeader CreateHeader(IEnumerable<TranslationUnit> units);
+
+        protected abstract TSource CreateSource(IEnumerable<TranslationUnit> units);
+
+        public override List<CodeGenerator> Generate(IEnumerable<TranslationUnit> units)
+        {
+            return new List<CodeGenerator>
+            {
+                CreateHeader(units),
+                CreateSource(units)
+            };
+        }
+
+        // TODO: Should be a better method for this maybe Configure.
+        public override bool SetupPasses()
+        {
+            {
+                var module = Context.Options.Modules[1];
+                GlobalTranslationUnit = Context.ASTContext.FindOrCreateTranslationUnit(
+                    Path.Combine(Context.Options.OutputDir, GeneratorOptions.OutputSubDir, "@package", "global.h")
+                );
+                GlobalTranslationUnit.Module = module;
+            }
+            {
+                var module = Context.Options.Modules[1];
+                InheritanceTranslationUnit = Context.ASTContext.FindOrCreateTranslationUnit(
+                    Path.Combine(Context.Options.OutputDir, GeneratorOptions.OutputSubDir, "@package", "inheritance.h")
+                );
+                InheritanceTranslationUnit.Module = module;
+            }
+            return true;
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableGeneratorContext.cs b/src/Generator/Generators/Registrable/RegistrableGeneratorContext.cs
new file mode 100644
index 000000000..2b55f8f92
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableGeneratorContext.cs
@@ -0,0 +1,129 @@
+namespace CppSharp.Generators.Registrable
+{
+    public class RegistrableGeneratorContext : InfoMapStack<object>
+    {
+        public static readonly InfoEntry IndentLevel = new("CppSharp.Generators.Registrable.IndentLevel");
+        public static readonly InfoEntry IsDetach = new("CppSharp.Generators.Registrable.IsDetach");
+        public static readonly InfoEntry RootContextName = new("CppSharp.Generators.Registrable.RootContextName");
+        public static readonly InfoEntry BindingContext = new("CppSharp.Generators.Registrable.BindingContext");
+        public static readonly InfoEntry CppContext = new("CppSharp.Generators.Registrable.CppContext");
+        public static readonly InfoEntry SanitizeType = new("CppSharp.Generators.Registrable.SanitizeType");
+        public static readonly InfoEntry TypeArgumentsPack = new("CppSharp.Generators.Registrable.TypeArgumentsPack");
+        public static readonly InfoEntry Resolvable = new("CppSharp.Generators.Registrable.Resolvable");
+        public static readonly InfoEntry TemplateLevel = new("CppSharp.Generators.Registrable.TemplateLevel");
+
+        public RegistrableGeneratorContext()
+        {
+        }
+
+        public DetachmentOption PeekIsDetach()
+        {
+            return PeekIsDetach(DetachmentOption.Off);
+        }
+
+        public DetachmentOption PeekIsDetach(DetachmentOption defaultValue)
+        {
+            return Peek(IsDetach, defaultValue);
+        }
+
+        public void PushIsDetach(DetachmentOption item)
+        {
+            Push(IsDetach, item);
+        }
+
+        public DetachmentOption PopIsDetach()
+        {
+            return Pop<DetachmentOption>(IsDetach);
+        }
+
+        public string PeekRootContextName(string defaultValue = default)
+        {
+            return Peek(RootContextName, defaultValue);
+        }
+
+        public void PushRootContextName(string item)
+        {
+            Push(RootContextName, item);
+        }
+
+        public string PopRootContextName()
+        {
+            return Pop<string>(RootContextName);
+        }
+
+        public string PeekBindingContext(string defaultValue = default)
+        {
+            return Peek(BindingContext, defaultValue);
+        }
+
+        public void PushBindingContext(string item)
+        {
+            Push(BindingContext, item);
+        }
+
+        public string PopBindingContext()
+        {
+            return Pop<string>(BindingContext);
+        }
+
+        public CppContext PeekCppContext(CppContext defaultValue = default)
+        {
+            return Peek(CppContext, defaultValue);
+        }
+
+        public void PushCppContext(CppContext item)
+        {
+            Push(CppContext, item);
+        }
+
+        public CppContext PopCppContext()
+        {
+            return Pop<CppContext>(CppContext);
+        }
+
+        public int PeekTemplateLevel(int defaultValue = default)
+        {
+            return Peek(TemplateLevel, defaultValue);
+        }
+
+        public void PushTemplateLevel(int item)
+        {
+            Push(TemplateLevel, item);
+        }
+
+        public int PopTemplateLevel()
+        {
+            return Pop<int>(TemplateLevel);
+        }
+    }
+
+    public class CppContext
+    {
+        public string FullyQualifiedName { get; set; }
+        public FQNOption Option { get; set; } = FQNOption.IgnoreAll;
+
+        public string GetFullQualifiedName(FQNOption option)
+        {
+            if (!option.IgnoreTemplateTypenameKeyword)
+            {
+                if (!Option.IgnoreTemplateTypenameKeyword)
+                {
+                    return "typename " + FullyQualifiedName;
+                }
+            }
+            return FullyQualifiedName;
+        }
+
+        public string GetFullQualifiedName()
+        {
+            return GetFullQualifiedName(FQNOption.IgnoreNone);
+        }
+    };
+
+    public enum DetachmentOption
+    {
+        On,
+        Off,
+        Forced
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableGeneratorOptions.cs b/src/Generator/Generators/Registrable/RegistrableGeneratorOptions.cs
new file mode 100644
index 000000000..d8b1b7371
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableGeneratorOptions.cs
@@ -0,0 +1,98 @@
+using CppSharp.Generators.C;
+
+namespace CppSharp.Generators.Registrable
+{
+    public enum ImportedClassTemplateMode
+    {
+        Direct,
+        Indirect,
+        Import
+    }
+
+    public abstract class RegistrableGeneratorOptions
+    {
+        public delegate string Delegate(string name);
+
+        public virtual Generator Generator { get; set; }
+
+        public virtual string OutputSubDir { get; }
+        public virtual string RootContextType { get; }
+        public virtual string RootContextName { get; }
+        public virtual string RegisterFunctionName { get; }
+        public virtual CInclude? BaseInclude { get; }
+        public Delegate BindingIdNamePredicate { get; }
+        public Delegate BindingIdValuePredicate { get; }
+        public Delegate BindingNamePredicate { get; }
+        public string TemplateTypenameState { get; }
+        public string TemplateTypenameContext { get; }
+        public string TemplateIdentifierState { get; }
+        public string TemplateIdentifierContext { get; }
+        public string TemplateContextDefaultType { get; }
+        public string TemplateContextDefaultValue { get; }
+        public ImportedClassTemplateMode ImportedTemplateMode { get; }
+        public string CppValidatorFileName { get; }
+        public string CmakeVariableHeader { get; }
+        public string CmakeVariableSource { get; }
+        public string EqualityFunctionTemplateFullyQualifiedName { get; }
+        public string StaticCastFunctionTemplateFullyQualifiedName { get; }
+        public string DynamicCastFunctionTemplateFullyQualifiedName { get; }
+
+        public virtual string DefaultOutputSubdir => "";
+        public abstract string DefaultRootContextType { get; }
+        public abstract string DefaultRootContextName { get; }
+        public virtual string DefaultRegisterFunctionName => "register_";
+        public virtual CInclude? DefaultBaseInclude => null;
+        public virtual Delegate DefaultBindingIdNamePredicate => (string name) => $"_cppbind_id_{name}";
+        public virtual Delegate DefaultBindingIdValuePredicate => (string name) => $"typeid({name}).name()";
+        public virtual Delegate DefaultBindingNamePredicate => (string name) => $"_cppbind_{name}";
+        public virtual string DefaultTemplateTypenameState => "CppBindState";
+        public virtual string DefaultTemplateTypenameContext => "CppBindContext";
+        public virtual string DefaultTemplateIdentifierState => "cpp_bind_state";
+        public virtual string DefaultTemplateIdentifierContext => "cpp_bind_context";
+        public abstract string DefaultTemplateContextDefaultType { get; }
+        public abstract string DefaultTemplateContextDefaultValue { get; }
+        public virtual ImportedClassTemplateMode DefaultImportedTemplateMode => ImportedClassTemplateMode.Indirect;
+        public virtual string DefaulCppValidatorFileName => "_cppbind_validator_";
+        public virtual string DefaultCmakeVariableHeader => "BINDINGS_HEADER";
+        public virtual string DefaultCmakeVariableSource => "BINDINGS_SOURCE";
+        public virtual string DefaultEqualityFunctionTemplateFullyQualifiedName => null;
+        public virtual string DefaultStaticCastFunctionTemplateFullyQualifiedName => null;
+        public virtual string DefaultDynamicCastFunctionTemplateFullyQualifiedName => null;
+
+        public RegistrableGeneratorOptions(Generator generator)
+        {
+            Generator = generator;
+            OutputSubDir = DefaultOutputSubdir;
+            RootContextType = DefaultRootContextType;
+            RootContextName = DefaultRootContextName;
+            RegisterFunctionName = DefaultRegisterFunctionName;
+            BaseInclude = DefaultBaseInclude;
+            BindingIdNamePredicate = DefaultBindingIdNamePredicate;
+            BindingIdValuePredicate = DefaultBindingIdValuePredicate;
+            BindingNamePredicate = DefaultBindingNamePredicate;
+            TemplateTypenameState = DefaultTemplateTypenameState;
+            TemplateTypenameContext = DefaultTemplateTypenameContext;
+            TemplateIdentifierState = DefaultTemplateIdentifierState;
+            TemplateIdentifierContext = DefaultTemplateIdentifierContext;
+            TemplateContextDefaultType = DefaultTemplateContextDefaultType;
+            TemplateContextDefaultValue = DefaultTemplateContextDefaultValue;
+            ImportedTemplateMode = DefaultImportedTemplateMode;
+            CppValidatorFileName = DefaulCppValidatorFileName;
+            CmakeVariableHeader = DefaultCmakeVariableHeader;
+            CmakeVariableSource = DefaultCmakeVariableSource;
+            EqualityFunctionTemplateFullyQualifiedName = DefaultEqualityFunctionTemplateFullyQualifiedName;
+            StaticCastFunctionTemplateFullyQualifiedName = DefaultStaticCastFunctionTemplateFullyQualifiedName;
+            DynamicCastFunctionTemplateFullyQualifiedName = DefaultDynamicCastFunctionTemplateFullyQualifiedName;
+        }
+    }
+
+    public abstract class TRegistrableGeneratorOptions<TGenerator> : RegistrableGeneratorOptions
+        where TGenerator : Generator
+    {
+        public override TGenerator Generator => (TGenerator)base.Generator;
+
+        public TRegistrableGeneratorOptions(TGenerator generator) : base(generator)
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableHeaders.cs b/src/Generator/Generators/Registrable/RegistrableHeaders.cs
new file mode 100644
index 000000000..7ee159fb4
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableHeaders.cs
@@ -0,0 +1,13 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable
+{
+    public abstract class RegistrableHeaders<TGenerator> : RegistrableCodeGenerator<TGenerator>
+        where TGenerator : Generator
+    {
+        public RegistrableHeaders(TGenerator generator, IEnumerable<TranslationUnit> units) : base(generator, units)
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableInfoEntries.cs b/src/Generator/Generators/Registrable/RegistrableInfoEntries.cs
new file mode 100644
index 000000000..35e384057
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableInfoEntries.cs
@@ -0,0 +1,6 @@
+namespace CppSharp.Generators.Registrable
+{
+    public class RegistrableInfoEntries
+    {
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableModuleHeader.cs b/src/Generator/Generators/Registrable/RegistrableModuleHeader.cs
new file mode 100644
index 000000000..b9b7ac55d
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableModuleHeader.cs
@@ -0,0 +1,19 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable
+{
+    public class RegistrableModuleHeader<TGenerator> : RegistrableCodeGenerator<TGenerator>
+        where TGenerator : Generator
+    {
+        public RegistrableModuleHeader(TGenerator generator, IEnumerable<TranslationUnit> units) : base(generator, units)
+        {
+        }
+
+        public override string FileExtension { get; } = "h";
+
+        public override void Process()
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableModuleSource.cs b/src/Generator/Generators/Registrable/RegistrableModuleSource.cs
new file mode 100644
index 000000000..2546fd216
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableModuleSource.cs
@@ -0,0 +1,19 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable
+{
+    public class RegistrableModuleSource<TGenerator> : RegistrableCodeGenerator<TGenerator>
+        where TGenerator : Generator
+    {
+        public RegistrableModuleSource(TGenerator generator, IEnumerable<TranslationUnit> units) : base(generator, units)
+        {
+        }
+
+        public override string FileExtension { get; } = "cpp";
+
+        public override void Process()
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableNamingStrategy.cs b/src/Generator/Generators/Registrable/RegistrableNamingStrategy.cs
new file mode 100644
index 000000000..e831031d5
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableNamingStrategy.cs
@@ -0,0 +1,460 @@
+using CppSharp.AST;
+using CppSharp.Generators.C;
+using CppSharp.Generators.Registrable.Lua.Sol;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CppSharp.Generators.Registrable
+{
+    public class RegistrableNamingStrategy<T> where T : LuaSolGenerator
+    {
+        protected T Generator;
+
+        public RegistrableNamingStrategy(T generator)
+        {
+            Generator = generator;
+        }
+
+        public bool IsNestedTemplate(Declaration declaration)
+        {
+            var currentDeclaration = declaration;
+            while (true)
+            {
+                currentDeclaration = currentDeclaration.OriginalNamespace;
+                if (currentDeclaration == null || currentDeclaration is TranslationUnit)
+                {
+                    break;
+                }
+                if (Utils.FindDescribedTemplate(currentDeclaration) != null)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public virtual string PrintClassTemplateParameter(Declaration declaration, TemplateParameterOption option)
+        {
+            var builder = new StringBuilder();
+            if (declaration is TypeTemplateParameter typeTemplateParameter)
+            {
+                if (!option.IgnoreKeyword)
+                {
+                    builder.Append("typename");
+                    if (typeTemplateParameter.IsParameterPack)
+                    {
+                        builder.Append("...");
+                    }
+                }
+                if (!string.IsNullOrEmpty(typeTemplateParameter.OriginalName))
+                {
+                    if (!option.IgnoreKeyword)
+                    {
+                        builder.Append(' ');
+                    }
+                    if (option.CustomPrefix != null)
+                    {
+                        builder.Append(option.CustomPrefix);
+                    }
+                    builder.Append(typeTemplateParameter.OriginalName);
+                }
+                if (!option.IgnoreKeyword)
+                {
+                    if (!option.IgnoreDefault)
+                    {
+                        if (typeTemplateParameter.DefaultArgument.Type != null)
+                        {
+                            builder.Append(" = ");
+                            builder.Append(typeTemplateParameter.DefaultArgument.Type.Visit(new CppTypePrinter(Generator.Context)));
+                        }
+                    }
+                }
+                else
+                {
+                    if (typeTemplateParameter.IsParameterPack)
+                    {
+                        builder.Append("...");
+                    }
+                }
+            }
+            else if (declaration is NonTypeTemplateParameter nonTypeTemplateParameter)
+            {
+                if (!option.IgnoreKeyword)
+                {
+                    builder.Append(nonTypeTemplateParameter.Type.Visit(new CppTypePrinter(Generator.Context)));
+                    if (nonTypeTemplateParameter.IsParameterPack)
+                    {
+                        builder.Append("...");
+                    }
+                }
+                if (!string.IsNullOrEmpty(nonTypeTemplateParameter.OriginalName))
+                {
+                    if (!option.IgnoreKeyword)
+                    {
+                        builder.Append(' ');
+                    }
+                    if (option.CustomPrefix != null)
+                    {
+                        builder.Append(option.CustomPrefix);
+                    }
+                    builder.Append(nonTypeTemplateParameter.OriginalName);
+                }
+                if (!option.IgnoreKeyword)
+                {
+                    if (!option.IgnoreDefault)
+                    {
+                        if (nonTypeTemplateParameter.DefaultArgument != null)
+                        {
+                            builder.Append(" = ");
+                            builder.Append(nonTypeTemplateParameter.DefaultArgument.ToString());
+                        }
+                    }
+                }
+                else
+                {
+                    if (nonTypeTemplateParameter.IsParameterPack)
+                    {
+                        builder.Append("...");
+                    }
+                }
+            }
+            return builder.ToString();
+        }
+
+        public virtual string PrintClassTemplateParameters(List<Declaration> parameters, bool includeEnclosingBrackets, TemplateParameterOption option)
+        {
+            var builder = new StringBuilder();
+            if (includeEnclosingBrackets)
+            {
+                builder.Append('<');
+            }
+            for (int i = 0; i < parameters.Count; i++)
+            {
+                if (i > 0)
+                {
+                    builder.Append(", ");
+                }
+                builder.Append(PrintClassTemplateParameter(parameters[i], option));
+            }
+            if (includeEnclosingBrackets)
+            {
+                builder.Append('>');
+            }
+            return builder.ToString();
+        }
+
+        public virtual string PrintClassTemplateSpecializationArgument(TemplateArgument templateArgument)
+        {
+            if (templateArgument.Kind == TemplateArgument.ArgumentKind.Integral)
+            {
+                return templateArgument.Integral.ToString();
+            }
+            return templateArgument.Type.Type.Visit(new CppTypePrinter(Generator.Context));
+        }
+
+        public virtual string PrintClassTemplateSpecializationArguments(List<TemplateArgument> arguments, bool includeEnclosingBrackets)
+        {
+            var builder = new StringBuilder();
+            if (includeEnclosingBrackets)
+            {
+                builder.Append('<');
+            }
+            for (int i = 0; i < arguments.Count; i++)
+            {
+                if (i > 0)
+                {
+                    builder.Append(", ");
+                }
+                builder.Append(PrintClassTemplateSpecializationArgument(arguments[i]));
+            }
+            if (includeEnclosingBrackets)
+            {
+                builder.Append('>');
+            }
+            return builder.ToString();
+        }
+
+        public virtual string GetQualifiedName(Declaration declaration, FQNOption option)
+        {
+            if (declaration is TranslationUnit)
+            {
+                return "";
+            }
+
+            var name = declaration.OriginalName;
+            var currentDeclaration = declaration;
+
+            if (currentDeclaration is ClassTemplateSpecialization specialization)
+            {
+                if (!option.IgnoreTemplateParameters)
+                {
+                    name = ($"{name}{PrintClassTemplateSpecializationArguments(specialization.Arguments, true)}");
+                }
+            }
+            else
+            {
+                Template template = null;
+                if (currentDeclaration is not ClassTemplate)
+                {
+                    var describedTemplate = Utils.FindDescribedTemplate(currentDeclaration);
+                    if (describedTemplate is ClassTemplate)
+                    {
+                        template = (ClassTemplate)describedTemplate;
+                    }
+                }
+                if (template != null)
+                {
+                    if (!option.IgnoreTemplateParameters)
+                    {
+                        name = ($"{name}{PrintClassTemplateParameters(template.Parameters, true, TemplateParameterOption.AsArgument)}");
+                    }
+                }
+            }
+
+            return name;
+        }
+
+        public virtual string GetFullyQualifiedName(Declaration declaration, FQNOption option)
+        {
+            if (declaration is TranslationUnit)
+            {
+                return "";
+            }
+
+            var name = new StringBuilder();
+            var currentDeclaration = declaration;
+            var needsTypename = false;
+            var depth = 0;
+
+            while (true)
+            {
+                if (currentDeclaration == null || currentDeclaration is TranslationUnit)
+                {
+                    break;
+                }
+                depth += 1;
+                var currentName = new StringBuilder();
+                currentName.Append(currentDeclaration.OriginalName);
+
+                if (currentDeclaration is ClassTemplateSpecialization specialization)
+                {
+                    if (!option.IgnoreTemplateTemplateKeyword)
+                    {
+                        if (IsNestedTemplate(currentDeclaration))
+                        {
+                            currentName.Insert(0, "template ");
+                        }
+                    }
+                    if (!option.IgnoreTemplateParameters)
+                    {
+                        if (depth > 1)
+                        {
+                            needsTypename = true;
+                        }
+                        currentName.Append(PrintClassTemplateSpecializationArguments(specialization.Arguments, true));
+                    }
+                }
+                else
+                {
+                    if (currentDeclaration is not ClassTemplate template)
+                    {
+                        template = (ClassTemplate)Utils.FindDescribedTemplate(currentDeclaration);
+                    }
+                    if (template != null)
+                    {
+                        if (!option.IgnoreTemplateTemplateKeyword)
+                        {
+                            if (IsNestedTemplate(currentDeclaration))
+                            {
+                                currentName.Insert(0, "template ");
+                            }
+                        }
+                        if (!option.IgnoreTemplateParameters)
+                        {
+                            if (depth > 1)
+                            {
+                                needsTypename = true;
+                            }
+                            currentName.Append($"{name}{PrintClassTemplateParameters(template.Parameters, true, TemplateParameterOption.AsArgument)}");
+                        }
+                    }
+                }
+
+                if (name.Length != 0)
+                {
+                    name.Insert(0, "::");
+                }
+                name.Insert(0, currentName);
+                currentDeclaration = currentDeclaration.OriginalNamespace;
+            }
+            if (!option.IgnoreGlobalNamespace)
+            {
+                name.Insert(0, "::");
+            }
+            if (!option.IgnoreTemplateTypenameKeyword)
+            {
+                if (needsTypename)
+                {
+                    name.Insert(0, "typename ");
+                }
+            }
+
+            return name.ToString();
+        }
+
+        public virtual string GetContextualName(Declaration declaration, RegistrableGeneratorContext context, FQNOption option)
+        {
+            Class @class = null;
+            Template template = null;
+            if (declaration is Class)
+            {
+                @class = declaration as Class;
+                template = Utils.FindDescribedTemplate(declaration);
+            }
+            else if (declaration is ClassTemplate classTemplate)
+            {
+                @class = classTemplate.TemplatedClass;
+                template = classTemplate;
+            }
+            if (@class is Class)
+            {
+                if (template is ClassTemplate)
+                {
+                    // TODO: check if ClassTemplate is collapsible
+                }
+
+                if (@class.Access == AccessSpecifier.Protected)
+                {
+                    return GetCppContext(@class, context, FQNOption.IgnoreNone);
+                }
+                return GetFullyQualifiedName(declaration, option);
+            }
+            return GetCppContext(declaration, context, new FQNOption(false, true, false, false)) + "::" + GetQualifiedName(declaration, option);
+        }
+
+        public virtual string GetRegistrationFunctionName(Declaration declaration, bool isRecusrive = false)
+        {
+            if (declaration is TranslationUnit translationUnit)
+            {
+                return isRecusrive ? "" : $"register_{translationUnit.FileNameWithoutExtension}";
+            }
+
+            var name = declaration.OriginalName;
+            var currentDeclaration = declaration;
+            while (true)
+            {
+                currentDeclaration = currentDeclaration.OriginalNamespace;
+                if (currentDeclaration == null || currentDeclaration is TranslationUnit)
+                {
+                    break;
+                }
+                name = currentDeclaration.OriginalName + "_" + name;
+            }
+            return name;
+        }
+
+        public virtual string GetRegistrationNameQuoted(Declaration declaration)
+        {
+            return $"\"{declaration.Name}\"";
+        }
+
+        public virtual string GetBindingIdName(Declaration declaration)
+        {
+            return Generator.GeneratorOptions.BindingIdNamePredicate(GetRegistrationFunctionName(declaration));
+        }
+
+        public virtual string GetBindingIdValue(Declaration declaration, RegistrableGeneratorContext context)
+        {
+            return Generator.GeneratorOptions.BindingIdValuePredicate(GetContextualName(declaration, context, FQNOption.IgnoreNone));
+        }
+
+        public virtual string GetBindingName(Declaration declaration)
+        {
+            return Generator.GeneratorOptions.BindingNamePredicate(GetRegistrationFunctionName(declaration));
+        }
+
+        public virtual string GetRootContextName(RegistrableGeneratorContext context)
+        {
+            if (context != null)
+            {
+                var rootContextName = context.PeekRootContextName();
+                if (rootContextName != null)
+                {
+                    return rootContextName;
+                }
+            }
+            return "state";
+        }
+
+        public virtual string GetBindingContextNamespacePredicate(string state, string key)
+        {
+            return $"get_namespace({state}, \"{key}\")";
+        }
+
+        public virtual string GetBindingContext(Declaration declaration, RegistrableGeneratorContext context)
+        {
+            if (context != null)
+            {
+                var rootContextName = context.PeekRootContextName();
+                if (rootContextName != null)
+                {
+                    return rootContextName;
+                }
+            }
+            if (declaration.Namespace is TranslationUnit)
+            {
+                return GetRootContextName(context);
+            }
+            else
+            {
+                var name = GetRootContextName(context);
+                var currentDeclaration = declaration.Namespace;
+                var parentList = new List<Declaration>();
+                while (true)
+                {
+                    if (currentDeclaration == null || currentDeclaration is TranslationUnit)
+                    {
+                        break;
+                    }
+                    parentList.Insert(0, currentDeclaration);
+                    currentDeclaration = currentDeclaration.Namespace;
+                }
+                foreach (var parent in parentList)
+                {
+                    name = GetBindingContextNamespacePredicate(name, parent.Name);
+                }
+                return name;
+            }
+        }
+
+        public virtual string GetCppContext(Declaration entity, RegistrableGeneratorContext context, FQNOption option)
+        {
+            if (context != null)
+            {
+                var cppContext = context.PeekCppContext();
+                if (cppContext != null)
+                {
+                    return cppContext.GetFullQualifiedName(option);
+                }
+            }
+            return GetFullyQualifiedName(entity.OriginalNamespace, option);
+        }
+
+        public virtual string GetMembershipScopeName(Function function, RegistrableGeneratorContext context)
+        {
+            if (function is Method method)
+            {
+                return GetCppContext(method, context, new FQNOption()
+                {
+                    IgnoreTemplateTypenameKeyword = true
+                }) + "::";
+            }
+            return "";
+        }
+
+        public virtual string GetClassTemplateName(Declaration declaration)
+        {
+            return $"functor_{GetRegistrationFunctionName(declaration)}";
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/RegistrableSources.cs b/src/Generator/Generators/Registrable/RegistrableSources.cs
new file mode 100644
index 000000000..31c2811c0
--- /dev/null
+++ b/src/Generator/Generators/Registrable/RegistrableSources.cs
@@ -0,0 +1,13 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable
+{
+    public abstract class RegistrableSources<TGenerator> : RegistrableCodeGenerator<TGenerator>
+        where TGenerator : Generator
+    {
+        public RegistrableSources(TGenerator generator, IEnumerable<TranslationUnit> units) : base(generator, units)
+        {
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Utils/FQNOption.cs b/src/Generator/Generators/Registrable/Utils/FQNOption.cs
new file mode 100644
index 000000000..026b0a93a
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Utils/FQNOption.cs
@@ -0,0 +1,44 @@
+namespace CppSharp.Generators.Registrable
+{
+    public class FQNOption
+    {
+        public static readonly FQNOption IgnoreNone = new(false, false, false, false);
+        public static readonly FQNOption IgnoreAll = new(true, true, true, true);
+
+        public bool IgnoreGlobalNamespace { get; set; }
+        public bool IgnoreTemplateTypenameKeyword { get; set; }
+        public bool IgnoreTemplateTemplateKeyword { get; set; }
+        public bool IgnoreTemplateParameters { get; set; }
+
+        public FQNOption(bool ignoreGlobalNamespace = false,
+                  bool ignoreTemplateTypenameKeyword = false,
+                  bool ignoreTemplateTemplateKeyword = false,
+                  bool ignoreTemplateParameters = false)
+        {
+            IgnoreGlobalNamespace = ignoreGlobalNamespace;
+            IgnoreTemplateTypenameKeyword = ignoreTemplateTypenameKeyword;
+            IgnoreTemplateTemplateKeyword = ignoreTemplateTemplateKeyword;
+            IgnoreTemplateParameters = ignoreTemplateParameters;
+        }
+
+        public static FQNOption operator |(FQNOption lhs, FQNOption rhs)
+        {
+            return new FQNOption(
+                lhs.IgnoreGlobalNamespace | rhs.IgnoreGlobalNamespace,
+                lhs.IgnoreTemplateTypenameKeyword | rhs.IgnoreTemplateTypenameKeyword,
+                lhs.IgnoreTemplateTemplateKeyword | rhs.IgnoreTemplateTemplateKeyword,
+                lhs.IgnoreTemplateParameters | rhs.IgnoreTemplateParameters
+            );
+        }
+
+        public static FQNOption operator &(FQNOption lhs, FQNOption rhs)
+        {
+            return new FQNOption(
+                lhs.IgnoreGlobalNamespace & rhs.IgnoreGlobalNamespace,
+                lhs.IgnoreTemplateTypenameKeyword & rhs.IgnoreTemplateTypenameKeyword,
+                lhs.IgnoreTemplateTemplateKeyword & rhs.IgnoreTemplateTemplateKeyword,
+                lhs.IgnoreTemplateParameters & rhs.IgnoreTemplateParameters
+            );
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Utils/InfoEntry.cs b/src/Generator/Generators/Registrable/Utils/InfoEntry.cs
new file mode 100644
index 000000000..b2055b901
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Utils/InfoEntry.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CppSharp.Generators.Registrable
+{
+    public class InfoEntry : IEquatable<InfoEntry>
+    {
+        public static readonly HashSet<InfoEntry> Registered = new();
+
+        public string Name { get; }
+
+        public InfoEntry(string name)
+        {
+            if (Registered.Any(kind => kind.Name == name))
+            {
+                throw new Exception($"InfoEntry has an already registered name: {Name}");
+            }
+            Name = name;
+            Registered.Add(this);
+        }
+
+        public static bool operator ==(InfoEntry obj1, InfoEntry obj2)
+        {
+            if (ReferenceEquals(obj1, obj2))
+            {
+                return true;
+            }
+            if (obj1 is null)
+            {
+                return false;
+            }
+            if (obj2 is null)
+            {
+                return false;
+            }
+            return obj1.Equals(obj2);
+        }
+
+        public static bool operator !=(InfoEntry obj1, InfoEntry obj2) => !(obj1 == obj2);
+
+        public bool Equals(InfoEntry other)
+        {
+            if (other is null)
+            {
+                return false;
+            }
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+            return Name.Equals(other.Name);
+        }
+
+        public override bool Equals(object obj) => Equals(obj as InfoEntry);
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return Name.GetHashCode();
+            }
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Utils/InfoMap.cs b/src/Generator/Generators/Registrable/Utils/InfoMap.cs
new file mode 100644
index 000000000..3017d00a1
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Utils/InfoMap.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace CppSharp.Generators.Registrable
+{
+    public class InfoMap<T> : Dictionary<InfoEntry, T>
+    {
+        public InfoMap() : base()
+        {
+        }
+
+        public T1 Get<T1>(InfoEntry infoEntry) where T1 : T
+        {
+            return (T1)this[infoEntry];
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Utils/InfoMapStack.cs b/src/Generator/Generators/Registrable/Utils/InfoMapStack.cs
new file mode 100644
index 000000000..2fec16530
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Utils/InfoMapStack.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace CppSharp.Generators.Registrable
+{
+    public class InfoMapStack<T> : InfoMap<Stack<T>>
+    {
+        public InfoMapStack() : base()
+        {
+        }
+
+        public T1 Peek<T1>(InfoEntry infoEntry, T1 defaultValue = default) where T1 : T
+        {
+            if (TryGetValue(infoEntry, out Stack<T> stack))
+            {
+                if (stack.Count > 0)
+                {
+                    return (T1)stack.Peek();
+                }
+            }
+            return defaultValue;
+        }
+
+        public T1 Pop<T1>(InfoEntry infoEntry) where T1 : T
+        {
+            if (TryGetValue(infoEntry, out Stack<T> stack))
+            {
+                return (T1)stack.Pop();
+            }
+            throw new InvalidOperationException();
+        }
+
+        public void Push<T1>(InfoEntry infoEntry, T1 item) where T1 : T
+        {
+            if (!TryGetValue(infoEntry, out Stack<T> stack))
+            {
+                this[infoEntry] = stack = new Stack<T>();
+            }
+            stack.Push(item);
+        }
+
+        public bool TryPeek<T1>(InfoEntry infoEntry, [MaybeNullWhen(false)] out T1 result) where T1 : T
+        {
+            if (TryGetValue(infoEntry, out Stack<T> stack))
+            {
+                bool tempReturn = stack.TryPop(out T tempResult);
+                result = (T1)tempResult;
+                return tempReturn;
+            }
+            result = default;
+            return false;
+        }
+
+        public bool TryPop<T1>(InfoEntry infoEntry, [MaybeNullWhen(false)] out T1 result) where T1 : T
+        {
+            if (TryGetValue(infoEntry, out Stack<T> stack))
+            {
+                bool tempReturn = stack.TryPop(out T tempResult);
+                result = (T1)tempResult;
+                return tempReturn;
+            }
+            result = default;
+            return false;
+        }
+
+        public void Scoped(InfoEntry infoEntry, T item, Action action)
+        {
+            Push(infoEntry, item);
+            action();
+            Pop<T>(infoEntry);
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Utils/TemplateParameterOption.cs b/src/Generator/Generators/Registrable/Utils/TemplateParameterOption.cs
new file mode 100644
index 000000000..db32620e8
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Utils/TemplateParameterOption.cs
@@ -0,0 +1,22 @@
+namespace CppSharp.Generators.Registrable
+{
+    public class TemplateParameterOption
+    {
+        public static readonly TemplateParameterOption AsParameter = new(false, false);
+        public static readonly TemplateParameterOption AsParameterNoDefault = new(false, true);
+        public static readonly TemplateParameterOption AsArgument = new(true, true);
+
+        public bool IgnoreKeyword { get; set; }
+        public bool IgnoreDefault { get; set; }
+        public string CustomPrefix { get; set; }
+
+        TemplateParameterOption(bool ignoreKeyword = false,
+            bool ignoreDefault = false,
+            string customPrefix = "")
+        {
+            IgnoreKeyword = ignoreKeyword;
+            IgnoreDefault = ignoreDefault;
+            CustomPrefix = customPrefix;
+        }
+    }
+}
diff --git a/src/Generator/Generators/Registrable/Utils/Utils.cs b/src/Generator/Generators/Registrable/Utils/Utils.cs
new file mode 100644
index 000000000..ebca3efd3
--- /dev/null
+++ b/src/Generator/Generators/Registrable/Utils/Utils.cs
@@ -0,0 +1,139 @@
+using CppSharp.AST;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CppSharp.Generators.Registrable
+{
+    public static class Utils
+    {
+        public static Template FindDescribedTemplate(Declaration declaration)
+        {
+            foreach (var template in declaration.Namespace.Templates)
+            {
+                if (template.TemplatedDecl == declaration)
+                {
+                    return template;
+                }
+            }
+            return null;
+        }
+
+        public static DetachmentOption FindDetachmentOption(Declaration declaration)
+        {
+            return (declaration.Namespace is Class) ? DetachmentOption.Off : DetachmentOption.On;
+        }
+
+        public static bool HasPossibleOverload(Function function)
+        {
+            var parent = function.OriginalNamespace;
+            if (parent is Class @class)
+            {
+                foreach (var item in @class.Methods)
+                {
+                    if (item.OriginalFunction == null)
+                    {
+                        if (item != function)
+                        {
+                            if (item.OriginalName == function.Name)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                foreach (var item in @class.Functions)
+                {
+                    if (item.OriginalFunction == null)
+                    {
+                        if (item != function)
+                        {
+                            if (item.OriginalName == function.Name)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                foreach (var item in @class.Templates.Where(template => template is FunctionTemplate).Cast<FunctionTemplate>())
+                {
+                    var templatedFunction = item.TemplatedFunction;
+                    if (templatedFunction.OriginalFunction == null)
+                    {
+                        if (templatedFunction != function)
+                        {
+                            if (templatedFunction.OriginalName == function.Name)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public static bool HasPossibleTemplateOverload(Function function)
+        {
+            var parent = function.OriginalNamespace;
+            if (parent is Class @class)
+            {
+                foreach (var item in @class.Templates.Where(template => template is FunctionTemplate).Cast<FunctionTemplate>())
+                {
+                    var templatedFunction = item.TemplatedFunction;
+                    if (templatedFunction.OriginalFunction == null)
+                    {
+                        if (templatedFunction != function)
+                        {
+                            if (templatedFunction.OriginalName == function.Name)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public static bool HasPossibleTemplateOverload(Method method)
+        {
+            if (method.Kind == CXXMethodKind.UsingDirective)
+            {
+                return true;
+            }
+            return HasPossibleTemplateOverload(method as Function);
+        }
+
+        public static bool IsDefaultTemplateParameter(Declaration parameter)
+        {
+            if (parameter is TypeTemplateParameter typeTemplateParameter)
+            {
+                return typeTemplateParameter.DefaultArgument.Type != null;
+            }
+            else if (parameter is NonTypeTemplateParameter nonTypeTemplateParameter)
+            {
+                return nonTypeTemplateParameter.DefaultArgument != null;
+            }
+            else if (parameter is TemplateTemplateParameter templateTemplateParameter)
+            {
+                throw new InvalidOperationException();
+            }
+            throw new InvalidOperationException();
+        }
+
+        public static bool IsDefaultTemplateParameterList(List<Declaration> parameters)
+        {
+            foreach (var parameter in parameters)
+            {
+                if (!IsDefaultTemplateParameter(parameter))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}