diff --git a/.github/actions/install-wasi-sdk/action.yml b/.github/actions/install-wasi-sdk/action.yml
index f0ecf0efc..6917f08b4 100644
--- a/.github/actions/install-wasi-sdk/action.yml
+++ b/.github/actions/install-wasi-sdk/action.yml
@@ -5,25 +5,25 @@ runs:
   using: composite
   steps:
     - run: |
-        curl https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-28/wasi-sdk-28.0-x86_64-linux.tar.gz -L | tar xzvf -
-        echo "WASI_SDK_PATH=`pwd`/wasi-sdk-28.0-x86_64-linux" >> $GITHUB_ENV
+        curl https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-x86_64-linux.tar.gz -L | tar xzvf -
+        echo "WASI_SDK_PATH=`pwd`/wasi-sdk-29.0-x86_64-linux" >> $GITHUB_ENV
       if: runner.os == 'Linux'
       shell: bash
     - run: |
-        curl https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-28/wasi-sdk-28.0-x86_64-macos.tar.gz -L | tar xzvf -
-        echo "WASI_SDK_PATH=`pwd`/wasi-sdk-28.0-x86_64-macos" >> $GITHUB_ENV
+        curl https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-x86_64-macos.tar.gz -L | tar xzvf -
+        echo "WASI_SDK_PATH=`pwd`/wasi-sdk-29.0-x86_64-macos" >> $GITHUB_ENV
       if: runner.os == 'macOS'
       shell: bash
     - run: |
-        curl https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-28/wasi-sdk-28.0-x86_64-windows.tar.gz -L | tar xzvf -
-        echo "WASI_SDK_PATH=`pwd`/wasi-sdk-28.0-x86_64-windows" >> $GITHUB_ENV
+        curl https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-x86_64-windows.tar.gz -L | tar xzvf -
+        echo "WASI_SDK_PATH=`pwd`/wasi-sdk-29.0-x86_64-windows" >> $GITHUB_ENV
       if: runner.os == 'Windows'
       shell: bash
     - name: Setup `wasm-tools`
       uses: bytecodealliance/actions/wasm-tools/setup@v1
       with:
-        version: "1.240.0"
+        version: "1.241.2"
     - name: Setup `wasmtime`
       uses: bytecodealliance/actions/wasmtime/setup@v1
       with:
-        version: "38.0.3"
+        version: "dev"
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 29d22b10e..9c50c0608 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -122,7 +122,7 @@ jobs:
       with:
         submodules: true
     - name: Install Rust
-      run: rustup update beta --no-self-update && rustup default beta
+      run: rustup update nightly --no-self-update && rustup default nightly
     - run: rustup target add wasm32-wasip2
     - uses: ./.github/actions/install-wasi-sdk
     - run: |
diff --git a/tests/runtime-async/async/cancel-import/runner.c b/tests/runtime-async/async/cancel-import/runner.c
index 129ab45f4..b028cd064 100644
--- a/tests/runtime-async/async/cancel-import/runner.c
+++ b/tests/runtime-async/async/cancel-import/runner.c
@@ -8,7 +8,7 @@ int main() {
   {
     test_future_void_writer_t writer;
     test_future_void_t reader = test_future_void_new(&writer);
-    runner_subtask_status_t status = test_async_pending_import(reader);
+    runner_subtask_status_t status = test_pending_import(reader);
     assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
     runner_subtask_t subtask = RUNNER_SUBTASK_HANDLE(status);
     assert(subtask != 0);
@@ -31,7 +31,7 @@ int main() {
     test_future_void_t reader2 = test_future_void_new(&writer2);
 
     // start up one task, it'll be in "STARTED"
-    runner_subtask_status_t status = test_async_pending_import(reader1);
+    runner_subtask_status_t status = test_pending_import(reader1);
     assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
     runner_subtask_t subtask1 = RUNNER_SUBTASK_HANDLE(status);
     assert(subtask1 != 0);
@@ -39,7 +39,7 @@ int main() {
     // Start up a second task after setting the backpressure flag, forcing it
     // to be in the "STARTING" state.
     test_backpressure_set(true);
-    status = test_async_pending_import(reader2);
+    status = test_pending_import(reader2);
     assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTING);
     runner_subtask_t subtask2 = RUNNER_SUBTASK_HANDLE(status);
     assert(subtask2 != 0);
diff --git a/tests/runtime-async/async/cancel-import/test.c b/tests/runtime-async/async/cancel-import/test.c
index 3e06e433b..fb41b6836 100644
--- a/tests/runtime-async/async/cancel-import/test.c
+++ b/tests/runtime-async/async/cancel-import/test.c
@@ -9,7 +9,7 @@ struct my_task {
   exports_test_future_void_t future;
 };
 
-test_callback_code_t exports_test_async_pending_import(exports_test_future_void_t x) {
+test_callback_code_t exports_test_pending_import(exports_test_future_void_t x) {
   struct my_task *task = (struct my_task*) malloc(sizeof(struct my_task));
   assert(task != NULL);
   test_waitable_status_t status = exports_test_future_void_read(x);
@@ -22,7 +22,7 @@ test_callback_code_t exports_test_async_pending_import(exports_test_future_void_
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
-test_callback_code_t exports_test_async_pending_import_callback(test_event_t *event) {
+test_callback_code_t exports_test_pending_import_callback(test_event_t *event) {
   struct my_task *task = (struct my_task*) test_context_get();
   if (event->event == TEST_EVENT_CANCEL) {
     assert(event->waitable == 0);
@@ -37,7 +37,7 @@ test_callback_code_t exports_test_async_pending_import_callback(test_event_t *ev
     assert(event->waitable == task->future);
     assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
     assert(TEST_WAITABLE_COUNT(event->code) == 0);
-    exports_test_async_pending_import_return();
+    exports_test_pending_import_return();
   }
 
   test_waitable_join(task->future, 0);
diff --git a/tests/runtime-async/async/future-cancel-read/runner.c b/tests/runtime-async/async/future-cancel-read/runner.c
index 2bce22318..2f3b67f5d 100644
--- a/tests/runtime-async/async/future-cancel-read/runner.c
+++ b/tests/runtime-async/async/future-cancel-read/runner.c
@@ -8,7 +8,7 @@ int main() {
     test_future_u32_writer_t writer;
     test_future_u32_t reader = test_future_u32_new(&writer);
 
-    runner_subtask_status_t status = test_async_cancel_before_read(reader);
+    runner_subtask_status_t status = test_cancel_before_read(reader);
     assert(status == RUNNER_SUBTASK_RETURNED);
     uint32_t value = 0;
     runner_waitable_status_t wstatus = test_future_u32_write(writer, &value);
@@ -21,7 +21,7 @@ int main() {
     test_future_u32_writer_t writer;
     test_future_u32_t reader = test_future_u32_new(&writer);
 
-    runner_subtask_status_t status = test_async_cancel_after_read(reader);
+    runner_subtask_status_t status = test_cancel_after_read(reader);
     assert(status == RUNNER_SUBTASK_RETURNED);
 
     uint32_t value = 0;
@@ -36,7 +36,7 @@ int main() {
     test_future_u32_t data_reader = test_future_u32_new(&data_writer);
     test_future_void_writer_t signal_writer;
     test_future_void_t signal_reader = test_future_void_new(&signal_writer);
-    runner_subtask_status_t status = test_async_start_read_then_cancel(data_reader, signal_reader);
+    runner_subtask_status_t status = test_start_read_then_cancel(data_reader, signal_reader);
     assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
     runner_subtask_t task = RUNNER_SUBTASK_HANDLE(status);
 
diff --git a/tests/runtime-async/async/future-cancel-read/test.c b/tests/runtime-async/async/future-cancel-read/test.c
index 86b1d95fe..a8775c401 100644
--- a/tests/runtime-async/async/future-cancel-read/test.c
+++ b/tests/runtime-async/async/future-cancel-read/test.c
@@ -5,17 +5,17 @@
 #include <stdlib.h>
 
 // This is a test of a Rust-ism, nothing to do in C.
-test_callback_code_t exports_test_async_cancel_before_read(exports_test_future_u32_t x) {
+test_callback_code_t exports_test_cancel_before_read(exports_test_future_u32_t x) {
   exports_test_future_u32_drop_readable(x);
-  exports_test_async_cancel_before_read_return();
+  exports_test_cancel_before_read_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_callback_code_t exports_test_async_cancel_before_read_callback(test_event_t *event) {
+test_callback_code_t exports_test_cancel_before_read_callback(test_event_t *event) {
   assert(0);
 }
 
-test_callback_code_t exports_test_async_cancel_after_read(exports_test_future_u32_t x) {
+test_callback_code_t exports_test_cancel_after_read(exports_test_future_u32_t x) {
   uint32_t result;
   test_waitable_status_t status = exports_test_future_u32_read(x, &result);
   assert(status == TEST_WAITABLE_STATUS_BLOCKED);
@@ -25,11 +25,11 @@ test_callback_code_t exports_test_async_cancel_after_read(exports_test_future_u3
 
   exports_test_future_u32_drop_readable(x);
 
-  exports_test_async_cancel_after_read_return();
+  exports_test_cancel_after_read_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_callback_code_t exports_test_async_cancel_after_read_callback(test_event_t *event) {
+test_callback_code_t exports_test_cancel_after_read_callback(test_event_t *event) {
   assert(0);
 }
 
@@ -40,7 +40,7 @@ struct start_read_then_cancel_state {
   uint32_t result;
 };
 
-test_callback_code_t exports_test_async_start_read_then_cancel(
+test_callback_code_t exports_test_start_read_then_cancel(
   exports_test_future_u32_t data,
   exports_test_future_void_t signal
 ) {
@@ -62,7 +62,7 @@ test_callback_code_t exports_test_async_start_read_then_cancel(
   return TEST_CALLBACK_CODE_WAIT(state->set);
 }
 
-test_callback_code_t exports_test_async_start_read_then_cancel_callback(test_event_t *event) {
+test_callback_code_t exports_test_start_read_then_cancel_callback(test_event_t *event) {
   struct start_read_then_cancel_state *state =
     (struct start_read_then_cancel_state*) test_context_get();
   assert(event->event == TEST_EVENT_FUTURE_READ);
@@ -80,6 +80,6 @@ test_callback_code_t exports_test_async_start_read_then_cancel_callback(test_eve
   exports_test_future_void_drop_readable(state->signal);
   test_waitable_set_drop(state->set);
 
-  exports_test_async_start_read_then_cancel_return();
+  exports_test_start_read_then_cancel_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
diff --git a/tests/runtime-async/async/future-cancel-write/runner.c b/tests/runtime-async/async/future-cancel-write/runner.c
index 297733292..fd6ea53e5 100644
--- a/tests/runtime-async/async/future-cancel-write/runner.c
+++ b/tests/runtime-async/async/future-cancel-write/runner.c
@@ -53,7 +53,7 @@ int main() {
     runner_waitable_status_t status = test_future_string_write(writer, &string);
     assert(status == RUNNER_WAITABLE_STATUS_BLOCKED);
 
-    runner_subtask_status_t status2 = test_async_read_and_drop(reader);
+    runner_subtask_status_t status2 = test_read_and_drop(reader);
     assert(status2 == RUNNER_SUBTASK_RETURNED);
 
     status = test_future_string_cancel_write(writer);
diff --git a/tests/runtime-async/async/future-cancel-write/test.c b/tests/runtime-async/async/future-cancel-write/test.c
index 00c75d321..1845264d4 100644
--- a/tests/runtime-async/async/future-cancel-write/test.c
+++ b/tests/runtime-async/async/future-cancel-write/test.c
@@ -7,7 +7,7 @@ void exports_test_take_then_drop(exports_test_future_string_t x) {
   exports_test_future_string_drop_readable(x);
 }
 
-test_callback_code_t exports_test_async_read_and_drop(exports_test_future_string_t x) {
+test_callback_code_t exports_test_read_and_drop(exports_test_future_string_t x) {
   test_string_t string;
   test_waitable_status_t status = exports_test_future_string_read(x, &string);
   assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
@@ -16,10 +16,10 @@ test_callback_code_t exports_test_async_read_and_drop(exports_test_future_string
   exports_test_future_string_drop_readable(x);
   test_string_free(&string);
 
-  exports_test_async_read_and_drop_return();
+  exports_test_read_and_drop_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_callback_code_t exports_test_async_read_and_drop_callback(test_event_t *event) {
+test_callback_code_t exports_test_read_and_drop_callback(test_event_t *event) {
   assert(0);
 }
diff --git a/tests/runtime-async/async/pending-import/runner.c b/tests/runtime-async/async/pending-import/runner.c
index 251bf5f8f..78fe38c9c 100644
--- a/tests/runtime-async/async/pending-import/runner.c
+++ b/tests/runtime-async/async/pending-import/runner.c
@@ -7,7 +7,7 @@
 int main() {
   test_future_void_writer_t writer;
   test_future_void_t reader = test_future_void_new(&writer);
-  runner_subtask_status_t status = test_async_pending_import(reader);
+  runner_subtask_status_t status = test_pending_import(reader);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t subtask = RUNNER_SUBTASK_HANDLE(status);
   assert(subtask != 0);
diff --git a/tests/runtime-async/async/pending-import/test.c b/tests/runtime-async/async/pending-import/test.c
index 9cb643a56..378583f7d 100644
--- a/tests/runtime-async/async/pending-import/test.c
+++ b/tests/runtime-async/async/pending-import/test.c
@@ -9,7 +9,7 @@ struct my_task {
   exports_test_future_void_t future;
 };
 
-test_callback_code_t exports_test_async_pending_import(exports_test_future_void_t x) {
+test_callback_code_t exports_test_pending_import(exports_test_future_void_t x) {
   struct my_task *task = (struct my_task*) malloc(sizeof(struct my_task));
   assert(task != NULL);
   test_waitable_status_t status = exports_test_future_void_read(x);
@@ -22,13 +22,13 @@ test_callback_code_t exports_test_async_pending_import(exports_test_future_void_
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
-test_callback_code_t exports_test_async_pending_import_callback(test_event_t *event) {
+test_callback_code_t exports_test_pending_import_callback(test_event_t *event) {
   struct my_task *task = (struct my_task*) test_context_get();
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == task->future);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
   assert(TEST_WAITABLE_COUNT(event->code) == 0);
-  exports_test_async_pending_import_return();
+  exports_test_pending_import_return();
 
   test_waitable_join(task->future, 0);
   exports_test_future_void_drop_readable(task->future);
diff --git a/tests/runtime-async/async/ping-pong/runner.c b/tests/runtime-async/async/ping-pong/runner.c
index 02c07b922..e08612ab4 100644
--- a/tests/runtime-async/async/ping-pong/runner.c
+++ b/tests/runtime-async/async/ping-pong/runner.c
@@ -12,7 +12,7 @@ int main() {
   runner_string_t y;
   runner_string_set(&y, "world");
   test_future_string_t ping_result;
-  runner_subtask_status_t status = test_async_ping(reader, y, &ping_result);
+  runner_subtask_status_t status = test_ping(reader, y, &ping_result);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t ping = RUNNER_SUBTASK_HANDLE(status);
 
@@ -46,7 +46,7 @@ int main() {
   // Start the `pong` subtask
   runner_string_t pong_result;
   reader = test_future_string_new(&writer);
-  status = test_async_pong(reader, &pong_result);
+  status = test_pong(reader, &pong_result);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t pong = RUNNER_SUBTASK_HANDLE(status);
 
diff --git a/tests/runtime-async/async/ping-pong/test.c b/tests/runtime-async/async/ping-pong/test.c
index a493074fd..86614d6ee 100644
--- a/tests/runtime-async/async/ping-pong/test.c
+++ b/tests/runtime-async/async/ping-pong/test.c
@@ -17,7 +17,7 @@ struct ping_task {
   exports_test_future_string_writer_t writer;
 };
 
-test_callback_code_t exports_test_async_ping(exports_test_future_string_t x, test_string_t *y) {
+test_callback_code_t exports_test_ping(exports_test_future_string_t x, test_string_t *y) {
   // Initialize a new task
   struct ping_task *task = (struct ping_task*) malloc(sizeof(struct ping_task));
   assert(task != NULL);
@@ -37,7 +37,7 @@ test_callback_code_t exports_test_async_ping(exports_test_future_string_t x, tes
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
-test_callback_code_t exports_test_async_ping_callback(test_event_t *event) {
+test_callback_code_t exports_test_ping_callback(test_event_t *event) {
   struct ping_task *task = (struct ping_task*) test_context_get();
   switch (task->state) {
     case PING_S1: {
@@ -54,7 +54,7 @@ test_callback_code_t exports_test_async_ping_callback(test_event_t *event) {
       // Create a new future and start the return of our task with this future.
       exports_test_future_string_writer_t writer;
       exports_test_future_string_t reader = exports_test_future_string_new(&writer);
-      exports_test_async_ping_return(reader);
+      exports_test_ping_return(reader);
       task->writer = writer;
 
       // Concatenate `task->read_result` and `task->arg`.
@@ -114,7 +114,7 @@ struct pong_task {
   test_waitable_set_t set;
 };
 
-test_callback_code_t exports_test_async_pong(exports_test_future_string_t x) {
+test_callback_code_t exports_test_pong(exports_test_future_string_t x) {
   struct pong_task *task = (struct pong_task*) malloc(sizeof(struct pong_task));
   assert(task != NULL);
   task->future = x;
@@ -130,7 +130,7 @@ test_callback_code_t exports_test_async_pong(exports_test_future_string_t x) {
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
-test_callback_code_t exports_test_async_pong_callback(test_event_t *event) {
+test_callback_code_t exports_test_pong_callback(test_event_t *event) {
   struct pong_task *task = (struct pong_task*) test_context_get();
 
   // assert this event is a future read completion
@@ -149,7 +149,7 @@ test_callback_code_t exports_test_async_pong_callback(test_event_t *event) {
   task->set = 0;
 
   // return our string
-  exports_test_async_pong_return(task->read_result);
+  exports_test_pong_return(task->read_result);
   test_string_free(&task->read_result);
 
   free(task);
diff --git a/tests/runtime-async/async/simple-call-import/runner.c b/tests/runtime-async/async/simple-call-import/runner.c
index b1d0de15d..26f9d0f79 100644
--- a/tests/runtime-async/async/simple-call-import/runner.c
+++ b/tests/runtime-async/async/simple-call-import/runner.c
@@ -3,7 +3,7 @@
 #include <runner.h>
 
 int main() {
-  runner_subtask_status_t status = test_async_f();
+  runner_subtask_status_t status = test_f();
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_RETURNED);
   assert(RUNNER_SUBTASK_HANDLE(status) == 0);
 }
diff --git a/tests/runtime-async/async/simple-call-import/test.c b/tests/runtime-async/async/simple-call-import/test.c
index cf5fbbd7e..f1ec0ddcb 100644
--- a/tests/runtime-async/async/simple-call-import/test.c
+++ b/tests/runtime-async/async/simple-call-import/test.c
@@ -3,11 +3,11 @@
 #include <assert.h>
 #include <test.h>
 
-test_subtask_status_t exports_test_async_f() {
-  exports_test_async_f_return();
+test_subtask_status_t exports_test_f() {
+  exports_test_f_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_f_callback(test_event_t *event) {
+test_subtask_status_t exports_test_f_callback(test_event_t *event) {
   assert(0);
 }
diff --git a/tests/runtime-async/async/simple-future/runner.c b/tests/runtime-async/async/simple-future/runner.c
index ad976a30c..2be9b8157 100644
--- a/tests/runtime-async/async/simple-future/runner.c
+++ b/tests/runtime-async/async/simple-future/runner.c
@@ -11,7 +11,7 @@ int main() {
     runner_waitable_status_t status = test_future_void_write(writer);
     assert(status == RUNNER_WAITABLE_STATUS_BLOCKED);
 
-    runner_subtask_status_t subtask = test_async_read_future(reader);
+    runner_subtask_status_t subtask = test_read_future(reader);
     assert(RUNNER_SUBTASK_STATE(subtask) == RUNNER_SUBTASK_RETURNED);
 
     runner_waitable_set_t set = runner_waitable_set_new();
@@ -34,7 +34,7 @@ int main() {
     runner_waitable_status_t status = test_future_void_write(writer);
     assert(status == RUNNER_WAITABLE_STATUS_BLOCKED);
 
-    runner_subtask_status_t subtask = test_async_drop_future(reader);
+    runner_subtask_status_t subtask = test_drop_future(reader);
     assert(RUNNER_SUBTASK_STATE(subtask) == RUNNER_SUBTASK_RETURNED);
 
     runner_waitable_set_t set = runner_waitable_set_new();
diff --git a/tests/runtime-async/async/simple-future/test.c b/tests/runtime-async/async/simple-future/test.c
index d791ca904..a95f67ac8 100644
--- a/tests/runtime-async/async/simple-future/test.c
+++ b/tests/runtime-async/async/simple-future/test.c
@@ -3,25 +3,25 @@
 #include <assert.h>
 #include <test.h>
 
-test_subtask_status_t exports_test_async_read_future(exports_test_future_void_t future) {
+test_subtask_status_t exports_test_read_future(exports_test_future_void_t future) {
   test_waitable_status_t status = exports_test_future_void_read(future);
   assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
   assert(TEST_WAITABLE_COUNT(status) == 0);
   exports_test_future_void_drop_readable(future);
-  exports_test_async_read_future_return();
+  exports_test_read_future_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_read_future_callback(test_event_t *event) {
+test_subtask_status_t exports_test_read_future_callback(test_event_t *event) {
   assert(0);
 }
 
-test_subtask_status_t exports_test_async_drop_future(exports_test_future_void_t future) {
+test_subtask_status_t exports_test_drop_future(exports_test_future_void_t future) {
   exports_test_future_void_drop_readable(future);
-  exports_test_async_drop_future_return();
+  exports_test_drop_future_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_drop_future_callback(test_event_t *event) {
+test_subtask_status_t exports_test_drop_future_callback(test_event_t *event) {
   assert(0);
 }
diff --git a/tests/runtime-async/async/simple-import-params-results/runner.c b/tests/runtime-async/async/simple-import-params-results/runner.c
index fe7854029..d4766016d 100644
--- a/tests/runtime-async/async/simple-import-params-results/runner.c
+++ b/tests/runtime-async/async/simple-import-params-results/runner.c
@@ -4,28 +4,28 @@
 #include <runner.h>
 
 int main() {
-  runner_subtask_status_t status = test_async_one_argument(1);
+  runner_subtask_status_t status = test_one_argument(1);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_RETURNED);
   assert(RUNNER_SUBTASK_HANDLE(status) == 0);
 
   uint32_t result = 0xffffffff;
-  status = test_async_one_result(&result);
+  status = test_one_result(&result);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_RETURNED);
   assert(RUNNER_SUBTASK_HANDLE(status) == 0);
   assert(result == 2);
 
   result = 0xffffffff;
-  status = test_async_one_argument_and_result(3, &result);
+  status = test_one_argument_and_result(3, &result);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_RETURNED);
   assert(RUNNER_SUBTASK_HANDLE(status) == 0);
   assert(result == 4);
 
-  status = test_async_two_arguments(5, 6);
+  status = test_two_arguments(5, 6);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_RETURNED);
   assert(RUNNER_SUBTASK_HANDLE(status) == 0);
 
   result = 0xffffffff;
-  status = test_async_two_arguments_and_result(7, 8, &result);
+  status = test_two_arguments_and_result(7, 8, &result);
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_RETURNED);
   assert(RUNNER_SUBTASK_HANDLE(status) == 0);
   assert(result == 9);
diff --git a/tests/runtime-async/async/simple-import-params-results/test.c b/tests/runtime-async/async/simple-import-params-results/test.c
index bdaad1603..34fab4176 100644
--- a/tests/runtime-async/async/simple-import-params-results/test.c
+++ b/tests/runtime-async/async/simple-import-params-results/test.c
@@ -3,53 +3,53 @@
 #include <assert.h>
 #include <test.h>
 
-test_subtask_status_t exports_test_async_one_argument(uint32_t x) {
+test_subtask_status_t exports_test_one_argument(uint32_t x) {
   assert(x == 1);
-  exports_test_async_one_argument_return();
+  exports_test_one_argument_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_one_argument_callback(test_event_t *event) {
+test_subtask_status_t exports_test_one_argument_callback(test_event_t *event) {
   assert(0);
 }
 
-test_subtask_status_t exports_test_async_one_result() {
-  exports_test_async_one_result_return(2);
+test_subtask_status_t exports_test_one_result() {
+  exports_test_one_result_return(2);
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_one_result_callback(test_event_t *event) {
+test_subtask_status_t exports_test_one_result_callback(test_event_t *event) {
   assert(0);
 }
 
-test_subtask_status_t exports_test_async_one_argument_and_result(uint32_t x) {
+test_subtask_status_t exports_test_one_argument_and_result(uint32_t x) {
   assert(x == 3);
-  exports_test_async_one_argument_and_result_return(4);
+  exports_test_one_argument_and_result_return(4);
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_one_argument_and_result_callback(test_event_t *event) {
+test_subtask_status_t exports_test_one_argument_and_result_callback(test_event_t *event) {
   assert(0);
 }
 
-test_subtask_status_t exports_test_async_two_arguments(uint32_t x, uint32_t y) {
+test_subtask_status_t exports_test_two_arguments(uint32_t x, uint32_t y) {
   assert(x == 5);
   assert(y == 6);
-  exports_test_async_two_arguments_return();
+  exports_test_two_arguments_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_two_arguments_callback(test_event_t *event) {
+test_subtask_status_t exports_test_two_arguments_callback(test_event_t *event) {
   assert(0);
 }
 
-test_subtask_status_t exports_test_async_two_arguments_and_result(uint32_t x, uint32_t y) {
+test_subtask_status_t exports_test_two_arguments_and_result(uint32_t x, uint32_t y) {
   assert(x == 7);
   assert(y == 8);
-  exports_test_async_two_arguments_and_result_return(9);
+  exports_test_two_arguments_and_result_return(9);
   return TEST_CALLBACK_CODE_EXIT;
 }
 
-test_subtask_status_t exports_test_async_two_arguments_and_result_callback(test_event_t *event) {
+test_subtask_status_t exports_test_two_arguments_and_result_callback(test_event_t *event) {
   assert(0);
 }
diff --git a/tests/runtime-async/async/simple-pending-import/runner.c b/tests/runtime-async/async/simple-pending-import/runner.c
index 4c72a1d4b..8c1d9d753 100644
--- a/tests/runtime-async/async/simple-pending-import/runner.c
+++ b/tests/runtime-async/async/simple-pending-import/runner.c
@@ -3,7 +3,7 @@
 #include <runner.h>
 
 int main() {
-  runner_subtask_status_t status = test_async_f();
+  runner_subtask_status_t status = test_f();
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t handle = RUNNER_SUBTASK_HANDLE(status);
   assert(handle != 0);
diff --git a/tests/runtime-async/async/simple-pending-import/test.c b/tests/runtime-async/async/simple-pending-import/test.c
index 1d1cf8440..5b2ac08a2 100644
--- a/tests/runtime-async/async/simple-pending-import/test.c
+++ b/tests/runtime-async/async/simple-pending-import/test.c
@@ -3,14 +3,14 @@
 #include <assert.h>
 #include <test.h>
 
-test_subtask_status_t exports_test_async_f() {
+test_subtask_status_t exports_test_f() {
   return TEST_CALLBACK_CODE_YIELD;
 }
 
-test_subtask_status_t exports_test_async_f_callback(test_event_t *event) {
+test_subtask_status_t exports_test_f_callback(test_event_t *event) {
   assert(event->event == TEST_EVENT_NONE);
   assert(event->waitable == 0);
   assert(event->code == 0);
-  exports_test_async_f_return();
+  exports_test_f_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
diff --git a/tests/runtime-async/async/simple-stream-payload/runner.c b/tests/runtime-async/async/simple-stream-payload/runner.c
index 209ef761a..2669a6f2b 100644
--- a/tests/runtime-async/async/simple-stream-payload/runner.c
+++ b/tests/runtime-async/async/simple-stream-payload/runner.c
@@ -14,7 +14,7 @@ int main() {
   assert(status == RUNNER_WAITABLE_STATUS_BLOCKED);
 
   // Start the subtask
-  runner_subtask_status_t subtask_status = test_async_read_stream(reader);
+  runner_subtask_status_t subtask_status = test_read_stream(reader);
   assert(RUNNER_SUBTASK_STATE(subtask_status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t subtask = RUNNER_SUBTASK_HANDLE(subtask_status);
 
diff --git a/tests/runtime-async/async/simple-stream-payload/test.c b/tests/runtime-async/async/simple-stream-payload/test.c
index 8b9649ebe..e0843eefd 100644
--- a/tests/runtime-async/async/simple-stream-payload/test.c
+++ b/tests/runtime-async/async/simple-stream-payload/test.c
@@ -7,7 +7,7 @@ static test_waitable_set_t SET = 0;
 static exports_test_stream_u8_t STREAM = 0;
 static uint8_t BUF[2];
 
-test_subtask_status_t exports_test_async_read_stream(exports_test_stream_u8_t stream) {
+test_subtask_status_t exports_test_read_stream(exports_test_stream_u8_t stream) {
   test_waitable_status_t status = exports_test_stream_u8_read(stream, BUF, 1);
   assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
   assert(TEST_WAITABLE_COUNT(status) == 1);
@@ -23,7 +23,7 @@ test_subtask_status_t exports_test_async_read_stream(exports_test_stream_u8_t st
   return TEST_CALLBACK_CODE_WAIT(SET);
 }
 
-test_subtask_status_t exports_test_async_read_stream_callback(test_event_t *event) {
+test_subtask_status_t exports_test_read_stream_callback(test_event_t *event) {
   assert(event->event == TEST_EVENT_STREAM_READ);
   assert(event->waitable == STREAM);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
@@ -50,6 +50,6 @@ test_subtask_status_t exports_test_async_read_stream_callback(test_event_t *even
 
   test_waitable_set_drop(SET);
 
-  exports_test_async_read_stream_return();
+  exports_test_read_stream_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
diff --git a/tests/runtime-async/async/simple-stream/runner.c b/tests/runtime-async/async/simple-stream/runner.c
index 9e7bfdfe9..0476043ac 100644
--- a/tests/runtime-async/async/simple-stream/runner.c
+++ b/tests/runtime-async/async/simple-stream/runner.c
@@ -12,7 +12,7 @@ int main() {
   assert(status == RUNNER_WAITABLE_STATUS_BLOCKED);
 
   // Start the subtask
-  runner_subtask_status_t subtask_status = test_async_read_stream(reader);
+  runner_subtask_status_t subtask_status = test_read_stream(reader);
   assert(RUNNER_SUBTASK_STATE(subtask_status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t subtask = RUNNER_SUBTASK_HANDLE(subtask_status);
 
diff --git a/tests/runtime-async/async/simple-stream/test.c b/tests/runtime-async/async/simple-stream/test.c
index e0c875a25..ba36f02f7 100644
--- a/tests/runtime-async/async/simple-stream/test.c
+++ b/tests/runtime-async/async/simple-stream/test.c
@@ -6,7 +6,7 @@
 test_waitable_set_t SET = 0;
 exports_test_stream_void_t STREAM = 0;
 
-test_subtask_status_t exports_test_async_read_stream(exports_test_stream_void_t stream) {
+test_subtask_status_t exports_test_read_stream(exports_test_stream_void_t stream) {
   test_waitable_status_t status = exports_test_stream_void_read(stream, 1);
   assert(TEST_WAITABLE_STATE(status) == TEST_WAITABLE_COMPLETED);
   assert(TEST_WAITABLE_COUNT(status) == 1);
@@ -21,7 +21,7 @@ test_subtask_status_t exports_test_async_read_stream(exports_test_stream_void_t
   return TEST_CALLBACK_CODE_WAIT(SET);
 }
 
-test_subtask_status_t exports_test_async_read_stream_callback(test_event_t *event) {
+test_subtask_status_t exports_test_read_stream_callback(test_event_t *event) {
   assert(event->event == TEST_EVENT_STREAM_READ);
   assert(event->waitable == STREAM);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);
@@ -32,6 +32,6 @@ test_subtask_status_t exports_test_async_read_stream_callback(test_event_t *even
 
   test_waitable_set_drop(SET);
 
-  exports_test_async_read_stream_return();
+  exports_test_read_stream_return();
   return TEST_CALLBACK_CODE_EXIT;
 }
diff --git a/tests/runtime-async/async/simple-yield/runner.c b/tests/runtime-async/async/simple-yield/runner.c
index b0db671cc..e1c9ec2f1 100644
--- a/tests/runtime-async/async/simple-yield/runner.c
+++ b/tests/runtime-async/async/simple-yield/runner.c
@@ -3,7 +3,7 @@
 #include <runner.h>
 
 int main() {
-  runner_subtask_status_t status = test_async_f();
+  runner_subtask_status_t status = test_f();
   assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
   runner_subtask_t task = RUNNER_SUBTASK_HANDLE(status);
 
diff --git a/tests/runtime-async/async/simple-yield/test.c b/tests/runtime-async/async/simple-yield/test.c
index c23180c18..fd8a52e79 100644
--- a/tests/runtime-async/async/simple-yield/test.c
+++ b/tests/runtime-async/async/simple-yield/test.c
@@ -4,15 +4,15 @@
 #include <test.h>
 #include <stdio.h>
 
-test_subtask_status_t exports_test_async_f() {
+test_subtask_status_t exports_test_f() {
   return TEST_CALLBACK_CODE_YIELD;
 }
 
-test_subtask_status_t exports_test_async_f_callback(test_event_t *event) {
+test_subtask_status_t exports_test_f_callback(test_event_t *event) {
   assert(event->event == TEST_EVENT_NONE);
   assert(event->waitable == 0);
   assert(event->code == 0);
   test_yield();
-  exports_test_async_f_return();
+  exports_test_f_return();
   return TEST_CALLBACK_CODE_EXIT;
 }