diff --git a/tests/runtime-new/lists/runner.cs b/tests/runtime-new/lists/runner.cs
new file mode 100644
index 000000000..c6f082646
--- /dev/null
+++ b/tests/runtime-new/lists/runner.cs
@@ -0,0 +1,164 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using RunnerWorld.wit.imports.test.lists;
+using System.Text;
+
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        ToTestInterop.EmptyListParam(new byte[0]);
+        ToTestInterop.EmptyStringParam("");
+
+        {
+            byte[] result = ToTestInterop.EmptyListResult();
+            Debug.Assert(result.Length == 0);
+        }
+
+        {
+            string result = ToTestInterop.EmptyStringResult();
+            Debug.Assert(result.Length == 0);
+        }
+
+        ToTestInterop.ListParam(new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 });
+        ToTestInterop.ListParam((new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }).AsSpan());
+        ToTestInterop.ListParam((new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }).AsMemory());
+        ToTestInterop.ListParam2("foo");
+        ToTestInterop.ListParam3(new List<String>() {
+                "foo",
+                "bar",
+                "baz"
+            });
+
+        ToTestInterop.ListParam4(new List<List<String>>() {
+                new List<String>() {
+                    "foo",
+                    "bar"
+               },
+                new List<String>() {
+                    "baz"
+                }
+            });
+
+        List<string> randomStrings = new List<string>();
+        for (int i = 0; i < 1000; i++)
+        {
+            randomStrings.Add(Guid.NewGuid().ToString());
+        }
+        ToTestInterop.ListParamLarge(randomStrings);
+
+        {
+            byte[] result = ToTestInterop.ListResult();
+            Debug.Assert(result.Length == 5);
+            Debug.Assert(result[0] == (byte)1);
+            Debug.Assert(result[1] == (byte)2);
+            Debug.Assert(result[2] == (byte)3);
+            Debug.Assert(result[3] == (byte)4);
+            Debug.Assert(result[4] == (byte)5);
+        }
+
+        {
+            string result = ToTestInterop.ListResult2();
+            Console.WriteLine(result);
+            Debug.Assert(result == "hello!");
+        }
+
+        {
+            List<String> result = ToTestInterop.ListResult3();
+            Debug.Assert(result.Count() == 2);
+            Console.WriteLine(result[0]);
+            Console.WriteLine(result[1]);
+            Debug.Assert(result[0] == "hello,");
+            Debug.Assert(result[1] == "world!");
+        }
+
+        string[] strings = { "x", "", "hello", "hello ⚑ world" };
+        foreach (string s in strings)
+        {
+            string result = ToTestInterop.StringRoundtrip(s);
+            Debug.Assert(result == s);
+
+            byte[] bytes = Encoding.UTF8.GetBytes(s);
+            Debug.Assert(bytes.SequenceEqual(ToTestInterop.ListRoundtrip(bytes)));
+        }
+
+        {
+            var (u, s) = ToTestInterop.ListMinmax8(
+                new byte[] { byte.MinValue, byte.MaxValue },
+                new sbyte[] { sbyte.MinValue, sbyte.MaxValue }
+            );
+
+            Debug.Assert(u.Length == 2 && u[0] == byte.MinValue && u[1] == byte.MaxValue);
+            Debug.Assert(s.Length == 2 && s[0] == sbyte.MinValue && s[1] == sbyte.MaxValue);
+        }
+
+        {
+            var (u, s) = ToTestInterop.ListMinmax16(
+                new ushort[] { ushort.MinValue, ushort.MaxValue },
+                new short[] { short.MinValue, short.MaxValue }
+            );
+
+            Console.WriteLine(u[0]);
+            Console.WriteLine(u[1]);
+            Debug.Assert(u.Length == 2, $"u.Length {u.Length}");
+            Debug.Assert(u[0] == ushort.MinValue, $"u[0] == {u[0]}");
+            Debug.Assert(u[1] == ushort.MaxValue, $"u[1] == {u[1]}");
+
+            Debug.Assert(s.Length == 2);
+            Console.WriteLine(s[0]);
+            Console.WriteLine(s[1]);
+            Debug.Assert(s.Length == 2 && s[0] == short.MinValue && s[1] == short.MaxValue);
+        }
+
+        {
+            var (u, s) = ToTestInterop.ListMinmax32(
+                new uint[] { uint.MinValue, uint.MaxValue },
+                new int[] { int.MinValue, int.MaxValue }
+            );
+
+            Debug.Assert(u.Length == 2 && u[0] == uint.MinValue && u[1] == uint.MaxValue);
+            Debug.Assert(s.Length == 2 && s[0] == int.MinValue && s[1] == int.MaxValue);
+        }
+
+        {
+            var (u, s) = ToTestInterop.ListMinmax64(
+                new ulong[] { ulong.MinValue, ulong.MaxValue },
+                new long[] { long.MinValue, long.MaxValue }
+            );
+
+            Debug.Assert(u.Length == 2 && u[0] == ulong.MinValue && u[1] == ulong.MaxValue);
+
+            Debug.Assert(s.Length == 2 && s[0] == long.MinValue && s[1] == long.MaxValue);
+        }
+
+        {
+            var (u, s) = ToTestInterop.ListMinmaxFloat(
+                new float[] {
+                        float.MinValue,
+                        float.MaxValue,
+                        float.NegativeInfinity,
+                        float.PositiveInfinity
+                },
+                new double[] {
+                        double.MinValue,
+                        double.MaxValue,
+                        double.NegativeInfinity,
+                        double.PositiveInfinity
+                });
+
+            Debug.Assert(u.Length == 4
+                && u[0] == float.MinValue
+                && u[1] == float.MaxValue
+                && u[2] == float.NegativeInfinity
+                && u[3] == float.PositiveInfinity);
+
+            Debug.Assert(s.Length == 4
+                && s[0] == double.MinValue
+                && s[1] == double.MaxValue
+                && s[2] == double.NegativeInfinity
+                && s[3] == double.PositiveInfinity);
+        }
+    }
+}
diff --git a/tests/runtime-new/lists/test.cs b/tests/runtime-new/lists/test.cs
new file mode 100644
index 000000000..1d2e1cbf6
--- /dev/null
+++ b/tests/runtime-new/lists/test.cs
@@ -0,0 +1,162 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using System.Text;
+
+namespace TestWorld.wit.exports.test.lists
+{
+    public class ToTestImpl : ITestWorld
+    {
+
+        public static uint AllocatedBytes()
+        {
+            return 0;
+        }
+
+        public static void EmptyListParam(byte[] a)
+        {
+            Debug.Assert(a.Length == 0);
+        }
+
+        public static void EmptyStringParam(string a)
+        {
+            Debug.Assert(a.Length == 0);
+        }
+
+        public static byte[] EmptyListResult()
+        {
+            return new byte[0];
+        }
+
+        public static string EmptyStringResult()
+        {
+            return "";
+        }
+
+        public static void ListParam(byte[] a)
+        {
+            Debug.Assert(a.Length == 4);
+            Debug.Assert(a[0] == 1);
+            Debug.Assert(a[1] == 2);
+            Debug.Assert(a[2] == 3);
+            Debug.Assert(a[3] == 4);
+        }
+
+        public static void ListParam2(string a)
+        {
+            Debug.Assert(a.Equals("foo"));
+        }
+
+        public static void ListParam3(List<String> a)
+        {
+            Debug.Assert(a.Count() == 3);
+            Debug.Assert(a[0].Equals("foo"));
+            Debug.Assert(a[1].Equals("bar"));
+            Debug.Assert(a[2].Equals("baz"));
+        }
+
+        public static void ListParam4(List<List<String>> a)
+        {
+            Debug.Assert(a.Count() == 2);
+            Debug.Assert(a[0].Count() == 2);
+            Debug.Assert(a[1].Count() == 1);
+
+            Debug.Assert(a[0][0].Equals("foo"));
+            Debug.Assert(a[0][1].Equals("bar"));
+            Debug.Assert(a[1][0].Equals("baz"));
+        }
+
+        public static void ListParam5(List<(byte, uint, byte)> a)
+        {
+            Debug.Assert(a.Count() == 2);
+            Debug.Assert(a[0].Item1 == 1);
+            Debug.Assert(a[0].Item2 == 2);
+            Debug.Assert(a[0].Item3 == 3);
+            Debug.Assert(a[1].Item1 == 4);
+            Debug.Assert(a[1].Item2 == 5);
+            Debug.Assert(a[1].Item3 == 6);
+        }
+
+        public static void ListParamLarge(List<String> a)
+        {
+            Debug.Assert(a.Count() == 1000);
+        }
+
+        public static byte[] ListResult()
+        {
+            return new byte[] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 };
+        }
+
+        public static string ListResult2()
+        {
+            return "hello!";
+        }
+
+        public static List<string> ListResult3()
+        {
+            return new List<string>() {
+                "hello,",
+                "world!"
+                };
+        }
+
+        public static byte[] ListRoundtrip(byte[] a)
+        {
+            return a;
+        }
+
+        public static string stringRoundtrip(string a)
+        {
+            return a;
+        }
+
+        public static (byte[], byte[]) ListMinmax8(byte[] a, byte[] b)
+        {
+            return new(a, b);
+        }
+
+        public static (short[], short[]) ListMinmax16(short[] a, short[] b)
+        {
+            return new(a, b);
+        }
+
+        public static (int[], int[]) ListMinmax32(int[] a, int[] b)
+        {
+            return new(a, b);
+        }
+
+        public static (long[], long[]) ListMinmax64(long[] a, long[] b)
+        {
+            return new(a, b);
+        }
+
+        public static (float[], double[]) ListMinmaxFloat(float[] a, double[] b)
+        {
+            return new(a, b);
+        }
+        public static (byte[], sbyte[]) ListMinmax8(byte[] a, sbyte[] b)
+        {
+            return (a, b);
+        }
+
+        public static (ushort[], short[]) ListMinmax16(ushort[] a, short[] b)
+        {
+            return (a, b);
+        }
+
+        public static (uint[], int[]) ListMinmax32(uint[] a, int[] b)
+        {
+            return (a, b);
+        }
+
+        public static (ulong[], long[]) ListMinmax64(ulong[] a, long[] b)
+        {
+            return (a, b);
+        }
+
+        public static string StringRoundtrip(string a)
+        {
+            return a;
+        }
+    }
+}
diff --git a/tests/runtime/lists.rs b/tests/runtime/lists.rs
deleted file mode 100644
index 712cd8003..000000000
--- a/tests/runtime/lists.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use anyhow::Result;
-use wasmtime::Store;
-
-wasmtime::component::bindgen!({
-    path: "tests/runtime/lists",
-});
-
-#[derive(Default)]
-pub struct MyImports;
-
-impl test::lists::test::Host for MyImports {
-    fn empty_list_param(&mut self, a: Vec<u8>) {
-        assert!(a.is_empty());
-    }
-
-    fn empty_string_param(&mut self, a: String) {
-        assert_eq!(a, "");
-    }
-
-    fn empty_list_result(&mut self) -> Vec<u8> {
-        Vec::new()
-    }
-
-    fn empty_string_result(&mut self) -> String {
-        String::new()
-    }
-
-    fn list_param(&mut self, list: Vec<u8>) {
-        assert_eq!(list, [1, 2, 3, 4]);
-    }
-
-    fn list_param2(&mut self, ptr: String) {
-        assert_eq!(ptr, "foo");
-    }
-
-    fn list_param3(&mut self, ptr: Vec<String>) {
-        assert_eq!(ptr.len(), 3);
-        assert_eq!(ptr[0], "foo");
-        assert_eq!(ptr[1], "bar");
-        assert_eq!(ptr[2], "baz");
-    }
-
-    fn list_param4(&mut self, ptr: Vec<Vec<String>>) {
-        assert_eq!(ptr.len(), 2);
-        assert_eq!(ptr[0][0], "foo");
-        assert_eq!(ptr[0][1], "bar");
-        assert_eq!(ptr[1][0], "baz");
-    }
-
-    fn list_param5(&mut self, ptr: Vec<(u8, u32, u8)>) {
-        assert_eq!(ptr, [(1, 2, 3), (4, 5, 6)]);
-    }
-
-    fn list_param_large(&mut self, ptr: Vec<String>) {
-        assert_eq!(ptr.len(), 1000);
-    }
-
-    fn list_result(&mut self) -> Vec<u8> {
-        vec![1, 2, 3, 4, 5]
-    }
-
-    fn list_result2(&mut self) -> String {
-        "hello!".to_string()
-    }
-
-    fn list_result3(&mut self) -> Vec<String> {
-        vec!["hello,".to_string(), "world!".to_string()]
-    }
-
-    fn list_roundtrip(&mut self, list: Vec<u8>) -> Vec<u8> {
-        list.to_vec()
-    }
-
-    fn string_roundtrip(&mut self, s: String) -> String {
-        s.to_string()
-    }
-
-    fn list_minmax8(&mut self, u: Vec<u8>, s: Vec<i8>) -> (Vec<u8>, Vec<i8>) {
-        assert_eq!(u, [u8::MIN, u8::MAX]);
-        assert_eq!(s, [i8::MIN, i8::MAX]);
-        (u, s)
-    }
-
-    fn list_minmax16(&mut self, u: Vec<u16>, s: Vec<i16>) -> (Vec<u16>, Vec<i16>) {
-        assert_eq!(u, [u16::MIN, u16::MAX]);
-        assert_eq!(s, [i16::MIN, i16::MAX]);
-        (u, s)
-    }
-
-    fn list_minmax32(&mut self, u: Vec<u32>, s: Vec<i32>) -> (Vec<u32>, Vec<i32>) {
-        assert_eq!(u, [u32::MIN, u32::MAX]);
-        assert_eq!(s, [i32::MIN, i32::MAX]);
-        (u, s)
-    }
-
-    fn list_minmax64(&mut self, u: Vec<u64>, s: Vec<i64>) -> (Vec<u64>, Vec<i64>) {
-        assert_eq!(u, [u64::MIN, u64::MAX]);
-        assert_eq!(s, [i64::MIN, i64::MAX]);
-        (u, s)
-    }
-
-    fn list_minmax_float(&mut self, u: Vec<f32>, s: Vec<f64>) -> (Vec<f32>, Vec<f64>) {
-        assert_eq!(u, [f32::MIN, f32::MAX, f32::NEG_INFINITY, f32::INFINITY]);
-        assert_eq!(s, [f64::MIN, f64::MAX, f64::NEG_INFINITY, f64::INFINITY]);
-        (u, s)
-    }
-}
-
-#[test]
-fn run() -> Result<()> {
-    crate::run_test(
-        "lists",
-        |linker| Lists::add_to_linker(linker, |x| &mut x.0),
-        |store, component, linker| Lists::instantiate(store, component, linker),
-        run_test,
-    )
-}
-
-fn run_test(lists: Lists, store: &mut Store<crate::Wasi<MyImports>>) -> Result<()> {
-    let bytes = lists.call_allocated_bytes(&mut *store)?;
-    lists.call_test_imports(&mut *store)?;
-    let exports = lists.test_lists_test();
-    exports.call_empty_list_param(&mut *store, &[])?;
-    exports.call_empty_string_param(&mut *store, "")?;
-    assert!(exports.call_empty_list_result(&mut *store)?.is_empty());
-    assert_eq!(exports.call_empty_string_result(&mut *store)?, "");
-    exports.call_list_param(&mut *store, &[1, 2, 3, 4])?;
-    exports.call_list_param2(&mut *store, "foo")?;
-    exports.call_list_param3(
-        &mut *store,
-        &["foo".to_owned(), "bar".to_owned(), "baz".to_owned()],
-    )?;
-    exports.call_list_param4(
-        &mut *store,
-        &[
-            vec!["foo".to_owned(), "bar".to_owned()],
-            vec!["baz".to_owned()],
-        ],
-    )?;
-    let arg0: Vec<String> = (0..1000).map(|_| "string".to_string()).collect();
-    exports.call_list_param_large(&mut *store, &arg0)?;
-    assert_eq!(exports.call_list_result(&mut *store)?, [1, 2, 3, 4, 5]);
-    assert_eq!(exports.call_list_result2(&mut *store)?, "hello!");
-    assert_eq!(
-        exports.call_list_result3(&mut *store)?,
-        ["hello,", "world!"]
-    );
-    assert_eq!(exports.call_string_roundtrip(&mut *store, "x")?, "x");
-    assert_eq!(exports.call_string_roundtrip(&mut *store, "")?, "");
-    assert_eq!(
-        exports.call_string_roundtrip(&mut *store, "hello ⚑ world")?,
-        "hello ⚑ world"
-    );
-    // Ensure that we properly called `free` everywhere in all the glue that we
-    // needed to.
-    assert_eq!(bytes, lists.call_allocated_bytes(&mut *store)?);
-    Ok(())
-}
diff --git a/tests/runtime/lists/wasm.cs b/tests/runtime/lists/wasm.cs
deleted file mode 100644
index 2a7b96258..000000000
--- a/tests/runtime/lists/wasm.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using System.Diagnostics;
-using ListsWorld.wit.imports.test.lists;
-using System.Text;
-
-namespace ListsWorld {
-
-    public class ListsWorldImpl : IListsWorld
-    {
-        public static uint AllocatedBytes()
-        {
-            return 0;
-        }
-
-        public static void TestImports()
-        {
-
-            TestInterop.EmptyListParam(new byte[0]);
-            TestInterop.EmptyStringParam("");
-
-            {
-                byte[] result = TestInterop.EmptyListResult();
-                Debug.Assert(result.Length == 0);
-            }
-
-            {
-                string result = TestInterop.EmptyStringResult();
-                Debug.Assert(result.Length == 0);
-            }
-
-            TestInterop.ListParam(new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 });
-            TestInterop.ListParam((new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }).AsSpan());
-            TestInterop.ListParam((new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }).AsMemory());
-            TestInterop.ListParam2("foo");
-            TestInterop.ListParam3(new List<String>() {
-                "foo",
-                "bar",
-                "baz"
-            });
-
-            TestInterop.ListParam4(new List<List<String>>() {
-                new List<String>() {
-                    "foo",
-                    "bar"
-               },
-                new List<String>() {
-                    "baz"
-                }
-            });
-
-            List<string> randomStrings = new List<string>();
-            for (int i = 0; i < 1000; i++)
-            {
-                randomStrings.Add(Guid.NewGuid().ToString());
-            }
-            TestInterop.ListParamLarge(randomStrings);
-
-            {
-               byte[] result = TestInterop.ListResult();
-               Debug.Assert(result.Length == 5);
-               Debug.Assert(result[0] == (byte)1);
-               Debug.Assert(result[1] == (byte)2);
-               Debug.Assert(result[2] == (byte)3);
-               Debug.Assert(result[3] == (byte)4);
-               Debug.Assert(result[4] == (byte)5);
-            }
-
-            {
-               string result = TestInterop.ListResult2();
-               Console.WriteLine(result);
-               Debug.Assert(result == "hello!");
-            }
-
-            {
-               List<String> result = TestInterop.ListResult3();
-               Debug.Assert(result.Count() == 2);
-               Console.WriteLine(result[0]);
-               Console.WriteLine(result[1]);
-               Debug.Assert(result[0] == "hello,");
-               Debug.Assert(result[1] == "world!");
-            }
-
-            string[] strings = { "x", "", "hello", "hello ⚑ world" };
-            foreach (string s in strings)
-            {
-                string result = TestInterop.StringRoundtrip(s);
-                Debug.Assert(result == s);
-
-                byte[] bytes = Encoding.UTF8.GetBytes(s);
-                Debug.Assert(bytes.SequenceEqual(TestInterop.ListRoundtrip(bytes)));
-            }
-
-            {
-                var (u, s) = TestInterop.ListMinmax8(
-                    new byte[] { byte.MinValue,byte.MaxValue },
-                    new sbyte[] { sbyte.MinValue, sbyte.MaxValue }
-                );
-
-                Debug.Assert(u.Length == 2 && u[0] == byte.MinValue && u[1] == byte.MaxValue);
-                Debug.Assert(s.Length == 2 && s[0] == sbyte.MinValue && s[1] == sbyte.MaxValue);
-            }
-
-            {
-                var (u, s) = TestInterop.ListMinmax16(
-                    new ushort[] { ushort.MinValue, ushort.MaxValue },
-                    new short[] { short.MinValue, short.MaxValue }
-                );
-
-                Console.WriteLine(u[0]);
-                Console.WriteLine(u[1]);
-                Debug.Assert(u.Length == 2, $"u.Length {u.Length}");
-                Debug.Assert(u[0] == ushort.MinValue, $"u[0] == {u[0]}");
-                Debug.Assert(u[1] == ushort.MaxValue, $"u[1] == {u[1]}");
-
-                Debug.Assert(s.Length == 2);
-                Console.WriteLine(s[0]);
-                Console.WriteLine(s[1]);
-                Debug.Assert(s.Length == 2 && s[0] == short.MinValue && s[1] == short.MaxValue);
-            }
-
-            {
-                var (u, s) = TestInterop.ListMinmax32(
-                    new uint[] { uint.MinValue, uint.MaxValue },
-                    new int[] { int.MinValue, int.MaxValue }
-                );
-
-                Debug.Assert(u.Length == 2 && u[0] == uint.MinValue && u[1] == uint.MaxValue);
-                Debug.Assert(s.Length == 2 && s[0] == int.MinValue && s[1] == int.MaxValue);
-            }
-
-            {
-                var (u, s) = TestInterop.ListMinmax64(
-                    new ulong[] { ulong.MinValue, ulong.MaxValue },
-                    new long[] { long.MinValue, long.MaxValue }
-                );
-
-                Debug.Assert(u.Length == 2 && u[0] == ulong.MinValue && u[1] == ulong.MaxValue);
-
-                Debug.Assert(s.Length == 2 && s[0] == long.MinValue && s[1] == long.MaxValue);
-            }
-
-            {
-                var (u, s) = TestInterop.ListMinmaxFloat(
-                    new float[] {
-                        float.MinValue,
-                        float.MaxValue,
-                        float.NegativeInfinity,
-                        float.PositiveInfinity
-                    },
-                    new double[] {
-                        double.MinValue,
-                        double.MaxValue,
-                        double.NegativeInfinity,
-                        double.PositiveInfinity
-                    });
-
-                Debug.Assert(u.Length == 4
-                    && u[0] == float.MinValue
-                    && u[1] == float.MaxValue
-                    && u[2] == float.NegativeInfinity
-                    && u[3] == float.PositiveInfinity);
-
-                Debug.Assert(s.Length == 4
-                    && s[0] == double.MinValue
-                    && s[1] == double.MaxValue
-                    && s[2] == double.NegativeInfinity
-                    && s[3] == double.PositiveInfinity);
-            }
-        }
-    }
-}
-
-namespace ListsWorld.wit.exports.test.lists
-{
-    public class TestImpl : ITest
-    {
-
-        public static void EmptyListParam(byte[] a)
-        {
-            Debug.Assert(a.Length == 0);
-        }
-
-        public static void EmptyStringParam(string a)
-        {
-            Debug.Assert(a.Length == 0);
-        }
-
-        public static byte[] EmptyListResult()
-        {
-            return new byte[0];
-        }
-
-        public static string EmptyStringResult()
-        {
-            return "";
-        }
-
-        public static void ListParam(byte[] a)
-        {
-            Debug.Assert(a.Length == 4);
-            Debug.Assert(a[0] == 1);
-            Debug.Assert(a[1] == 2);
-            Debug.Assert(a[2] == 3);
-            Debug.Assert(a[3] == 4);
-        }
-
-        public static void ListParam2(string a)
-        {
-            Debug.Assert(a.Equals("foo"));
-        }
-
-        public static void ListParam3(List<String> a)
-        {
-            Debug.Assert(a.Count() == 3);
-            Debug.Assert(a[0].Equals("foo"));
-            Debug.Assert(a[1].Equals("bar"));
-            Debug.Assert(a[2].Equals("baz"));
-        }
-
-        public static void ListParam4(List<List<String>> a)
-        {
-            Debug.Assert(a.Count() == 2);
-            Debug.Assert(a[0].Count() == 2);
-            Debug.Assert(a[1].Count() == 1);
-
-            Debug.Assert(a[0][0].Equals("foo"));
-            Debug.Assert(a[0][1].Equals("bar"));
-            Debug.Assert(a[1][0].Equals("baz"));
-        }
-
-        public static void ListParam5(List<(byte, uint, byte)> a)
-        {
-            Debug.Assert(a.Count() == 2);
-            Debug.Assert(a[0].Item1 == 1);
-            Debug.Assert(a[0].Item2 == 2);
-            Debug.Assert(a[0].Item3 == 3);
-            Debug.Assert(a[1].Item1 == 4);
-            Debug.Assert(a[1].Item2 == 5);
-            Debug.Assert(a[1].Item3 == 6);
-        }
-
-        public static void ListParamLarge(List<String> a)
-        {
-            Debug.Assert(a.Count() == 1000);
-        }
-
-        public static byte[] ListResult()
-        {
-            return new byte[] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 };
-        }
-
-        public static string ListResult2()
-        {
-            return "hello!";
-        }
-
-        public static List<string> ListResult3()
-        {
-            return new List<string>() {
-                "hello,",
-                "world!"
-                };
-        }
-
-        public static byte[] ListRoundtrip(byte[] a)
-        {
-            return a;
-        }
-
-        public static string stringRoundtrip(string a)
-        {
-            return a;
-        }
-
-        public static (byte[], byte[]) ListMinmax8(byte[] a, byte[] b)
-        {
-            return new(a, b);
-        }
-
-        public static (short[], short[]) ListMinmax16(short[] a, short[] b)
-        {
-            return new(a, b);
-        }
-
-        public static (int[], int[]) ListMinmax32(int[] a, int[] b)
-        {
-            return new(a, b);
-        }
-
-        public static (long[], long[]) ListMinmax64(long[] a, long[] b)
-        {
-            return new(a, b);
-        }
-
-        public static (float[], double[]) ListMinmaxFloat(float[] a, double[] b)
-        {
-            return new(a, b);
-        }
-        public static (byte[], sbyte[]) ListMinmax8(byte[] a, sbyte[] b)
-        {
-            return (a, b);
-        }
-
-        public static (ushort[], short[]) ListMinmax16(ushort[] a, short[] b)
-        {
-            return (a, b);
-        }
-
-        public static (uint[], int[]) ListMinmax32(uint[] a, int[] b)
-        {
-            return (a, b);
-        }
-
-        public static (ulong[], long[]) ListMinmax64(ulong[] a, long[] b)
-        {
-            return (a, b);
-        }
-
-        public static string StringRoundtrip(string a)
-        {
-            return a;
-        }
-    }
-}
diff --git a/tests/runtime/lists/world.wit b/tests/runtime/lists/world.wit
deleted file mode 100644
index 3c9635339..000000000
--- a/tests/runtime/lists/world.wit
+++ /dev/null
@@ -1,37 +0,0 @@
-package test:lists;
-
-interface test {
-  empty-list-param: func(a: list<u8>);
-  empty-string-param: func(a: string);
-  empty-list-result: func() -> list<u8>;
-  empty-string-result: func() -> string;
-
-  list-param: func(a: list<u8>);
-  list-param2: func(a: string);
-  list-param3: func(a: list<string>);
-  list-param4: func(a: list<list<string>>);
-  list-param5: func(a: list<tuple<u8, u32, u8>>);
-  list-param-large: func(a: list<string>);
-  list-result: func() -> list<u8>;
-  list-result2: func() -> string;
-  list-result3: func() -> list<string>;
-
-  list-minmax8: func(a: list<u8>, b: list<s8>) -> tuple<list<u8>, list<s8>>;
-  list-minmax16: func(a: list<u16>, b: list<s16>) -> tuple<list<u16>, list<s16>>;
-  list-minmax32: func(a: list<u32>, b: list<s32>) -> tuple<list<u32>, list<s32>>;
-  list-minmax64: func(a: list<u64>, b: list<s64>) -> tuple<list<u64>, list<s64>>;
-  list-minmax-float: func(a: list<f32>, b: list<f64>)
-    -> tuple<list<f32>, list<f64>>;
-
-  list-roundtrip: func(a: list<u8>) -> list<u8>;
-
-  string-roundtrip: func(a: string) -> string;
-}
-
-world lists {
-  import test;
-  export test;
-
-  export test-imports: func();
-  export allocated-bytes: func() -> u32;
-}
diff --git a/tests/runtime/main.rs b/tests/runtime/main.rs
index 3399f2ca4..fc572abc7 100644
--- a/tests/runtime/main.rs
+++ b/tests/runtime/main.rs
@@ -14,7 +14,6 @@ use wit_component::{ComponentEncoder, StringEncoding};
 use wit_parser::{Resolve, WorldId, WorldItem};
 
 mod flavorful;
-mod lists;
 mod options;
 mod other_dependencies;
 mod ownership;