diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 4e7ba51a6f22ec4ae58438456a7ff074e9246344..dbf673ae37b24a62e28ca0e4b31ff5573a356b13 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -161,6 +161,27 @@ jobs:
         run: sh ci/powerpc64le-linux-release.sh
         timeout-minutes: 240
 
+  riscv64-linux-debug:
+    runs-on: [self-hosted, riscv64-linux]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/riscv64-linux-debug.sh
+        timeout-minutes: 420
+  riscv64-linux-release:
+    runs-on: [self-hosted, riscv64-linux]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/riscv64-linux-release.sh
+        timeout-minutes: 360
+
   s390x-linux-debug:
     runs-on: [self-hosted, s390x-linux]
     steps:
diff --git a/ci/aarch64-openbsd-debug.sh b/ci/aarch64-openbsd-debug.sh
index 70efda05a9e70693b773250da8fa1e78d199281c..434873d59658dc208937350932ab9beb08ed6ad8 100755
--- a/ci/aarch64-openbsd-debug.sh
+++ b/ci/aarch64-openbsd-debug.sh
@@ -50,6 +50,8 @@ stage3-debug/bin/zig build install test docs \
   -Duse-zig-libcxx \
   -Denable-llvm \
   -Dno-lib \
-  -Dskip-non-native
+  -Dskip-non-native \
+  -Dskip-compile-errors \
+  -Dskip-single-threaded
 
 stage4-debug/bin/zig test ../test/behavior.zig
diff --git a/ci/aarch64-openbsd-release.sh b/ci/aarch64-openbsd-release.sh
index e194f6ecb1b9a244a3171c1297b94b7e9b26f70d..c9693daf0a9a949b35c8329e7d979d2b9ea3ed21 100755
--- a/ci/aarch64-openbsd-release.sh
+++ b/ci/aarch64-openbsd-release.sh
@@ -52,7 +52,9 @@ stage3-release/bin/zig build install test docs \
   -Duse-zig-libcxx \
   -Denable-llvm \
   -Dno-lib \
-  -Dskip-non-native
+  -Dskip-non-native \
+  -Dskip-compile-errors \
+  -Dskip-single-threaded
 
 # Ensure that the fuzzer at least compiles.
 # https://codeberg.org/ziglang/zig/issues/30728
diff --git a/ci/riscv64-linux-debug.sh b/ci/riscv64-linux-debug.sh
index da378243787f312266399bc414b0e12fefae8b71..5179e37620404240e068af6613352477277c5c34 100755
--- a/ci/riscv64-linux-debug.sh
+++ b/ci/riscv64-linux-debug.sh
@@ -50,6 +50,8 @@ stage3-debug/bin/zig build install test docs \
   -Duse-zig-libcxx \
   -Denable-llvm \
   -Dno-lib \
-  -Dskip-non-native
+  -Dskip-non-native \
+  -Dskip-compile-errors \
+  -Dskip-single-threaded
 
 stage4-debug/bin/zig test ../test/behavior.zig
diff --git a/ci/riscv64-linux-release.sh b/ci/riscv64-linux-release.sh
index 89d42ec283a84065bd51a2f99e63efd601b4423a..f43b090fb0a0c691afbc0b6c78826c9f10c6c82e 100755
--- a/ci/riscv64-linux-release.sh
+++ b/ci/riscv64-linux-release.sh
@@ -52,7 +52,9 @@ stage3-release/bin/zig build install test docs \
   -Duse-zig-libcxx \
   -Denable-llvm \
   -Dno-lib \
-  -Dskip-non-native
+  -Dskip-non-native \
+  -Dskip-compile-errors \
+  -Dskip-single-threaded
 
 # Ensure that the fuzzer at least compiles.
 stage3-release/bin/zig build test-std --fuzz=1K -Dno-lib -Dfuzz-only -Doptimize=ReleaseSafe
diff --git a/lib/std/crypto/hybrid_kem.zig b/lib/std/crypto/hybrid_kem.zig
index a811523f072266d69a789dbdb232f066929611b6..860bb8c44c0f56469d678e9bde0d5cbaff727f16 100644
--- a/lib/std/crypto/hybrid_kem.zig
+++ b/lib/std/crypto/hybrid_kem.zig
@@ -13,6 +13,7 @@
 //! The combiner uses the C2PRI construction to derive the final shared secret
 //! from the component shared secrets, ciphertext, and public key.
 
+const builtin = @import("builtin");
 const std = @import("std");
 const crypto = std.crypto;
 const fmt = std.fmt;
@@ -370,6 +371,8 @@ test "MLKEM768-X25519 basic round trip" {
 }
 
 test "MLKEM768-X25519 test vector 0" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -394,6 +397,8 @@ test "MLKEM768-X25519 test vector 0" {
 }
 
 test "MLKEM768-X25519 test vector 1" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -418,6 +423,8 @@ test "MLKEM768-X25519 test vector 1" {
 }
 
 test "MLKEM768-X25519 test vector 2" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -442,6 +449,8 @@ test "MLKEM768-X25519 test vector 2" {
 }
 
 test "MLKEM768-X25519 test vector 3" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -466,6 +475,8 @@ test "MLKEM768-X25519 test vector 3" {
 }
 
 test "MLKEM768-X25519 test vector 4" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -490,6 +501,8 @@ test "MLKEM768-X25519 test vector 4" {
 }
 
 test "MLKEM768-X25519 test vector 5" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -514,6 +527,8 @@ test "MLKEM768-X25519 test vector 5" {
 }
 
 test "MLKEM768-X25519 test vector 6" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -538,6 +553,8 @@ test "MLKEM768-X25519 test vector 6" {
 }
 
 test "MLKEM768-X25519 test vector 7" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -562,6 +579,8 @@ test "MLKEM768-X25519 test vector 7" {
 }
 
 test "MLKEM768-X25519 test vector 8" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -586,6 +605,8 @@ test "MLKEM768-X25519 test vector 8" {
 }
 
 test "MLKEM768-X25519 test vector 9" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1216]u8 = undefined;
     var randomness: [64]u8 = undefined;
@@ -610,6 +631,8 @@ test "MLKEM768-X25519 test vector 9" {
 }
 
 test "MLKEM768-P256 test vector 0" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -634,6 +657,8 @@ test "MLKEM768-P256 test vector 0" {
 }
 
 test "MLKEM768-P256 test vector 1" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -658,6 +683,8 @@ test "MLKEM768-P256 test vector 1" {
 }
 
 test "MLKEM768-P256 test vector 2" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -682,6 +709,8 @@ test "MLKEM768-P256 test vector 2" {
 }
 
 test "MLKEM768-P256 test vector 3" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -706,6 +735,8 @@ test "MLKEM768-P256 test vector 3" {
 }
 
 test "MLKEM768-P256 test vector 4" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -730,6 +761,8 @@ test "MLKEM768-P256 test vector 4" {
 }
 
 test "MLKEM768-P256 test vector 5" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -754,6 +787,8 @@ test "MLKEM768-P256 test vector 5" {
 }
 
 test "MLKEM768-P256 test vector 6" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -778,6 +813,8 @@ test "MLKEM768-P256 test vector 6" {
 }
 
 test "MLKEM768-P256 test vector 7" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -802,6 +839,8 @@ test "MLKEM768-P256 test vector 7" {
 }
 
 test "MLKEM768-P256 test vector 8" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -826,6 +865,8 @@ test "MLKEM768-P256 test vector 8" {
 }
 
 test "MLKEM768-P256 test vector 9" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1249]u8 = undefined;
     var randomness: [160]u8 = undefined;
@@ -850,6 +891,8 @@ test "MLKEM768-P256 test vector 9" {
 }
 
 test "MLKEM1024-P384 test vector 0" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -874,6 +917,8 @@ test "MLKEM1024-P384 test vector 0" {
 }
 
 test "MLKEM1024-P384 test vector 1" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -898,6 +943,8 @@ test "MLKEM1024-P384 test vector 1" {
 }
 
 test "MLKEM1024-P384 test vector 2" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -922,6 +969,8 @@ test "MLKEM1024-P384 test vector 2" {
 }
 
 test "MLKEM1024-P384 test vector 3" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -946,6 +995,8 @@ test "MLKEM1024-P384 test vector 3" {
 }
 
 test "MLKEM1024-P384 test vector 4" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -970,6 +1021,8 @@ test "MLKEM1024-P384 test vector 4" {
 }
 
 test "MLKEM1024-P384 test vector 5" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -994,6 +1047,8 @@ test "MLKEM1024-P384 test vector 5" {
 }
 
 test "MLKEM1024-P384 test vector 6" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -1018,6 +1073,8 @@ test "MLKEM1024-P384 test vector 6" {
 }
 
 test "MLKEM1024-P384 test vector 7" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -1042,6 +1099,8 @@ test "MLKEM1024-P384 test vector 7" {
 }
 
 test "MLKEM1024-P384 test vector 8" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
@@ -1066,6 +1125,8 @@ test "MLKEM1024-P384 test vector 8" {
 }
 
 test "MLKEM1024-P384 test vector 9" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     var expected_ek: [1665]u8 = undefined;
     var randomness: [80]u8 = undefined;
diff --git a/lib/std/crypto/ml_kem.zig b/lib/std/crypto/ml_kem.zig
index f758576a2d45171018be2b2620a5292a2643be8e..65d4c81ec9744f75123b89f31e6e00ae357c6845 100644
--- a/lib/std/crypto/ml_kem.zig
+++ b/lib/std/crypto/ml_kem.zig
@@ -1522,6 +1522,8 @@ test "Compression" {
 }
 
 test "noise" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     var seed: [32]u8 = undefined;
     for (&seed, 0..) |*s, i| {
         s.* = @as(u8, @intCast(i));
@@ -1655,14 +1657,20 @@ test "Test happy flow" {
 // Code to test NIST Known Answer Tests (KAT), see PQCgenKAT.c.
 
 test "NIST KAT test d00.Kyber512" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     try testNistKat(d00.Kyber512, "e9c2bd37133fcb40772f81559f14b1f58dccd1c816701be9ba6214d43baf4547");
 }
 
 test "NIST KAT test d00.Kyber1024" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     try testNistKat(d00.Kyber1024, "89248f2f33f7f4f7051729111f3049c409a933ec904aedadf035f30fa5646cd5");
 }
 
 test "NIST KAT test d00.Kyber768" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch.isRiscv64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/37128
+
     try testNistKat(d00.Kyber768, "a1e122cad3c24bc51622e4c242d8b8acbcd3f618fee4220400605ca8f9ea02c2");
 }
 
diff --git a/test/tests.zig b/test/tests.zig
index 7fa149519bf04daf725d6707f59630e9e40e6dd5..a0e4cbc6d3d656beb8b7bf713e423a3ac52ee8aa 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -2323,38 +2323,38 @@ pub const debugger_matrix: []const RunnerTarget = &.{
     },
 };
 
-fn compatible32bitArch(host: *const std.Target) ?std.Target.Cpu.Arch {
+fn supportedCompatArch(host: *const std.Target, arch: std.Target.Cpu.Arch) bool {
     return switch (host.os.tag) {
         .freebsd => switch (host.cpu.arch) {
-            .aarch64 => .arm,
-            .powerpc64 => .powerpc,
-            else => null,
+            .aarch64 => arch == .arm,
+            else => false,
         },
         .illumos => switch (host.cpu.arch) {
-            .x86_64 => .x86,
-            else => null,
+            .x86_64 => arch == .x86,
+            else => false,
         },
         .linux => switch (host.cpu.arch) {
-            .aarch64 => .arm,
-            .aarch64_be => .armeb,
-            .mips64 => .mips,
-            .mips64el => .mipsel,
-            .powerpc64 => .powerpc,
-            .sparc64 => .sparc,
-            .x86_64 => .x86,
-            else => null,
+            .aarch64 => arch == .arm or arch == .thumb,
+            .aarch64_be => arch == .armeb or arch == .thumbeb,
+            .mips64 => arch == .mips,
+            .mips64el => arch == .mipsel,
+            .powerpc64 => arch == .powerpc,
+            .riscv64 => arch == .riscv32,
+            .sparc64 => arch == .sparc,
+            .x86_64 => arch == .x86,
+            else => false,
         },
         .netbsd => switch (host.cpu.arch) {
-            .riscv64 => .riscv32,
-            .sparc64 => .sparc,
-            .x86_64 => .x86,
-            else => null,
+            .riscv64 => arch == .riscv32,
+            .sparc64 => arch == .sparc,
+            .x86_64 => arch == .x86,
+            else => false,
         },
         .windows => switch (host.cpu.arch) {
-            .x86_64 => .x86,
-            else => null,
+            .x86_64 => arch == .x86,
+            else => false,
         },
-        else => null,
+        else => false,
     };
 }
 
@@ -2362,15 +2362,22 @@ pub fn isNative(actual_target: *const std.Build.ResolvedTarget, host: *const std
     if (actual_target.query.isNative()) return true;
     const actual = &actual_target.result;
 
-    if (actual.cpu.arch != host.cpu.arch and
-        actual.cpu.arch != compatible32bitArch(host))
-    {
+    if (actual.cpu.arch != host.cpu.arch and !supportedCompatArch(host, actual.cpu.arch))
         return false;
-    }
 
     if (actual.os.tag != host.os.tag)
         return false;
 
+    // This check is really only necessary for the case where `host.cpu.arch.isAarch64()` and
+    // `actual.cpu.arch.isArm()`. As they are wholly separate `std.Target` families with their own
+    // feature bits, the logic below would produce complete nonsense.
+    //
+    // This does mean that we aren't actually checking feature compatibility between these two
+    // families even though we should. That's not a problem currently, but in the future, we may
+    // need to add a special code path just for this specific case...
+    if (actual.cpu.arch.family() != host.cpu.arch.family())
+        return true;
+
     // Remove features that don't actually affect compatibility.
     const irrelevant: std.Target.Cpu.Feature.Set = switch (host.cpu.arch) {
         .x86_64 => std.Target.x86.featureSet(&.{
@@ -2891,15 +2898,6 @@ fn addOneModuleTest(
     const libc_suffix = if (test_target.link_libc == true) "-libc" else "";
     const model_txt = target.cpu.model.name;
 
-    // These emulated targets need a lot more RAM for unknown reasons.
-    const max_rss = if (mem.eql(u8, options.name, "std") and
-        (target.cpu.arch == .hexagon or
-            (target.cpu.arch.isRISCV() and !resolved_target.query.isNative()) or
-            target.cpu.arch.isWasm()))
-        options.max_rss * 2
-    else
-        options.max_rss;
-
     const these_tests = b.addTest(.{
         .root_module = b.createModule(.{
             .root_source_file = b.path(options.root_src),
@@ -2911,7 +2909,7 @@ fn addOneModuleTest(
             .sanitize_thread = options.sanitize_thread,
             .single_threaded = test_target.single_threaded,
         }),
-        .max_rss = max_rss,
+        .max_rss = options.max_rss,
         .filters = options.test_filters,
         .use_llvm = test_target.use_llvm,
         .use_lld = test_target.use_lld,