diff --git a/include/SDL3/SDL_asyncio.h b/include/SDL3/SDL_asyncio.h
index 3c983913df..a366cd9371 100644
--- a/include/SDL3/SDL_asyncio.h
+++ b/include/SDL3/SDL_asyncio.h
@@ -144,7 +144,7 @@ typedef enum SDL_AsyncIOResult
 {
     SDL_ASYNCIO_COMPLETE,  /**< request was completed without error */
     SDL_ASYNCIO_FAILURE,   /**< request failed for some reason; check SDL_GetError()! */
-    SDL_ASYNCIO_CANCELLED  /**< request was cancelled before completing. */
+    SDL_ASYNCIO_CANCELED   /**< request was canceled before completing. */
 } SDL_AsyncIOResult;
 
 /**
diff --git a/src/file/generic/SDL_asyncio_generic.c b/src/file/generic/SDL_asyncio_generic.c
index 9c1e442dcd..749b2cac27 100644
--- a/src/file/generic/SDL_asyncio_generic.c
+++ b/src/file/generic/SDL_asyncio_generic.c
@@ -64,7 +64,7 @@ static void AsyncIOTaskComplete(SDL_AsyncIOTask *task)
 // This is called directly, without a threadpool, if !SDL_ASYNCIO_USE_THREADPOOL.
 static void SynchronousIO(SDL_AsyncIOTask *task)
 {
-    SDL_assert(task->result != SDL_ASYNCIO_CANCELLED);  // shouldn't have gotten in here if cancelled!
+    SDL_assert(task->result != SDL_ASYNCIO_CANCELED);  // shouldn't have gotten in here if canceled!
 
     GenericAsyncIOData *data = (GenericAsyncIOData *) task->asyncio->userdata;
     SDL_IOStream *io = data->io;
@@ -184,7 +184,7 @@ static void QueueAsyncIOTask(SDL_AsyncIOTask *task)
     SDL_LockMutex(threadpool_lock);
 
     if (stop_threadpool) {  // just in case.
-        task->result = SDL_ASYNCIO_CANCELLED;
+        task->result = SDL_ASYNCIO_CANCELED;
         AsyncIOTaskComplete(task);
     } else {
         LINKED_LIST_PREPEND(task, threadpool_tasks, threadpool);
@@ -239,7 +239,7 @@ static void ShutdownThreadpool(void)
         SDL_AsyncIOTask *task;
         while ((task = LINKED_LIST_START(threadpool_tasks, threadpool)) != NULL) {
             LINKED_LIST_UNLINK(task, threadpool);
-            task->result = SDL_ASYNCIO_CANCELLED;
+            task->result = SDL_ASYNCIO_CANCELED;
             AsyncIOTaskComplete(task);
         }
 
@@ -300,14 +300,14 @@ static bool generic_asyncioqueue_queue_task(void *userdata, SDL_AsyncIOTask *tas
 static void generic_asyncioqueue_cancel_task(void *userdata, SDL_AsyncIOTask *task)
 {
     #if !SDL_ASYNCIO_USE_THREADPOOL  // in theory, this was all synchronous and should never call this, but just in case.
-    task->result = SDL_ASYNCIO_CANCELLED;
+    task->result = SDL_ASYNCIO_CANCELED;
     AsyncIOTaskComplete(task);
     #else
     // we can't stop i/o that's in-flight, but we _can_ just refuse to start it if the threadpool hadn't picked it up yet.
     SDL_LockMutex(threadpool_lock);
     if (LINKED_LIST_PREV(task, threadpool) != NULL) {  // still in the queue waiting to be run? Take it out.
         LINKED_LIST_UNLINK(task, threadpool);
-        task->result = SDL_ASYNCIO_CANCELLED;
+        task->result = SDL_ASYNCIO_CANCELED;
         AsyncIOTaskComplete(task);
     }
     SDL_UnlockMutex(threadpool_lock);
diff --git a/src/file/io_uring/SDL_asyncio_liburing.c b/src/file/io_uring/SDL_asyncio_liburing.c
index b4544fd08c..40fef7f553 100644
--- a/src/file/io_uring/SDL_asyncio_liburing.c
+++ b/src/file/io_uring/SDL_asyncio_liburing.c
@@ -225,7 +225,7 @@ static SDL_AsyncIOTask *ProcessCQE(LibUringAsyncIOQueueData *queuedata, struct i
             task = (SDL_AsyncIOTask *) cancel_task->app_userdata;
             SDL_free(cancel_task);
             if (cqe->res >= 0) {  // cancel was successful?
-                task->result = SDL_ASYNCIO_CANCELLED;
+                task->result = SDL_ASYNCIO_CANCELED;
             } else {
                 task = NULL; // it already finished or was too far along to cancel, so we'll pick up the actual results later.
             }
diff --git a/src/file/windows/SDL_asyncio_windows_ioring.c b/src/file/windows/SDL_asyncio_windows_ioring.c
index 48ff25f1bc..fcf03501b0 100644
--- a/src/file/windows/SDL_asyncio_windows_ioring.c
+++ b/src/file/windows/SDL_asyncio_windows_ioring.c
@@ -195,7 +195,7 @@ static SDL_AsyncIOTask *ProcessCQE(WinIoRingAsyncIOQueueData *queuedata, IORING_
             task = (SDL_AsyncIOTask *) cancel_task->app_userdata;
             SDL_free(cancel_task);
             if (SUCCEEDED(cqe->ResultCode)) {  // cancel was successful?
-                task->result = SDL_ASYNCIO_CANCELLED;
+                task->result = SDL_ASYNCIO_CANCELED;
             } else {
                 task = NULL; // it already finished or was too far along to cancel, so we'll pick up the actual results later.
             }
diff --git a/test/testasyncio.c b/test/testasyncio.c
index b330b4a9a4..43a95c4ca6 100644
--- a/test/testasyncio.c
+++ b/test/testasyncio.c
@@ -139,7 +139,7 @@ static void async_io_task_complete(const SDL_AsyncIOOutcome *outcome)
         #define RESCASE(x) case x: resultstr = #x; break
         RESCASE(SDL_ASYNCIO_COMPLETE);
         RESCASE(SDL_ASYNCIO_FAILURE);
-        RESCASE(SDL_ASYNCIO_CANCELLED);
+        RESCASE(SDL_ASYNCIO_CANCELED);
         #undef RESCASE
     }