diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/PackageUtils.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/PackageUtils.cs
new file mode 100644
index 00000000000..c9e3e85bb29
--- /dev/null
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/PackageUtils.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Text;
+using Xamarin.Android.Tasks;
+using Xamarin.ProjectTools;
+
+namespace Xamarin.Android.Build.Tests;
+
+class PackageUtils
+{
+	/// <summary>
+	/// Constructs Android package name parameter for the <see cref="XamarinAndroidApplicationProject" /> which includes
+	/// the runtime used to build and run the application. A unique per-runtime package name is necessary so that elements
+	/// of different runtimes don't mix when running the same test for several of them.
+	/// </summary>
+	public static string MakePackageName (AndroidRuntime runtime, [CallerMemberName] string packageName = "")
+	{
+		if (String.IsNullOrEmpty (packageName)) {
+			throw new ArgumentException ("Must not be null or empty", nameof (packageName));
+		}
+
+		var sb = new StringBuilder (packageName);
+		sb.Append ('_');
+		sb.Append (runtime.ToString ().ToLowerInvariant ());
+
+		return sb.ToString ();
+	}
+}
diff --git a/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs b/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs
index b0a1594b404..717abe5925f 100644
--- a/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs
+++ b/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs
@@ -29,17 +29,46 @@ public void Teardown ()
 			proj = null;
 		}
 
+		static IEnumerable<object[]> Get_DotNetRun_Data ()
+		{
+			var ret = new List<object[]> ();
+
+			foreach (AndroidRuntime runtime in Enum.GetValues (typeof (AndroidRuntime))) {
+				AddTestData (true, "llvm-ir", runtime);
+				AddTestData (false, "llvm-ir", runtime);
+				AddTestData (true, "managed", runtime);
+				// NOTE: TypeMappingStep is not yet setup for Debug mode
+				//AddTestData (false, "managed", runtime);
+			}
+
+			return ret;
+
+			void AddTestData (bool isRelease, string typemapImplementation, AndroidRuntime runtime)
+			{
+				ret.Add (new object[] {
+					isRelease,
+					typemapImplementation,
+					runtime,
+				});
+			}
+		}
+
 		[Test]
-		[TestCase (true, "llvm-ir")]
-		[TestCase (false, "llvm-ir")]
-		[TestCase (true, "managed")]
-		// NOTE: TypeMappingStep is not yet setup for Debug mode
-		//[TestCase (false, "managed")]
-		public void DotNetRun (bool isRelease, string typemapImplementation)
+		[TestCaseSource (nameof (Get_DotNetRun_Data))]
+		public void DotNetRun (bool isRelease, string typemapImplementation, AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			if (runtime == AndroidRuntime.NativeAOT && typemapImplementation == "llvm-ir") {
+				Assert.Ignore ("NativeAOT doesn't work with LLVM-IR typemaps");
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease
 			};
+			proj.SetRuntime (runtime);
 			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
 			using var builder = CreateApkBuilder ();
 			builder.Save (proj);
@@ -54,13 +83,16 @@ public void DotNetRun (bool isRelease, string typemapImplementation)
 		}
 
 		[Test]
-		[TestCase (true)]
-		[TestCase (false)]
-		public void DeployToDevice (bool isRelease)
+		public void DeployToDevice ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease
 			};
+			proj.SetRuntime (runtime);
 			using var builder = CreateApkBuilder ();
 			builder.Save (proj);
 
@@ -90,11 +122,16 @@ public void DeployToDevice (bool isRelease)
 		}
 
 		[Test]
-		public void ActivityAliasRuns ([Values (true, false)] bool isRelease)
+		public void ActivityAliasRuns ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease
 			};
+			proj.SetRuntime (runtime);
 			proj.AndroidManifest = proj.AndroidManifest.Replace ("</application>", @"
 <activity-alias
 			android:name="".MainActivityAlias""
@@ -117,8 +154,17 @@ public void ActivityAliasRuns ([Values (true, false)] bool isRelease)
 		}
 
 		[Test]
-		public void NativeAssemblyCacheWithSatelliteAssemblies ([Values (true, false)] bool enableMarshalMethods, [Values (AndroidRuntime.MonoVM, AndroidRuntime.CoreCLR)] AndroidRuntime runtime)
+		public void NativeAssemblyCacheWithSatelliteAssemblies ([Values] bool enableMarshalMethods, [Values] AndroidRuntime runtime)
 		{
+			const bool isRelease = true;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			if (runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("NativeAOT doesn't support individual assemblies");
+			}
+
 			if (enableMarshalMethods && runtime == AndroidRuntime.CoreCLR) {
 				// This currently fails with the following exception:
 				//
@@ -135,6 +181,7 @@ public void NativeAssemblyCacheWithSatelliteAssemblies ([Values (true, false)] b
 
 			var path = Path.Combine ("temp", TestName);
 			var lib = new XamarinAndroidLibraryProject {
+				IsRelease = isRelease,
 				ProjectName = "Localization",
 				OtherBuildItems = {
 					new BuildItem ("EmbeddedResource", "Foo.resx") {
@@ -153,8 +200,8 @@ public void NativeAssemblyCacheWithSatelliteAssemblies ([Values (true, false)] b
 				);
 			}
 
-			proj = new XamarinAndroidApplicationProject {
-				IsRelease = true,
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
+				IsRelease = isRelease,
 				EnableMarshalMethods = enableMarshalMethods,
 			};
 			proj.SetRuntime (runtime);
@@ -179,13 +226,15 @@ public void NativeAssemblyCacheWithSatelliteAssemblies ([Values (true, false)] b
 		}
 
 		[Test]
-		public void GlobalLayoutEvent_ShouldRegisterAndFire_OnActivityLaunch (
-		  [Values (false, true)] bool isRelease,
-		  [Values (AndroidRuntime.MonoVM, AndroidRuntime.CoreCLR)] AndroidRuntime runtime)
+		public void GlobalLayoutEvent_ShouldRegisterAndFire_OnActivityLaunch ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
 			string expectedLogcatOutput = "Bug 29730: GlobalLayout event handler called!";
 
-			proj = new XamarinAndroidApplicationProject () {
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 				SupportedOSPlatformVersion = "23",
 			};
@@ -213,17 +262,22 @@ void Button_ViewTreeObserver_GlobalLayout (object sender, EventArgs e)
 			}, Path.Combine (Root, builder.ProjectDirectory, "startup-logcat.log"), 60), $"Output did not contain {expectedLogcatOutput}!");
 		}
 
-		// TODO: check if AppDomain.CurrentDomain.UnhandledException even works in CoreCLR
+		// TODO: check if AppDomain.CurrentDomain.UnhandledException even works in CoreCLR and NativeAOT
 		[Test]
-		public void SubscribeToAppDomainUnhandledException ([Values (AndroidRuntime.MonoVM, AndroidRuntime.CoreCLR)] AndroidRuntime runtime)
+		public void SubscribeToAppDomainUnhandledException ([Values] AndroidRuntime runtime)
 		{
-			if (runtime == AndroidRuntime.CoreCLR) {
-				Assert.Ignore ("AppDomain.CurrentDomain.UnhandledException doesn't work in CoreCLR");
+			const bool isRelease = true;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
 				return;
 			}
 
-			proj = new XamarinAndroidApplicationProject () {
-				IsRelease = true,
+			if (runtime == AndroidRuntime.CoreCLR || runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("AppDomain.CurrentDomain.UnhandledException doesn't work in CoreCLR or NativeAOT");
+				return;
+			}
+
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
+				IsRelease = isRelease,
 			};
 			proj.SetRuntime (runtime);
 			if (runtime == AndroidRuntime.MonoVM) {
@@ -280,18 +334,56 @@ void Reset ()
 			}
 		}
 
+		static IEnumerable<object[]> Get_SmokeTestBuildAndRunWithSpecialCharacters_Data ()
+		{
+			var ret = new List<object[]> ();
+
+			foreach (AndroidRuntime runtime in Enum.GetValues (typeof (AndroidRuntime))) {
+				AddTestData ("テスト", runtime);
+				AddTestData ("随机生成器", runtime);
+				AddTestData ("中国", runtime);
+			}
+
+			return ret;
+
+			void AddTestData (string testName, AndroidRuntime runtime)
+			{
+				ret.Add (new object[] {
+					testName,
+					runtime,
+				});
+			}
+		}
+
 		[Test]
 		[Category ("UsesDevice")]
-		[TestCase ("テスト")]
-		[TestCase ("随机生成器")]
-		[TestCase ("中国")]
-		public void SmokeTestBuildAndRunWithSpecialCharacters (string testName)
+		[TestCaseSource (nameof (Get_SmokeTestBuildAndRunWithSpecialCharacters_Data))]
+		public void SmokeTestBuildAndRunWithSpecialCharacters (string testName, AndroidRuntime runtime)
 		{
+			const bool isRelease = true;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			// TODO: fix NativeAOT builds. Despite the .so library being preset in the apk (and named correctly)
+			//       all the tests fail with one of:
+			//
+			//  java.lang.UnsatisfiedLinkError: dlopen failed: library "libテスト.so" not found
+			//  java.lang.UnsatisfiedLinkError: dlopen failed: library "lib中国.so" not found
+			//  java.lang.UnsatisfiedLinkError: dlopen failed: library "lib随机生成器.so" not found
+			//
+			// It might be an issue with the Android shared libary loader or name encoding in the archive. It might
+			// be a good idea to limit .so names to ASCII.
+			if (runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("NativeAOT doesn't work well with diacritics in the application library name");
+			}
+
 			var rootPath = Path.Combine (Root, "temp", TestName);
-			var proj = new XamarinFormsAndroidApplicationProject () {
+			var proj = new XamarinFormsAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				ProjectName = testName,
-				IsRelease = true,
+				IsRelease = isRelease,
 			};
+			proj.SetRuntime (runtime);
 			proj.SetAndroidSupportedAbis (DeviceAbi);
 			proj.SetDefaultTargetDevice ();
 			using (var builder = CreateApkBuilder (Path.Combine (rootPath, proj.ProjectName))){
@@ -326,10 +418,28 @@ public void SmokeTestBuildAndRunWithSpecialCharacters (string testName)
 		[Test]
 		public void CustomLinkDescriptionPreserve (
 		  [Values (AndroidLinkMode.SdkOnly, AndroidLinkMode.Full)] AndroidLinkMode linkMode,
-		  [Values (AndroidRuntime.MonoVM)] AndroidRuntime runtime
+		  [Values] AndroidRuntime runtime
 		)
 		{
+			const bool isRelease = true;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			if (runtime == AndroidRuntime.CoreCLR) {
+				Assert.Ignore ("Currently broken on CoreCLR");
+			}
+
+			// TODO: NativeAOT perhaps should work here (ignoring all the MonoAOT settings?), but for now it fails with
+			//
+			//  Microsoft.NET.Sdk.FrameworkReferenceResolution.targets(120,5): error NETSDK1207: Ahead-of-time compilation is not supported for the target framework.
+			//
+			if (runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("NativeAOT is currently broken here");
+			}
+
 			var lib1 = new XamarinAndroidLibraryProject () {
+				IsRelease = isRelease,
 				ProjectName = "Library1",
 				Sources = {
 					new BuildItem.Source ("SomeClass.cs") {
@@ -367,6 +477,7 @@ public class LinkModeFullClass {
 			lib1.SetRuntime (runtime);
 
 			var lib2 = new DotNetStandard {
+				IsRelease = isRelease,
 				ProjectName = "LinkTestLib",
 				Sdk = "Microsoft.NET.Sdk",
 				TargetFramework = "netstandard2.0",
@@ -393,8 +504,8 @@ public class LinkModeFullClass {
 			};
 			lib2.SetRuntime (runtime);
 
-			proj = new XamarinFormsAndroidApplicationProject () {
-				IsRelease = true,
+			proj = new XamarinFormsAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
+				IsRelease = isRelease,
 				AndroidLinkModeRelease = linkMode,
 				References = {
 					new BuildItem ("ProjectReference", "..\\Library1\\Library1.csproj"),
@@ -473,11 +584,15 @@ string getResource (string name)
 		}
 
 		[Test]
-		public void JsonDeserializationCreatesJavaHandle ([Values (false, true)] bool isRelease)
+		public void JsonDeserializationCreatesJavaHandle ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
-			proj = new XamarinAndroidApplicationProject () {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 			};
+			proj.SetRuntime (runtime);
 			// error SYSLIB0011: 'BinaryFormatter.Serialize(Stream, object)' is obsolete: 'BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.'
 			proj.SetProperty ("NoWarn", "SYSLIB0011");
 
@@ -503,7 +618,7 @@ void TestJsonDeserialization (Person p)
 			StreamReader sr = new StreamReader (stream);
 
 			Console.WriteLine ($""JSON Person representation: {sr.ReadToEnd ()}"");
-
+/
 			stream.Position = 0;
 			Person p2 = (Person) serializer.ReadObject (stream);
 
@@ -565,14 +680,22 @@ public override Type BindToType (string assemblyName, string typeName)
 		}
 
 		[Test]
-		public void RunWithInterpreterEnabled ([Values (false, true)] bool isRelease)
+		public void RunWithInterpreterEnabled ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
-			proj = new XamarinAndroidApplicationProject () {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			// MonoVM-only test, for now (until CoreCLR has interpreter we can use)
+			if (runtime != AndroidRuntime.MonoVM) {
+				Assert.Ignore ("MonoVM-only test for the moment");
+			}
+
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 				AotAssemblies = false, // Release defaults to Profiled AOT for .NET 6
 			};
-			// MonoVM-only test
-			proj.SetRuntime (Android.Tasks.AndroidRuntime.MonoVM);
+			proj.SetRuntime (runtime);
 			var abis = new string[] { "armeabi-v7a", "arm64-v8a", "x86", "x86_64" };
 			proj.SetAndroidSupportedAbis (abis);
 			proj.SetProperty (proj.CommonProperties, "UseInterpreter", "True");
@@ -644,11 +767,19 @@ bool SeenFailedToLoad (string line)
 		}
 
 		[Test]
-		public void SingleProject_ApplicationId ([Values (false, true)] bool testOnly)
+		public void SingleProject_ApplicationId ([Values] bool testOnly, [Values] AndroidRuntime runtime)
 		{
+			bool isRelease = runtime == AndroidRuntime.NativeAOT;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
 			AssertCommercialBuild ();
 
-			proj = new XamarinAndroidApplicationProject ();
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
+				IsRelease = isRelease,
+			};
+			proj.SetRuntime (runtime);
 			proj.SetProperty ("ApplicationId", "com.i.should.get.overridden.by.the.manifest");
 			if (testOnly)
 				proj.AndroidManifest = proj.AndroidManifest.Replace ("<application", "<application android:testOnly=\"true\"");
@@ -664,22 +795,50 @@ public void SingleProject_ApplicationId ([Values (false, true)] bool testOnly)
 		}
 
 		[Test]
-		public void AppWithStyleableUsageRuns ([Values (true, false)] bool useCLR, [Values (true, false)] bool isRelease,
-			[Values (true, false)] bool linkResources, [Values (true, false)] bool useStringTypeMaps)
+		public void AppWithStyleableUsageRuns ([Values] bool isRelease,	[Values] bool linkResources, [Values] bool useStringTypeMaps, [Values] AndroidRuntime runtime)
 		{
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
 			// Not all combinations are valid, ignore those that aren't
-			if (!useCLR && useStringTypeMaps) {
-				Assert.Ignore ("String-based typemaps mode is used only in CoreCLR apps");
+			if (runtime == AndroidRuntime.MonoVM && useStringTypeMaps) {
+				Assert.Ignore ("String-based typemaps mode is used only in CoreCLR and NativeAOT apps");
 			}
 
-			if (useCLR && isRelease && useStringTypeMaps) {
+			if (runtime != AndroidRuntime.MonoVM && isRelease && useStringTypeMaps) {
 				Assert.Ignore ("String-based typemaps mode is available only in Debug CoreCLR builds");
 			}
 
+			// TODO: fix this for NativeAOT
+			if (runtime == AndroidRuntime.NativeAOT && isRelease && !useStringTypeMaps) {
+				// This configuration currently fails with a long stack trace, the gist of it is:
+				//
+				//  AndroidRuntime: java.lang.RuntimeException: Unable to start activity ComponentInfo{com.xamarin.appwithstyleableusageruns_nativeaot/com.xamarin.appwithstyleableusageruns_nativeaot.MainActivity}
+				//  AndroidRuntime: Caused by: android.view.InflateException: Binary XML file line #1 in com.xamarin.appwithstyleableusageruns_nativeaot:layout/main: Binary XML file line #1 in com.xamarin.appwithstyleableusageruns_nativeaot:layout/main: Error inflating class crc64f75eeacfa0ca1368.MyLayout
+				//  AndroidRuntime: Caused by: android.view.InflateException: Binary XML file line #1 in com.xamarin.appwithstyleableusageruns_nativeaot:layout/main: Error inflating class crc64f75eeacfa0ca1368.MyLayout
+				//  AndroidRuntime: Caused by: java.lang.reflect.InvocationTargetException
+				//  AndroidRuntime: Caused by: net.dot.jni.internal.JavaProxyThrowable: System.NotSupportedException: Could not activate { PeerReference=0x7fe9706698/I IdentityHashCode=0xd12aeee Java.Type=crc64f75eeacfa0ca1368/MyLayout } for managed type 'UnnamedProject.MyLayout'.
+				//  AndroidRuntime:  ---> System.Reflection.TargetInvocationException: Arg_TargetInvocationException
+				//  AndroidRuntime:  ---> System.IO.FileNotFoundException: IO_FileNotFound_FileName, _Microsoft.Android.Resource.Designer
+				//  AndroidRuntime: IO_FileName_Name, _Microsoft.Android.Resource.Designer
+				//  DOTNET  : FATAL UNHANDLED EXCEPTION: Java.Lang.Exception: Unable to start activity ComponentInfo{com.xamarin.appwithstyleableusageruns_nativeaot/com.xamarin.appwithstyleableusageruns_nativeaot.MainActivity}
+				//  DOTNET  :  ---> Java.Lang.Exception: Binary XML file line #1 in com.xamarin.appwithstyleableusageruns_nativeaot:layout/main: Binary XML file line #1 in com.xamarin.appwithstyleableusageruns_nativeaot:layout/main: Error inflating class crc64f75eeacfa0ca1368.MyLayout
+				//  DOTNET  :  ---> Java.Lang.Exception: Binary XML file line #1 in com.xamarin.appwithstyleableusageruns_nativeaot:layout/main: Error inflating class crc64f75eeacfa0ca1368.MyLayout
+				//  DOTNET  :  ---> Java.Lang.ReflectiveOperationException: Exception_WasThrown, Java.Lang.ReflectiveOperationException
+				//  DOTNET  :  ---> System.NotSupportedException: Could not activate { PeerReference=0x7fe9706698/I IdentityHashCode=0xd12aeee Java.Type=crc64f75eeacfa0ca1368/MyLayout } for managed type 'UnnamedProject.MyLayout'.
+				//  DOTNET  :  ---> System.Reflection.TargetInvocationException: Arg_TargetInvocationException
+				//  DOTNET  :  ---> System.IO
+				//  eruns_nativeaot: No implementation found for void mono.android.Runtime.propagateUncaughtException(java.lang.Thread, java.lang.Throwable) (tried Java_mono_android_Runtime_propagateUncaughtException and Java_mono_android_Runtime_propagateUncaughtException__Ljava_lang_Thread_2Ljava_lang_Throwable_2) - is the library loaded, e.g. System.loadLibrary?
+				Assert.Ignore ("NativeAOT is broken without string-based typemaps");
+			}
+
 			var rootPath = Path.Combine (Root, "temp", TestName);
 			var lib = new XamarinAndroidLibraryProject () {
+				IsRelease = isRelease,
 				ProjectName = "Styleable.Library"
 			};
+			lib.SetRuntime (runtime);
 
 			lib.AndroidResources.Add (new AndroidItem.AndroidResource ("Resources\\values\\styleables.xml") {
 				TextContent = () => @"<?xml version='1.0' encoding='utf-8'?>
@@ -721,10 +880,10 @@ public MyLibraryLayout (Android.Content.Context context, Android.Util.IAttribute
 }"
 			});
 
-			proj = new XamarinAndroidApplicationProject () {
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 			};
-			proj.SetProperty ("UseMonoRuntime", useCLR ? "false" : "true");
+			proj.SetRuntime (runtime);
 			proj.AddReference (lib);
 
 			proj.AndroidResources.Add (new AndroidItem.AndroidResource ("Resources\\values\\styleables.xml") {
@@ -762,9 +921,11 @@ public MyLayout (Android.Content.Context context, Android.Util.IAttributeSet att
 }
 ");
 
-			string[] abis = useCLR switch {
-				true => new string [] { "arm64-v8a", "x86_64" },
-				false => new string [] { "armeabi-v7a", "arm64-v8a", "x86", "x86_64" },
+			string[] abis = runtime switch {
+				AndroidRuntime.CoreCLR => new string [] { "arm64-v8a", "x86_64" },
+				AndroidRuntime.NativeAOT => new string [] { "arm64-v8a", "x86_64" },
+				AndroidRuntime.MonoVM => new string [] { "armeabi-v7a", "arm64-v8a", "x86", "x86_64" },
+				_ => throw new NotSupportedException ($"Unsupported runtime {runtime}")
 			};
 
 			proj.SetAndroidSupportedAbis (abis);
@@ -775,7 +936,7 @@ public MyLayout (Android.Content.Context context, Android.Util.IAttributeSet att
 			Assert.IsTrue (builder.Install (proj), "Install should have succeeded.");
 
 			Dictionary<string, string>? environmentVariables = null;
-			if (useCLR && !isRelease && useStringTypeMaps) {
+			if (runtime == AndroidRuntime.CoreCLR && !isRelease && useStringTypeMaps) {
 				// The variable must have content to enable string-based typemaps
 				environmentVariables = new (StringComparer.Ordinal) {
 					{"CI_TYPEMAP_DEBUG_USE_STRINGS", "yes"}
@@ -790,16 +951,33 @@ public MyLayout (Android.Content.Context context, Android.Util.IAttributeSet att
 		}
 
 		[Test]
-		public void CheckXamarinFormsAppDeploysAndAButtonWorks ()
+		public void CheckXamarinFormsAppDeploysAndAButtonWorks ([Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinFormsAndroidApplicationProject ();
+			bool isRelease = runtime == AndroidRuntime.NativeAOT;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			// TODO: fix for NativeAOT. Currently fails with:
+			//
+			//  DOTNET  : FATAL UNHANDLED EXCEPTION: System.InvalidCastException: Unable to convert instance of type 'AndroidX.AppCompat.Widget.AppCompatImageButton' to type 'AndroidX.AppCompat.Widget.Toolbar'.
+			if (runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("NativeAOT type mapping fails");
+			}
+
+			string packageName = PackageUtils.MakePackageName (runtime);
+			var proj = new XamarinFormsAndroidApplicationProject (packageName: packageName) {
+				IsRelease = isRelease,
+			};
+			proj.SetRuntime (runtime);
 			proj.SetAndroidSupportedAbis (DeviceAbi);
-			var builder = CreateApkBuilder ();
+			var builder = CreateApkBuilder (packageName: packageName);
 
 			Assert.IsTrue (builder.Build (proj), "Build should have succeeded.");
 			builder.BuildLogFile = "install.log";
 			Assert.IsTrue (builder.Install (proj), "Install should have succeeded.");
 
+			ClearAdbLogcat ();
 			AdbStartActivity ($"{proj.PackageName}/{proj.JavaPackageName}.MainActivity");
 			WaitForActivityToStart (proj.PackageName, "MainActivity",
 				Path.Combine (Root, builder.ProjectDirectory, "startup-logcat.log"), 15);
@@ -812,11 +990,14 @@ public void CheckXamarinFormsAppDeploysAndAButtonWorks ()
 		}
 
 		[Test]
-		public void SkiaSharpCanvasBasedAppRuns ([Values (true, false)] bool isRelease, [Values (true, false)] bool addResource)
+		public void SkiaSharpCanvasBasedAppRuns ([Values] bool isRelease, [Values] bool addResource, [Values] AndroidRuntime runtime)
 		{
-			var app = new XamarinAndroidApplicationProject () {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			var app = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime, "SkiaSharpCanvasTest")) {
 				IsRelease = isRelease,
-				PackageName = "Xamarin.SkiaSharpCanvasTest",
 				PackageReferences = {
 					KnownPackages.SkiaSharp,
 					KnownPackages.SkiaSharp_Views,
@@ -824,6 +1005,7 @@ public void SkiaSharpCanvasBasedAppRuns ([Values (true, false)] bool isRelease,
 					KnownPackages.AndroidXAppCompatResources,
 				},
 			};
+			app.SetRuntime (runtime);
 			app.AndroidResources.Add (new AndroidItem.AndroidResource ("Resources\\values\\styles.xml") {
 				TextContent = () => @"<resources><style name='AppTheme' parent='Theme.AppCompat.Light.DarkActionBar'/></resources>",
 			});
@@ -909,7 +1091,8 @@ private void OnPaintSurface(object sender, SKPaintSurfaceEventArgs e)
 			using (var b = CreateApkBuilder (Path.Combine ("temp", TestName, app.ProjectName))) {
 				b.BuildLogFile = "build1.log";
 				b.ThrowOnBuildFailure = false;
-				if (!addResource) {
+				// TODO: fix for NativeAOT
+				if (!addResource && runtime != AndroidRuntime.NativeAOT) {
 					Assert.IsFalse (b.Build (app, doNotCleanupOnUpdate: true), $"Build of {app.ProjectName} should have failed.");
 					Assert.IsTrue (b.LastBuildOutput.ContainsText (isRelease ? "IL8000" : "XA8000"));
 					Assert.IsTrue (b.LastBuildOutput.ContainsText ("@styleable/SKCanvasView"), "Expected '@styleable/SKCanvasView' in build output.");
@@ -929,9 +1112,15 @@ private void OnPaintSurface(object sender, SKPaintSurfaceEventArgs e)
 
 
 		[Test]
-		public void CheckResouceIsOverridden ()
+		public void CheckResouceIsOverridden ([Values] AndroidRuntime runtime)
 		{
+			bool isRelease = runtime == AndroidRuntime.NativeAOT;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
 			var library = new XamarinAndroidLibraryProject () {
+				IsRelease = isRelease,
 				ProjectName = "Library1",
 				AndroidResources = {
 					new AndroidItem.AndroidResource (() => "Resources\\values\\strings2.xml") {
@@ -942,7 +1131,9 @@ public void CheckResouceIsOverridden ()
 					},
 				},
 			};
+			library.SetRuntime (runtime);
 			var library2 = new XamarinAndroidLibraryProject () {
+				IsRelease = isRelease,
 				ProjectName = "Library2",
 				AndroidResources = {
 					new AndroidItem.AndroidResource (() => "Resources\\values\\strings2.xml") {
@@ -953,13 +1144,15 @@ public void CheckResouceIsOverridden ()
 					},
 				},
 			};
-			var app = new XamarinAndroidApplicationProject () {
-				PackageName = "Xamarin.ResourceTest",
+			library2.SetRuntime (runtime);
+			var app = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime, "ResourceTest")) {
+				IsRelease = isRelease,
 				References = {
 					new BuildItem.ProjectReference ("..\\Library1\\Library1.csproj"),
 					new BuildItem.ProjectReference ("..\\Library2\\Library2.csproj"),
 				},
 			};
+			app.SetRuntime (runtime);
 			app.LayoutMain = app.LayoutMain.Replace ("@string/hello", "@string/hello_me");
 			using (var l1 = CreateDllBuilder (Path.Combine ("temp", TestName, library.ProjectName)))
 			using (var l2 = CreateDllBuilder (Path.Combine ("temp", TestName, library2.ProjectName)))
@@ -1026,16 +1219,25 @@ public void CheckResouceIsOverridden ()
 		[Test]
 		[Category ("WearOS")]
 		public void DotNetInstallAndRunPreviousSdk (
-				[Values (false, true)] bool isRelease,
-				[Values ("net9.0-android")] string targetFramework)
+				[Values] bool isRelease,
+				[Values ("net9.0-android")] string targetFramework,
+				[Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinFormsAndroidApplicationProject () {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			// Mono-only test for the moment (until net10 or later is the "previous" framework)
+			if (runtime != AndroidRuntime.MonoVM) {
+				Assert.Ignore ("Mono-only test util net9 is no longer the 'previous' SDK");
+			}
+
+			var proj = new XamarinFormsAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				TargetFramework = targetFramework,
 				IsRelease = isRelease,
 				EnableDefaultItems = true,
 			};
-			// Mono-only test
-			proj.SetRuntime (AndroidRuntime.MonoVM);
+			proj.SetRuntime (runtime);
 
 			// Requires 32-bit ABIs
 			proj.SetAndroidSupportedAbis (["armeabi-v7a", "arm64-v8a", "x86", "x86_64"]);
@@ -1052,16 +1254,22 @@ public void DotNetInstallAndRunPreviousSdk (
 
 		[Test]
 		public void DotNetInstallAndRunMinorAPILevels (
-				[Values (false, true)] bool isRelease,
-				[Values ("net10.0-android36.1")] string targetFramework)
+				[Values] bool isRelease,
+				[Values ("net10.0-android36.1")] string targetFramework,
+				[Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject () {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				TargetFramework = targetFramework,
 				IsRelease = isRelease,
 				ExtraNuGetConfigSources = {
 					Path.Combine (XABuildPaths.BuildOutputDirectory, "nuget-unsigned"),
 				}
 			};
+			proj.SetRuntime (runtime);
 
 			// TODO: update on new minor API levels to use an introduced minor API
 			proj.MainActivity = proj.DefaultMainActivity
@@ -1096,9 +1304,18 @@ public MyTextObjectFont (PdfPageTextObjectFont font) : base (font)
 		}
 
 		[Test]
-		public void TypeAndMemberRemapping ([Values (false, true)] bool isRelease)
+		public void TypeAndMemberRemapping ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject () {
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			// TODO: fix for NativeAOT, if possible
+			if (runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("Type and member mapping is currently unsupported under NativeAOT");
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 				EnableDefaultItems = true,
 				OtherBuildItems = {
@@ -1115,6 +1332,7 @@ public void TypeAndMemberRemapping ([Values (false, true)] bool isRelease)
 					},
 				},
 			};
+			proj.SetRuntime (runtime);
 			proj.MainActivity = proj.DefaultMainActivity.Replace (": Activity", ": global::Example.RemapActivity");
 			var builder = CreateApkBuilder ();
 			Assert.IsTrue (builder.Build (proj), "`dotnet build` should succeed");
@@ -1137,9 +1355,22 @@ public void TypeAndMemberRemapping ([Values (false, true)] bool isRelease)
 		}
 
 		[Test]
-		public void SupportDesugaringStaticInterfaceMethods ()
+		public void SupportDesugaringStaticInterfaceMethods ([Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject () {
+			const bool isRelease = true;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			// TODO: fix for NativeAOT, if possible. Currently fails with:
+			//
+			//  Process: com.xamarin.supportdesugaringstaticinterfacemethods_nativeaot, PID: 13888
+			//  java.lang.NoSuchMethodError: no static method "Lexample/StaticMethodsInterface;.getValue()I"
+			if (runtime == AndroidRuntime.NativeAOT) {
+				Assert.Ignore ("Currently broken on NativeAOT");
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = true,
 				EnableDefaultItems = true,
 				OtherBuildItems = {
@@ -1152,6 +1383,7 @@ public void SupportDesugaringStaticInterfaceMethods ()
 					},
 				},
 			};
+			proj.SetRuntime (runtime);
 
 			// Note: To properly test, Desugaring must be *enabled*, which requires that
 			// `$(SupportedOSPlatformVersion)` be *less than* 23.  21 is currently the default,
@@ -1177,16 +1409,21 @@ public void SupportDesugaringStaticInterfaceMethods ()
 		}
 
 		[Test]
-		[TestCase (false, true)]
-		[TestCase (false, false)]
-		[TestCase (true, false)]
-		public void FastDeployEnvironmentFiles (bool isRelease, bool embedAssembliesIntoApk)
+		public void FastDeployEnvironmentFiles ([Values] bool isRelease, [Values] bool embedAssembliesIntoApk, [Values] AndroidRuntime runtime)
 		{
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			if (!isRelease && !embedAssembliesIntoApk) {
+				Assert.Ignore ("Not a FastDev configuration");
+			}
+
 			if (embedAssembliesIntoApk) {
 				AssertCommercialBuild ();
 			}
 
-			var proj = new XamarinAndroidApplicationProject {
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				ProjectName = nameof (FastDeployEnvironmentFiles),
 				RootNamespace = nameof (FastDeployEnvironmentFiles),
 				IsRelease = isRelease,
@@ -1201,6 +1438,7 @@ public void FastDeployEnvironmentFiles (bool isRelease, bool embedAssembliesInto
 					}
 				}
 			};
+			proj.SetRuntime (runtime);
 			proj.SetProperty ("DiagnosticAddress", "127.0.0.1");
 			proj.SetProperty ("DiagnosticPort", "9000");
 			proj.SetProperty ("DiagnosticSuspend", "false");
@@ -1261,10 +1499,14 @@ public void FastDeployEnvironmentFiles (bool isRelease, bool embedAssembliesInto
 		}
 
 		[Test]
-		public void FixLegacyResourceDesignerStep ([Values (true, false)] bool isRelease)
+		public void FixLegacyResourceDesignerStep ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
 			string previousTargetFramework = "net9.0-android";
 
+			// Don't call SetRuntime on library projects (at least until "previous" framework bumps to at least 10.0)
 			var library1 = new XamarinAndroidLibraryProject {
 				IsRelease = isRelease,
 				TargetFramework = previousTargetFramework,
@@ -1291,10 +1533,11 @@ public void FixLegacyResourceDesignerStep ([Values (true, false)] bool isRelease
 			library2.AndroidResources.Clear ();
 			library2.SetProperty ("AndroidGenerateResourceDesigner", "false"); // Disable Android Resource Designer generation
 			library2.AddReference (library1);
-			proj = new XamarinAndroidApplicationProject {
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 				ProjectName = "MyApp",
 			};
+			proj.SetRuntime (runtime);
 			proj.AddReference (library2);
 			proj.MainActivity = proj.DefaultMainActivity.Replace ("//${AFTER_ONCREATE}", "Console.WriteLine(Foo.Hello);");
 
@@ -1315,17 +1558,21 @@ public void FixLegacyResourceDesignerStep ([Values (true, false)] bool isRelease
 		}
 
 		[Test]
-		public void MicrosoftIntune ([Values (false, true)] bool isRelease)
+		public void MicrosoftIntune ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
 			Assert.Ignore ("https://github.com/xamarin/xamarin-android/issues/8548");
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
 
-			proj = new XamarinAndroidApplicationProject {
+			proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 				PackageReferences = {
 					KnownPackages.AndroidXAppCompat,
 					KnownPackages.Microsoft_Intune_Maui_Essentials_android,
 				},
 			};
+			proj.SetRuntime (runtime);
 			proj.MainActivity = proj.DefaultMainActivity
 				.Replace ("Icon = \"@drawable/icon\")]", "Icon = \"@drawable/icon\", Theme = \"@style/Theme.AppCompat.Light.DarkActionBar\")]")
 				.Replace ("public class MainActivity : Activity", "public class MainActivity : AndroidX.AppCompat.App.AppCompatActivity");
@@ -1351,8 +1598,12 @@ public void MicrosoftIntune ([Values (false, true)] bool isRelease)
 		}
 
 		[Test]
-		public void GradleFBProj ([Values (false, true)] bool isRelease)
+		public void GradleFBProj ([Values] bool isRelease, [Values] AndroidRuntime runtime)
 		{
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
 			var moduleName = "Library";
 			var gradleTestProjectDir = Path.Combine (Root, "temp", "gradle", TestName);
 			var gradleModule = new AndroidGradleModule (Path.Combine (gradleTestProjectDir, moduleName));
@@ -1400,7 +1651,7 @@ public static void logEvent(String eventName) {{
 			};
 			gradleProject.Create ();
 
-			var proj = new XamarinAndroidApplicationProject {
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
 				IsRelease = isRelease,
 				ExtraNuGetConfigSources = {
 					"https://api.nuget.org/v3/index.json",
@@ -1454,6 +1705,7 @@ public static void logEvent(String eventName) {{
 					},
 				},
 			};
+			proj.SetRuntime (runtime);
 			proj.MainActivity = proj.DefaultMainActivity.Replace ("//${AFTER_ONCREATE}", @"
 Facebook.FacebookSdk.InitializeSDK(this, Java.Lang.Boolean.True);
 Facebook.FacebookSdk.LogEvent(""TestFacebook"");
@@ -1498,9 +1750,17 @@ public void NativeAOTSample ()
 		}
 
 		[Test]
-		public void AppStartsWithManagedMarshalMethodsLookupEnabled ()
+		public void AppStartsWithManagedMarshalMethodsLookupEnabled ([Values] AndroidRuntime runtime)
 		{
-			var proj = new XamarinAndroidApplicationProject { IsRelease = true };
+			const bool isRelease = true;
+			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
+				IsRelease = isRelease,
+			};
+			proj.SetRuntime (runtime);
 			proj.SetProperty ("AndroidUseMarshalMethods", "true");
 			proj.SetProperty ("_AndroidUseManagedMarshalMethodsLookup", "true");