diff --git a/Directory.Packages.props b/Directory.Packages.props
index ae946f6d17..237a523ec7 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -17,12 +17,13 @@
     <!-- Silk.NET.Core -->
     <PackageVersion Include="Fody" Version="6.9.3" PrivateAssets="all" />
     <PackageVersion Include="InlineIL.Fody" Version="1.10.2" PrivateAssets="all" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="5.0.0-1.25277.114" />
+    <PackageVersion
+      Include="Microsoft.CodeAnalysis.PublicApiAnalyzers"
+      Version="5.0.0-1.25277.114"
+    />
     <!-- Analyzers -->
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.3.0" />
     <!-- SilkTouch -->
-    <PackageVersion Include="Autofac" Version="9.3.4" />
-    <PackageVersion Include="Autofac.Extensions.DependencyInjection" Version="11.0.2" />
     <PackageVersion Include="ClangSharp.PInvokeGenerator" Version="22.1.8" />
     <PackageVersion Include="CSharpier.Core" Version="1.3.0" />
     <PackageVersion Include="Humanizer.Core" Version="2.14.1" />
@@ -34,11 +35,17 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="5.3.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.9" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.CommandLine" Version="10.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="10.0.9" />
+    <PackageVersion
+      Include="Microsoft.Extensions.Configuration.EnvironmentVariables"
+      Version="10.0.9"
+    />
     <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="10.0.9" />
     <PackageVersion Include="Microsoft.Extensions.FileSystemGlobbing" Version="10.0.9" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Console" Version="10.0.9" />
-    <PackageVersion Include="Microsoft.VisualStudio.Setup.Configuration.Interop" Version="3.14.2075" />
+    <PackageVersion
+      Include="Microsoft.VisualStudio.Setup.Configuration.Interop"
+      Version="3.14.2075"
+    />
     <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     <PackageVersion Include="System.Configuration.ConfigurationManager" Version="10.0.9" />
     <PackageVersion Include="System.IO.Hashing" Version="10.0.9" />
diff --git a/sources/SilkTouch/SilkTouch/Clang/ClangScraper.cs b/sources/SilkTouch/SilkTouch/Clang/ClangScraper.cs
index e9b134734b..d0a935ea98 100644
--- a/sources/SilkTouch/SilkTouch/Clang/ClangScraper.cs
+++ b/sources/SilkTouch/SilkTouch/Clang/ClangScraper.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Concurrent;
+using System.CommandLine;
+using System.CommandLine.Invocation;
 using System.Diagnostics;
 using ClangSharp;
 using ClangSharp.Interop;
@@ -10,6 +12,7 @@
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
 using Silk.NET.SilkTouch.Caching;
+using Silk.NET.SilkTouch.CommandLine;
 using Silk.NET.SilkTouch.Mods;
 using Silk.NET.SilkTouch.Sources;
 using static ClangSharp.Interop.CXDiagnosticSeverity;
@@ -25,7 +28,6 @@ namespace Silk.NET.SilkTouch.Clang;
 /// </param>
 /// <param name="documentFactory">The document factory to use.</param>
 /// <param name="config">The configuration to use.</param>
-/// <param name="hostConfig">The host configuration to use.</param>
 /// <param name="logger">The logger to use.</param>
 /// <param name="inputResolver">The input resolver to use.</param>
 /// <param name="responseFileMods">The mods that modify response files before they are fed to ClangSharp.</param>
@@ -34,15 +36,29 @@ public sealed class ClangScraper(
     ResponseFileHandler rspHandler,
     DocumentFactory documentFactory,
     ClangScraper.Configuration config,
-    SilkTouchHostConfiguration hostConfig,
     ILogger<ClangScraper> logger,
     IInputResolver inputResolver,
     ICacheProvider? cacheProvider = null,
     IEnumerable<IResponseFileMod>? responseFileMods = null
-) : IMod
+) : IMod, ICommandLineConfigurable
 {
     // TODO add Windows SDK and Xcode configuration
 
+    private static Option<bool> UseCacheOnlyOption { get; } =
+        new(["--use-cache-only"], () => false)
+        {
+            Description = $"Limits {nameof(ClangScraper)} to only using the cache.",
+        };
+
+    private static Option<bool> GenerateCacheOnlyOption { get; } =
+        new(["--generate-cache-only"], () => false)
+        {
+            Description = $"Limits {nameof(ClangScraper)} to only generating the cache.",
+        };
+
+    private bool _useCacheOnly = false;
+    private bool _generateCacheOnly = false;
+
     /// <summary>
     /// Configuration for the <see cref="ClangScraper"/> mod.
     /// </summary>
@@ -88,12 +104,25 @@ public record Configuration
         /// Whether this mod should end the generation job after a "generate cache only" run.
         /// </summary>
         /// <remarks>
-        /// A "generate cache only" run is a run where <see cref="SilkTouchHostConfiguration.GenerateCacheOnly"/> is set to true.
         /// The intended use pattern is setting this to true for the last <see cref="ClangScraper"/> mod in a job.
         /// </remarks>
         public bool ExitAfterGenerateCacheOnlyRun { get; init; }
     }
 
+    /// <inheritdoc />
+    public void RegisterCommandLineOptions(Action<Option> register)
+    {
+        register.Invoke(UseCacheOnlyOption);
+        register.Invoke(GenerateCacheOnlyOption);
+    }
+
+    /// <inheritdoc />
+    public void ReadCommandLineOptions(InvocationContext ctx)
+    {
+        _useCacheOnly = ctx.ParseResult.GetValueForOption(UseCacheOnlyOption);
+        _generateCacheOnly = ctx.ParseResult.GetValueForOption(GenerateCacheOnlyOption);
+    }
+
     /// <summary>
     /// Runs ClangSharp to obtain the raw bindings for the given response file.
     /// </summary>
@@ -395,7 +424,7 @@ public async Task ExecuteAsync(IModContext ctx, CancellationToken ct = default)
 
         // Try generating the raw bindings with ClangSharp
         // If scraping needs to be skipped or if the scrape fails, then fall back to a cache if available
-        var shouldScrape = !hostConfig.UseCacheOnly && config.ScrapeIf.Invoke();
+        var shouldScrape = !_useCacheOnly && config.ScrapeIf.Invoke();
 
         var cacheKey =
             resolvedConfig.CacheKey != null
@@ -431,7 +460,7 @@ public async Task ExecuteAsync(IModContext ctx, CancellationToken ct = default)
             }
         }
 
-        if (hostConfig.GenerateCacheOnly)
+        if (_generateCacheOnly)
         {
             // GenerateCacheOnly is intended to be used when not all caches are available (eg: for multi-platform cache population),
             // so we don't validate whether a cache was generated or not in this branch
diff --git a/sources/SilkTouch/SilkTouch/CommandLine/ICommandLineConfigurable.cs b/sources/SilkTouch/SilkTouch/CommandLine/ICommandLineConfigurable.cs
new file mode 100644
index 0000000000..5c678e0d5f
--- /dev/null
+++ b/sources/SilkTouch/SilkTouch/CommandLine/ICommandLineConfigurable.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using System.CommandLine.Invocation;
+
+namespace Silk.NET.SilkTouch.CommandLine;
+
+/// <summary>
+/// Provides a way to register command line options and read them after they have been parsed.
+/// </summary>
+public interface ICommandLineConfigurable
+{
+    /// <summary>
+    /// Registers the command line options through the provided callback.
+    /// </summary>
+    /// <remarks>
+    /// Options are recommended to be statically defined so they can be deduplicated.
+    /// </remarks>
+    public void RegisterCommandLineOptions(Action<Option> register);
+
+    /// <summary>
+    /// Reads the command line options from the provided context.
+    /// </summary>
+    public void ReadCommandLineOptions(InvocationContext ctx);
+}
diff --git a/sources/SilkTouch/SilkTouch/Silk.NET.SilkTouch.csproj b/sources/SilkTouch/SilkTouch/Silk.NET.SilkTouch.csproj
index afc4f29d09..c5cf2978db 100644
--- a/sources/SilkTouch/SilkTouch/Silk.NET.SilkTouch.csproj
+++ b/sources/SilkTouch/SilkTouch/Silk.NET.SilkTouch.csproj
@@ -6,8 +6,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Autofac" />
-    <PackageReference Include="Autofac.Extensions.DependencyInjection" />
     <PackageReference Include="ClangSharp.PInvokeGenerator" />
     <PackageReference Include="CSharpier.Core" />
     <PackageReference Include="Humanizer.Core" />
diff --git a/sources/SilkTouch/SilkTouch/SilkTouchHost.cs b/sources/SilkTouch/SilkTouch/SilkTouchHost.cs
index 144883a650..8072d24483 100644
--- a/sources/SilkTouch/SilkTouch/SilkTouchHost.cs
+++ b/sources/SilkTouch/SilkTouch/SilkTouchHost.cs
@@ -2,18 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using System.CommandLine.Invocation;
 using System.Diagnostics.CodeAnalysis;
-using Autofac;
-using Autofac.Extensions.DependencyInjection;
 using Microsoft.Build.Locator;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Console;
 using Silk.NET.SilkTouch.Caching;
 using Silk.NET.SilkTouch.Clang;
+using Silk.NET.SilkTouch.CommandLine;
 using Silk.NET.SilkTouch.Mods;
-using Silk.NET.SilkTouch.Mods.Bakery;
 using Silk.NET.SilkTouch.Sources;
 
 namespace Silk.NET.SilkTouch;
@@ -46,17 +43,7 @@ public class SilkTouchHost
             Description = "Maximum number of parallel jobs.",
         };
 
-    private static Option<bool> UseCacheOnlyOption { get; } =
-        new(["--use-cache-only"], () => false)
-        {
-            Description = "Limits the generator to only using the cache.",
-        };
-
-    private static Option<bool> GenerateCacheOnlyOption { get; } =
-        new(["--generate-cache-only"], () => false)
-        {
-            Description = "Limits the generator to only generating the cache.",
-        };
+    private LogLevel _minimumLogLevel = LogLevel.Information;
 
     private readonly Dictionary<string, JobDefinition> _jobDefinitions = [];
 
@@ -85,86 +72,134 @@ public SilkTouchHost DefineJob(
     /// </summary>
     public async Task RunAsync(string[] args)
     {
-        var rootCommand = new RootCommand
-        {
-            LoggingOption,
-            SkipOption,
-            OnlyOption,
-            JobsOption,
-            UseCacheOnlyOption,
-            GenerateCacheOnlyOption,
-        };
+        // Register MSBuild
+        MSBuildLocator.RegisterDefaults();
+
+        // Build service provider
+        var services = new ServiceCollection();
+        Configure(services);
+        var provider = services.BuildServiceProvider();
+
+        // Create all jobs
+        var jobs = _jobDefinitions.ToDictionary(
+            jobKvp => jobKvp.Key,
+            jobKvp =>
+            {
+                return new SilkTouchJob(
+                    jobKvp.Key,
+                    jobKvp.Value.Config,
+                    services =>
+                    {
+                        ConfigureForward(provider, services);
+                        jobKvp.Value.Configure.Invoke(services.SilkTouch());
+                    }
+                );
+            }
+        );
 
-        rootCommand.SetHandler(async ctx =>
+        try
         {
-            try
+            // Gather job options
+            var options = new HashSet<Option>();
+            foreach (var job in jobs.Values)
             {
-                // Register MSBuild
-                MSBuildLocator.RegisterDefaults();
+                var configurables = job.Provider.GetServices<ICommandLineConfigurable>();
+                foreach (var configurable in configurables)
+                {
+                    configurable.RegisterCommandLineOptions(option =>
+                    {
+                        options.Add(option);
+                    });
+                }
+            }
 
-                // Build container
-                var builder = new ContainerBuilder();
-                Configure(builder, ctx);
-                await using ILifetimeScope container = builder.Build();
+            var rootCommand = new RootCommand { LoggingOption, SkipOption, OnlyOption, JobsOption };
 
-                var jobKeysToRun = new HashSet<string>(
-                    ctx.ParseResult.GetValueForOption(OnlyOption) ?? [],
-                    StringComparer.OrdinalIgnoreCase
-                );
+            foreach (var option in options)
+            {
+                rootCommand.Add(option);
+            }
 
-                var jobKeysToSkip = new HashSet<string>(
-                    ctx.ParseResult.GetValueForOption(SkipOption) ?? [],
-                    StringComparer.OrdinalIgnoreCase
-                );
+            rootCommand.SetHandler(async ctx =>
+            {
+                _minimumLogLevel = ctx.ParseResult.GetValueForOption(LoggingOption);
 
-                var jobsToRun = _jobDefinitions.Where(job =>
+                // Apply job options
+                foreach (var job in jobs.Values)
                 {
-                    if (jobKeysToSkip.Contains(job.Key))
+                    var configurables = job.Provider.GetServices<ICommandLineConfigurable>();
+                    foreach (var configurable in configurables)
                     {
-                        return false;
+                        configurable.ReadCommandLineOptions(ctx);
                     }
+                }
 
-                    return jobKeysToRun.Count == 0 || jobKeysToRun.Contains(job.Key);
-                });
-
-                var logger = container.Resolve<ILogger<SilkTouchHost>>();
                 try
                 {
-                    await Parallel.ForEachAsync(
-                        jobsToRun,
-                        new ParallelOptions
-                        {
-                            MaxDegreeOfParallelism = ctx.ParseResult.GetValueForOption(JobsOption),
-                        },
-                        async (jobKvp, ct) =>
+                    var jobKeysToRun = new HashSet<string>(
+                        ctx.ParseResult.GetValueForOption(OnlyOption) ?? [],
+                        StringComparer.OrdinalIgnoreCase
+                    );
+
+                    var jobKeysToSkip = new HashSet<string>(
+                        ctx.ParseResult.GetValueForOption(SkipOption) ?? [],
+                        StringComparer.OrdinalIgnoreCase
+                    );
+
+                    var jobsToRun = _jobDefinitions.Keys.Where(jobKey =>
+                    {
+                        if (jobKeysToSkip.Contains(jobKey))
                         {
-                            using var job = new SilkTouchJob(
-                                jobKvp.Key,
-                                jobKvp.Value.Config,
-                                container,
-                                builder => jobKvp.Value.Configure.Invoke(builder.SilkTouch())
-                            );
-
-                            await job.RunAsync(ct);
+                            return false;
                         }
-                    );
+
+                        return jobKeysToRun.Count == 0 || jobKeysToRun.Contains(jobKey);
+                    });
+
+                    var logger = provider.GetRequiredService<ILogger<SilkTouchHost>>();
+                    try
+                    {
+                        await Parallel.ForEachAsync(
+                            jobsToRun,
+                            new ParallelOptions
+                            {
+                                MaxDegreeOfParallelism = ctx.ParseResult.GetValueForOption(
+                                    JobsOption
+                                ),
+                            },
+                            async (jobKey, ct) =>
+                            {
+                                var job = jobs[jobKey];
+                                await job.RunAsync(ct);
+                            }
+                        );
+                    }
+                    catch (Exception e)
+                    {
+                        logger.LogError(e, "Error occurred while running SilkTouch");
+                        throw;
+                    }
                 }
                 catch (Exception e)
                 {
-                    logger.LogError(e, "Error occurred while running SilkTouch");
-                    throw;
+                    Console.WriteLine(e);
+                    Exit(1);
                 }
-            }
-            catch (Exception e)
+
+                Exit(0);
+            });
+
+            await rootCommand.InvokeAsync(args);
+        }
+        finally
+        {
+            foreach (var job in jobs.Values)
             {
-                Console.WriteLine(e);
-                Exit(1);
+                job.Dispose();
             }
 
-            Exit(0);
-        });
-
-        await rootCommand.InvokeAsync(args);
+            await provider.DisposeAsync();
+        }
     }
 
     [DoesNotReturn]
@@ -173,11 +208,12 @@ private static void Exit(int exitCode) =>
         Environment.Exit(exitCode);
 
     /// <summary>
-    /// Dependencies defined here will be shared by all jobs.
+    /// Dependencies defined here are only accessible to the host.
+    /// Make them available to the jobs by using <see cref="ConfigureForward"/>.
     /// </summary>
-    private void Configure(ContainerBuilder builder, InvocationContext ctx)
+    private void Configure(IServiceCollection services)
     {
-        var services = new ServiceCollection()
+        services
             .AddLogging(builder =>
             {
                 builder.AddSimpleConsole(opts =>
@@ -189,72 +225,46 @@ private void Configure(ContainerBuilder builder, InvocationContext ctx)
                     opts.IncludeScopes = false;
                 });
 
-                builder.SetMinimumLevel(ctx.ParseResult.GetValueForOption(LoggingOption));
+                // This avoids depending on the CLI options during container building
+                builder.AddFilter(IsLogLevelEnabled);
             })
             .AddOptions();
 
-        builder.Populate(services);
+        services.AddSingleton<IModContextFactory, MSBuildModContextFactory>();
+        services.AddSingleton<ICacheProvider, FileSystemCacheProvider>();
+        services.AddSingleton<IInputSource, GitInputSource>();
+        services.AddSingleton<IInputSource, NuGetInputSource>();
+        services.AddSingleton<IInputResolver, UriBasedInputResolver>();
 
+        if (OperatingSystem.IsWindows())
         {
-            // Create config
-            var config = new SilkTouchHostConfiguration()
-            {
-                UseCacheOnly = ctx.ParseResult.GetValueForOption(UseCacheOnlyOption),
-                GenerateCacheOnly = ctx.ParseResult.GetValueForOption(GenerateCacheOnlyOption),
-            };
-
-            if (config.GenerateCacheOnly && config.UseCacheOnly)
-            {
-                throw new InvalidOperationException(
-                    $"{UseCacheOnlyOption.Name} and {GenerateCacheOnlyOption.Name} cannot be enabled at the same time."
-                );
-            }
-
-            builder.RegisterInstance(config).SingleInstance();
-
-            builder
-                .RegisterType<MSBuildModContextFactory>()
-                .As<IModContextFactory>()
-                .SingleInstance();
-
-            builder.RegisterType<ResponseFileHandler>().SingleInstance();
-
-            builder
-                .RegisterType<DefaultBakeStrategy>()
-                .AsSelf()
-                .AsImplementedInterfaces()
-                .SingleInstance();
-
-            builder.RegisterType<FileSystemCacheProvider>().As<ICacheProvider>().SingleInstance();
-
-            builder.RegisterType<GitInputSource>().As<IInputSource>().SingleInstance();
-
-            builder.RegisterType<NuGetInputSource>().As<IInputSource>().SingleInstance();
+            services.AddSingleton<IStdIncludeResolver, WindowsStdIncludeResolver>();
+        }
+        else if (OperatingSystem.IsMacOS())
+        {
+            services.AddSingleton<IStdIncludeResolver, MacOSStdIncludeResolver>();
+        }
+        else
+        {
+            services.AddSingleton<IStdIncludeResolver, UnixStdIncludeResolver>();
+        }
+    }
 
-            builder.RegisterType<UriBasedInputResolver>().As<IInputResolver>().SingleInstance();
+    private bool IsLogLevelEnabled(LogLevel level) => level >= _minimumLogLevel;
 
-            if (OperatingSystem.IsWindows())
-            {
-                builder
-                    .RegisterType<WindowsStdIncludeResolver>()
-                    .As<IStdIncludeResolver>()
-                    .SingleInstance();
-            }
-            else if (OperatingSystem.IsMacOS())
-            {
-                builder
-                    .RegisterType<MacOSStdIncludeResolver>()
-                    .As<IStdIncludeResolver>()
-                    .SingleInstance();
-            }
-            else
-            {
-                builder
-                    .RegisterType<UnixStdIncludeResolver>()
-                    .As<IStdIncludeResolver>()
-                    .SingleInstance();
-            }
-        }
+    /// <summary>
+    /// Dependencies defined here will be available to jobs.
+    /// </summary>
+    private void ConfigureForward(IServiceProvider host, IServiceCollection services)
+    {
+        // Prefer to match the registration order above
+        services.AddSingleton(host.GetRequiredService<ILoggerFactory>());
+        services.AddSingleton(typeof(ILogger<>), typeof(Logger<>));
+
+        services.AddSingleton(host.GetRequiredService<IModContextFactory>());
+        services.AddSingleton(host.GetRequiredService<ICacheProvider>());
+        services.AddSingleton(host.GetRequiredService<IInputResolver>());
+        services.AddSingleton(host.GetRequiredService<IStdIncludeResolver>());
     }
 
     private record JobDefinition(
diff --git a/sources/SilkTouch/SilkTouch/SilkTouchHostConfiguration.cs b/sources/SilkTouch/SilkTouch/SilkTouchHostConfiguration.cs
deleted file mode 100644
index cc897afbfb..0000000000
--- a/sources/SilkTouch/SilkTouch/SilkTouchHostConfiguration.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Silk.NET.SilkTouch.Clang;
-
-namespace Silk.NET.SilkTouch;
-
-/// <summary>
-/// Represents the configuration for the <see cref="SilkTouchHost"/> shared by multiple bindings generation jobs.
-/// </summary>
-public record SilkTouchHostConfiguration
-{
-    /// <summary>
-    /// Limits the generator to only using the cache.
-    /// </summary>
-    /// <remarks>
-    /// Currently only affects <see cref="ClangScraper"/>.
-    /// </remarks>
-    public required bool UseCacheOnly { get; init; }
-
-    /// <summary>
-    /// Limits the generator to only generating the cache.
-    /// </summary>
-    /// <remarks>
-    /// Currently only affects <see cref="ClangScraper"/>.
-    /// </remarks>
-    public required bool GenerateCacheOnly { get; init; }
-}
diff --git a/sources/SilkTouch/SilkTouch/SilkTouchJob.cs b/sources/SilkTouch/SilkTouch/SilkTouchJob.cs
index d98398146f..8cf3118bd2 100644
--- a/sources/SilkTouch/SilkTouch/SilkTouchJob.cs
+++ b/sources/SilkTouch/SilkTouch/SilkTouchJob.cs
@@ -2,9 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
-using Autofac;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Silk.NET.SilkTouch.Clang;
 using Silk.NET.SilkTouch.Mods;
+using Silk.NET.SilkTouch.Mods.Bakery;
 using Silk.NET.SilkTouch.Mods.Transformation;
 using Silk.NET.SilkTouch.Sources;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -16,8 +18,6 @@ namespace Silk.NET.SilkTouch;
 /// </summary>
 internal class SilkTouchJob : IDisposable
 {
-    private readonly ILifetimeScope _container;
-
     private readonly ILogger<SilkTouchJob> _logger;
     private readonly IInputResolver _inputResolver;
     private readonly IModContextFactory _modContextFactory;
@@ -34,45 +34,51 @@ internal class SilkTouchJob : IDisposable
     public SilkTouchConfiguration Config { get; private set; }
 
     /// <summary>
-    /// Gets the loaded mods for this generator instance.
+    /// Gets the loaded mods for this job.
     /// </summary>
     public IReadOnlyList<IMod> Mods { get; }
 
+    /// <summary>
+    /// The service provider for this job.
+    /// </summary>
+    public ServiceProvider Provider;
+
     /// <summary>
     /// Creates a new <see cref="SilkTouchJob"/>.
     /// </summary>
     /// <param name="key">The job key.</param>
     /// <param name="config">The job config.</param>
-    /// <param name="parentContainer">The parent container. Should be the one from the <see cref="SilkTouchHost"/>.</param>
     /// <param name="configure">
-    /// The action that configures the dependency container used by this job.
+    /// The action that configures the services used by this job.
     /// You'll want to register SilkTouch mods during this action. See <see cref="SilkTouchRegistrationExtensions"/>.
     /// </param>
     public SilkTouchJob(
         string key,
         SilkTouchConfiguration config,
-        ILifetimeScope parentContainer,
-        Action<ContainerBuilder> configure
+        Action<IServiceCollection> configure
     )
     {
         Key = key;
         Config = config;
 
-        _logger = parentContainer.Resolve<ILogger<SilkTouchJob>>();
-        _inputResolver = parentContainer.Resolve<IInputResolver>();
-        _container = parentContainer.BeginLifetimeScope(builder =>
+        var services = new ServiceCollection();
         {
             // Register default dependencies
-            builder.RegisterType<DocumentFactory>().SingleInstance();
-            builder.RegisterType<FunctionTransformer>().SingleInstance();
+            services.AddSingleton<DocumentFactory>();
+            services.AddSingleton<FunctionTransformer>();
+            services.AddSingleton<ResponseFileHandler>();
+            services.AddSingleton<IBakeStrategy, DefaultBakeStrategy>();
 
             // Register user defined dependencies
-            configure.Invoke(builder);
-        });
+            configure.Invoke(services);
+        }
 
-        _modContextFactory = _container.Resolve<IModContextFactory>();
-        _documentFactory = _container.Resolve<DocumentFactory>();
-        Mods = _container.Resolve<IMod[]>();
+        Provider = services.BuildServiceProvider();
+        _logger = Provider.GetRequiredService<ILogger<SilkTouchJob>>();
+        _inputResolver = Provider.GetRequiredService<IInputResolver>();
+        _modContextFactory = Provider.GetRequiredService<IModContextFactory>();
+        _documentFactory = Provider.GetRequiredService<DocumentFactory>();
+        Mods = Provider.GetRequiredService<IEnumerable<IMod>>().ToArray();
     }
 
     /// <summary>
@@ -175,5 +181,5 @@ await File.ReadAllTextAsync(Config.DefaultLicenseHeader, ct)
     }
 
     /// <inheritdoc />
-    public void Dispose() => _container.Dispose();
+    public void Dispose() => Provider.Dispose();
 }
diff --git a/sources/SilkTouch/SilkTouch/SilkTouchRegistrationExtensions.cs b/sources/SilkTouch/SilkTouch/SilkTouchRegistrationExtensions.cs
index c6dc9061ba..7b397ccac5 100644
--- a/sources/SilkTouch/SilkTouch/SilkTouchRegistrationExtensions.cs
+++ b/sources/SilkTouch/SilkTouch/SilkTouchRegistrationExtensions.cs
@@ -1,8 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Autofac;
-using Autofac.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Silk.NET.SilkTouch.Clang;
 using Silk.NET.SilkTouch.Mods;
 using Silk.NET.SilkTouch.Mods.Transformation;
@@ -18,8 +17,8 @@ public static class SilkTouchRegistrationExtensions
     /// Entrypoint to the rest of the SilkTouch registration methods.
     /// Begins a <see cref="SilkTouchRegistrationContext"/>.
     /// </summary>
-    public static SilkTouchRegistrationContext SilkTouch(this ContainerBuilder builder) =>
-        new(builder);
+    public static SilkTouchRegistrationContext SilkTouch(this IServiceCollection services) =>
+        new(services);
 
     // Non-mods
     extension(SilkTouchRegistrationContext context)
@@ -42,11 +41,7 @@ public SilkTouchRegistrationContext WithDefaultFunctionTransformers(
         /// <returns></returns>
         public SilkTouchRegistrationContext WithPtrRefTransformer()
         {
-            context
-                .Builder.RegisterType<PtrRefTransformer>()
-                .AsImplementedInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsInterfaces<PtrRefTransformer>();
             return context;
         }
 
@@ -58,17 +53,9 @@ public SilkTouchRegistrationContext WithBoolTransformer(
             BoolTransformer.Configuration? boolTransformerConfig = null
         )
         {
-            context
-                .Builder.RegisterType<BoolTransformer>()
-                .WithParameter(
-                    new TypedParameter(
-                        typeof(BoolTransformer.Configuration),
-                        boolTransformerConfig ?? new()
-                    )
-                )
-                .AsImplementedInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsInterfaces<BoolTransformer>(
+                boolTransformerConfig ?? new()
+            );
             return context;
         }
 
@@ -78,11 +65,7 @@ public SilkTouchRegistrationContext WithBoolTransformer(
         /// <returns></returns>
         public SilkTouchRegistrationContext WithArrayParameterTransformer()
         {
-            context
-                .Builder.RegisterType<ArrayParameterTransformer>()
-                .AsImplementedInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsInterfaces<ArrayParameterTransformer>();
             return context;
         }
     }
@@ -97,14 +80,7 @@ public SilkTouchRegistrationContext AddApiProfiles(
             AddApiProfiles.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<AddApiProfiles>()
-                .WithParameter(
-                    new TypedParameter(typeof(AddApiProfiles.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<AddApiProfiles>(config ?? new());
             return context;
         }
 
@@ -113,12 +89,7 @@ public SilkTouchRegistrationContext AddApiProfiles(
         /// </summary>
         public SilkTouchRegistrationContext ClangScraper(ClangScraper.Configuration config)
         {
-            context
-                .Builder.RegisterType<ClangScraper>()
-                .WithParameter(new TypedParameter(typeof(ClangScraper.Configuration), config))
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ClangScraper>(config);
             return context;
         }
 
@@ -127,14 +98,7 @@ public SilkTouchRegistrationContext ClangScraper(ClangScraper.Configuration conf
         /// </summary>
         public SilkTouchRegistrationContext AddIncludes(AddIncludes.Configuration? config = null)
         {
-            context
-                .Builder.RegisterType<AddIncludes>()
-                .WithParameter(
-                    new TypedParameter(typeof(AddIncludes.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<AddIncludes>(config ?? new());
             return context;
         }
 
@@ -143,12 +107,7 @@ public SilkTouchRegistrationContext AddIncludes(AddIncludes.Configuration? confi
         /// </summary>
         public SilkTouchRegistrationContext AddOpaqueStructs(AddOpaqueStructs.Configuration config)
         {
-            context
-                .Builder.RegisterType<AddOpaqueStructs>()
-                .WithParameter(new TypedParameter(typeof(AddOpaqueStructs.Configuration), config))
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<AddOpaqueStructs>(config);
             return context;
         }
 
@@ -157,14 +116,7 @@ public SilkTouchRegistrationContext AddOpaqueStructs(AddOpaqueStructs.Configurat
         /// </summary>
         public SilkTouchRegistrationContext AddVTables(AddVTables.Configuration? config = null)
         {
-            context
-                .Builder.RegisterType<AddVTables>()
-                .WithParameter(
-                    new TypedParameter(typeof(AddVTables.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<AddVTables>(config ?? new());
             return context;
         }
 
@@ -173,12 +125,7 @@ public SilkTouchRegistrationContext AddVTables(AddVTables.Configuration? config
         /// </summary>
         public SilkTouchRegistrationContext BakeSourceSets(BakeSourceSets.Configuration config)
         {
-            context
-                .Builder.RegisterType<BakeSourceSets>()
-                .WithParameter(new TypedParameter(typeof(BakeSourceSets.Configuration), config))
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<BakeSourceSets>(config);
             return context;
         }
 
@@ -187,12 +134,7 @@ public SilkTouchRegistrationContext BakeSourceSets(BakeSourceSets.Configuration
         /// </summary>
         public SilkTouchRegistrationContext ChangeNamespace(ChangeNamespace.Configuration config)
         {
-            context
-                .Builder.RegisterType<ChangeNamespace>()
-                .WithParameter(new TypedParameter(typeof(ChangeNamespace.Configuration), config))
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ChangeNamespace>(config);
             return context;
         }
 
@@ -203,12 +145,7 @@ public SilkTouchRegistrationContext ChangeNativeClass(
             ChangeNativeClass.Configuration config
         )
         {
-            context
-                .Builder.RegisterType<ChangeNativeClass>()
-                .WithParameter(new TypedParameter(typeof(ChangeNativeClass.Configuration), config))
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ChangeNativeClass>(config);
             return context;
         }
 
@@ -217,11 +154,7 @@ ChangeNativeClass.Configuration config
         /// </summary>
         public SilkTouchRegistrationContext ExtractEnumConstants()
         {
-            context
-                .Builder.RegisterType<ExtractEnumConstants>()
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ExtractEnumConstants>();
             return context;
         }
 
@@ -230,11 +163,7 @@ public SilkTouchRegistrationContext ExtractEnumConstants()
         /// </summary>
         public SilkTouchRegistrationContext ExtractFunctionPointers()
         {
-            context
-                .Builder.RegisterType<ExtractFunctionPointers>()
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ExtractFunctionPointers>();
             return context;
         }
 
@@ -243,11 +172,7 @@ public SilkTouchRegistrationContext ExtractFunctionPointers()
         /// </summary>
         public SilkTouchRegistrationContext ExtractHandles()
         {
-            context
-                .Builder.RegisterType<ExtractHandles>()
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ExtractHandles>();
             return context;
         }
 
@@ -256,11 +181,7 @@ public SilkTouchRegistrationContext ExtractHandles()
         /// </summary>
         public SilkTouchRegistrationContext ExtractNestedTypes()
         {
-            context
-                .Builder.RegisterType<ExtractNestedTypes>()
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<ExtractNestedTypes>();
             return context;
         }
 
@@ -271,14 +192,7 @@ public SilkTouchRegistrationContext IdentifySharedPrefixes(
             IdentifySharedPrefixes.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<IdentifySharedPrefixes>()
-                .WithParameter(
-                    new TypedParameter(typeof(IdentifySharedPrefixes.Configuration), config)
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<IdentifySharedPrefixes>(config);
             return context;
         }
 
@@ -289,14 +203,7 @@ public SilkTouchRegistrationContext InterceptNativeFunctions(
             InterceptNativeFunctions.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<InterceptNativeFunctions>()
-                .WithParameter(
-                    new TypedParameter(typeof(InterceptNativeFunctions.Configuration), config)
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<InterceptNativeFunctions>(config);
             return context;
         }
 
@@ -305,11 +212,7 @@ public SilkTouchRegistrationContext InterceptNativeFunctions(
         /// </summary>
         public SilkTouchRegistrationContext MarkNativeNames()
         {
-            context
-                .Builder.RegisterType<MarkNativeNames>()
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<MarkNativeNames>();
             return context;
         }
 
@@ -320,14 +223,7 @@ public SilkTouchRegistrationContext MixKhronosData(
             MixKhronosData.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<MixKhronosData>()
-                .WithParameter(
-                    new TypedParameter(typeof(MixKhronosData.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<MixKhronosData>(config ?? new());
             return context;
         }
 
@@ -338,14 +234,7 @@ public SilkTouchRegistrationContext PrettifyNames(
             PrettifyNames.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<PrettifyNames>()
-                .WithParameter(
-                    new TypedParameter(typeof(PrettifyNames.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<PrettifyNames>(config ?? new());
             return context;
         }
 
@@ -356,14 +245,7 @@ public SilkTouchRegistrationContext StripAttributes(
             StripAttributes.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<StripAttributes>()
-                .WithParameter(
-                    new TypedParameter(typeof(StripAttributes.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<StripAttributes>(config ?? new());
             return context;
         }
 
@@ -374,14 +256,7 @@ public SilkTouchRegistrationContext TransformEnums(
             TransformEnums.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<TransformEnums>()
-                .WithParameter(
-                    new TypedParameter(typeof(TransformEnums.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<TransformEnums>(config ?? new());
             return context;
         }
 
@@ -390,11 +265,7 @@ public SilkTouchRegistrationContext TransformEnums(
         /// </summary>
         public SilkTouchRegistrationContext TransformFunctions()
         {
-            context
-                .Builder.RegisterType<TransformFunctions>()
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<TransformFunctions>();
             return context;
         }
 
@@ -405,14 +276,9 @@ public SilkTouchRegistrationContext TransformHandles(
             TransformHandles.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<TransformHandles>()
-                .WithParameter(
-                    new TypedParameter(typeof(TransformHandles.Configuration), config ?? new())
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<TransformHandles>(
+                config ?? new()
+            );
             return context;
         }
 
@@ -423,46 +289,58 @@ public SilkTouchRegistrationContext TransformProperties(
             TransformProperties.Configuration? config = null
         )
         {
-            context
-                .Builder.RegisterType<TransformProperties>()
-                .WithParameter(
-                    new TypedParameter(typeof(TransformProperties.Configuration), config)
-                )
-                .AsHierarchyAndInterfaces()
-                .SingleInstance();
-
+            context.Services.AddSingletonAsHierarchyAndInterfaces<TransformProperties>(config);
             return context;
         }
     }
 
-    extension<TLimit, TConcreteActivatorData>(
-        IRegistrationBuilder<TLimit, TConcreteActivatorData, SingleRegistrationStyle> registration
-    )
-        where TConcreteActivatorData : IConcreteActivatorData
+    extension(IServiceCollection services)
     {
-        private IRegistrationBuilder<
-            TLimit,
-            TConcreteActivatorData,
-            SingleRegistrationStyle
-        > AsHierarchyAndInterfaces()
-        {
-            var type = registration.ActivatorData.Activator.LimitType;
-            var typesToRegister = new HashSet<Type>();
-            typesToRegister.UnionWith(type.GetInterfaces());
+        private IServiceCollection AddSingletonAsInterfaces<T>(object? parameter = null)
+            where T : class => services.AddSingletonAs<T>(typeof(T).GetInterfaces(), parameter);
 
-            var current = type;
+        private IServiceCollection AddSingletonAsHierarchyAndInterfaces<T>(object? parameter = null)
+            where T : class
+        {
+            var types = new HashSet<Type>(typeof(T).GetInterfaces());
+            var current = typeof(T);
             while (current != null)
             {
-                typesToRegister.Add(current);
+                types.Add(current);
                 current = current.BaseType;
             }
 
-            return registration.As(typesToRegister.ToArray());
+            return services.AddSingletonAs<T>(types, parameter);
+        }
+
+        private IServiceCollection AddSingletonAs<T>(IEnumerable<Type> types, object? parameter)
+            where T : class
+        {
+            var key = new object();
+            object[] parameters = parameter is null ? [] : [parameter];
+
+            services.AddKeyedSingleton(
+                typeof(T),
+                key,
+                (sp, _) => ActivatorUtilities.CreateInstance<T>(sp, parameters)
+            );
+
+            services.AddSingleton(typeof(T), sp => sp.GetRequiredKeyedService<T>(key));
+
+            foreach (var type in types)
+            {
+                if (type != typeof(T))
+                {
+                    services.AddSingleton(type, sp => sp.GetRequiredKeyedService<T>(key));
+                }
+            }
+
+            return services;
         }
     }
 
     /// <summary>
-    /// Helper for registering SilkTouch to a <see cref="ContainerBuilder"/>
+    /// Helper for registering SilkTouch to a <see cref="IServiceCollection"/>
     /// </summary>
-    public record struct SilkTouchRegistrationContext(ContainerBuilder Builder);
+    public record struct SilkTouchRegistrationContext(IServiceCollection Services);
 }