diff --git a/Directory.Build.props b/Directory.Build.props
index 01b9dbeef57..2daee1a4e94 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -24,6 +24,10 @@
     <RollForward>Major</RollForward>
   </PropertyGroup>
 
+  <PropertyGroup Condition=" '$(MSBuildRuntimeType)' == 'Core' ">
+    <_EnableMarshalMethods>NoThanks</_EnableMarshalMethods> <!-- set to YesPlease to enable -->
+  </PropertyGroup>
+
   <PropertyGroup>
     <ProductVersion>12.3.99</ProductVersion>
     <!-- NuGet package version numbers. See Documentation/guides/OneDotNet.md.
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateJavaStubs.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateJavaStubs.cs
index 21e8cfa283b..00e08ff4305 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateJavaStubs.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateJavaStubs.cs
@@ -26,6 +26,8 @@ namespace Xamarin.Android.Tasks
 
 	public class GenerateJavaStubs : AndroidTask
 	{
+		public const string MarshalMethodsRegisterTaskKey = ".:!MarshalMethods!:.";
+
 		public override string TaskPrefix => "GJS";
 
 		[Required]
@@ -338,6 +340,9 @@ bool CreateJavaSources (IEnumerable<TypeDefinition> javaTypes, TypeDefinitionCac
 			string monoInit = GetMonoInitSource (AndroidSdkPlatform);
 			bool hasExportReference = ResolvedAssemblies.Any (assembly => Path.GetFileName (assembly.ItemSpec) == "Mono.Android.Export.dll");
 			bool generateOnCreateOverrides = int.Parse (AndroidSdkPlatform) <= 10;
+#if ENABLE_MARSHAL_METHODS
+			var overriddenMethodDescriptors = new List<OverriddenMethodDescriptor> ();
+#endif
 
 			bool ok = true;
 			foreach (var t in javaTypes) {
@@ -355,6 +360,9 @@ bool CreateJavaSources (IEnumerable<TypeDefinition> javaTypes, TypeDefinitionCac
 						};
 
 						jti.Generate (writer);
+#if ENABLE_MARSHAL_METHODS
+						overriddenMethodDescriptors.AddRange (jti.OverriddenMethodDescriptors);
+#endif
 						writer.Flush ();
 
 						var path = jti.GetDestinationPath (outputPath);
@@ -388,6 +396,9 @@ bool CreateJavaSources (IEnumerable<TypeDefinition> javaTypes, TypeDefinitionCac
 					}
 				}
 			}
+#if ENABLE_MARSHAL_METHODS
+			BuildEngine4.RegisterTaskObjectAssemblyLocal (MarshalMethodsRegisterTaskKey, overriddenMethodDescriptors, RegisteredTaskObjectLifetime.Build);
+#endif
 			return ok;
 		}
 
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GeneratePackageManagerJava.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GeneratePackageManagerJava.cs
index 909cf9ddad6..57f3805d4ee 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GeneratePackageManagerJava.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GeneratePackageManagerJava.cs
@@ -299,8 +299,16 @@ void AddEnvironment ()
 
 			int assemblyCount = 0;
 			HashSet<string> archAssemblyNames = null;
-
+#if ENABLE_MARSHAL_METHODS
+			var uniqueAssemblyNames = new HashSet<string> (StringComparer.OrdinalIgnoreCase);
+#endif
 			Action<ITaskItem> updateAssemblyCount = (ITaskItem assembly) => {
+				string assemblyName = Path.GetFileName (assembly.ItemSpec);
+#if ENABLE_MARSHAL_METHODS
+				if (!uniqueAssemblyNames.Contains (assemblyName)) {
+					uniqueAssemblyNames.Add (assemblyName);
+				}
+#endif
 				if (!UseAssemblyStore) {
 					assemblyCount++;
 					return;
@@ -316,7 +324,6 @@ void AddEnvironment ()
 				} else {
 					archAssemblyNames ??= new HashSet<string> (StringComparer.OrdinalIgnoreCase);
 
-					string assemblyName = Path.GetFileName (assembly.ItemSpec);
 					if (!archAssemblyNames.Contains (assemblyName)) {
 						assemblyCount++;
 						archAssemblyNames.Add (assemblyName);
@@ -431,16 +438,34 @@ void AddEnvironment ()
 				JNIEnvRegisterJniNativesToken = jnienv_registerjninatives_method_token,
 			};
 			appConfigAsmGen.Init ();
-
+#if ENABLE_MARSHAL_METHODS
+			var marshalMethodsAsmGen = new MarshalMethodsNativeAssemblyGenerator () {
+				NumberOfAssembliesInApk = assemblyCount,
+				UniqueAssemblyNames = uniqueAssemblyNames,
+				OverriddenMethodDescriptors = BuildEngine4.GetRegisteredTaskObjectAssemblyLocal<List<Java.Interop.Tools.JavaCallableWrappers.OverriddenMethodDescriptor>> (GenerateJavaStubs.MarshalMethodsRegisterTaskKey, RegisteredTaskObjectLifetime.Build)
+			};
+			marshalMethodsAsmGen.Init ();
+#endif
 			foreach (string abi in SupportedAbis) {
-				string baseAsmFilePath = Path.Combine (EnvironmentOutputDirectory, $"environment.{abi.ToLowerInvariant ()}");
-				string llFilePath  = $"{baseAsmFilePath}.ll";
+				string targetAbi = abi.ToLowerInvariant ();
+				string environmentBaseAsmFilePath = Path.Combine (EnvironmentOutputDirectory, $"environment.{targetAbi}");
+				string marshalMethodsBaseAsmFilePath = Path.Combine (EnvironmentOutputDirectory, $"marshal_methods.{targetAbi}");
+				string environmentLlFilePath  = $"{environmentBaseAsmFilePath}.ll";
+				string marshalMethodsLlFilePath = $"{marshalMethodsBaseAsmFilePath}.ll";
 
+				AndroidTargetArch targetArch = GetAndroidTargetArchForAbi (abi);
+				using (var sw = MemoryStreamPool.Shared.CreateStreamWriter ()) {
+					appConfigAsmGen.Write (targetArch, sw, environmentLlFilePath);
+					sw.Flush ();
+					Files.CopyIfStreamChanged (sw.BaseStream, environmentLlFilePath);
+				}
+#if ENABLE_MARSHAL_METHODS
 				using (var sw = MemoryStreamPool.Shared.CreateStreamWriter ()) {
-					appConfigAsmGen.Write (GetAndroidTargetArchForAbi (abi), sw, llFilePath);
+					marshalMethodsAsmGen.Write (targetArch, sw, marshalMethodsLlFilePath);
 					sw.Flush ();
-					Files.CopyIfStreamChanged (sw.BaseStream, llFilePath);
+					Files.CopyIfStreamChanged (sw.BaseStream, marshalMethodsLlFilePath);
 				}
+#endif
 			}
 
 			void AddEnvironmentVariable (string name, string value)
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/PrepareAbiItems.cs b/src/Xamarin.Android.Build.Tasks/Tasks/PrepareAbiItems.cs
index 23d501ab4c7..9845aaa1ef4 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/PrepareAbiItems.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/PrepareAbiItems.cs
@@ -14,7 +14,9 @@ public class PrepareAbiItems : AndroidTask
 		const string TypeMapBase = "typemaps";
 		const string EnvBase = "environment";
 		const string CompressedAssembliesBase = "compressed_assemblies";
-
+#if ENABLE_MARSHAL_METHODS
+		const string MarshalMethodsBase = "marshal_methods";
+#endif
 		public override string TaskPrefix => "PAI";
 
 		[Required]
@@ -50,6 +52,10 @@ public override bool RunTask ()
 				baseName = EnvBase;
 			} else if (String.Compare ("compressed", Mode, StringComparison.OrdinalIgnoreCase) == 0) {
 				baseName = CompressedAssembliesBase;
+#if ENABLE_MARSHAL_METHODS
+			} else if (String.Compare ("marshal_methods", Mode, StringComparison.OrdinalIgnoreCase) == 0) {
+				baseName = MarshalMethodsBase;
+#endif
 			} else {
 				Log.LogError ($"Unknown mode: {Mode}");
 				return false;
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.apkdesc
index 8b358568ed1..0d6c210b010 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.apkdesc
@@ -8,7 +8,7 @@
       "Size": 60736
     },
     "assemblies/Mono.Android.dll": {
-      "Size": 152435
+      "Size": 152344
     },
     "assemblies/rc.bin": {
       "Size": 1083
@@ -59,13 +59,13 @@
       "Size": 9591
     },
     "assemblies/UnnamedProject.dll": {
-      "Size": 3560
+      "Size": 3555
     },
     "classes.dex": {
       "Size": 348440
     },
     "lib/arm64-v8a/libmonodroid.so": {
-      "Size": 484512
+      "Size": 510920
     },
     "lib/arm64-v8a/libmonosgen-2.0.so": {
       "Size": 4667768
@@ -80,7 +80,7 @@
       "Size": 146816
     },
     "lib/arm64-v8a/libxamarin-app.so": {
-      "Size": 15944
+      "Size": 15904
     },
     "META-INF/BNDLTOOL.RSA": {
       "Size": 1213
@@ -92,7 +92,7 @@
       "Size": 3646
     },
     "res/drawable-hdpi-v4/icon.png": {
-      "Size": 4762
+      "Size": 4791
     },
     "res/drawable-mdpi-v4/icon.png": {
       "Size": 2200
@@ -116,5 +116,5 @@
       "Size": 1904
     }
   },
-  "PackageSize": 3492724
+  "PackageSize": 3500916
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleLegacy.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleLegacy.apkdesc
index 7a6cbc2b3c6..a0a7e65caa1 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleLegacy.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleLegacy.apkdesc
@@ -5,10 +5,10 @@
       "Size": 2604
     },
     "assemblies/Java.Interop.dll": {
-      "Size": 67948
+      "Size": 67950
     },
     "assemblies/Mono.Android.dll": {
-      "Size": 257194
+      "Size": 257187
     },
     "assemblies/mscorlib.dll": {
       "Size": 769016
@@ -23,7 +23,7 @@
       "Size": 2879
     },
     "classes.dex": {
-      "Size": 349820
+      "Size": 349736
     },
     "lib/arm64-v8a/libmono-btls-shared.so": {
       "Size": 1613872
@@ -32,7 +32,7 @@
       "Size": 750976
     },
     "lib/arm64-v8a/libmonodroid.so": {
-      "Size": 392576
+      "Size": 421872
     },
     "lib/arm64-v8a/libmonosgen-2.0.so": {
       "Size": 4030448
@@ -74,5 +74,5 @@
       "Size": 1724
     }
   },
-  "PackageSize": 4044500
+  "PackageSize": 4052692
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.apkdesc
index e981a113ca9..bbccb008f52 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.apkdesc
@@ -11,7 +11,7 @@
       "Size": 66806
     },
     "assemblies/Mono.Android.dll": {
-      "Size": 447633
+      "Size": 447543
     },
     "assemblies/mscorlib.dll": {
       "Size": 3888
@@ -119,7 +119,7 @@
       "Size": 1906
     },
     "assemblies/UnnamedProject.dll": {
-      "Size": 117250
+      "Size": 117244
     },
     "assemblies/Xamarin.AndroidX.Activity.dll": {
       "Size": 5941
@@ -191,7 +191,7 @@
       "Size": 3460820
     },
     "lib/arm64-v8a/libmonodroid.so": {
-      "Size": 484512
+      "Size": 510920
     },
     "lib/arm64-v8a/libmonosgen-2.0.so": {
       "Size": 4667768
@@ -206,7 +206,7 @@
       "Size": 146816
     },
     "lib/arm64-v8a/libxamarin-app.so": {
-      "Size": 98480
+      "Size": 98440
     },
     "META-INF/android.support.design_material.version": {
       "Size": 12
@@ -773,7 +773,7 @@
       "Size": 470
     },
     "res/drawable-hdpi-v4/icon.png": {
-      "Size": 4762
+      "Size": 4791
     },
     "res/drawable-hdpi-v4/notification_bg_low_normal.9.png": {
       "Size": 212
@@ -1961,5 +1961,5 @@
       "Size": 341228
     }
   },
-  "PackageSize": 8347981
+  "PackageSize": 8356173
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsLegacy.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsLegacy.apkdesc
index 184dca5e391..691f59a584e 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsLegacy.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsLegacy.apkdesc
@@ -8,10 +8,10 @@
       "Size": 7215
     },
     "assemblies/Java.Interop.dll": {
-      "Size": 68913
+      "Size": 68916
     },
     "assemblies/Mono.Android.dll": {
-      "Size": 567718
+      "Size": 567711
     },
     "assemblies/Mono.Security.dll": {
       "Size": 68432
@@ -65,22 +65,22 @@
       "Size": 131930
     },
     "assemblies/Xamarin.AndroidX.DrawerLayout.dll": {
-      "Size": 15426
+      "Size": 15425
     },
     "assemblies/Xamarin.AndroidX.Fragment.dll": {
-      "Size": 43135
+      "Size": 43134
     },
     "assemblies/Xamarin.AndroidX.Legacy.Support.Core.UI.dll": {
-      "Size": 6715
+      "Size": 6714
     },
     "assemblies/Xamarin.AndroidX.Lifecycle.Common.dll": {
       "Size": 7062
     },
     "assemblies/Xamarin.AndroidX.Lifecycle.LiveData.Core.dll": {
-      "Size": 7193
+      "Size": 7194
     },
     "assemblies/Xamarin.AndroidX.Lifecycle.ViewModel.dll": {
-      "Size": 4872
+      "Size": 4873
     },
     "assemblies/Xamarin.AndroidX.Loader.dll": {
       "Size": 13585
@@ -113,7 +113,7 @@
       "Size": 43497
     },
     "classes.dex": {
-      "Size": 3462252
+      "Size": 3462080
     },
     "lib/arm64-v8a/libmono-btls-shared.so": {
       "Size": 1613872
@@ -122,7 +122,7 @@
       "Size": 750976
     },
     "lib/arm64-v8a/libmonodroid.so": {
-      "Size": 392576
+      "Size": 421872
     },
     "lib/arm64-v8a/libmonosgen-2.0.so": {
       "Size": 4030448
@@ -1883,5 +1883,5 @@
       "Size": 341040
     }
   },
-  "PackageSize": 9562270
+  "PackageSize": 9570462
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/ApplicationConfigNativeAssemblyGenerator.cs b/src/Xamarin.Android.Build.Tasks/Utilities/ApplicationConfigNativeAssemblyGenerator.cs
index ba2f35e8bad..a8f24dd85a5 100644
--- a/src/Xamarin.Android.Build.Tasks/Utilities/ApplicationConfigNativeAssemblyGenerator.cs
+++ b/src/Xamarin.Android.Build.Tasks/Utilities/ApplicationConfigNativeAssemblyGenerator.cs
@@ -1,10 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 
 using Java.Interop.Tools.TypeNameMappings;
-using K4os.Hash.xxHash;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 
@@ -342,21 +340,11 @@ void WriteDSOCache (LlvmIrGenerator generator)
 
 			// We need to hash here, because the hash is architecture-specific
 			foreach (StructureInstance<DSOCacheEntry> entry in dsoCache) {
-				entry.Obj.hash = HashName (entry.Obj.HashedName);
+				entry.Obj.hash = HashName (entry.Obj.HashedName, is64Bit);
 			}
 			dsoCache.Sort ((StructureInstance<DSOCacheEntry> a, StructureInstance<DSOCacheEntry> b) => a.Obj.hash.CompareTo (b.Obj.hash));
 
 			generator.WriteStructureArray (dsoCacheEntryStructureInfo, dsoCache, "dso_cache");
-
-			ulong HashName (string name)
-			{
-				byte[] nameBytes = Encoding.UTF8.GetBytes (name);
-				if (is64Bit) {
-					return XXH64.DigestOf (nameBytes, 0, nameBytes.Length);
-				}
-
-				return (ulong)XXH32.DigestOf (nameBytes, 0, nameBytes.Length);
-			}
 		}
 	}
 }
diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrComposer.cs b/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrComposer.cs
index 4f65a90ffac..5347a1912cf 100644
--- a/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrComposer.cs
+++ b/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrComposer.cs
@@ -1,5 +1,8 @@
 using System;
 using System.IO;
+using System.Text;
+
+using K4os.Hash.xxHash;
 
 using Xamarin.Android.Tools;
 
@@ -37,6 +40,16 @@ protected static string GetAbiName (AndroidTargetArch arch)
 			};
 		}
 
+		protected ulong HashName (string name, bool is64Bit)
+		{
+			byte[] nameBytes = Encoding.UTF8.GetBytes (name);
+			if (is64Bit) {
+				return XXH64.DigestOf (nameBytes, 0, nameBytes.Length);
+			}
+
+			return (ulong)XXH32.DigestOf (nameBytes, 0, nameBytes.Length);
+		}
+
 		/// <summary>
 		/// Initialize the composer. It needs to allocate and populate all the structures that
 		/// are used by the composer, before they can be mapped by the generator. The code here
diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrGenerator.cs b/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrGenerator.cs
index ec30d96f62a..c639fb1742d 100644
--- a/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrGenerator.cs
+++ b/src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/LlvmIrGenerator.cs
@@ -423,11 +423,12 @@ bool WriteStructureArrayStart<T> (StructureInfo<T> info, IList<StructureInstance
 			return named;
 		}
 
-		void WriteStructureArrayEnd<T> (StructureInfo<T> info, string? symbolName, ulong count, bool named, bool skipFinalComment = false, TextWriter? output = null)
+		void WriteStructureArrayEnd<T> (StructureInfo<T> info, string? symbolName, ulong count, bool named, bool skipFinalComment = false, TextWriter? output = null, bool isArrayOfPointers = false)
 		{
 			output = EnsureOutput (output);
 
-			output.Write ($", align {GetAggregateAlignment (info.MaxFieldAlignment, info.Size * count)}");
+			int alignment = isArrayOfPointers ? PointerSize : GetAggregateAlignment (info.MaxFieldAlignment, info.Size * count);
+			output.Write ($", align {alignment}");
 			if (named && !skipFinalComment) {
 				WriteEOL ($"end of '{symbolName!}' array", output);
 			} else {
@@ -438,21 +439,21 @@ void WriteStructureArrayEnd<T> (StructureInfo<T> info, string? symbolName, ulong
 		/// <summary>
 		/// Writes an array of <paramref name="count"/> zero-initialized entries.  <paramref name="options"/> specifies the symbol attributes (visibility, writeability etc)
 		/// </summary>
-		public void WriteStructureArray<T> (StructureInfo<T> info, ulong count, LlvmIrVariableOptions options, string? symbolName = null, bool writeFieldComment = true, string? initialComment = null)
+		public void WriteStructureArray<T> (StructureInfo<T> info, ulong count, LlvmIrVariableOptions options, string? symbolName = null, bool writeFieldComment = true, string? initialComment = null, bool isArrayOfPointers = false)
 		{
 			bool named = WriteStructureArrayStart<T> (info, null, options, symbolName, initialComment);
+			string pointerAsterisk = isArrayOfPointers ? "*" : String.Empty;
+			Output.Write ($"[{count} x %struct.{info.Name}{pointerAsterisk}] zeroinitializer");
 
-			Output.Write ($"[{count} x %struct.{info.Name}] zeroinitializer");
-
-			WriteStructureArrayEnd<T> (info, symbolName, (ulong)count, named, skipFinalComment: true);
+			WriteStructureArrayEnd<T> (info, symbolName, (ulong)count, named, skipFinalComment: true, isArrayOfPointers: isArrayOfPointers);
 		}
 
 		/// <summary>
 		/// Writes an array of <paramref name="count"/> zero-initialized entries. The array will be generated as a local, writable symbol.
 		/// </summary>
-		public void WriteStructureArray<T> (StructureInfo<T> info, ulong count, string? symbolName = null, bool writeFieldComment = true, string? initialComment = null)
+		public void WriteStructureArray<T> (StructureInfo<T> info, ulong count, string? symbolName = null, bool writeFieldComment = true, string? initialComment = null, bool isArrayOfPointers = false)
 		{
-			WriteStructureArray<T> (info, count, LlvmIrVariableOptions.Default, symbolName, writeFieldComment, initialComment);
+			WriteStructureArray<T> (info, count, LlvmIrVariableOptions.Default, symbolName, writeFieldComment, initialComment, isArrayOfPointers);
 		}
 
 		/// <summary>
diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsNativeAssemblyGenerator.cs b/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsNativeAssemblyGenerator.cs
new file mode 100644
index 00000000000..cb2a8d56df5
--- /dev/null
+++ b/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsNativeAssemblyGenerator.cs
@@ -0,0 +1,114 @@
+#if ENABLE_MARSHAL_METHODS
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+using Java.Interop.Tools.TypeNameMappings;
+using Java.Interop.Tools.JavaCallableWrappers;
+
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+using Xamarin.Android.Tasks.LLVMIR;
+
+namespace Xamarin.Android.Tasks
+{
+	class MarshalMethodsNativeAssemblyGenerator : LlvmIrComposer
+	{
+		// This is here only to generate strongly-typed IR
+		internal sealed class MonoClass
+		{}
+
+		struct MarshalMethodsManagedClass
+		{
+			uint       token;
+
+			[NativePointer (IsNull = true)]
+			MonoClass  klass;
+		};
+
+		public ICollection<string> UniqueAssemblyNames { get; set; }
+		public int NumberOfAssembliesInApk { get; set; }
+		public List<OverriddenMethodDescriptor> OverriddenMethodDescriptors { get; set; }
+
+		StructureInfo<TypeMappingReleaseNativeAssemblyGenerator.MonoImage> monoImage;
+		StructureInfo<MonoClass> monoClass;
+
+		public override void Init ()
+		{}
+
+		protected override void MapStructures (LlvmIrGenerator generator)
+		{
+			monoImage = generator.MapStructure<TypeMappingReleaseNativeAssemblyGenerator.MonoImage> ();
+			monoClass = generator.MapStructure<MonoClass> ();
+		}
+
+		protected override void Write (LlvmIrGenerator generator)
+		{
+			WriteAssemblyImageCache (generator);
+		}
+
+		void WriteAssemblyImageCache (LlvmIrGenerator generator)
+		{
+			if (UniqueAssemblyNames == null) {
+				throw new InvalidOperationException ("Internal error: unique assembly names not provided");
+			}
+
+			if (UniqueAssemblyNames.Count != NumberOfAssembliesInApk) {
+				throw new InvalidOperationException ("Internal error: number of assemblies in the apk doesn't match the number of unique assembly names");
+			}
+
+			bool is64Bit = generator.Is64Bit;
+			generator.WriteStructureArray (monoImage, (ulong)NumberOfAssembliesInApk, "assembly_image_cache", isArrayOfPointers: true);
+
+			if (is64Bit) {
+				WriteHashes<ulong> ();
+			} else {
+				WriteHashes<uint> ();
+			}
+
+			void WriteHashes<T> () where T: struct
+			{
+				var hashes = new Dictionary<T, (string name, uint index)> ();
+				uint index = 0;
+				foreach (string name in UniqueAssemblyNames) {
+					string clippedName = Path.GetFileNameWithoutExtension (name);
+					ulong hashFull = HashName (name, is64Bit);
+					ulong hashClipped = HashName (clippedName, is64Bit);
+
+					//
+					// If the number of name forms changes, xamarin-app.hh MUST be updated to set value of the
+					// `number_of_assembly_name_forms_in_image_cache` constant to the number of forms.
+					//
+					hashes.Add ((T)Convert.ChangeType (hashFull, typeof(T)), (name, index));
+					hashes.Add ((T)Convert.ChangeType (hashClipped, typeof(T)), (clippedName, index));
+
+					index++;
+				}
+				List<T> keys = hashes.Keys.ToList ();
+				keys.Sort ();
+
+				generator.WriteCommentLine ("Each entry maps hash of an assembly name to an index into the `assembly_image_cache` array");
+				generator.WriteArray (
+					keys,
+					LlvmIrVariableOptions.GlobalConstant,
+					"assembly_image_cache_hashes",
+					(int idx, T value) => $"{idx}: {hashes[value].name} => 0x{value:x} => {hashes[value].index}"
+				);
+
+				var indices = new List<uint> ();
+				for (int i = 0; i < keys.Count; i++) {
+					indices.Add (hashes[keys[i]].index);
+				}
+				generator.WriteArray (
+					indices,
+					LlvmIrVariableOptions.GlobalConstant,
+					"assembly_image_cache_indices"
+				);
+			}
+		}
+	}
+}
+#endif
diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingReleaseNativeAssemblyGenerator.cs b/src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingReleaseNativeAssemblyGenerator.cs
index 7804dfba5a7..40c923a6e56 100644
--- a/src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingReleaseNativeAssemblyGenerator.cs
+++ b/src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingReleaseNativeAssemblyGenerator.cs
@@ -67,7 +67,7 @@ public int Compare (StructureInstance<TypeMapJava> a, StructureInstance<TypeMapJ
 		}
 
 		// This is here only to generate strongly-typed IR
-		sealed class MonoImage
+		internal sealed class MonoImage
 		{}
 
 		// Order of fields and their type must correspond *exactly* to that in
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
index fdbb3444b8d..f8388dbdc0a 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
@@ -24,6 +24,10 @@
     <NoWarn>$(NoWarn);CA1310</NoWarn>
   </PropertyGroup>
 
+  <PropertyGroup Condition=" '$(_EnableMarshalMethods)' == 'YesPlease' ">
+    <DefineConstants>$(DefineConstants);ENABLE_MARSHAL_METHODS</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
     <Reference Include="pdb2mdb.exe">
       <HintPath>..\..\bin\$(Configuration)\lib\xamarin.android\xbuild\Xamarin\Android\pdb2mdb.exe</HintPath>
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
index 97006ecbd88..d58d740ee13 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
@@ -1591,6 +1591,15 @@ because xbuild doesn't support framework reference assemblies.
     Mode="compressed">
       <Output TaskParameter="AssemblySources" ItemName="_CompressedAssembliesAssemblySource" />
   </PrepareAbiItems>
+  <PrepareAbiItems
+    Condition=" '$(_EnableMarshalMethods)' == 'YesPlease' "
+    BuildTargetAbis="@(_BuildTargetAbis)"
+    NativeSourcesDir="$(_NativeAssemblySourceDir)"
+    InstantRunEnabled="$(_InstantRunEnabled)"
+    Debug="$(AndroidIncludeDebugSymbols)"
+    Mode="marshal_methods">
+      <Output TaskParameter="AssemblySources" ItemName="_MarshalMethodsAssemblySource" />
+  </PrepareAbiItems>
 </Target>
 
 <Target Name="_GenerateEnvironmentFiles" DependsOnTargets="_ReadAndroidManifest">
@@ -1901,6 +1910,9 @@ because xbuild doesn't support framework reference assemblies.
     <_CompressedNativeAssemblyTarget Include="@(_CompressedAssembliesAssemblySource->'$([System.IO.Path]::ChangeExtension('%(Identity)', '.o'))')">
       <abi>%(_CompressedAssembliesAssemblySource.abi)</abi>
     </_CompressedNativeAssemblyTarget>
+    <_NativeAssemblyTarget Include="@(_MarshalMethodsAssemblySource->'$([System.IO.Path]::ChangeExtension('%(Identity)', '.o'))')">
+      <abi>%(_MarshalMethodsAssemblySource.abi)</abi>
+    </_NativeAssemblyTarget>
   </ItemGroup>
 </Target>
 
@@ -1920,10 +1932,10 @@ because xbuild doesn't support framework reference assemblies.
 
 <Target Name="_CompileNativeAssemblySources"
     DependsOnTargets="_PrepareNativeAssemblyItems;_GenerateCompressedAssembliesNativeSourceFiles"
-    Inputs="@(_TypeMapAssemblySource);@(_TypeMapAssemblyInclude);@(_EnvironmentAssemblySource);@(_CompressedAssembliesAssemblySource)"
+    Inputs="@(_TypeMapAssemblySource);@(_TypeMapAssemblyInclude);@(_EnvironmentAssemblySource);@(_CompressedAssembliesAssemblySource);@(_MarshalMethodsAssemblySource)"
     Outputs="@(_NativeAssemblyTarget)">
   <CompileNativeAssembly
-      Sources="@(_TypeMapAssemblySource);@(_EnvironmentAssemblySource);@(_CompressedAssembliesAssemblySource)"
+      Sources="@(_TypeMapAssemblySource);@(_EnvironmentAssemblySource);@(_CompressedAssembliesAssemblySource);@(_MarshalMethodsAssemblySource)"
       DebugBuild="$(AndroidIncludeDebugSymbols)"
       WorkingDirectory="$(_NativeAssemblySourceDir)"
       AndroidBinUtilsDirectory="$(AndroidBinUtilsDirectory)"
diff --git a/src/monodroid/CMakeLists.txt b/src/monodroid/CMakeLists.txt
index 578311eedae..df12154ad10 100644
--- a/src/monodroid/CMakeLists.txt
+++ b/src/monodroid/CMakeLists.txt
@@ -19,6 +19,8 @@ project(
   LANGUAGES CXX C
   )
 
+option(COMPILER_DIAG_COLOR "Show compiler diagnostics/errors in color" ON)
+
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -48,6 +50,8 @@ option(STRIP_DEBUG "Strip debugging information when linking" ${STRIP_DEBUG_DEFA
 option(DISABLE_DEBUG "Disable the built-in debugging code" OFF)
 option(USE_CCACHE "Use ccache, if found, to speed up recompilation" ${CCACHE_OPTION_DEFAULT})
 
+set(ENABLE_MARSHAL_METHODS False)
+
 if((MINGW OR NOT WIN32) AND USE_CCACHE)
   if(CMAKE_CXX_COMPILER MATCHES "/ccache/")
     message(STATUS "ccache: compiler already uses ccache")
@@ -269,6 +273,9 @@ add_compile_definitions(HAVE_CONFIG_H)
 add_compile_definitions(_REENTRANT)
 add_compile_definitions(JI_DLL_EXPORT)
 add_compile_definitions(MONO_DLL_EXPORT)
+if(ENABLE_MARSHAL_METHODS)
+  add_compile_definitions(ENABLE_MARSHAL_METHODS)
+endif()
 
 if(ENABLE_NET)
   add_compile_definitions(NET)
@@ -345,6 +352,12 @@ set(LOCAL_COMMON_COMPILER_ARGS
   -Wuninitialized
   )
 
+if(COMPILER_DIAG_COLOR)
+  list(APPEND LOCAL_COMMON_COMPILER_ARGS
+    -fdiagnostics-color=always
+    )
+endif()
+
 set(LOCAL_COMMON_LINKER_ARGS "")
 if(ANDROID)
   if (ENABLE_CLANG_ASAN OR ENABLE_CLANG_UBSAN)
@@ -460,6 +473,9 @@ endif()
 set(XAMARIN_INTERNAL_API_LIB xa-internal-api${CHECKED_BUILD_INFIX})
 set(XAMARIN_DEBUG_APP_HELPER_LIB xamarin-debug-app-helper${CHECKED_BUILD_INFIX})
 set(XAMARIN_APP_STUB_LIB xamarin-app)
+if(ENABLE_MARSHAL_METHODS)
+  set(XAMARIN_APP_MARSHALING_LIB xamarin-app-marshaling)
+endif()
 
 string(TOLOWER ${CMAKE_BUILD_TYPE} XAMARIN_MONO_ANDROID_SUFFIX)
 set(XAMARIN_MONO_ANDROID_LIB "mono-android${CHECKED_BUILD_INFIX}.${XAMARIN_MONO_ANDROID_SUFFIX}")
@@ -477,6 +493,7 @@ set(XAMARIN_MONODROID_SOURCES
   ${SOURCES_DIR}/globals.cc
   ${SOURCES_DIR}/logger.cc
   ${SOURCES_DIR}/monodroid-glue.cc
+  ${SOURCES_DIR}/mono-image-loader.cc
   ${SOURCES_DIR}/osbridge.cc
   ${SOURCES_DIR}/shared-constants.cc
   ${SOURCES_DIR}/timezones.cc
@@ -494,6 +511,12 @@ if(ANDROID)
     ${LZ4_SOURCES}
     )
 
+  if(NOT DEBUG_BUILD AND ENABLE_NET AND ENABLE_MARSHAL_METHODS)
+    list(APPEND XAMARIN_MONODROID_SOURCES
+      ${SOURCES_DIR}/xamarin-android-app-context.cc
+      )
+  endif()
+
   if(NOT USES_LIBSTDCPP)
     list(APPEND XAMARIN_MONODROID_SOURCES
       ${BIONIC_SOURCES_DIR}/cxa_guard.cc
@@ -550,9 +573,21 @@ set(XAMARIN_DEBUG_APP_HELPER_SOURCES
   ${SOURCES_DIR}/shared-constants.cc
   )
 
+if(ENABLE_MARSHAL_METHODS)
+  set(XAMARIN_APP_MARSHALING_LIB_SOURCES
+    ${SOURCES_DIR}/xamarin-app-marshaling.cc
+  )
+endif()
+
 # Build
 configure_file(jni/host-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/include/host-config.h)
 
+if(MINGW OR WIN32)
+  list(APPEND MONOSGEN_LIB_LINK -lmonosgen-2.0.dll)
+else()
+  list(APPEND MONOSGEN_LIB_LINK -lmonosgen-2.0)
+endif()
+
 if(NOT (ANDROID AND ENABLE_NET))
   add_library(
     ${XAMARIN_INTERNAL_API_LIB}
@@ -583,6 +618,20 @@ target_link_options(
   )
 
 if(ANDROID)
+  if(NOT DEBUG_BUILD AND ENABLE_NET AND ENABLE_MARSHAL_METHODS)
+    # The marshaling lib is used only when building for devices
+    add_library(
+      ${XAMARIN_APP_MARSHALING_LIB}
+      SHARED
+      ${XAMARIN_APP_MARSHALING_LIB_SOURCES}
+      )
+
+    target_link_libraries(
+      ${XAMARIN_APP_MARSHALING_LIB}
+      ${MONOSGEN_LIB_LINK}
+      )
+  endif()
+
   # Only Android builds need to go in separate directories, desktop builds have the same ABI
   set_target_properties(
     ${XAMARIN_APP_STUB_LIB}
@@ -669,11 +718,7 @@ if(APPLE)
     )
 endif()
 
-if(MINGW OR WIN32)
-  list(APPEND LINK_LIBS -lmonosgen-2.0.dll)
-else()
-  list(APPEND LINK_LIBS -lmonosgen-2.0)
-endif()
+list(APPEND LINK_LIBS ${MONOSGEN_LIB_LINK})
 
 if(NOT MINGW AND NOT WIN32)
   set(DEBUG_HELPER_LINK_LIBS "-ldl")
@@ -694,3 +739,10 @@ target_link_libraries(
   ${XAMARIN_MONO_ANDROID_LIB}
   ${LINK_LIBS} xamarin-app
   )
+
+if((NOT DEBUG_BUILD) AND ANDROID AND ENABLE_NET AND ENABLE_MARSHAL_METHODS)
+  target_link_libraries(
+    ${XAMARIN_MONO_ANDROID_LIB}
+    ${XAMARIN_APP_MARSHALING_LIB}
+  )
+endif()
diff --git a/src/monodroid/jni/application_dso_stub.cc b/src/monodroid/jni/application_dso_stub.cc
index de2ee8445fc..f93ade77481 100644
--- a/src/monodroid/jni/application_dso_stub.cc
+++ b/src/monodroid/jni/application_dso_stub.cc
@@ -144,3 +144,48 @@ DSOCacheEntry dso_cache[] = {
 		.handle = nullptr,
 	},
 };
+
+//
+// Support for marshal methods
+//
+#if defined (RELEASE) && defined (ANDROID) && defined (NET)
+MonoImage* assembly_image_cache[] = {
+	nullptr,
+	nullptr,
+
+};
+
+// Each element contains an index into `assembly_image_cache`
+const uint32_t assembly_image_cache_indices[] = {
+	0,
+	1,
+	1,
+	1,
+};
+
+// hashes point to indices in `assembly_image_cache_indices`
+const xamarin::android::hash_t assembly_image_cache_hashes[] = {
+	0,
+	1,
+	2,
+	3,
+};
+
+uint32_t marshal_methods_number_of_classes = 2;
+MarshalMethodsManagedClass marshal_methods_class_cache[] = {
+	{
+		.token = 0,
+		.klass = nullptr,
+	},
+
+	{
+		.token = 0,
+		.klass = nullptr,
+	},
+};
+
+void xamarin_app_init ([[maybe_unused]] get_function_pointer_fn fn)
+{
+	// Dummy
+}
+#endif // def RELEASE && def ANDROID && def NET
diff --git a/src/monodroid/jni/embedded-assemblies.cc b/src/monodroid/jni/embedded-assemblies.cc
index 328d0240a38..c3c6f864911 100644
--- a/src/monodroid/jni/embedded-assemblies.cc
+++ b/src/monodroid/jni/embedded-assemblies.cc
@@ -32,10 +32,12 @@
 #include "embedded-assemblies.hh"
 #include "globals.hh"
 #include "monodroid-glue.hh"
+#include "mono-image-loader.hh"
 #include "xamarin-app.hh"
 #include "cpp-util.hh"
 #include "startup-aware-lock.hh"
 #include "timing-internal.hh"
+#include "search.hh"
 
 using namespace xamarin::android;
 using namespace xamarin::android::internal;
@@ -151,42 +153,6 @@ EmbeddedAssemblies::get_assembly_data (AssemblyStoreSingleAssemblyRuntimeData co
 	get_assembly_data (e.image_data, e.descriptor->data_size, "<assembly_store>", assembly_data, assembly_data_size);
 }
 
-#if defined (NET)
-MonoAssembly*
-EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, MonoAssemblyLoadContextGCHandle alc_gchandle, [[maybe_unused]] MonoError *error)
-{
-	auto loader = [&] (uint8_t *assembly_data, uint32_t assembly_data_size, const char *name) -> MonoImage* {
-		return mono_image_open_from_data_alc (
-			alc_gchandle,
-			reinterpret_cast<char*>(assembly_data),
-			assembly_data_size,
-			0 /* need_copy */,
-			nullptr /* status */,
-			name
-		);
-	};
-
-	return open_from_bundles (aname, loader, false /* ref_only */);
-}
-#endif // def NET
-
-MonoAssembly*
-EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, bool ref_only)
-{
-	auto loader = [&] (uint8_t *assembly_data, uint32_t assembly_data_size, const char *name) -> MonoImage* {
-		return mono_image_open_from_data_with_name (
-			reinterpret_cast<char*>(assembly_data),
-			assembly_data_size,
-			0,
-			nullptr,
-			ref_only,
-			name
-		);
-	};
-
-	return open_from_bundles (aname, loader, ref_only);
-}
-
 template<bool LogMapping>
 force_inline void
 EmbeddedAssemblies::map_runtime_file (XamarinAndroidBundledAssembly& file) noexcept
@@ -239,12 +205,13 @@ EmbeddedAssemblies::map_debug_data (XamarinAndroidBundledAssembly& file) noexcep
 	map_runtime_file<false> (file);
 }
 
+template<LoaderData TLoaderData>
 force_inline MonoAssembly*
 EmbeddedAssemblies::load_bundled_assembly (
 	XamarinAndroidBundledAssembly& assembly,
 	dynamic_local_string<SENSIBLE_PATH_MAX> const& name,
 	dynamic_local_string<SENSIBLE_PATH_MAX> const& abi_name,
-	std::function<MonoImage*(uint8_t*, uint32_t, const char*)> loader,
+	TLoaderData loader_data,
 	bool ref_only) noexcept
 {
 	if (assembly.name == nullptr || assembly.name[0] == '\0') {
@@ -267,7 +234,7 @@ EmbeddedAssemblies::load_bundled_assembly (
 	uint32_t assembly_data_size;
 
 	get_assembly_data (assembly, assembly_data, assembly_data_size);
-	MonoImage *image = loader (assembly_data, assembly_data_size, name.get ());
+	MonoImage *image = MonoImageLoader::load (name, loader_data, assembly_data, assembly_data_size);
 	if (image == nullptr) {
 		return nullptr;
 	}
@@ -300,7 +267,8 @@ EmbeddedAssemblies::load_bundled_assembly (
 
 	MonoImageOpenStatus status;
 	MonoAssembly *a = mono_assembly_load_from_full (image, name.get (), &status, ref_only);
-	if (a == nullptr) {
+	if (a == nullptr || status != MonoImageOpenStatus::MONO_IMAGE_OK) {
+		log_warn (LOG_ASSEMBLY, "Failed to load managed assembly '%s'. %s", name.get (), mono_image_strerror (status));
 		return nullptr;
 	}
 
@@ -311,8 +279,9 @@ EmbeddedAssemblies::load_bundled_assembly (
 	return a;
 }
 
+template<LoaderData TLoaderData>
 force_inline MonoAssembly*
-EmbeddedAssemblies::individual_assemblies_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, std::function<MonoImage*(uint8_t*, size_t, const char*)> loader, bool ref_only) noexcept
+EmbeddedAssemblies::individual_assemblies_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, TLoaderData loader_data, bool ref_only) noexcept
 {
 	if (!utils.ends_with (name, SharedConstants::DLL_EXTENSION)) {
 		name.append (SharedConstants::DLL_EXTENSION);
@@ -329,7 +298,7 @@ EmbeddedAssemblies::individual_assemblies_open_from_bundles (dynamic_local_strin
 	MonoAssembly *a = nullptr;
 
 	for (size_t i = 0; i < application_config.number_of_assemblies_in_apk; i++) {
-		a = load_bundled_assembly (bundled_assemblies [i], name, abi_name, loader, ref_only);
+		a = load_bundled_assembly (bundled_assemblies [i], name, abi_name, loader_data, ref_only);
 		if (a != nullptr) {
 			return a;
 		}
@@ -337,7 +306,7 @@ EmbeddedAssemblies::individual_assemblies_open_from_bundles (dynamic_local_strin
 
 	if (extra_bundled_assemblies != nullptr) {
 		for (XamarinAndroidBundledAssembly& assembly : *extra_bundled_assemblies) {
-			a = load_bundled_assembly (assembly, name, abi_name, loader, ref_only);
+			a = load_bundled_assembly (assembly, name, abi_name, loader_data, ref_only);
 			if (a != nullptr) {
 				return a;
 			}
@@ -377,8 +346,9 @@ EmbeddedAssemblies::find_assembly_store_entry ([[maybe_unused]] hash_t hash, [[m
 	return nullptr;
 }
 
+template<LoaderData TLoaderData>
 force_inline MonoAssembly*
-EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, std::function<MonoImage*(uint8_t*, size_t, const char*)> loader, bool ref_only) noexcept
+EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, TLoaderData loader_data, bool ref_only) noexcept
 {
 	size_t len = name.length ();
 	bool have_dll_ext = utils.ends_with (name, SharedConstants::DLL_EXTENSION);
@@ -411,6 +381,7 @@ EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSI
 		AssemblyStoreRuntimeData &rd = assembly_stores[hash_entry->store_id];
 		if (hash_entry->local_store_index >= rd.assembly_count) {
 			log_fatal (LOG_ASSEMBLY, "Invalid index %u into local store assembly descriptor array", hash_entry->local_store_index);
+			abort ();
 		}
 
 		AssemblyStoreAssemblyDescriptor *bba = &rd.assemblies[hash_entry->local_store_index];
@@ -459,7 +430,7 @@ EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSI
 	}
 
 	get_assembly_data (assembly_runtime_info, assembly_data, assembly_data_size);
-	MonoImage *image = loader (assembly_data, assembly_data_size, name.get ());
+	MonoImage *image = MonoImageLoader::load (name, loader_data, name_hash, assembly_data, assembly_data_size);
 	if (image == nullptr) {
 		log_warn (LOG_ASSEMBLY, "Failed to load MonoImage of '%s'", name.get ());
 		return nullptr;
@@ -472,7 +443,8 @@ EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSI
 
 	MonoImageOpenStatus status;
 	MonoAssembly *a = mono_assembly_load_from_full (image, name.get (), &status, ref_only);
-	if (a == nullptr) {
+	if (a == nullptr || status != MonoImageOpenStatus::MONO_IMAGE_OK) {
+		log_warn (LOG_ASSEMBLY, "Failed to load managed assembly '%s'. %s", name.get (), mono_image_strerror (status));
 		return nullptr;
 	}
 
@@ -482,8 +454,12 @@ EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSI
 	return a;
 }
 
-MonoAssembly*
-EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, std::function<MonoImage*(uint8_t*, size_t, const char*)> loader, bool ref_only)
+// TODO: need to forbid loading assemblies into non-default ALC if they contain marshal method callbacks.
+//       The best way is probably to store the information in the assembly `MonoImage*` cache. We should
+//       abort() if the assembly contains marshal callbacks.
+template<LoaderData TLoaderData>
+force_inline MonoAssembly*
+EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, TLoaderData loader_data, [[maybe_unused]] MonoError *error, bool ref_only) noexcept
 {
 	const char *culture = mono_assembly_name_get_culture (aname);
 	const char *asmname = mono_assembly_name_get_name (aname);
@@ -497,9 +473,9 @@ EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, std::function<Mo
 
 	MonoAssembly *a;
 	if (application_config.have_assembly_store) {
-		a = assembly_store_open_from_bundles (name, loader, ref_only);
+		a = assembly_store_open_from_bundles (name, loader_data, ref_only);
 	} else {
-		a = individual_assemblies_open_from_bundles (name, loader, ref_only);
+		a = individual_assemblies_open_from_bundles (name, loader_data, ref_only);
 	}
 
 	if (a == nullptr) {
@@ -513,20 +489,29 @@ EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, std::function<Mo
 MonoAssembly*
 EmbeddedAssemblies::open_from_bundles (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data, MonoError *error)
 {
-	return embeddedAssemblies.open_from_bundles (aname, alc_gchandle, error);
+	constexpr bool ref_only = false;
+	return embeddedAssemblies.open_from_bundles (aname, alc_gchandle, error, ref_only);
 }
 #else // def NET
+
+// The duplicated `ref_only` parameters in the two functions below look weird, but the first one of them is used to
+// call the right instance of the templateed MonoImageLoader::load method (just as`alc_gchandle` above) which loads a
+// `MonoImage`, while the other is used when loading a `MonoAssembly`
 MonoAssembly*
 EmbeddedAssemblies::open_from_bundles_refonly (MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data)
 {
-	return embeddedAssemblies.open_from_bundles (aname, true);
+	constexpr bool ref_only = false;
+
+	return embeddedAssemblies.open_from_bundles (aname, ref_only /* loader_data */, nullptr /* error */, ref_only);
 }
 #endif // ndef NET
 
 MonoAssembly*
 EmbeddedAssemblies::open_from_bundles_full (MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data)
 {
-	return embeddedAssemblies.open_from_bundles (aname, false);
+	constexpr bool ref_only = false;
+
+	return embeddedAssemblies.open_from_bundles (aname, ref_only /* loader_data */, nullptr /* error */, ref_only);
 }
 
 void
@@ -602,41 +587,6 @@ EmbeddedAssemblies::binary_search (const Key *key, const Entry *base, size_t nme
 	return nullptr;
 }
 
-force_inline ssize_t
-EmbeddedAssemblies::binary_search (hash_t key, const hash_t *arr, size_t n) noexcept
-{
-	ssize_t left = -1;
-	ssize_t right = static_cast<ssize_t>(n);
-
-	while (right - left > 1) {
-		ssize_t middle = (left + right) >> 1;
-		if (arr[middle] < key) {
-			left = middle;
-		} else {
-			right = middle;
-		}
-	}
-
-	return arr[right] == key ? right : -1;
-}
-
-force_inline ptrdiff_t
-EmbeddedAssemblies::binary_search_branchless (hash_t x, const hash_t *arr, uint32_t len) noexcept
-{
-	const hash_t *base = arr;
-	while (len > 1) {
-		uint32_t half = len >> 1;
-		// __builtin_prefetch(&base[(len - half) / 2]);
-		// __builtin_prefetch(&base[half + (len - half) / 2]);
-		base = (base[half] < x ? &base[half] : base);
-		len -= half;
-	}
-
-	//return *(base + (*base < x));
-	ptrdiff_t ret = (base + (*base < x)) - arr;
-	return arr[ret] == x ? ret : -1;
-}
-
 #if defined (RELEASE) && defined (ANDROID)
 force_inline const TypeMapModuleEntry*
 EmbeddedAssemblies::binary_search (uint32_t key, const TypeMapModuleEntry *arr, uint32_t n) noexcept
@@ -719,7 +669,7 @@ EmbeddedAssemblies::typemap_java_to_managed (hash_t hash, const MonoString *java
 	// In microbrenchmarks, `binary_search_branchless` is faster than `binary_search` but in "real" application tests,
 	// the simple version appears to yield faster startup... Leaving both for now, for further investigation and
 	// potential optimizations
-	ssize_t idx = binary_search (hash, map_java_hashes, java_type_count);
+	ssize_t idx = Search::binary_search (hash, map_java_hashes, java_type_count);
 	//ptrdiff_t idx = binary_search_branchless (hash, map_java_hashes, java_type_count);
 
 	TypeMapJava const* java_entry = idx >= 0 ? &map_java[idx] : nullptr;
diff --git a/src/monodroid/jni/embedded-assemblies.hh b/src/monodroid/jni/embedded-assemblies.hh
index 5e59a7cb1a0..58f12334e49 100644
--- a/src/monodroid/jni/embedded-assemblies.hh
+++ b/src/monodroid/jni/embedded-assemblies.hh
@@ -4,14 +4,6 @@
 
 #include <array>
 
-#undef HAVE_CONCEPTS
-
-// Xcode has supports for concepts only since 12.5
-#if __has_include (<concepts>)
-#define HAVE_CONCEPTS
-#include <concepts>
-#endif // __has_include
-
 #include <cerrno>
 #include <cstring>
 #include <limits>
@@ -29,9 +21,18 @@
 #include "strings.hh"
 #include "xamarin-app.hh"
 #include "cpp-util.hh"
+#include "mono-image-loader.hh"
 #include "shared-constants.hh"
 #include "xxhash.hh"
 
+#undef HAVE_CONCEPTS
+
+// Xcode has supports for concepts only since 12.5
+#if __has_include (<concepts>)
+#define HAVE_CONCEPTS
+#include <concepts>
+#endif // __has_include
+
 struct TypeMapHeader;
 
 namespace xamarin::android::internal {
@@ -52,8 +53,18 @@ namespace xamarin::android::internal {
 		a.data ();
 		requires std::same_as<typename T::value_type, uint8_t>;
 	};
+
+	template<typename T>
+	concept LoaderData = requires (T a) {
+		requires std::same_as<T, bool>
+#if defined (NET)
+		|| std::same_as<T, MonoAssemblyLoadContextGCHandle>
+#endif
+		;
+	};
 #else
 #define ByteArrayContainer class
+#define LoaderData typename
 #endif
 
 	class EmbeddedAssemblies final
@@ -171,23 +182,27 @@ namespace xamarin::android::internal {
 		STATIC_IN_ANDROID_RELEASE MonoReflectionType* typemap_java_to_managed (hash_t hash, const MonoString *java_type_name) noexcept;
 		size_t register_from (const char *apk_file, monodroid_should_register should_register);
 		void gather_bundled_assemblies_from_apk (const char* apk, monodroid_should_register should_register);
-#if defined (NET)
-		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, MonoAssemblyLoadContextGCHandle alc_gchandle, MonoError *error);
-#endif // def NET
-		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, bool ref_only);
-		MonoAssembly* individual_assemblies_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, std::function<MonoImage*(uint8_t*, size_t, const char*)> loader, bool ref_only) noexcept;
-		MonoAssembly* assembly_store_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, std::function<MonoImage*(uint8_t*, size_t, const char*)> loader, bool ref_only) noexcept;
-		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, std::function<MonoImage*(uint8_t*, size_t, const char*)> loader, bool ref_only);
+
+		template<LoaderData TLoaderData>
+		MonoAssembly* individual_assemblies_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, TLoaderData loader_data, bool ref_only) noexcept;
+
+		template<LoaderData TLoaderData>
+		MonoAssembly* assembly_store_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, TLoaderData loader_data, bool ref_only) noexcept;
+
+		template<LoaderData TLoaderData>
+		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, TLoaderData loader_data, MonoError *error, bool ref_only) noexcept;
 
 		template<bool LogMapping>
 		void map_runtime_file (XamarinAndroidBundledAssembly& file) noexcept;
 		void map_assembly (XamarinAndroidBundledAssembly& file) noexcept;
 		void map_debug_data (XamarinAndroidBundledAssembly& file) noexcept;
+
+		template<LoaderData TLoaderData>
 		MonoAssembly* load_bundled_assembly (
 			XamarinAndroidBundledAssembly& assembly,
 			dynamic_local_string<SENSIBLE_PATH_MAX> const& name,
 			dynamic_local_string<SENSIBLE_PATH_MAX> const& abi_name,
-			std::function<MonoImage*(uint8_t*, uint32_t, const char*)> loader,
+			TLoaderData loader_data,
 			bool ref_only) noexcept;
 
 #if defined (DEBUG) || !defined (ANDROID)
@@ -279,8 +294,6 @@ namespace xamarin::android::internal {
 
 		template<typename Key, typename Entry, int (*compare)(const Key*, const Entry*), bool use_extra_size = false>
 		static const Entry* binary_search (const Key *key, const Entry *base, size_t nmemb, size_t extra_size = 0) noexcept;
-		static ssize_t binary_search (hash_t key, const hash_t *arr, size_t n) noexcept;
-		static ptrdiff_t binary_search_branchless (hash_t x, const hash_t *arr, uint32_t len) noexcept;
 
 #if defined (DEBUG) || !defined (ANDROID)
 		static int compare_type_name (const char *type_name, const TypeMapEntry *entry) noexcept;
diff --git a/src/monodroid/jni/mono-image-loader.cc b/src/monodroid/jni/mono-image-loader.cc
new file mode 100644
index 00000000000..ea2cc39a822
--- /dev/null
+++ b/src/monodroid/jni/mono-image-loader.cc
@@ -0,0 +1,5 @@
+#include "mono-image-loader.hh"
+
+#if defined (USE_CACHE)
+size_t xamarin::android::internal::MonoImageLoader::number_of_cache_index_entries = application_config.number_of_assemblies_in_apk * number_of_assembly_name_forms_in_image_cache;
+#endif // def USE_CACHE
diff --git a/src/monodroid/jni/mono-image-loader.hh b/src/monodroid/jni/mono-image-loader.hh
new file mode 100644
index 00000000000..b844f5c3acb
--- /dev/null
+++ b/src/monodroid/jni/mono-image-loader.hh
@@ -0,0 +1,148 @@
+// Dear Emacs, this is a -*- C++ -*- header
+#if !defined (__MONO_IMAGE_LOADER_HH)
+#define __MONO_IMAGE_LOADER_HH
+
+#include <cstdint>
+#include <cstddef>
+
+#include <mono/metadata/image.h>
+#if defined (NET)
+#include <mono/metadata/mono-private-unstable.h>
+#endif
+#include <mono/metadata/object.h>
+
+#include "platform-compat.hh"
+#include "xamarin-app.hh"
+#include "xxhash.hh"
+#include "search.hh"
+#include "strings.hh"
+
+#if defined (RELEASE) && defined (ANDROID) && defined (NET) && defined (ENABLE_MARSHAL_METHODS)
+#define USE_CACHE 1
+#endif
+
+namespace xamarin::android::internal {
+	enum class MonoImageLoaderContext
+	{
+		ALC,
+		AppDomain,
+	};
+
+	class MonoImageLoader final
+	{
+	public:
+#if defined (USE_CACHE)
+		force_inline static MonoImage* get_from_index (size_t index) noexcept
+		{
+			if (index >= application_config.number_of_assemblies_in_apk) {
+				return nullptr;
+			}
+
+			return get_from_index_quick (index);
+		}
+
+		force_inline static MonoImage* get_with_hash (hash_t hash) noexcept
+		{
+			ssize_t index = find_index (hash);
+			if (index < 0) {
+				return nullptr;
+			}
+
+			return get_from_index_quick (static_cast<size_t>(index));
+		}
+#endif // def USE_CACHE
+
+#if defined (NET)
+		force_inline static MonoImage* load (dynamic_local_string<SENSIBLE_PATH_MAX> const& name, MonoAssemblyLoadContextGCHandle alc_gchandle, hash_t name_hash, uint8_t *assembly_data, uint32_t assembly_data_size) noexcept
+		{
+			log_info (LOG_DEFAULT, "Loading assembly %s; hash 0x%zx", name.get (), name_hash);
+			MonoImageOpenStatus status;
+			MonoImage *image = mono_image_open_from_data_alc (
+				alc_gchandle,
+				reinterpret_cast<char*>(assembly_data),
+				assembly_data_size,
+				0 /* need_copy */,
+				&status,
+				name.get ()
+			);
+
+			return stash_and_return (image, status, name_hash);
+		}
+
+		force_inline static MonoImage* load (dynamic_local_string<SENSIBLE_PATH_MAX> const& name, MonoAssemblyLoadContextGCHandle alc_gchandle, uint8_t *assembly_data, uint32_t assembly_data_size) noexcept
+		{
+
+			return load (name, alc_gchandle, xxhash::hash (name.get (), name.length ()), assembly_data, assembly_data_size);
+		}
+#endif // def NET
+
+		force_inline static MonoImage* load (dynamic_local_string<SENSIBLE_PATH_MAX> const& name, bool ref_only, hash_t name_hash, uint8_t *assembly_data, uint32_t assembly_data_size) noexcept
+		{
+			MonoImageOpenStatus status;
+			MonoImage *image = mono_image_open_from_data_with_name (
+				reinterpret_cast<char*>(assembly_data),
+				assembly_data_size,
+				0,
+				&status,
+				ref_only,
+				name.get ()
+			);
+
+			return stash_and_return (image, status, name_hash);
+		}
+
+		force_inline static MonoImage* load (dynamic_local_string<SENSIBLE_PATH_MAX> const& name, bool ref_only, uint8_t *assembly_data, uint32_t assembly_data_size) noexcept
+		{
+			return load (name, ref_only, xxhash::hash (name.get (), name.length ()), assembly_data, assembly_data_size);
+		}
+
+	private:
+#if defined (USE_CACHE)
+		// Performs NO BOUNDS CHECKING (intended!)
+		force_inline static MonoImage* get_from_index_quick (size_t index) noexcept
+		{
+			return assembly_image_cache[index];
+		}
+
+		force_inline static ssize_t find_index (hash_t hash) noexcept
+		{
+			ssize_t idx = Search::binary_search (hash, assembly_image_cache_hashes, number_of_cache_index_entries);
+			return idx >= 0 ? assembly_image_cache_indices[idx] : -1;
+
+		}
+#endif // def USE_CACHE
+
+		force_inline static MonoImage* stash_and_return (MonoImage *image, MonoImageOpenStatus status, [[maybe_unused]] hash_t hash) noexcept
+		{
+#if ENABLE_MARSHAL_METHODS
+			log_info (LOG_DEFAULT, "Stashing image %p; hash 0x%zx", image, hash);
+#endif
+			if (image == nullptr || status != MonoImageOpenStatus::MONO_IMAGE_OK) {
+				log_warn (LOG_ASSEMBLY, "Failed to open assembly image for '%s'. %s", mono_image_strerror (status));
+				return nullptr;
+			}
+
+#if defined (USE_CACHE)
+			ssize_t index = find_index (hash);
+			log_info (LOG_DEFAULT, "Index matching the hash == %zd", index);
+			if (index < 0) {
+				// TODO: Warn?
+				return image;
+			}
+
+			log_info (LOG_DEFAULT, "Stashing");
+			// We don't need to worry about locking here.  Even if we're overwriting an entry just set by another
+			// thread, the image pointer is going to be the same (at least currently, it will change when we have
+			// support for unloadable Assembly Load Contexts) and the actual write operation to the destination is
+			// atomic
+			assembly_image_cache[index] = image;
+#endif // def RELEASE && def ANDROID && def NET
+			return image;
+		}
+
+#if defined (USE_CACHE)
+		static size_t number_of_cache_index_entries;
+#endif // def USE_CACHE
+	};
+}
+#endif // ndef __MONO_IMAGE_LOADER_HH
diff --git a/src/monodroid/jni/mono_android_Runtime.h b/src/monodroid/jni/mono_android_Runtime.h
index 2dfa0a6cf00..7cc5c5230f9 100644
--- a/src/monodroid/jni/mono_android_Runtime.h
+++ b/src/monodroid/jni/mono_android_Runtime.h
@@ -87,6 +87,12 @@ JNIEXPORT void JNICALL Java_mono_android_Runtime_propagateUncaughtException
 JNIEXPORT void JNICALL Java_mono_android_Runtime_dumpTimingData
   (JNIEnv *, jclass);
 
+JNIEXPORT void JNICALL Java_helloandroid_MainActivity_n_1onCreate__Landroid_os_Bundle_2
+  (JNIEnv *, jclass, jobject);
+
+JNIEXPORT jobject JNICALL Java_helloandroid_MainActivity_n_1onCreateView__Landroid_view_View_2Ljava_lang_String_2Landroid_content_Context_2Landroid_util_AttributeSet_2
+  (JNIEnv *env, jclass klass, jobject view, jstring name, jobject context, jobject attrs);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/monodroid/jni/monodroid-glue-internal.hh b/src/monodroid/jni/monodroid-glue-internal.hh
index ed557fe0ab1..d9ccfef9cd4 100644
--- a/src/monodroid/jni/monodroid-glue-internal.hh
+++ b/src/monodroid/jni/monodroid-glue-internal.hh
@@ -350,7 +350,11 @@ namespace xamarin::android::internal
 
 #if defined (NET)
 		static void monodroid_debugger_unhandled_exception (MonoException *ex);
-#endif
+
+#if defined (RELEASE) && defined (ANDROID)
+		static void* get_function_pointer (uint32_t mono_image_index, uint32_t class_token, uint32_t method_token) noexcept;
+#endif // def RELEASE && def ANDROID
+#endif // def NET
 
 #if defined (DEBUG)
 		void set_debug_env_vars (void);
diff --git a/src/monodroid/jni/monodroid-glue.cc b/src/monodroid/jni/monodroid-glue.cc
index 53ef0a1bc61..47006d4d17d 100644
--- a/src/monodroid/jni/monodroid-glue.cc
+++ b/src/monodroid/jni/monodroid-glue.cc
@@ -873,6 +873,10 @@ MonodroidRuntime::mono_runtime_init ([[maybe_unused]] dynamic_local_string<PROPE
 #ifndef RELEASE
 	mono_install_assembly_preload_hook (open_from_update_dir, nullptr);
 #endif
+
+#if defined (RELEASE) && defined (ANDROID) && defined (NET) && ENABLE_MARSHAL_METHODS
+	xamarin_app_init (get_function_pointer);
+#endif // def RELEASE && def ANDROID && def NET
 }
 
 #if defined (NET)
@@ -1344,11 +1348,9 @@ MonodroidRuntime::find_dso_cache_entry ([[maybe_unused]] hash_t hash) noexcept
 	size_t entry_count = application_config.number_of_dso_cache_entries;
 	DSOCacheEntry *entries = dso_cache;
 
-	log_debug (LOG_ASSEMBLY, "dso_cache: looking for hash 0x%zx", hash);
 	while (entry_count > 0) {
 		ret = entries + (entry_count / 2);
 		entry_hash = static_cast<hash_t> (ret->hash);
-		log_debug (LOG_ASSEMBLY, "dso_cache: entry_hash == 0x%zx", entry_hash);
 		auto result = hash <=> entry_hash;
 
 		if (result < 0) {
@@ -2501,6 +2503,18 @@ MonodroidRuntime::Java_mono_android_Runtime_register (JNIEnv *env, jstring manag
 		total_time_index = internal_timing->start_event (TimingEventKind::RuntimeRegister);
 	}
 
+#if defined (ENABLE_MARSHAL_METHODS)
+	const char *mt_ptr = env->GetStringUTFChars (managedType, nullptr);
+	log_info (LOG_DEFAULT, "[TESTING] Registering managed type: '%s'", mt_ptr);
+	bool ignore = strcmp (mt_ptr, "HelloAndroid.MainActivity, HelloAndroid") == 0;
+	env->ReleaseStringUTFChars (managedType, mt_ptr);
+
+	if (ignore) {
+		log_info (LOG_DEFAULT, "[TESTING] This type's registration is ignored");
+		return;
+	}
+#endif
+
 	jsize managedType_len = env->GetStringLength (managedType);
 	const jchar *managedType_ptr = env->GetStringChars (managedType, nullptr);
 	int methods_len = env->GetStringLength (methods);
diff --git a/src/monodroid/jni/search.hh b/src/monodroid/jni/search.hh
new file mode 100644
index 00000000000..554126d2bee
--- /dev/null
+++ b/src/monodroid/jni/search.hh
@@ -0,0 +1,48 @@
+// Dear Emacs, this is a -*- C++ -*- header
+#if !defined (__SEARCH_HH)
+#define __SEARCH_HH
+
+#include <sys/types.h>
+
+#include "platform-compat.hh"
+#include "xxhash.hh"
+
+namespace xamarin::android::internal {
+	class Search final
+	{
+	public:
+		force_inline static ssize_t binary_search (hash_t key, const hash_t *arr, size_t n) noexcept
+		{
+			ssize_t left = -1;
+			ssize_t right = static_cast<ssize_t>(n);
+
+			while (right - left > 1) {
+				ssize_t middle = (left + right) >> 1;
+				if (arr[middle] < key) {
+					left = middle;
+				} else {
+					right = middle;
+				}
+			}
+
+			return arr[right] == key ? right : -1;
+		}
+
+		force_inline static ptrdiff_t binary_search_branchless (hash_t x, const hash_t *arr, uint32_t len) noexcept
+		{
+			const hash_t *base = arr;
+			while (len > 1) {
+				uint32_t half = len >> 1;
+				// __builtin_prefetch(&base[(len - half) / 2]);
+				// __builtin_prefetch(&base[half + (len - half) / 2]);
+				base = (base[half] < x ? &base[half] : base);
+				len -= half;
+			}
+
+			//return *(base + (*base < x));
+			ptrdiff_t ret = (base + (*base < x)) - arr;
+			return arr[ret] == x ? ret : -1;
+		}
+	};
+}
+#endif // ndef __SEARCH_HH
diff --git a/src/monodroid/jni/xamarin-android-app-context.cc b/src/monodroid/jni/xamarin-android-app-context.cc
new file mode 100644
index 00000000000..e904e03e806
--- /dev/null
+++ b/src/monodroid/jni/xamarin-android-app-context.cc
@@ -0,0 +1,28 @@
+#include <mono/metadata/class.h>
+
+#include "monodroid-glue-internal.hh"
+#include "mono-image-loader.hh"
+
+using namespace xamarin::android::internal;
+
+void* MonodroidRuntime::get_function_pointer (uint32_t mono_image_index, uint32_t class_token, uint32_t method_token) noexcept
+{
+	MonoImage *image = MonoImageLoader::get_from_index (mono_image_index);
+
+	// TODO: implement MonoClassLoader with caching. Best to use indexes instead of keying on tokens.
+	MonoClass *method_klass = mono_class_get (image, class_token);
+	MonoMethod *method = mono_get_method (image, method_token, method_klass);
+
+	MonoError error;
+	void *ret = mono_method_get_unmanaged_callers_only_ftnptr (method, &error);
+	if (ret == nullptr || error.error_code != MONO_ERROR_NONE) {
+		// TODO: make the error message friendlier somehow (class, method and assembly names)
+		log_fatal (LOG_DEFAULT,
+		           "Failed to obtain function pointer to method with token 0x%x; class token: 0x%x; assembly index: %u",
+		           method_token, class_token, mono_images_cleanup
+		);
+		abort ();
+	}
+
+	return ret;
+}
diff --git a/src/monodroid/jni/xamarin-app-marshaling.cc b/src/monodroid/jni/xamarin-app-marshaling.cc
new file mode 100644
index 00000000000..39e706e089d
--- /dev/null
+++ b/src/monodroid/jni/xamarin-app-marshaling.cc
@@ -0,0 +1,59 @@
+#include <cstdlib>
+#include <android/log.h>
+
+#include <jni.h>
+
+#include <mono/metadata/appdomain.h>
+#include <mono/metadata/class.h>
+#include <mono/metadata/object.h>
+
+#include "xamarin-app.hh"
+
+static get_function_pointer_fn get_function_pointer;
+
+void xamarin_app_init (get_function_pointer_fn fn)
+{
+	get_function_pointer = fn;
+}
+
+using android_app_activity_on_create_bundle_fn = void (*) (JNIEnv *env, jclass klass, jobject savedInstanceState);
+static android_app_activity_on_create_bundle_fn android_app_activity_on_create_bundle = nullptr;
+
+JNIEXPORT void
+JNICALL Java_helloandroid_MainActivity_n_1onCreate__Landroid_os_Bundle_2 (JNIEnv *env, jclass klass, jobject savedInstanceState)
+{
+	//	log_info (LOG_DEFAULT, "%s (%p, %p, %p)", __PRETTY_FUNCTION__, env, klass, savedInstanceState);
+
+	if (android_app_activity_on_create_bundle == nullptr) {
+		void *fn = get_function_pointer (
+			16 /* Mono.Android.dll index */,
+			0x020000AF /* Android.App.Activity token */,
+			0x0600055B /* n_OnCreate_Landroid_os_Bundle_ */
+		);
+
+		android_app_activity_on_create_bundle = reinterpret_cast<android_app_activity_on_create_bundle_fn>(fn);
+	}
+
+	android_app_activity_on_create_bundle (env, klass, savedInstanceState);
+}
+
+using android_app_activity_on_create_view_fn = jobject (*) (JNIEnv *env, jclass klass, jobject view, jstring name, jobject context, jobject attrs);
+static android_app_activity_on_create_view_fn android_app_activity_on_create_view = nullptr;
+
+JNIEXPORT jobject
+JNICALL Java_helloandroid_MainActivity_n_1onCreateView__Landroid_view_View_2Ljava_lang_String_2Landroid_content_Context_2Landroid_util_AttributeSet_2 (JNIEnv *env, jclass klass, jobject view, jstring name, jobject context, jobject attrs)
+{
+	//	log_info (LOG_DEFAULT, "%s (%p, %p, %p, %p, %p, %p)", __PRETTY_FUNCTION__, env, klass, view, name, context, attrs);
+
+	if (android_app_activity_on_create_view == nullptr) {
+		void *fn = get_function_pointer (
+			16 /* Mono.Android.dll index */,
+			0x020000AF /* Android.App.Activity token */,
+			0x06000564 /* n_OnCreateView_Landroid_view_View_Ljava_lang_String_Landroid_content_Context_Landroid_util_AttributeSet_ */
+		);
+
+		android_app_activity_on_create_view = reinterpret_cast<android_app_activity_on_create_view_fn>(fn);
+	}
+
+	return android_app_activity_on_create_view (env, klass, view, name, context, attrs);
+}
diff --git a/src/monodroid/jni/xamarin-app.hh b/src/monodroid/jni/xamarin-app.hh
index a13e64d61ef..1055b3b8fab 100644
--- a/src/monodroid/jni/xamarin-app.hh
+++ b/src/monodroid/jni/xamarin-app.hh
@@ -258,4 +258,41 @@ MONO_API MONO_API_EXPORT AssemblyStoreSingleAssemblyRuntimeData assembly_store_b
 MONO_API MONO_API_EXPORT AssemblyStoreRuntimeData assembly_stores[];
 
 MONO_API MONO_API_EXPORT DSOCacheEntry dso_cache[];
+
+//
+// Support for marshal methods
+//
+#if defined (RELEASE) && defined (ANDROID) && defined (NET)
+struct MarshalMethodsManagedClass
+{
+	const uint32_t   token;
+	MonoClass       *klass;
+};
+
+// Number of assembly name forms for which we generate hashes (essentially file name mutations. For instance
+// `HelloWorld.dll`, `HelloWorld`, `en-US/HelloWorld` etc). This is multiplied by the number of assemblies in the apk to
+// obtain number of entries in the `assembly_image_cache_hashes` and `assembly_image_cache_indices` entries
+constexpr uint32_t number_of_assembly_name_forms_in_image_cache = 2;
+
+// These 3 arrays constitute the cache used to store pointers to loaded managed assemblies.
+// Three arrays are used so that we can have multiple hashes pointing to the same MonoImage*.
+//
+// This is done by the `assembly_image_cache_hashes` containing hases for all mutations of some
+// assembly's name (e.g. with culture prefix, without extension etc) and position of that hash in
+// `assembly_image_cache_hashes` is an index into `assembly_image_cache_indices` which, in turn,
+// stores final index into the `assembly_image_cache` array.
+//
+MONO_API MONO_API_EXPORT MonoImage* assembly_image_cache[];
+MONO_API MONO_API_EXPORT const uint32_t assembly_image_cache_indices[];
+MONO_API MONO_API_EXPORT const xamarin::android::hash_t assembly_image_cache_hashes[];
+
+// Number of unique classes which contain native callbacks we bind
+MONO_API MONO_API_EXPORT uint32_t marshal_methods_number_of_classes;
+MONO_API MONO_API_EXPORT MarshalMethodsManagedClass marshal_methods_class_cache[];
+
+using get_function_pointer_fn = void*(*)(uint32_t mono_image_index, uint32_t class_token, uint32_t method_token);
+
+MONO_API_EXPORT void xamarin_app_init (get_function_pointer_fn fn);
+#endif // def RELEASE && def ANDROID && def NET
+
 #endif // __XAMARIN_ANDROID_TYPEMAP_H