diff --git a/src/changelog/3.4.0/306-usable-from-a-publishaot-build.xml b/src/changelog/3.4.0/306-usable-from-a-publishaot-build.xml
new file mode 100644
index 000000000..62c79d4a0
--- /dev/null
+++ b/src/changelog/3.4.0/306-usable-from-a-publishaot-build.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<entry xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns="https://logging.apache.org/xml/ns"
+       xsi:schemaLocation="https://logging.apache.org/xml/ns https://logging.apache.org/xml/ns/log4j-changelog-0.xsd"
+       type="fixed">
+  <issue id="233" link="https://github.com/apache/logging-log4net/issues/233"/>
+  <issue id="306" link="https://github.com/apache/logging-log4net/pull/306"/>
+  <description format="asciidoc">Make log4net usable from a `PublishAot` build, where `LogManager.GetLogger()`
+  used to throw `PlatformNotSupportedException` from `Assembly.GetCallingAssembly()`, and where
+  repositories and pattern converters were left without a constructor by the trimmer. Configuration
+  has to be done in code - see the new
+  https://logging.apache.org/log4net/latest/manual/native-aot.html[Native AOT and trimming] page
+  (reported by @vpenades, implemented by @FreeAndNil in https://github.com/apache/logging-log4net/pull/306[#306])</description>
+</entry>
diff --git a/src/log4net.Tests/Util/CallerAssemblyTest.cs b/src/log4net.Tests/Util/CallerAssemblyTest.cs
new file mode 100644
index 000000000..cfc134696
--- /dev/null
+++ b/src/log4net.Tests/Util/CallerAssemblyTest.cs
@@ -0,0 +1,76 @@
+#region Apache License
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to you under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#endregion
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using log4net.Util;
+using NUnit.Framework;
+
+namespace log4net.Tests.Util;
+
+/// <summary>
+/// Tests for <see cref="CallerAssembly"/>, the guard that keeps the
+/// <see cref="Assembly.GetCallingAssembly()"/> based overloads usable under Native AOT.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The AOT half of the behaviour cannot be covered here - these tests always run on a JIT
+/// runtime, where <see cref="CallerAssembly.IsSupported"/> is <see langword="true"/> and
+/// <see cref="CallerAssembly.Fallback"/> is never consulted. What they do cover is that the
+/// guard stays inert on a JIT runtime, so that no call site silently starts attributing
+/// loggers to the entry assembly instead of the caller.
+/// </para>
+/// </remarks>
+[TestFixture]
+public class CallerAssemblyTest
+{
+  /// <summary>
+  /// The probe recognises a runtime that does implement
+  /// <see cref="Assembly.GetCallingAssembly()"/>, so the guard stays out of the way everywhere
+  /// except Native AOT. A false negative here would silently move every logger to the entry
+  /// assembly's repository.
+  /// </summary>
+  [Test]
+  public void IsSupportedOnAJitRuntime() => Assert.That(CallerAssembly.IsSupported, Is.True);
+
+  /// <summary>
+  /// There is always a replacement assembly to attribute a call to, even though the entry
+  /// assembly is <see langword="null"/> in a host without a managed entry point.
+  /// </summary>
+  [Test]
+  public void FallbackIsAvailable() => Assert.That(CallerAssembly.Fallback, Is.Not.Null);
+
+  /// <summary>
+  /// The guard has to leave <see cref="Assembly.GetCallingAssembly()"/> in the method whose
+  /// caller is wanted, so a call from this assembly still resolves to this assembly.
+  /// </summary>
+  [Test]
+  public void GuardedCallStillReportsTheCallersAssembly()
+    => Assert.That(GuardedCallingAssembly(), Is.SameAs(typeof(CallerAssemblyTest).Assembly));
+
+  /// <summary>
+  /// Stands in for a public log4net entry point. Inlining is suppressed because it would
+  /// hand <see cref="Assembly.GetCallingAssembly()"/> a different frame - the same effect
+  /// that makes the release build of <see cref="SystemInfoTest"/> unable to assert on an
+  /// exact assembly.
+  /// </summary>
+  [MethodImpl(MethodImplOptions.NoInlining)]
+  private static Assembly GuardedCallingAssembly()
+    => CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback;
+}
diff --git a/src/log4net.Tests/Util/SystemInfoTest.cs b/src/log4net.Tests/Util/SystemInfoTest.cs
index 9b9067c91..c24914ff1 100644
--- a/src/log4net.Tests/Util/SystemInfoTest.cs
+++ b/src/log4net.Tests/Util/SystemInfoTest.cs
@@ -23,6 +23,8 @@
 
 using NUnit.Framework;
 
+using System.Configuration;
+using System.IO;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -171,4 +173,102 @@ public void EqualsIgnoringCase_DifferentStrings_false()
   [Platform(Include = "Win,Linux,MacOsX")]
   public void IsAndoid()
     => Assert.That(typeof(SystemInfo).GetProperty("IsAndroid", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null), Is.False);
+
+  /// <summary>
+  /// <see cref="SystemInfo.GetAppSetting"/> falls back to environment variables once the
+  /// configuration system has failed - which is what happens under Native AOT, where
+  /// System.Configuration is trimmed away.
+  /// </summary>
+  /// <remarks>
+  /// <para>
+  /// That failure cannot be provoked on a JIT runtime, so the latch that records it is flipped
+  /// directly, the same way <see cref="IsAndoid"/> reaches a non-public member. The environment
+  /// must stay untouched while the configuration system still works, otherwise a malformed
+  /// <c>app.config</c> would silently change where every setting comes from.
+  /// </para>
+  /// </remarks>
+  [Test]
+  [NonParallelizable]
+  public void GetAppSettingFallsBackToTheEnvironmentOnceConfigurationIsUnavailable()
+  {
+    const string Key = "log4net.Tests.AppSettingFallback";
+    const string Value = "from-the-environment";
+
+    FieldInfo latch = AppSettingsUnavailableLatch();
+    bool originalLatch = (bool)latch.GetValue(null)!;
+    Environment.SetEnvironmentVariable(Key, Value);
+    try
+    {
+      latch.SetValue(null, false);
+      Assert.That(SystemInfo.GetAppSetting(Key), Is.Null);
+
+      latch.SetValue(null, true);
+      Assert.That(SystemInfo.GetAppSetting(Key), Is.EqualTo(Value));
+    }
+    finally
+    {
+      latch.SetValue(null, originalLatch);
+      Environment.SetEnvironmentVariable(Key, null);
+    }
+  }
+
+  /// <summary>
+  /// A key that is missing from the environment as well reads as <see langword="null"/>, so the
+  /// fallback leaves callers with the same "no such setting" answer they get from a working
+  /// configuration system.
+  /// </summary>
+  [Test]
+  [NonParallelizable]
+  public void GetAppSettingReturnsNullForAnUnsetEnvironmentVariable()
+  {
+    FieldInfo latch = AppSettingsUnavailableLatch();
+    bool originalLatch = (bool)latch.GetValue(null)!;
+    try
+    {
+      latch.SetValue(null, true);
+      Assert.That(SystemInfo.GetAppSetting("log4net.Tests.NoSuchSettingAnywhere"), Is.Null);
+    }
+    finally
+    {
+      latch.SetValue(null, originalLatch);
+    }
+  }
+
+  /// <summary>
+  /// A configuration file that does not parse is reported, not routed to the environment - the
+  /// behaviour on every runtime that has a working configuration system is unchanged.
+  /// </summary>
+  [Test]
+  public void MalformedConfigurationIsNotTreatedAsAMissingConfigurationSystem()
+    => Assert.That(IsMissingConfigurationSystem(new ConfigurationErrorsException("malformed")), Is.False);
+
+  /// <summary>
+  /// Native AOT surfaces a trimmed configuration system as a <see cref="ConfigurationErrorsException"/>,
+  /// the same type a malformed file produces, so only the inner exception tells them apart.
+  /// </summary>
+  [Test]
+  public void TrimmedConfigurationSystemIsRecognisedThroughTheInnerException()
+    => Assert.That(IsMissingConfigurationSystem(
+        new ConfigurationErrorsException("Configuration system failed to initialize",
+          new MissingMethodException("No parameterless constructor defined for type 'System.Configuration.ClientConfigurationHost'."))),
+      Is.True);
+
+  /// <summary>
+  /// A deployment without the System.Configuration.ConfigurationManager assembly fails on the
+  /// outermost exception rather than an inner one.
+  /// </summary>
+  [Test]
+  public void MissingConfigurationAssemblyIsRecognised()
+    => Assert.That(IsMissingConfigurationSystem(new FileNotFoundException("System.Configuration.ConfigurationManager")), Is.True);
+
+  private static bool IsMissingConfigurationSystem(Exception exception)
+  {
+    MethodInfo method = typeof(SystemInfo).GetMethod("IsMissingConfigurationSystem", BindingFlags.Static | BindingFlags.NonPublic)
+      ?? throw new InvalidOperationException("SystemInfo.IsMissingConfigurationSystem no longer exists - update this test along with it.");
+    return (bool)method.Invoke(null, [exception])!;
+  }
+
+  private static FieldInfo AppSettingsUnavailableLatch()
+    => typeof(SystemInfo).GetField("_configurationSystemUnavailable", BindingFlags.Static | BindingFlags.NonPublic)
+      ?? throw new InvalidOperationException("SystemInfo._configurationSystemUnavailable no longer exists - update this test along with it.");
 }
\ No newline at end of file
diff --git a/src/log4net.Tests/log4net.Tests.csproj b/src/log4net.Tests/log4net.Tests.csproj
index 1ce53b952..f9668c7a3 100644
--- a/src/log4net.Tests/log4net.Tests.csproj
+++ b/src/log4net.Tests/log4net.Tests.csproj
@@ -19,6 +19,7 @@
     <VSTestLogger>quackers</VSTestLogger>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="..\log4net\Util\CallerAssembly.cs" Link="Util\CallerAssembly.cs" />
     <Compile Include="..\log4net\Diagnostics\CodeAnalysis\CallerArgumentExpressionAttribute.cs" Link="Diagnostics\CodeAnalysis\CallerArgumentExpressionAttribute.cs" />
     <Compile Include="..\log4net\Diagnostics\CodeAnalysis\IsExternalInit.cs" Link="Diagnostics\CodeAnalysis\IsExternalInit.cs" />
   </ItemGroup>
diff --git a/src/log4net/Appender/FileAppender.cs b/src/log4net/Appender/FileAppender.cs
index 5b444afd2..993e2974e 100644
--- a/src/log4net/Appender/FileAppender.cs
+++ b/src/log4net/Appender/FileAppender.cs
@@ -19,6 +19,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Runtime.Serialization;
 using System.Text;
@@ -838,14 +839,21 @@ public override void OnClose()
   /// <summary>
   /// Default locking model (when no locking model was configured)
   /// </summary>
+  [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
   private static Type _defaultLockingModelType = typeof(ExclusiveLock);
 
   /// <summary>
   /// Specify default locking model
   /// </summary>
   /// <typeparam name="TLockingModel">Type of LockingModel</typeparam>
-  public static void SetDefaultLockingModelType<TLockingModel>()
-    where TLockingModel : LockingModelBase
+  /// <remarks>
+  /// <para>
+  /// The locking model is created with <see cref="Activator.CreateInstance(Type)"/>, so the
+  /// <c>new()</c> constraint is what keeps its constructor alive in a trimmed or Native AOT build.
+  /// </para>
+  /// </remarks>
+  public static void SetDefaultLockingModelType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TLockingModel>()
+    where TLockingModel : LockingModelBase, new()
     => _defaultLockingModelType = typeof(TLockingModel);
 
   /// <summary>
diff --git a/src/log4net/Config/BasicConfigurator.cs b/src/log4net/Config/BasicConfigurator.cs
index ea7dfa684..2af06e672 100644
--- a/src/log4net/Config/BasicConfigurator.cs
+++ b/src/log4net/Config/BasicConfigurator.cs
@@ -73,7 +73,8 @@ public static class BasicConfigurator
   /// layout style.
   /// </para>
   /// </remarks>
-  public static ICollection Configure() => Configure(LogManager.GetRepository(Assembly.GetCallingAssembly()));
+  public static ICollection Configure()
+    => Configure(LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback));
 
   /// <summary>
   /// Initializes the log4net system using the specified appenders.
@@ -88,7 +89,7 @@ public static ICollection Configure(params IAppender[] appenders)
   {
     List<LogLog> configurationMessages = new();
 
-    ILoggerRepository repository = LogManager.GetRepository(Assembly.GetCallingAssembly());
+    ILoggerRepository repository = LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
     using (new LogLog.LogReceivedAdapter(configurationMessages))
     {
diff --git a/src/log4net/Config/RepositoryAttribute.cs b/src/log4net/Config/RepositoryAttribute.cs
index fd5c6308e..5cba2d6ec 100644
--- a/src/log4net/Config/RepositoryAttribute.cs
+++ b/src/log4net/Config/RepositoryAttribute.cs
@@ -18,6 +18,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace log4net.Config;
 
@@ -104,5 +105,6 @@ public RepositoryAttribute()
   /// repository.
   /// </para>
   /// </remarks>
+  [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] 
   public Type? RepositoryType { get; set; }
 }
\ No newline at end of file
diff --git a/src/log4net/Config/XmlConfigurator.cs b/src/log4net/Config/XmlConfigurator.cs
index fa060cb1d..e7ffd2db5 100644
--- a/src/log4net/Config/XmlConfigurator.cs
+++ b/src/log4net/Config/XmlConfigurator.cs
@@ -140,7 +140,7 @@ private static void InternalConfigure(ILoggerRepository repository, Func<XmlElem
   /// </remarks>
   /// <seealso cref="Log4NetConfigurationSectionHandler"/>
   public static ICollection Configure() 
-    => Configure(LogManager.GetRepository(Assembly.GetCallingAssembly()));
+    => Configure(LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback));
 
   /// <summary>
   /// Configures log4net using a <c>log4net</c> element
@@ -156,7 +156,7 @@ public static ICollection Configure(XmlElement element)
   {
     List<LogLog> configurationMessages = [];
 
-    ILoggerRepository repository = LogManager.GetRepository(Assembly.GetCallingAssembly());
+    ILoggerRepository repository = LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
     using (new LogLog.LogReceivedAdapter(configurationMessages))
     {
@@ -222,9 +222,11 @@ public static ICollection Configure(FileInfo configFile)
   {
     List<LogLog> configurationMessages = [];
 
+    Assembly repositoryAssembly = CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback;
+
     using (new LogLog.LogReceivedAdapter(configurationMessages))
     {
-      InternalConfigure(LogManager.GetRepository(Assembly.GetCallingAssembly()), configFile);
+      InternalConfigure(LogManager.GetRepository(repositoryAssembly), configFile);
     }
 
     return configurationMessages;
@@ -248,7 +250,7 @@ public static ICollection Configure(Uri configUri)
   {
     List<LogLog> configurationMessages = [];
 
-    ILoggerRepository repository = LogManager.GetRepository(Assembly.GetCallingAssembly());
+    ILoggerRepository repository = LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
     using (new LogLog.LogReceivedAdapter(configurationMessages))
     {
       InternalConfigure(repository, configUri);
@@ -277,7 +279,7 @@ public static ICollection Configure(Stream configStream)
   {
     List<LogLog> configurationMessages = [];
 
-    ILoggerRepository repository = LogManager.GetRepository(Assembly.GetCallingAssembly());
+    ILoggerRepository repository = LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
     using (new LogLog.LogReceivedAdapter(configurationMessages))
     {
       InternalConfigure(repository, configStream);
@@ -644,7 +646,7 @@ public static ICollection ConfigureAndWatch(FileInfo configFile)
   {
     List<LogLog> configurationMessages = [];
 
-    ILoggerRepository repository = LogManager.GetRepository(Assembly.GetCallingAssembly());
+    ILoggerRepository repository = LogManager.GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
     using (new LogLog.LogReceivedAdapter(configurationMessages))
     {
diff --git a/src/log4net/Core/DefaultRepositorySelector.cs b/src/log4net/Core/DefaultRepositorySelector.cs
index a14d6c820..406f11529 100644
--- a/src/log4net/Core/DefaultRepositorySelector.cs
+++ b/src/log4net/Core/DefaultRepositorySelector.cs
@@ -21,6 +21,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 
 using log4net.Config;
@@ -71,12 +72,13 @@ public class DefaultRepositorySelector : IRepositorySelector
   /// </remarks>
   /// <exception cref="ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null" />.</exception>
   /// <exception cref="ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="ILoggerRepository"/>.</exception>
-  public DefaultRepositorySelector(Type defaultRepositoryType)
+  public DefaultRepositorySelector([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type defaultRepositoryType)
   {
     // Check that the type is a repository
     if (!typeof(ILoggerRepository).IsAssignableFrom(defaultRepositoryType.EnsureNotNull()))
     {
-      throw SystemInfo.CreateArgumentOutOfRangeException("defaultRepositoryType", defaultRepositoryType, $"Parameter: defaultRepositoryType, Value: [{defaultRepositoryType}] out of range. Argument must implement the ILoggerRepository interface");
+      throw SystemInfo.CreateArgumentOutOfRangeException("defaultRepositoryType", defaultRepositoryType, 
+        $"Parameter: defaultRepositoryType, Value: [{defaultRepositoryType}] out of range. Argument must implement the ILoggerRepository interface");
     }
 
     this._defaultRepositoryType = defaultRepositoryType;
@@ -175,7 +177,8 @@ public ILoggerRepository GetRepository(string repositoryName)
   /// </para>
   /// </remarks>
   /// <exception cref="ArgumentNullException"><paramref name="assembly"/> is <see langword="null" />.</exception>
-  public ILoggerRepository CreateRepository(Assembly assembly, Type repositoryType) 
+  public ILoggerRepository CreateRepository(Assembly assembly, 
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType) 
     => CreateRepository(assembly, repositoryType, DefaultRepositoryName, true);
 
   /// <summary>
@@ -216,7 +219,9 @@ public ILoggerRepository CreateRepository(Assembly assembly, Type repositoryType
   /// </para>
   /// </remarks>
   /// <exception cref="ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null" />.</exception>
-  public ILoggerRepository CreateRepository(Assembly repositoryAssembly, Type? repositoryType, string repositoryName, bool readAssemblyAttributes)
+  public ILoggerRepository CreateRepository(Assembly repositoryAssembly, 
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type? repositoryType, 
+    string repositoryName, bool readAssemblyAttributes)
   {
     repositoryAssembly.EnsureNotNull();
 
@@ -305,7 +310,8 @@ public ILoggerRepository CreateRepository(Assembly repositoryAssembly, Type? rep
   /// </remarks>
   /// <exception cref="ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null" />.</exception>
   /// <exception cref="LogException"><paramref name="repositoryName"/> already exists.</exception>
-  public ILoggerRepository CreateRepository(string repositoryName, Type? repositoryType)
+  public ILoggerRepository CreateRepository(string repositoryName, 
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type? repositoryType)
   {
     repositoryName.EnsureNotNull();
 
@@ -479,7 +485,8 @@ protected virtual void OnLoggerRepositoryCreatedEvent(ILoggerRepository reposito
   /// <param name="repositoryName">in/out param to hold the repository name to use for the assembly, caller should set this to the default value before calling.</param>
   /// <param name="repositoryType">in/out param to hold the type of the repository to create for the assembly, caller should set this to the default value before calling.</param>
   /// <exception cref="ArgumentNullException"><paramref name="assembly" /> is <see langword="null" />.</exception>
-  private void GetInfoForAssembly(Assembly assembly, ref string repositoryName, ref Type repositoryType)
+  private void GetInfoForAssembly(Assembly assembly, ref string repositoryName,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] ref Type repositoryType)
   {
     assembly.EnsureNotNull();
 
@@ -735,5 +742,7 @@ private void LoadAliases(Assembly assembly, ILoggerRepository repository)
   private readonly Dictionary<string, ILoggerRepository> _name2Repository = new(StringComparer.Ordinal);
   private readonly Dictionary<Assembly, ILoggerRepository> _assembly2Repository = [];
   private readonly Dictionary<string, ILoggerRepository> _alias2Repository = new(StringComparer.Ordinal);
+
+  [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] 
   private readonly Type _defaultRepositoryType;
 }
\ No newline at end of file
diff --git a/src/log4net/Core/IRepositorySelector.cs b/src/log4net/Core/IRepositorySelector.cs
index 2ac3d52d8..30b85186d 100644
--- a/src/log4net/Core/IRepositorySelector.cs
+++ b/src/log4net/Core/IRepositorySelector.cs
@@ -18,6 +18,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 
 using log4net.Repository;
@@ -127,7 +128,8 @@ public interface IRepositorySelector
   /// this association.
   /// </para>
   /// </remarks>
-  ILoggerRepository CreateRepository(Assembly assembly, Type repositoryType);
+  ILoggerRepository CreateRepository(Assembly assembly,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType);
 
   /// <summary>
   /// Creates a new repository with the name specified.
@@ -142,7 +144,8 @@ public interface IRepositorySelector
   /// same name will return the same repository instance.
   /// </para>
   /// </remarks>
-  ILoggerRepository CreateRepository(string repositoryName, Type? repositoryType);
+  ILoggerRepository CreateRepository(string repositoryName,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type? repositoryType);
 
   /// <summary>
   /// Test if a named repository exists
diff --git a/src/log4net/Core/LoggerManager.cs b/src/log4net/Core/LoggerManager.cs
index 3ef057959..29176c800 100644
--- a/src/log4net/Core/LoggerManager.cs
+++ b/src/log4net/Core/LoggerManager.cs
@@ -18,6 +18,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text;
 using log4net.Util;
@@ -466,7 +467,8 @@ public static ILoggerRepository CreateRepository(string repository)
   /// </para>
   /// </remarks>
   /// <exception cref="LogException">The specified repository already exists.</exception>
-  public static ILoggerRepository CreateRepository(string repository, Type repositoryType)
+  public static ILoggerRepository CreateRepository(string repository,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType)
     => RepositorySelector.CreateRepository(repository.EnsureNotNull(), repositoryType.EnsureNotNull());
 
   /// <summary>
@@ -484,7 +486,8 @@ public static ILoggerRepository CreateRepository(string repository, Type reposit
   /// same assembly specified will return the same repository instance.
   /// </para>
   /// </remarks>
-  public static ILoggerRepository CreateRepository(Assembly repositoryAssembly, Type repositoryType)
+  public static ILoggerRepository CreateRepository(Assembly repositoryAssembly,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType)
     => RepositorySelector.CreateRepository(repositoryAssembly.EnsureNotNull(), repositoryType.EnsureNotNull());
 
   /// <summary>
diff --git a/src/log4net/Diagnostics/CodeAnalysis/DynamicallyAccessedMemberTypes.cs b/src/log4net/Diagnostics/CodeAnalysis/DynamicallyAccessedMemberTypes.cs
new file mode 100644
index 000000000..54cda914c
--- /dev/null
+++ b/src/log4net/Diagnostics/CodeAnalysis/DynamicallyAccessedMemberTypes.cs
@@ -0,0 +1,53 @@
+#region Apache License
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to you under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#endregion
+
+// inspired by https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/DynamicallyAccessedMemberTypes.cs
+
+#if !NET6_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Specifies the types of members that are dynamically accessed.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The trimmer matches this type by its full name rather than by identity, so the values have to
+/// keep the numbering the framework uses. Only the members log4net annotates with are declared;
+/// add further ones from the runtime source above as they are needed.
+/// </para>
+/// </remarks>
+[Flags]
+internal enum DynamicallyAccessedMemberTypes
+{
+  /// <summary>
+  /// Specifies no members.
+  /// </summary>
+  None = 0,
+
+  /// <summary>
+  /// Specifies the default, parameterless public constructor.
+  /// </summary>
+  PublicParameterlessConstructor = 0x0001,
+
+  /// <summary>
+  /// Specifies all public constructors.
+  /// </summary>
+  PublicConstructors = 0x0002 | PublicParameterlessConstructor,
+}
+#endif
diff --git a/src/log4net/Diagnostics/CodeAnalysis/DynamicallyAccessedMembersAttribute.cs b/src/log4net/Diagnostics/CodeAnalysis/DynamicallyAccessedMembersAttribute.cs
new file mode 100644
index 000000000..421f56ca7
--- /dev/null
+++ b/src/log4net/Diagnostics/CodeAnalysis/DynamicallyAccessedMembersAttribute.cs
@@ -0,0 +1,49 @@
+#region Apache License
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to you under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#endregion
+
+// inspired by https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/DynamicallyAccessedMembersAttribute.cs
+
+#if !NET6_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// States which members of a <see cref="Type"/> are accessed dynamically, so that a trimmer keeps
+/// them instead of removing them as unused.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Neither <c>net462</c> nor <c>netstandard2.0</c> declares this attribute, but the trimmer
+/// recognizes it by full name, so a library can supply its own and still be understood - which is
+/// what lets log4net keep working when a consumer publishes with <c>PublishAot</c> or
+/// <c>PublishTrimmed</c>.
+/// </para>
+/// </remarks>
+/// <param name="memberTypes">The members that are dynamically accessed.</param>
+[AttributeUsage(
+  AttributeTargets.Field | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter
+  | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Method,
+  Inherited = false)]
+internal sealed class DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes) : Attribute
+{
+  /// <summary>
+  /// Gets the members that are dynamically accessed.
+  /// </summary>
+  public DynamicallyAccessedMemberTypes MemberTypes { get; } = memberTypes;
+}
+#endif
diff --git a/src/log4net/Layout/PatternLayout.cs b/src/log4net/Layout/PatternLayout.cs
index 29e64746a..d1bf32cd2 100644
--- a/src/log4net/Layout/PatternLayout.cs
+++ b/src/log4net/Layout/PatternLayout.cs
@@ -18,6 +18,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Collections.Generic;
 using System.IO;
 
@@ -820,84 +821,78 @@ public class PatternLayout : LayoutSkeleton
   /// This static map is overridden by the converterRegistry instance map
   /// </para>
   /// </remarks>
-  private static readonly Dictionary<string, Type> _sGlobalRulesRegistry = new(StringComparer.Ordinal)
+  private static readonly Dictionary<string, ConverterInfo> _sGlobalRulesRegistry = CreateGlobalRulesRegistry();
+
+  /// <summary>
+  /// Builds the registry of built-in pattern converters.
+  /// </summary>
+  /// <returns>the built-in rules, keyed by the name used in a conversion pattern</returns>
+  /// <remarks>
+  /// <para>
+  /// The registry holds <see cref="ConverterInfo"/> rather than a bare <see cref="Type"/> because a
+  /// <see cref="Type"/> put into a collection loses any
+  /// <see cref="System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute"/> annotation,
+  /// which is what left these converters without a constructor once a Native AOT build had trimmed
+  /// them. <see cref="ConverterInfo.Type"/> carries the annotation, so it survives the round trip.
+  /// </para>
+  /// <para>
+  /// The <c>new()</c> constraint states the same requirement a second time, structurally: a
+  /// converter that loses its public parameterless constructor becomes a compile error here rather
+  /// than a run-time failure that only shows up in a trimmed build.
+  /// </para>
+  /// </remarks>
+  private static Dictionary<string, ConverterInfo> CreateGlobalRulesRegistry()
   {
-    ["literal"] = typeof(LiteralPatternConverter),
-    ["newline"] = typeof(NewLinePatternConverter),
-    ["n"] = typeof(NewLinePatternConverter),
+    Dictionary<string, ConverterInfo> rules = new(StringComparer.Ordinal);
+
+    Add<LiteralPatternConverter>("literal");
+    Add<NewLinePatternConverter>("newline", "n");
 
     // .NET Standard has no support for ASP.NET
 #if NET462_OR_GREATER
-    ["aspnet-cache"] = typeof(AspNetCachePatternConverter),
-    ["aspnet-context"] = typeof(AspNetContextPatternConverter),
-    ["aspnet-request"] = typeof(AspNetRequestPatternConverter),
-    ["aspnet-session"] = typeof(AspNetSessionPatternConverter),
+    Add<AspNetCachePatternConverter>("aspnet-cache");
+    Add<AspNetContextPatternConverter>("aspnet-context");
+    Add<AspNetRequestPatternConverter>("aspnet-request");
+    Add<AspNetSessionPatternConverter>("aspnet-session");
 #endif
 
-    ["c"] = typeof(LoggerPatternConverter),
-    ["logger"] = typeof(LoggerPatternConverter),
-
-    ["C"] = typeof(TypeNamePatternConverter),
-    ["class"] = typeof(TypeNamePatternConverter),
-    ["type"] = typeof(TypeNamePatternConverter),
-
-    ["d"] = typeof(DatePatternConverter),
-    ["date"] = typeof(DatePatternConverter),
-
-    ["exception"] = typeof(ExceptionPatternConverter),
-
-    ["F"] = typeof(FileLocationPatternConverter),
-    ["file"] = typeof(FileLocationPatternConverter),
-
-    ["l"] = typeof(FullLocationPatternConverter),
-    ["location"] = typeof(FullLocationPatternConverter),
-
-    ["L"] = typeof(LineLocationPatternConverter),
-    ["line"] = typeof(LineLocationPatternConverter),
-
-    ["m"] = typeof(MessagePatternConverter),
-    ["message"] = typeof(MessagePatternConverter),
-
-    ["M"] = typeof(MethodLocationPatternConverter),
-    ["method"] = typeof(MethodLocationPatternConverter),
-
-    ["p"] = typeof(LevelPatternConverter),
-    ["level"] = typeof(LevelPatternConverter),
-
-    ["P"] = typeof(PropertyPatternConverter),
-    ["property"] = typeof(PropertyPatternConverter),
-    ["properties"] = typeof(PropertyPatternConverter),
-
-    ["r"] = typeof(RelativeTimePatternConverter),
-    ["timestamp"] = typeof(RelativeTimePatternConverter),
-
-    ["stacktrace"] = typeof(StackTracePatternConverter),
-    ["stacktracedetail"] = typeof(StackTraceDetailPatternConverter),
-
-    ["t"] = typeof(ThreadPatternConverter),
-    ["thread"] = typeof(ThreadPatternConverter),
+    Add<LoggerPatternConverter>("c", "logger");
+    Add<TypeNamePatternConverter>("C", "class", "type");
+    Add<DatePatternConverter>("d", "date");
+    Add<ExceptionPatternConverter>("exception");
+    Add<FileLocationPatternConverter>("F", "file");
+    Add<FullLocationPatternConverter>("l", "location");
+    Add<LineLocationPatternConverter>("L", "line");
+    Add<MessagePatternConverter>("m", "message");
+    Add<MethodLocationPatternConverter>("M", "method");
+    Add<LevelPatternConverter>("p", "level");
+    Add<RelativeTimePatternConverter>("r", "timestamp");
+    Add<StackTracePatternConverter>("stacktrace");
+    Add<StackTraceDetailPatternConverter>("stacktracedetail");
+    Add<ThreadPatternConverter>("t", "thread");
 
     // For backwards compatibility the NDC patterns
-    ["x"] = typeof(NdcPatternConverter),
-    ["ndc"] = typeof(NdcPatternConverter),
+    Add<NdcPatternConverter>("x", "ndc");
 
     // For backwards compatibility the MDC patterns just do a property lookup
-    ["X"] = typeof(PropertyPatternConverter),
-    ["mdc"] = typeof(PropertyPatternConverter),
-
-    ["a"] = typeof(AppDomainPatternConverter),
-    ["appdomain"] = typeof(AppDomainPatternConverter),
+    Add<PropertyPatternConverter>("P", "property", "properties", "X", "mdc");
 
-    ["u"] = typeof(IdentityPatternConverter),
-    ["identity"] = typeof(IdentityPatternConverter),
+    Add<AppDomainPatternConverter>("a", "appdomain");
+    Add<IdentityPatternConverter>("u", "identity");
+    Add<UtcDatePatternConverter>("utcdate", "utcDate", "UtcDate");
+    Add<UserNamePatternConverter>("w", "username");
 
-    ["utcdate"] = typeof(UtcDatePatternConverter),
-    ["utcDate"] = typeof(UtcDatePatternConverter),
-    ["UtcDate"] = typeof(UtcDatePatternConverter),
+    return rules;
 
-    ["w"] = typeof(UserNamePatternConverter),
-    ["username"] = typeof(UserNamePatternConverter),
-  };
+    void Add<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(
+      params string[] names) where T : PatternConverter, new()
+    {
+      foreach (string name in names)
+      {
+        rules[name] = new() { Name = name, Type = typeof(T) };
+      }
+    }
+  }
 
   /// <summary>
   /// the head of the pattern converter chain
@@ -983,14 +978,9 @@ protected virtual PatternParser CreatePatternParser(string pattern)
     PatternParser patternParser = new(pattern);
 
     // Add all the builtin patterns
-    foreach (KeyValuePair<string, Type> entry in _sGlobalRulesRegistry)
+    foreach (KeyValuePair<string, ConverterInfo> entry in _sGlobalRulesRegistry)
     {
-      ConverterInfo converterInfo = new()
-      {
-        Name = entry.Key,
-        Type = entry.Value
-      };
-      patternParser.PatternConverters[entry.Key] = converterInfo;
+      patternParser.PatternConverters[entry.Key] = entry.Value;
     }
     // Add the instance patterns
     foreach (KeyValuePair<string, ConverterInfo> entry in _instanceRulesRegistry)
@@ -1093,7 +1083,8 @@ public void AddConverter(ConverterInfo converterInfo)
   /// <see cref="PatternConverter"/> type.
   /// </para>
   /// </remarks>
-  public void AddConverter(string name, Type type) => AddConverter(new()
+  public void AddConverter(string name,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type) => AddConverter(new()
   {
     Name = name.EnsureNotNull(),
     Type = type.EnsureNotNull()
diff --git a/src/log4net/LogManager.cs b/src/log4net/LogManager.cs
index cc255a540..36e958b86 100644
--- a/src/log4net/LogManager.cs
+++ b/src/log4net/LogManager.cs
@@ -71,7 +71,8 @@ public static class LogManager
   /// </remarks>
   /// <param name="name">The fully qualified logger name to look for.</param>
   /// <returns>The logger found, or <see langword="null"/> if no logger could be found.</returns>
-  public static ILog? Exists(string name) => Exists(Assembly.GetCallingAssembly(), name);
+  public static ILog? Exists(string name)
+    => Exists(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback, name);
 
   /// <overloads>Get the currently defined loggers.</overloads>
   /// <summary>
@@ -81,7 +82,8 @@ public static class LogManager
   /// <para>The root logger is <b>not</b> included in the returned array.</para>
   /// </remarks>
   /// <returns>All the defined loggers.</returns>
-  public static ILog[] GetCurrentLoggers() => GetCurrentLoggers(Assembly.GetCallingAssembly());
+  public static ILog[] GetCurrentLoggers()
+    => GetCurrentLoggers(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
   /// <overloads>Get or create a logger.</overloads>
   /// <summary>
@@ -101,7 +103,8 @@ public static class LogManager
   /// </remarks>
   /// <param name="name">The name of the logger to retrieve.</param>
   /// <returns>The logger with the name specified.</returns>
-  public static ILog GetLogger(string name) => GetLogger(Assembly.GetCallingAssembly(), name);
+  public static ILog GetLogger(string name)
+    => GetLogger(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback, name);
 
   /// <summary>
   /// Returns the named logger if it exists.
@@ -119,7 +122,8 @@ public static class LogManager
   /// The logger found, or <see langword="null"/> if the logger doesn't exist in the specified 
   /// repository.
   /// </returns>
-  public static ILog? Exists(string repository, string name) => WrapLogger(LoggerManager.Exists(repository, name));
+  public static ILog? Exists(string repository, string name) 
+    => WrapLogger(LoggerManager.Exists(repository, name));
 
   /// <summary>
   /// Returns the named logger if it exists.
@@ -137,7 +141,8 @@ public static class LogManager
   /// The logger, or <see langword="null"/> if the logger doesn't exist in the specified
   /// assembly's repository.
   /// </returns>
-  public static ILog? Exists(Assembly repositoryAssembly, string name) => WrapLogger(LoggerManager.Exists(repositoryAssembly, name));
+  public static ILog? Exists(Assembly repositoryAssembly, string name) 
+    => WrapLogger(LoggerManager.Exists(repositoryAssembly, name));
 
   /// <summary>
   /// Returns all the currently defined loggers in the specified repository.
@@ -147,7 +152,8 @@ public static class LogManager
   /// The root logger is <b>not</b> included in the returned array.
   /// </remarks>
   /// <returns>All the defined loggers.</returns>
-  public static ILog[] GetCurrentLoggers(string repository) => WrapLoggers(LoggerManager.GetCurrentLoggers(repository));
+  public static ILog[] GetCurrentLoggers(string repository) 
+    => WrapLoggers(LoggerManager.GetCurrentLoggers(repository));
 
   /// <summary>
   /// Returns all the currently defined loggers in the specified assembly's repository.
@@ -157,7 +163,8 @@ public static class LogManager
   /// The root logger is <b>not</b> included in the returned array.
   /// </remarks>
   /// <returns>All the defined loggers.</returns>
-  public static ILog[] GetCurrentLoggers(Assembly repositoryAssembly) => WrapLoggers(LoggerManager.GetCurrentLoggers(repositoryAssembly));
+  public static ILog[] GetCurrentLoggers(Assembly repositoryAssembly) 
+    => WrapLoggers(LoggerManager.GetCurrentLoggers(repositoryAssembly));
 
   /// <summary>
   /// Retrieves or creates a named logger.
@@ -178,7 +185,8 @@ public static class LogManager
   /// <param name="repository">The repository to lookup in.</param>
   /// <param name="name">The name of the logger to retrieve.</param>
   /// <returns>The logger with the name specified.</returns>
-  public static ILog GetLogger(string repository, string name) => WrapLogger(LoggerManager.GetLogger(repository, name))!;
+  public static ILog GetLogger(string repository, string name) 
+    => WrapLogger(LoggerManager.GetLogger(repository, name))!;
 
   /// <summary>
   /// Retrieves or creates a named logger.
@@ -211,7 +219,10 @@ public static ILog GetLogger(Assembly repositoryAssembly, string name)
   /// <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
   /// <returns>The logger with the name specified.</returns>
   public static ILog GetLogger(Type type) 
-    => GetLogger(Assembly.GetCallingAssembly(), type.EnsureNotNull().FullName!);
+    => GetLogger(CallerAssembly.IsSupported 
+        ? Assembly.GetCallingAssembly() 
+        : CallerAssembly.Fallback, 
+        type.EnsureNotNull().FullName!);
 
   /// <summary>
   /// Shorthand for <see cref="GetLogger(string)"/>.
@@ -277,7 +288,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// and again to a nested appender.
   /// </para>
   /// </remarks>
-  public static void ShutdownRepository() => ShutdownRepository(Assembly.GetCallingAssembly());
+  public static void ShutdownRepository()
+    => ShutdownRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
   /// <summary>
   /// Shuts down the repository for the repository specified.
@@ -299,7 +311,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// </para>
   /// </remarks>
   /// <param name="repository">The repository to shut down.</param>
-  public static void ShutdownRepository(string repository) => LoggerManager.ShutdownRepository(repository);
+  public static void ShutdownRepository(string repository) 
+    => LoggerManager.ShutdownRepository(repository);
 
   /// <summary>
   /// Shuts down the repository specified.
@@ -323,7 +336,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// </para>
   /// </remarks>
   /// <param name="repositoryAssembly">The assembly to use to look up the repository.</param>
-  public static void ShutdownRepository(Assembly repositoryAssembly) => LoggerManager.ShutdownRepository(repositoryAssembly);
+  public static void ShutdownRepository(Assembly repositoryAssembly) 
+    => LoggerManager.ShutdownRepository(repositoryAssembly);
 
   /// <overloads>Reset the configuration of a repository</overloads>
   /// <summary>
@@ -339,7 +353,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// message disabling is set to its default "off" value.
   /// </para>    
   /// </remarks>
-  public static void ResetConfiguration() => ResetConfiguration(Assembly.GetCallingAssembly());
+  public static void ResetConfiguration()
+    => ResetConfiguration(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
   /// <summary>
   /// Resets all values contained in this repository instance to their defaults.
@@ -371,7 +386,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// </para>    
   /// </remarks>
   /// <param name="repositoryAssembly">The assembly to use to look up the repository to reset.</param>
-  public static void ResetConfiguration(Assembly repositoryAssembly) => LoggerManager.ResetConfiguration(repositoryAssembly);
+  public static void ResetConfiguration(Assembly repositoryAssembly) 
+    => LoggerManager.ResetConfiguration(repositoryAssembly);
 
   /// <overloads>Get a logger repository.</overloads>
   /// <summary>
@@ -384,7 +400,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// </para>
   /// </remarks>
   /// <returns>The <see cref="ILoggerRepository"/> instance for the default repository.</returns>
-  public static ILoggerRepository GetRepository() => GetRepository(Assembly.GetCallingAssembly());
+  public static ILoggerRepository GetRepository()
+    => GetRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback);
 
   /// <summary>
   /// Returns the default <see cref="ILoggerRepository"/> instance.
@@ -410,7 +427,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// </para>
   /// </remarks>
   /// <param name="repositoryAssembly">The assembly to use to look up the repository.</param>
-  public static ILoggerRepository GetRepository(Assembly repositoryAssembly) => LoggerManager.GetRepository(repositoryAssembly);
+  public static ILoggerRepository GetRepository(Assembly repositoryAssembly) 
+    => LoggerManager.GetRepository(repositoryAssembly);
 
   /// <overloads>Create a logger repository.</overloads>
   /// <summary>
@@ -427,7 +445,9 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// the same repository instance.
   /// </para>
   /// </remarks>
-  public static ILoggerRepository CreateRepository(Type repositoryType) => CreateRepository(Assembly.GetCallingAssembly(), repositoryType);
+  public static ILoggerRepository CreateRepository(
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType)
+    => CreateRepository(CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback, repositoryType);
 
   /// <summary>
   /// Creates a repository with the specified name.
@@ -445,7 +465,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
   /// <returns>The <see cref="ILoggerRepository"/> created for the repository.</returns>
   /// <exception cref="LogException">The specified repository already exists.</exception>
-  public static ILoggerRepository CreateRepository(string repository) => LoggerManager.CreateRepository(repository);
+  public static ILoggerRepository CreateRepository(string repository) 
+    => LoggerManager.CreateRepository(repository);
 
   /// <summary>
   /// Creates a repository with the specified name and repository type.
@@ -462,7 +483,9 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// as the <see cref="ILoggerRepository"/> for the repository specified.</param>
   /// <returns>The <see cref="ILoggerRepository"/> created for the repository.</returns>
   /// <exception cref="LogException">The specified repository already exists.</exception>
-  public static ILoggerRepository CreateRepository(string repository, Type repositoryType) => LoggerManager.CreateRepository(repository, repositoryType);
+  public static ILoggerRepository CreateRepository(string repository, 
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType) 
+    => LoggerManager.CreateRepository(repository, repositoryType);
 
   /// <summary>
   /// Creates a repository for the specified assembly and repository type.
@@ -479,7 +502,9 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// and has a no arg constructor. An instance of this type will be created to act
   /// as the <see cref="ILoggerRepository"/> for the repository specified.</param>
   /// <returns>The <see cref="ILoggerRepository"/> created for the repository.</returns>
-  public static ILoggerRepository CreateRepository(Assembly repositoryAssembly, Type repositoryType) => LoggerManager.CreateRepository(repositoryAssembly, repositoryType);
+  public static ILoggerRepository CreateRepository(Assembly repositoryAssembly, 
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type repositoryType) 
+    => LoggerManager.CreateRepository(repositoryAssembly, repositoryType);
 
   /// <summary>
   /// Gets the list of currently defined repositories.
@@ -499,7 +524,8 @@ public static ILog GetLogger(Assembly repositoryAssembly, Type type)
   /// <returns><see langword="true"/> if all logging events were flushed successfully, else <see langword="false"/>.</returns>
   public static bool Flush(int millisecondsTimeout)
   {
-    if (LoggerManager.GetRepository(Assembly.GetCallingAssembly()) is not IFlushable flushableRepository)
+    Assembly callerAssembly = CallerAssembly.IsSupported ? Assembly.GetCallingAssembly() : CallerAssembly.Fallback;
+    if (LoggerManager.GetRepository(callerAssembly) is not IFlushable flushableRepository)
     {
       return false;
     }
diff --git a/src/log4net/Util/CallerAssembly.cs b/src/log4net/Util/CallerAssembly.cs
new file mode 100644
index 000000000..424a5b1d1
--- /dev/null
+++ b/src/log4net/Util/CallerAssembly.cs
@@ -0,0 +1,74 @@
+#region Apache License
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to you under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#endregion
+
+using System;
+using System.Reflection;
+
+namespace log4net.Util;
+
+/// <summary>
+/// Support for the <see cref="Assembly.GetCallingAssembly()"/> calls that select the
+/// <see cref="Repository.ILoggerRepository"/> of the caller.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Native AOT does not implement <see cref="Assembly.GetCallingAssembly()"/> - it throws
+/// <see cref="PlatformNotSupportedException"/> unconditionally, because the stack frames it
+/// would have to walk no longer exist after compilation. Callers therefore have to test
+/// <see cref="IsSupported"/> and use <see cref="Fallback"/> instead.
+/// </para>
+/// <para>
+/// The test cannot be hidden behind a helper that calls <see cref="Assembly.GetCallingAssembly()"/>
+/// itself: the calling assembly of such a helper is log4net, not the assembly that called log4net.
+/// <see cref="Assembly.GetCallingAssembly()"/> has to stay in the public method whose caller is
+/// wanted, so this class only supplies the flag and the replacement value.
+/// </para>
+/// </remarks>
+internal static class CallerAssembly
+{
+  /// <summary>
+  /// Whether <see cref="Assembly.GetCallingAssembly()"/> works on the current runtime.
+  /// </summary>
+  internal static bool IsSupported { get; } = Probe();
+
+  /// <summary>
+  /// The assembly to attribute a call to when <see cref="IsSupported"/> is <see langword="false"/>.
+  /// </summary>
+  /// <remarks>
+  /// <para>
+  /// The entry assembly is the closest available stand-in: an application published with
+  /// Native AOT is self-contained, so its loggers would almost always have ended up in the
+  /// entry assembly's repository anyway. Hosts without a managed entry point fall back to
+  /// log4net itself, which yields the default repository.
+  /// </para>
+  /// </remarks>
+  internal static Assembly Fallback { get; } = Assembly.GetEntryAssembly() ?? typeof(CallerAssembly).Assembly;
+
+  private static bool Probe()
+  {
+    try
+    {
+      return Assembly.GetCallingAssembly() is not null;
+    }
+    catch (PlatformNotSupportedException)
+    {
+      return false;
+    }
+  }
+}
diff --git a/src/log4net/Util/ConverterInfo.cs b/src/log4net/Util/ConverterInfo.cs
index 0a122f6ef..421354545 100644
--- a/src/log4net/Util/ConverterInfo.cs
+++ b/src/log4net/Util/ConverterInfo.cs
@@ -20,6 +20,7 @@
 */
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace log4net.Util;
 
@@ -42,6 +43,7 @@ public sealed class ConverterInfo
   /// <summary>
   /// Gets or sets the type of the converter. The type must extend <see cref="PatternConverter"/>.
   /// </summary>
+  [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] 
   public Type? Type { get; set; }
 
   /// <summary>
diff --git a/src/log4net/Util/PatternString.cs b/src/log4net/Util/PatternString.cs
index 568b272e6..7978c9566 100644
--- a/src/log4net/Util/PatternString.cs
+++ b/src/log4net/Util/PatternString.cs
@@ -18,6 +18,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 
 using log4net.Util.PatternStringConverters;
@@ -258,29 +259,51 @@ public class PatternString : IOptionHandler
   /// <summary>
   /// Internal map of converter identifiers to converter types.
   /// </summary>
-  private static readonly Dictionary<string, Type> _sGlobalRulesRegistry = new(StringComparer.Ordinal)
+  private static readonly Dictionary<string, ConverterInfo> _sGlobalRulesRegistry = CreateGlobalRulesRegistry();
+
+  /// <summary>
+  /// Builds the registry of built-in converters.
+  /// </summary>
+  /// <returns>the built-in rules, keyed by the name used in a pattern</returns>
+  /// <remarks>
+  /// <para>
+  /// Holds <see cref="ConverterInfo"/> rather than a bare <see cref="Type"/> for the reason given
+  /// on <see cref="Layout.PatternLayout"/>'s registry: a <see cref="Type"/> in a collection loses
+  /// its trimmer annotation, and these converters are only ever created reflectively.
+  /// </para>
+  /// </remarks>
+  private static Dictionary<string, ConverterInfo> CreateGlobalRulesRegistry()
   {
     // TODO - have added common variants of casing for utcdate and appsetting.
     // Wouldn't it be better to use a case-insensitive dictionary?
 
-    ["appdomain"] = typeof(AppDomainPatternConverter),
-    ["appsetting"] = typeof(AppSettingPatternConverter),
-    ["appSetting"] = typeof(AppSettingPatternConverter),
-    ["AppSetting"] = typeof(AppSettingPatternConverter),
-    ["date"] = typeof(DatePatternConverter),
-    ["env"] = typeof(EnvironmentPatternConverter),
-    ["envFolderPath"] = typeof(EnvironmentFolderPathPatternConverter),
-    ["identity"] = typeof(IdentityPatternConverter),
-    ["literal"] = typeof(LiteralPatternConverter),
-    ["newline"] = typeof(NewLinePatternConverter),
-    ["processid"] = typeof(ProcessIdPatternConverter),
-    ["property"] = typeof(PropertyPatternConverter),
-    ["random"] = typeof(RandomStringPatternConverter),
-    ["username"] = typeof(UserNamePatternConverter),
-    ["utcdate"] = typeof(UtcDatePatternConverter),
-    ["utcDate"] = typeof(UtcDatePatternConverter),
-    ["UtcDate"] = typeof(UtcDatePatternConverter),
-  };
+    Dictionary<string, ConverterInfo> rules = new(StringComparer.Ordinal);
+
+    Add<AppDomainPatternConverter>("appdomain");
+    Add<AppSettingPatternConverter>("appsetting", "appSetting", "AppSetting");
+    Add<DatePatternConverter>("date");
+    Add<EnvironmentPatternConverter>("env");
+    Add<EnvironmentFolderPathPatternConverter>("envFolderPath");
+    Add<IdentityPatternConverter>("identity");
+    Add<LiteralPatternConverter>("literal");
+    Add<NewLinePatternConverter>("newline");
+    Add<ProcessIdPatternConverter>("processid");
+    Add<PropertyPatternConverter>("property");
+    Add<RandomStringPatternConverter>("random");
+    Add<UserNamePatternConverter>("username");
+    Add<UtcDatePatternConverter>("utcdate", "utcDate", "UtcDate");
+
+    return rules;
+
+    void Add<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(
+      params string[] names) where T : PatternConverter, new()
+    {
+      foreach (string name in names)
+      {
+        rules[name] = new() { Name = name, Type = typeof(T) };
+      }
+    }
+  }
 
   /// <summary>
   /// the head of the pattern converter chain
@@ -379,14 +402,9 @@ private PatternParser CreatePatternParser(string pattern)
     PatternParser patternParser = new(pattern);
 
     // Add all the builtin patterns
-    foreach (KeyValuePair<string, Type> entry in _sGlobalRulesRegistry)
+    foreach (KeyValuePair<string, ConverterInfo> entry in _sGlobalRulesRegistry)
     {
-      ConverterInfo converterInfo = new()
-      {
-        Name = entry.Key,
-        Type = entry.Value
-      };
-      patternParser.PatternConverters.Add(entry.Key, converterInfo);
+      patternParser.PatternConverters.Add(entry.Key, entry.Value);
     }
     // Add the instance patterns
     foreach (KeyValuePair<string, ConverterInfo> entry in _instanceRulesRegistry)
@@ -461,7 +479,8 @@ public void AddConverter(ConverterInfo converterInfo)
   /// </summary>
   /// <param name="name">the name of the conversion pattern for this converter</param>
   /// <param name="type">the type of the converter</param>
-  public void AddConverter(string name, Type type)
+  public void AddConverter(string name,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type)
   {
     AddConverter(new()
     {
diff --git a/src/log4net/Util/SystemInfo.cs b/src/log4net/Util/SystemInfo.cs
index d5b9f9d39..d0c2647c6 100644
--- a/src/log4net/Util/SystemInfo.cs
+++ b/src/log4net/Util/SystemInfo.cs
@@ -22,6 +22,7 @@
 using System.Reflection;
 using System.IO;
 using System.Collections;
+using System.Runtime.CompilerServices;
 
 namespace log4net.Util;
 
@@ -475,7 +476,9 @@ public static string AssemblyFileName(Assembly myAssembly)
   /// </para>
   /// </remarks>
   public static Type? GetTypeFromString(string typeName, bool throwOnError, bool ignoreCase) 
-    => GetTypeFromString(Assembly.GetCallingAssembly(), typeName, throwOnError, ignoreCase);
+    => GetTypeFromString(CallerAssembly.IsSupported
+        ? Assembly.GetCallingAssembly()
+        : CallerAssembly.Fallback, typeName, throwOnError, ignoreCase);
 
   /// <summary>
   /// Loads the type specified in the type string.
@@ -680,20 +683,90 @@ public static bool TryParse(string s, out short val)
   /// <returns>the value for the key, or <see langword="null"/></returns>
   public static string? GetAppSetting(string key)
   {
-    if (IsAndroid)
-      return Environment.GetEnvironmentVariable(key); // Android does not support config files
+    // Android does not support config files, and neither does a runtime that has trimmed the
+    // configuration system away.
+    if (IsAndroid || _configurationSystemUnavailable)
+      return Environment.GetEnvironmentVariable(key);
     try
     {
-      return ConfigurationManager.AppSettings[key];
+      return ReadAppSetting(key);
     }
     catch (Exception e) when (!e.IsFatal())
     {
-      // If an exception is thrown here then it looks like the config file does not parse correctly.
+      if (IsMissingConfigurationSystem(e))
+      {
+        // There is no configuration system to read - Native AOT trims System.Configuration away.
+        // That is a property of the runtime rather than a fault, so it is not reported as an
+        // error, and the environment stands in for the config file as it does on Android.
+        _configurationSystemUnavailable = true;
+        LogLog.Debug(_declaringType,
+          "No configuration system on this runtime. Using environment variables for application settings.", e);
+        return Environment.GetEnvironmentVariable(key);
+      }
+
+      // The config file itself does not parse. Report it and treat the setting as absent, without
+      // falling back to the environment - a broken config file must not silently change where
+      // settings come from.
       LogLog.Error(_declaringType, "Exception while reading ConfigurationSettings. Check your .config file is well formed XML.", e);
     }
     return null;
   }
 
+  /// <summary>
+  /// Determines whether <paramref name="exception"/> means that there is no configuration system
+  /// on this runtime, as opposed to a configuration file that does not parse.
+  /// </summary>
+  /// <param name="exception">the exception thrown while reading an application setting</param>
+  /// <returns><see langword="true"/> if the configuration system itself is unavailable</returns>
+  /// <remarks>
+  /// <para>
+  /// The inner exceptions have to be walked, because Native AOT surfaces this as a
+  /// <see cref="ConfigurationErrorsException"/> - the very type a malformed file produces. What
+  /// distinguishes it is further down the chain: a <see cref="MissingMethodException"/> for
+  /// <c>ClientConfigurationHost</c>, whose constructor the trimmer removed.
+  /// </para>
+  /// <para>
+  /// An unrecognized failure is treated as a configuration file problem, which is the safer way
+  /// round: it is reported rather than silently swallowed.
+  /// </para>
+  /// </remarks>
+  private static bool IsMissingConfigurationSystem(Exception? exception)
+  {
+    for (; exception is not null; exception = exception.InnerException)
+    {
+      if (exception is MissingMethodException or TypeLoadException or FileNotFoundException
+        or PlatformNotSupportedException or NotSupportedException)
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// <summary>
+  /// Reads a single application setting.
+  /// </summary>
+  /// <param name="key">the application settings key to lookup</param>
+  /// <returns>the value for the key, or <see langword="null"/></returns>
+  /// <remarks>
+  /// <para>
+  /// Separate from <see cref="GetAppSetting"/>, and never inlined into it, so that the failure to
+  /// resolve <see cref="ConfigurationManager"/> itself is raised on entry to this method - inside
+  /// the caller's try block - rather than on entry to <see cref="GetAppSetting"/>, where nothing
+  /// would catch it and a <see cref="FileNotFoundException"/> would escape the static constructor
+  /// as a <see cref="TypeInitializationException"/>.
+  /// </para>
+  /// <para>
+  /// The package declares a dependency on System.Configuration.ConfigurationManager, so this only
+  /// arises where the assembly is deployed by other means than the package - it costs one method
+  /// to keep those deployments running instead of failing at type initialization.
+  /// </para>
+  /// </remarks>
+  [MethodImpl(MethodImplOptions.NoInlining)]
+  private static string? ReadAppSetting(string key) => ConfigurationManager.AppSettings[key];
+
+  private static bool _configurationSystemUnavailable;
+
   /// <summary>
   /// Convert a path into a fully qualified local file path.
   /// </summary>
diff --git a/src/log4net/Util/TypeConverters/ConverterRegistry.cs b/src/log4net/Util/TypeConverters/ConverterRegistry.cs
index 03259584a..af8518966 100644
--- a/src/log4net/Util/TypeConverters/ConverterRegistry.cs
+++ b/src/log4net/Util/TypeConverters/ConverterRegistry.cs
@@ -18,6 +18,7 @@
 #endregion
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Collections.Concurrent;
 
 namespace log4net.Util.TypeConverters;
@@ -82,7 +83,8 @@ public static void AddConverter(Type? destinationType, object? converter)
   /// </summary>
   /// <param name="destinationType">The type being converted to.</param>
   /// <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
-  public static void AddConverter(Type destinationType, Type converterType)
+  public static void AddConverter(Type destinationType,
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type converterType)
     => AddConverter(destinationType, CreateConverterInstance(converterType.EnsureNotNull()));
 
   /// <summary>
@@ -187,7 +189,8 @@ public static void AddConverter(Type destinationType, Type converterType)
   /// and must have a public default (no argument) constructor.
   /// </para>
   /// </remarks>
-  private static object? CreateConverterInstance(Type converterType)
+  private static object? CreateConverterInstance(
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type converterType)
   {
     // Check type is a converter
     if (typeof(IConvertFrom).IsAssignableFrom(converterType) || typeof(IConvertTo).IsAssignableFrom(converterType))
diff --git a/src/site/antora/modules/ROOT/nav.adoc b/src/site/antora/modules/ROOT/nav.adoc
index bf81497b5..8aadc37df 100644
--- a/src/site/antora/modules/ROOT/nav.adoc
+++ b/src/site/antora/modules/ROOT/nav.adoc
@@ -42,6 +42,7 @@
 **** xref:manual/configuration/appenders/udpappender.adoc[]
 *** xref:manual/configuration/filters.adoc[]
 *** xref:manual/configuration/layouts.adoc[]
+** xref:manual/native-aot.adoc[]
 ** xref:manual/examples.adoc[]
 ** xref:manual/faq.adoc[]
 * xref:features.adoc[]
diff --git a/src/site/antora/modules/ROOT/pages/manual/configuration.adoc b/src/site/antora/modules/ROOT/pages/manual/configuration.adoc
index 6d300ea6e..4619fd13d 100644
--- a/src/site/antora/modules/ROOT/pages/manual/configuration.adoc
+++ b/src/site/antora/modules/ROOT/pages/manual/configuration.adoc
@@ -21,6 +21,13 @@
 The recommended way to configure log4net is through a configuration file.
 This section explains the structure of a configuration file and how log4net processes it.
 
+[NOTE]
+====
+Configuration files cannot be used in an application published with `PublishAot`, because the types
+they name are removed by the trimmer.
+See xref:manual/native-aot.adoc[] for how to configure log4net in code instead.
+====
+
 [source,csharp]
 ----
 using Animals.Carnivora;
diff --git a/src/site/antora/modules/ROOT/pages/manual/native-aot.adoc b/src/site/antora/modules/ROOT/pages/manual/native-aot.adoc
new file mode 100644
index 000000000..ff101412f
--- /dev/null
+++ b/src/site/antora/modules/ROOT/pages/manual/native-aot.adoc
@@ -0,0 +1,196 @@
+////
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+////
+
+[#native-aot]
+= Native AOT and trimming
+
+log4net can be used from an application published with `PublishAot` or `PublishTrimmed`, with one
+important restriction: **you have to configure log4net in code.**
+
+A Native AOT application is compiled ahead of time and trimmed, so any type that is only ever named
+in a string is removed from the build. That is exactly how XML configuration works, which is why it
+cannot be supported.
+
+[#configuring]
+== Configuring in code
+
+Build the appenders and layouts yourself and hand them to
+xref:manual/configuration.adoc[`BasicConfigurator`].
+Because you construct them with `new`, the compiler sees them and keeps them:
+
+[source,csharp]
+----
+using log4net;
+using log4net.Appender;
+using log4net.Config;
+using log4net.Core;
+using log4net.Layout;
+
+ConsoleAppender appender = new()
+{
+  Layout = new PatternLayout("%level %logger - %message%newline"),
+  Threshold = Level.All,
+};
+appender.ActivateOptions();
+BasicConfigurator.Configure(appender);
+
+ILog log = LogManager.GetLogger(typeof(Program));
+log.Info("Hello from Native AOT.");
+----
+
+Conversion patterns work as usual. The built-in pattern converters are resolved by name at run time,
+but log4net declares them in a way the trimmer understands, so they are preserved for you.
+
+A custom converter is preserved as long as you register it by type:
+
+[source,csharp]
+----
+PatternLayout layout = new();
+layout.AddConverter("mine", typeof(MyPatternConverter));
+layout.ConversionPattern = "%mine %message%newline";
+layout.ActivateOptions();
+----
+
+[#levels-from-a-file]
+== Reading levels from a configuration file
+
+log4net cannot read a configuration file under Native AOT, but *your application can*, and levels
+can be set at any time through the API. That covers the common case of wanting to change verbosity
+without rebuilding, without needing XML configuration.
+
+Put the levels wherever your application already keeps its settings:
+
+[source,json]
+----
+{
+  "Logging": {
+    "Default": "WARN",
+    "Loggers": {
+      "Noisy.Component": "ERROR",
+      "Important.Component": "DEBUG"
+    }
+  }
+}
+----
+
+Read them yourself and apply them to the repository:
+
+[source,csharp]
+----
+using System.Text.Json;
+using log4net.Core;
+using log4net.Repository.Hierarchy;
+
+Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
+
+using JsonDocument document = JsonDocument.Parse(
+  File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "appsettings.json")));
+JsonElement logging = document.RootElement.GetProperty("Logging");
+
+// the level of the root logger, inherited by every logger that has none of its own
+if (hierarchy.LevelMap[logging.GetProperty("Default").GetString()!] is Level rootLevel)
+{
+  hierarchy.Root.Level = rootLevel;
+}
+
+// and levels for individual loggers
+foreach (JsonProperty entry in logging.GetProperty("Loggers").EnumerateObject())
+{
+  if (hierarchy.LevelMap[entry.Value.GetString()!] is Level loggerLevel)
+  {
+    ((Logger)hierarchy.GetLogger(entry.Name)).Level = loggerLevel;
+  }
+}
+----
+
+With the settings above, `Important.Component` logs from `DEBUG` upwards, `Noisy.Component` only
+`ERROR` and above, and every other logger inherits `WARN` from the root.
+
+[TIP]
+====
+`LevelMap` returns `null` for a name it does not know, which is why both lookups are written as
+`is Level`. An unrecognised name in the file then leaves the level unchanged rather than throwing.
+Custom levels registered with `hierarchy.LevelMap.Add(...)` can be named in the file too.
+====
+
+[NOTE]
+====
+`JsonDocument` is used here because it parses without reflection and is safe to trim.
+`JsonSerializer.Deserialize<T>()` is not, unless you generate a `JsonSerializerContext` for your
+settings type. Any other format your application can already read works just as well - the point is
+only that *your* code reads the file, not log4net's.
+====
+
+Levels can be changed whenever you like, so the same code can be run again to reload the file while
+the application is running.
+
+[#unsupported]
+== What does not work
+
+[IMPORTANT]
+====
+xref:manual/configuration.adoc[XML configuration] - `XmlConfigurator.Configure()`, the
+`log4net.config` file and the `<log4net>` section of `app.config` - is **not available** under
+Native AOT. Appender, layout and filter types are named as strings there, and the trimmer has no way
+to know that they are needed.
+
+This is about *log4net* reading the file. Your application can still read a file of its own and
+apply what it finds - see <<levels-from-a-file>>.
+====
+
+`ConfigurationManager` cannot initialize either, so log4net's own `appSettings` keys are read from
+**environment variables** instead. To set them, use the same names you would have used in
+`app.config`:
+
+[source,shell]
+----
+log4net.NullText=NULL
+log4net.NotAvailableText=N/A
+----
+
+[#repositories]
+== Loggers and repositories
+
+`Assembly.GetCallingAssembly()` is not implemented by Native AOT. The log4net methods that infer a
+repository from their caller - `LogManager.GetLogger(string)`, `LogManager.GetLogger(Type)`,
+`LogManager.GetRepository()` and their siblings - therefore fall back to the entry assembly.
+
+For most applications this changes nothing, because there is a single default repository and both
+answers lead to it. It matters only if you use **per-assembly repositories**, for example by placing
+
+[source,csharp]
+----
+[assembly: log4net.Config.Repository("MyRepository")]
+----
+
+on a library. Under Native AOT that library's loggers are placed in the entry assembly's repository
+rather than its own.
+
+If you depend on this, use the overloads that take the assembly explicitly. They are exact on every
+runtime and need no special handling:
+
+[source,csharp]
+----
+ILog log = LogManager.GetLogger(typeof(MyType).Assembly, typeof(MyType));
+----
+
+[#warnings]
+== Trimming warnings
+
+Publishing may report `IL3000` for `log4net.Util.SystemInfo.AssemblyLocationInfo`, because
+`Assembly.Location` returns an empty string for an assembly embedded in a single-file application.
+This affects the `%file`-style location information only; logging itself is unaffected.