diff --git a/src/main/emscripten/SDL_sysmain_callbacks.c b/src/main/emscripten/SDL_sysmain_callbacks.c
index babffb3b75..059e910c74 100644
--- a/src/main/emscripten/SDL_sysmain_callbacks.c
+++ b/src/main/emscripten/SDL_sysmain_callbacks.c
@@ -24,9 +24,61 @@
 
 #include <emscripten.h>
 
+// For Emscripten, we let you use SDL_HINT_MAIN_CALLBACK_RATE, because it might be useful to drop it super-low for
+//  things like loopwave that don't really do much but wait on the audio device, but be warned that browser timers
+//  are super-unreliable in modern times, so you likely won't hit your desired callback rate with good precision.
+// Almost all apps should leave this alone, so we can use requestAnimationFrame, which is intended to run reliably
+//  at the refresh rate of the user's display.
+static Uint32 callback_rate_increment = 0;
+static bool iterate_after_waitevent = false;
+static bool callback_rate_changed = false;
+static void SDLCALL MainCallbackRateHintChanged(void *userdata, const char *name, const char *oldValue, const char *newValue)
+{
+    callback_rate_changed = true;
+    iterate_after_waitevent = newValue && (SDL_strcmp(newValue, "waitevent") == 0);
+    if (iterate_after_waitevent) {
+        callback_rate_increment = 0;
+    } else {
+        const double callback_rate = newValue ? SDL_atof(newValue) : 0.0;
+        if (callback_rate > 0.0) {
+            callback_rate_increment = (Uint32) SDL_NS_TO_MS((double) SDL_NS_PER_SECOND / callback_rate);
+        } else {
+            callback_rate_increment = 0;
+        }
+    }
+}
+
+// just tell us when any new event is pushed on the queue, so we can check a flag for "waitevent" mode.
+static bool saw_new_event = false;
+static bool SDLCALL EmscriptenMainCallbackEventWatcher(void *userdata, SDL_Event *event)
+{
+    saw_new_event = true;
+    return true;
+}
+
 static void EmscriptenInternalMainloop(void)
 {
-    const SDL_AppResult rc = SDL_IterateMainCallbacks(true);
+    // callback rate changed? Update emscripten's mainloop iteration speed.
+    if (callback_rate_changed) {
+        callback_rate_changed = false;
+        if (callback_rate_increment == 0) {
+            emscripten_set_main_loop_timing(EM_TIMING_RAF, 1);
+        } else {
+            emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, callback_rate_increment);
+        }
+    }
+
+    if (iterate_after_waitevent) {
+        SDL_PumpEvents();
+        if (!saw_new_event) {
+            // do nothing yet. Note that we're still going to iterate here because we can't block,
+            // but we can stop the app's iteration from progressing until there's an event.
+            return;
+        }
+        saw_new_event = false;
+    }
+
+    const SDL_AppResult rc = SDL_IterateMainCallbacks(!iterate_after_waitevent);
     if (rc != SDL_APP_CONTINUE) {
         SDL_QuitMainCallbacks(rc);
         emscripten_cancel_main_loop();  // kill" the mainloop, so it stops calling back into it.
@@ -36,9 +88,18 @@ static void EmscriptenInternalMainloop(void)
 
 int SDL_EnterAppMainCallbacks(int argc, char *argv[], SDL_AppInit_func appinit, SDL_AppIterate_func appiter, SDL_AppEvent_func appevent, SDL_AppQuit_func appquit)
 {
-    const SDL_AppResult rc = SDL_InitMainCallbacks(argc, argv, appinit, appiter, appevent, appquit);
+    SDL_AppResult rc = SDL_InitMainCallbacks(argc, argv, appinit, appiter, appevent, appquit);
     if (rc == SDL_APP_CONTINUE) {
-        emscripten_set_main_loop(EmscriptenInternalMainloop, 0, 0);  // run at refresh rate, don't throw an exception since we do an orderly return.
+        if (!SDL_AddEventWatch(EmscriptenMainCallbackEventWatcher, NULL)) {
+            rc = SDL_APP_FAILURE;
+        } else {
+            SDL_AddHintCallback(SDL_HINT_MAIN_CALLBACK_RATE, MainCallbackRateHintChanged, NULL);
+            callback_rate_changed = false;
+            emscripten_set_main_loop(EmscriptenInternalMainloop, 0, 0);  // don't throw an exception since we do an orderly return.
+            if (callback_rate_increment > 0.0) {
+                emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, callback_rate_increment);
+            }
+        }
     } else {
         SDL_QuitMainCallbacks(rc);
     }
diff --git a/src/video/emscripten/SDL_emscriptenopengles.c b/src/video/emscripten/SDL_emscriptenopengles.c
index bb490bb016..39faf2fb01 100644
--- a/src/video/emscripten/SDL_emscriptenopengles.c
+++ b/src/video/emscripten/SDL_emscriptenopengles.c
@@ -28,6 +28,7 @@
 
 #include "SDL_emscriptenvideo.h"
 #include "SDL_emscriptenopengles.h"
+#include "../../main/SDL_main_callbacks.h"
 
 bool Emscripten_GLES_LoadLibrary(SDL_VideoDevice *_this, const char *path)
 {
@@ -50,10 +51,14 @@ bool Emscripten_GLES_SetSwapInterval(SDL_VideoDevice *_this, int interval)
     }
 
     if (Emscripten_ShouldSetSwapInterval(interval)) {
-        if (interval == 0) {
-            emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, 0);
-        } else {
-            emscripten_set_main_loop_timing(EM_TIMING_RAF, interval);
+        // don't change the mainloop timing if the app is also driving a main callback with this hint,
+        //  as we assume that was the more deliberate action.
+        if (!SDL_HasMainCallbacks() || !SDL_GetHint(SDL_HINT_MAIN_CALLBACK_RATE)) {
+            if (interval == 0) {
+                emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, 0);
+            } else {
+                emscripten_set_main_loop_timing(EM_TIMING_RAF, interval);
+            }
         }
     }