diff --git a/README.md b/README.md
index 4a6171d9..735c64b9 100644
--- a/README.md
+++ b/README.md
@@ -88,7 +88,7 @@ for complete device setup.
 ## App ownership
 
 Board configs describe hardware. They export neutral pieces such as
-`display_drv`, `touch_read`, `host_read`, and `timer_async`; they do not create
+`display_drv`, `touch_read`, and `host_read`; they do not create
 an application-level `appdev.App`.
 
 Non-LVGL examples in this repo opt into the optional `appdev` coordinator:
diff --git a/lib/examples/alien/alien.py b/lib/examples/alien/alien.py
index 8b002476..72160076 100644
--- a/lib/examples/alien/alien.py
+++ b/lib/examples/alien/alien.py
@@ -90,5 +90,5 @@ def _tick(_=None):
         tft_bitmap.bitmap(tft, alien, col, row)
         st["last_col"], st["old_row"] = col, row
 
-    app.every(_tick, period=10, async_=app.timer_async)
+    app.every(_tick, period=10)
 main()
\ No newline at end of file
diff --git a/lib/examples/apollo/apollo.py b/lib/examples/apollo/apollo.py
index e5ae96a6..ef2eb12c 100644
--- a/lib/examples/apollo/apollo.py
+++ b/lib/examples/apollo/apollo.py
@@ -143,4 +143,4 @@ def _tick(_=None):
 
 
 _init_apollo()
-app.every(_tick, period=20, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=20)
\ No newline at end of file
diff --git a/lib/examples/appdev_simpletest.py b/lib/examples/appdev_simpletest.py
index 3e1747e2..adef02f7 100644
--- a/lib/examples/appdev_simpletest.py
+++ b/lib/examples/appdev_simpletest.py
@@ -14,7 +14,7 @@ def _on_event(e):
 
 
 print("appdev_simpletest: started — click the canvas to see pointer events")
-app.every(_heartbeat, period=2000, async_=app.timer_async)
+app.every(_heartbeat, period=2000)
 
 # Subscribe broadly via device type so any pointer/key event prints.
 for et in (
diff --git a/lib/examples/appdev_touch_coords.py b/lib/examples/appdev_touch_coords.py
index f893974b..93a6a5ce 100644
--- a/lib/examples/appdev_touch_coords.py
+++ b/lib/examples/appdev_touch_coords.py
@@ -11,7 +11,7 @@
 import appdev
 import events
 
-from multimer import auto as timer
+import multimer
 
 FG, BG, ARM = 0xFFFF, 0x0000, 12
 W, H = display_drv.width, display_drv.height
@@ -66,13 +66,13 @@ def _on_up(e):
             % (gx, gy, tx, ty, gx - tx, gy - ty)
         )
         idx += 1
-        timer.sleep_ms(400)
+        multimer.sleep_ms(400)
         if idx >= len(TARGETS):
             _out("done %s" % (results,))
             display_drv.fill_rect(0, 0, W, H, BG)
         else:
             _show()
-            timer.sleep_ms(400)
+            multimer.sleep_ms(400)
     finally:
         _busy = False
 
diff --git a/lib/examples/audiolive_rack.py b/lib/examples/audiolive_rack.py
index ffaa12f0..99a80a4e 100644
--- a/lib/examples/audiolive_rack.py
+++ b/lib/examples/audiolive_rack.py
@@ -379,6 +379,6 @@ def _on_quit(_e=None):
 app.on(app.events.QUIT, _on_quit)
 
 _draw_tick()
-app.every(_audio_tick, period=AUDIO_MS, async_=app.timer_async)
-app.every(_draw_tick, period=DRAW_MS, async_=app.timer_async)
-app.every(_next_patch, period=PATCH_MS, async_=app.timer_async)
+app.every(_audio_tick, period=AUDIO_MS)
+app.every(_draw_tick, period=DRAW_MS)
+app.every(_next_patch, period=PATCH_MS)
diff --git a/lib/examples/bmp565_scroll.py b/lib/examples/bmp565_scroll.py
index bd34750d..3e42d65e 100644
--- a/lib/examples/bmp565_scroll.py
+++ b/lib/examples/bmp565_scroll.py
@@ -43,7 +43,7 @@ def _tick(_=None):
         draw_bg(0, i % display_drv.height, 0, i % image.height)
         st["i"] = i + 1
 
-    app.every(_tick, period=1, async_=app.timer_async)
+    app.every(_tick, period=1)
 
 
 main()
\ No newline at end of file
diff --git a/lib/examples/bmp565_scroll_sprite.py b/lib/examples/bmp565_scroll_sprite.py
index 8247da40..7fbc0052 100644
--- a/lib/examples/bmp565_scroll_sprite.py
+++ b/lib/examples/bmp565_scroll_sprite.py
@@ -118,7 +118,7 @@ def _tick(_=None):
 
     app.on(app.events.MOUSEMOTION, _on_motion)
     # ~20 fps once scrolling; first columns also tick so quit is always serviced.
-    app.every(_tick, period=50, async_=app.timer_async)
+    app.every(_tick, period=50)
 
 
 main()
\ No newline at end of file
diff --git a/lib/examples/bmp565_sprite.py b/lib/examples/bmp565_sprite.py
index 95eefa83..3f8adfa0 100644
--- a/lib/examples/bmp565_sprite.py
+++ b/lib/examples/bmp565_sprite.py
@@ -103,4 +103,4 @@ def _tick(_=None):
     st["pos_i"] = (st["pos_i"] + 1) % len(positions)
 
 
-app.every(_tick, period=100, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=100)
\ No newline at end of file
diff --git a/lib/examples/bmp565_sprite_transparent.py b/lib/examples/bmp565_sprite_transparent.py
index 44d4c204..5f4e8416 100644
--- a/lib/examples/bmp565_sprite_transparent.py
+++ b/lib/examples/bmp565_sprite_transparent.py
@@ -102,4 +102,4 @@ def _tick(_=None):
     st["pos_i"] = (st["pos_i"] + 1) % len(positions)
 
 
-app.every(_tick, period=100, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=100)
\ No newline at end of file
diff --git a/lib/examples/bouncing_balls.py b/lib/examples/bouncing_balls.py
index 31fa5397..835c2e16 100644
--- a/lib/examples/bouncing_balls.py
+++ b/lib/examples/bouncing_balls.py
@@ -103,4 +103,4 @@ def _tick(_=None):
         pygraphics.circle(display_drv, int(ball.x), int(ball.y), ball.r, ball.color, True)
 
 
-app.every(_tick, period=10, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=10)
\ No newline at end of file
diff --git a/lib/examples/boxlines.py b/lib/examples/boxlines.py
index 7bfdeb7f..92722078 100644
--- a/lib/examples/boxlines.py
+++ b/lib/examples/boxlines.py
@@ -82,4 +82,4 @@ def _tick(_=None):
     poll()
 
 
-app.every(_tick, period=1, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=1)
\ No newline at end of file
diff --git a/lib/examples/calc_graphics.py b/lib/examples/calc_graphics.py
index d12a690d..a4ad3ec8 100644
--- a/lib/examples/calc_graphics.py
+++ b/lib/examples/calc_graphics.py
@@ -25,7 +25,7 @@
 from calc_engine import CalcEngine
 import keys
 from pygraphics import RGB565, FrameBuffer
-from multimer import auto as timer
+import multimer
 from palettes import get_palette
 from appdev import TouchGrid
 
@@ -122,7 +122,7 @@ def __init__(self):
         # have no grid cell so the touch mapping never indexes them.
         keypad_keys = [None] * self.COLS + list(_CODES) + list(_KEY_ALIASES.keys())
         self._pending_release = None
-        self._release_timer = timer.Timer(-1)
+        self._release_timer = multimer.Timer(-1)
         self.keypad = TouchGrid(
             app,
             0,
@@ -264,7 +264,7 @@ def _on_press(self, code):
             self._handle_press(col, row, label)
             self._pending_release = (col, row, label)
             self._release_timer.init(
-                mode=timer.Timer.ONE_SHOT, period=150, callback=self._release
+                mode=multimer.Timer.ONE_SHOT, period=150, callback=self._release
             )
             return
         # Keyboard alias / digit without a grid cell — feed the engine only.
diff --git a/lib/examples/car_cluster/car_cluster.py b/lib/examples/car_cluster/car_cluster.py
index d6e9e179..85d4501d 100644
--- a/lib/examples/car_cluster/car_cluster.py
+++ b/lib/examples/car_cluster/car_cluster.py
@@ -143,7 +143,7 @@ def _drain_rails(_t):
             if _ui is not None and _ui.rails is not None:
                 _ui.rails.drain_pending()
 
-        app.on_tick(_drain_rails, period=30, async_=False)
+        app.on_tick(_drain_rails, period=30)
         _ui.rails.drain_pending()
         if _FREEZE:
             freeze(True)
diff --git a/lib/examples/color_test.py b/lib/examples/color_test.py
index 761d13cc..a2d0f44f 100644
--- a/lib/examples/color_test.py
+++ b/lib/examples/color_test.py
@@ -99,5 +99,5 @@ def poll():
     def _tick(_=None):
         poll()
 
-    app.every(_tick, period=1000, async_=app.timer_async)
+    app.every(_tick, period=1000)
 main()
\ No newline at end of file
diff --git a/lib/examples/dino.py b/lib/examples/dino.py
index fc97720d..bad781f2 100644
--- a/lib/examples/dino.py
+++ b/lib/examples/dino.py
@@ -545,5 +545,5 @@ def _tick(timer=None):
     game.tick(timer)
 
 
-_tick_subscription = app.every(_tick, period=FRAME_MS, async_=app.timer_async)
+_tick_subscription = app.every(_tick, period=FRAME_MS)
 game.draw()
\ No newline at end of file
diff --git a/lib/examples/displaysys_block_test.py b/lib/examples/displaysys_block_test.py
index 49207932..0ae5cbb1 100644
--- a/lib/examples/displaysys_block_test.py
+++ b/lib/examples/displaysys_block_test.py
@@ -80,4 +80,4 @@ def _tick(_=None):
         app.request_quit()
 
 
-app.every(_tick, period=1, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=1)
\ No newline at end of file
diff --git a/lib/examples/displaysys_fill_rect_test.py b/lib/examples/displaysys_fill_rect_test.py
index 0ea0f814..fb124864 100644
--- a/lib/examples/displaysys_fill_rect_test.py
+++ b/lib/examples/displaysys_fill_rect_test.py
@@ -65,4 +65,4 @@ def _tick(_=None):
         app.request_quit()
 
 
-app.every(_tick, period=1, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=1)
\ No newline at end of file
diff --git a/lib/examples/feathers.py b/lib/examples/feathers.py
index 6851b297..9494b6fd 100644
--- a/lib/examples/feathers.py
+++ b/lib/examples/feathers.py
@@ -123,4 +123,4 @@ def _tick(_=None):
     poll()
 
 
-app.every(_tick, period=1, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=1)
\ No newline at end of file
diff --git a/lib/examples/font_simpletest.py b/lib/examples/font_simpletest.py
index 4e0a5f01..d9612b12 100644
--- a/lib/examples/font_simpletest.py
+++ b/lib/examples/font_simpletest.py
@@ -139,7 +139,7 @@ def main():
     def _tick(_=None):
         poll()
 
-    app.every(_tick, period=1, async_=app.timer_async)
+    app.every(_tick, period=1)
 
 
 main()
\ No newline at end of file
diff --git a/lib/examples/fonts.py b/lib/examples/fonts.py
index ff4f21a7..16e227e0 100644
--- a/lib/examples/fonts.py
+++ b/lib/examples/fonts.py
@@ -105,5 +105,5 @@ def main():
     def _tick(_=None):
         poll()
 
-    app.every(_tick, period=1, async_=app.timer_async)
+    app.every(_tick, period=1)
 main()
\ No newline at end of file
diff --git a/lib/examples/google_photos/google_photos.py b/lib/examples/google_photos/google_photos.py
index 1cf6da75..9d2152c6 100644
--- a/lib/examples/google_photos/google_photos.py
+++ b/lib/examples/google_photos/google_photos.py
@@ -115,7 +115,7 @@ def _block_if_batch():
     path, MCU REPL, PyScript, the example kit) keeps the app alive by itself.
     """
     try:
-        from appdev import _hostloop
+        from multimer import _hostloop
         from display_driver import app
 
         if not _launched_with_m(_hostloop) or _hostloop.ambient():
@@ -124,19 +124,16 @@ def _block_if_batch():
             return
     except Exception:
         return
-    if app.strategy != _hostloop.AMBIENT or app.timer_async:
-        app.run()  # "none": blocking service loop (async timers: asyncio.run)
+    if app.strategy != _hostloop.AMBIENT:
+        app.run()  # "none": blocking service loop
         return
     # "ambient" was chosen at import time; the timer already drives the app,
-    # so just hold the main thread until the window closes. Hold it with the
-    # timer backend's own sleep, never time.sleep: on Windows the timer fires
-    # only while this thread is in an alertable wait (SleepEx), and a plain
-    # time.sleep starves it -- the window then never repaints and Windows
-    # marks it "Not Responding".
-    from multimer import auto as timer
+    # so just hold the main thread until the window closes, delivering on
+    # the way (multimer.sleep_ms serves the timers on every host).
+    import multimer
 
     while not app.quit_requested:
-        timer.sleep_ms(50)
+        multimer.sleep_ms(50)
 
 
 def _launched_with_m(_hostloop):
diff --git a/lib/examples/hello.py b/lib/examples/hello.py
index 8308286c..5c90da97 100644
--- a/lib/examples/hello.py
+++ b/lib/examples/hello.py
@@ -99,5 +99,5 @@ def main():
     def _tick(_=None):
         poll()
 
-    app.every(_tick, period=1, async_=app.timer_async)
+    app.every(_tick, period=1)
 main()
\ No newline at end of file
diff --git a/lib/examples/lv_test_timer.py b/lib/examples/lv_test_timer.py
index 4ec67a80..a5dd8405 100644
--- a/lib/examples/lv_test_timer.py
+++ b/lib/examples/lv_test_timer.py
@@ -38,7 +38,7 @@
 
 from board_config import display_drv
 from displaydev import env_get
-from multimer import auto as timer
+import multimer
 
 # Optional logical orientation for LVGL (hw MADCTL/SDL/PG or software rotate).
 _lv_rot = env_get("PYDEVICES_LV_ROTATION")
@@ -61,7 +61,7 @@
 
 
 def _mode_label():
-    return "async" if getattr(app, "timer_async", False) else "sync"
+    return multimer.info().get("source") or "sync"
 
 
 def get_state():
@@ -124,18 +124,9 @@ def _lvgl_label():
 
 
 def _timer_type():
-    # Deliberately not named ``timer``: that would shadow the module-level
-    # ``multimer.auto`` import this function falls back to, and the fallback
-    # then reads None on any provider that has not armed yet.
-    armed = getattr(app, "_timer", None)
-    if armed is not None:
-        return _format_timer_type(type(armed))
-    try:
-        from multimer import AsyncTimer
-
-        return _format_timer_type(AsyncTimer if app.timer_async else timer.Timer)
-    except ImportError:
-        return "?"
+    # multimer has one Timer class; what differs per host is the wake source.
+    info = multimer.info()
+    return "%s/%s" % (info.get("source"), info.get("delivery"))
 
 
 def get_platform_info():
@@ -285,9 +276,8 @@ def mock_read():
     try:
         deadline = time.time() + 1.5
         while (pending or get_state()["taps"] < 1) and time.time() < deadline:
-            # Pump: the host queue is drained from the app tick, which
-            # pump-based backends only deliver while the main thread sleeps here.
-            timer.sleep_ms(10)
+            # multimer.sleep_ms delivers on every host while this thread waits.
+            multimer.sleep_ms(10)
     finally:
         queue_dev._read = orig_read
     return get_state()["taps"]
@@ -364,10 +354,9 @@ def _run_kit_sync():
     deadline = time.time() + _DURATION_S
     clicked_taps = None
     while time.time() < deadline:
-        # timer.sleep_ms, not time.sleep: pump-based backends (threading on
-        # CircuitPython / Windows CPython, SDL2) deliver callbacks only
-        # while the main thread pumps. For librt this resolves to a plain sleep.
-        timer.sleep_ms(10)
+        # multimer.sleep_ms, not time.sleep: a host with no wake source
+        # (CircuitPython) delivers only while this thread waits here.
+        multimer.sleep_ms(10)
         if clicked_taps is None and get_state()["seconds"] >= 2:
             cx, cy = _button_center(btn)
             clicked_taps = _inject_click(cx, cy)
@@ -405,7 +394,7 @@ def run_kit():
     ``app.poll()`` while LVGL owns the host queue.
     """
     try:
-        if app.timer_async:
+        if multimer.loop_running():
             payload = app.run_async(_run_kit_async)
             if payload is not None and hasattr(payload, "done"):
                 _quit_and_exit(1)
diff --git a/lib/examples/palettes_demo.py b/lib/examples/palettes_demo.py
index 3c6628d0..da0af2c2 100644
--- a/lib/examples/palettes_demo.py
+++ b/lib/examples/palettes_demo.py
@@ -149,4 +149,4 @@ def _tick(_=None):
     poll()
 
 
-app.every(_tick, period=1, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=1)
\ No newline at end of file
diff --git a/lib/examples/pixel_sim_demos.py b/lib/examples/pixel_sim_demos.py
index 89ae26df..e4795885 100644
--- a/lib/examples/pixel_sim_demos.py
+++ b/lib/examples/pixel_sim_demos.py
@@ -443,4 +443,4 @@ def _tick(_=None):
         _next_at = now
 
 
-app.every(_tick, period=1, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=1)
\ No newline at end of file
diff --git a/lib/examples/proverbs/proverbs.py b/lib/examples/proverbs/proverbs.py
index 0bf8eb0c..adcdbdc7 100644
--- a/lib/examples/proverbs/proverbs.py
+++ b/lib/examples/proverbs/proverbs.py
@@ -108,7 +108,7 @@ def _tick(_=None):
 
         st["index"] = (st["index"] + 1) % len(proverbs)
 
-    app.every(_tick, period=5000, async_=app.timer_async)
+    app.every(_tick, period=5000)
 
 
 main()
\ No newline at end of file
diff --git a/lib/examples/pydevices_demo.py b/lib/examples/pydevices_demo.py
index a37a9853..3cf35d23 100644
--- a/lib/examples/pydevices_demo.py
+++ b/lib/examples/pydevices_demo.py
@@ -152,5 +152,5 @@ def _on_click(e):
 
 setup_scroll()
 redraw()
-app.every(_scroll_tick, period=40, async_=app.timer_async)
+app.every(_scroll_tick, period=40)
 app.on(app.events.MOUSEBUTTONDOWN, _on_click)
\ No newline at end of file
diff --git a/lib/examples/roku_remote/roku_graphics.py b/lib/examples/roku_remote/roku_graphics.py
index 531c3b59..74f9f23a 100644
--- a/lib/examples/roku_remote/roku_graphics.py
+++ b/lib/examples/roku_remote/roku_graphics.py
@@ -43,7 +43,7 @@
 app = appdev.App(board_config)
 import keys
 from pygraphics import RGB565, Area, FrameBuffer
-from multimer import auto as timer
+import multimer
 from roku_engine import (
     FRONTEND_BUTTONS,
     app_label,
@@ -223,7 +223,7 @@ def __init__(self, engine=None, start_page="devices"):
 
         self.buttons = []
         self._by_id = {}
-        self._status_timer = timer.Timer(-1)
+        self._status_timer = multimer.Timer(-1)
         self._pending_status = None
         self._pending_state = None
         self._playback_busy = False
@@ -311,7 +311,7 @@ def _soft():
         # Must not call Timer.deinit from this callback (librt deadlock).
         try:
             self._status_timer.init(
-                mode=timer.Timer.PERIODIC,
+                mode=multimer.Timer.PERIODIC,
                 period=250,
                 callback=self._status_pump,
                 hard=False,
diff --git a/lib/examples/roku_remote/roku_widgets.py b/lib/examples/roku_remote/roku_widgets.py
index 2de16c39..035907fb 100644
--- a/lib/examples/roku_remote/roku_widgets.py
+++ b/lib/examples/roku_remote/roku_widgets.py
@@ -297,7 +297,6 @@ def __init__(self, engine=None, start_page="devices"):
             self._pump_sub = self.app.every(
                 self._pump,
                 period=250,
-                async_=getattr(self.app, "timer_async", False),
             )
         except Exception:
             self._pump_sub = None
diff --git a/lib/examples/rotations.py b/lib/examples/rotations.py
index c3b326e0..5be70617 100644
--- a/lib/examples/rotations.py
+++ b/lib/examples/rotations.py
@@ -77,7 +77,7 @@ def poll():
     def _tick(_=None):
         poll()
 
-    app.every(_tick, period=2000, async_=app.timer_async)
+    app.every(_tick, period=2000)
 
 
 main()
\ No newline at end of file
diff --git a/lib/examples/scroll.py b/lib/examples/scroll.py
index a0556782..840bb2e7 100644
--- a/lib/examples/scroll.py
+++ b/lib/examples/scroll.py
@@ -80,4 +80,4 @@ def _tick(_=None):
     poll()
 
 
-app.every(_tick, period=10, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=10)
\ No newline at end of file
diff --git a/lib/examples/scroll_touch_test.py b/lib/examples/scroll_touch_test.py
index 073be470..e0df4430 100644
--- a/lib/examples/scroll_touch_test.py
+++ b/lib/examples/scroll_touch_test.py
@@ -104,4 +104,4 @@ def _on_mode_tick(_=None):
 
 _rebuild()
 app.on(app.events.MOUSEBUTTONDOWN, _on_click)
-app.every(_on_mode_tick, period=100, async_=app.timer_async)
\ No newline at end of file
+app.every(_on_mode_tick, period=100)
\ No newline at end of file
diff --git a/lib/examples/simon.py b/lib/examples/simon.py
index 29d8fc57..23b18e02 100644
--- a/lib/examples/simon.py
+++ b/lib/examples/simon.py
@@ -314,4 +314,4 @@ def _on_tick(_=None):
 
 draw_board()
 app.on(events.MOUSEBUTTONUP, _on_up)
-app.every(_on_tick, period=20, async_=getattr(app, "timer_async", False))
\ No newline at end of file
+app.every(_on_tick, period=20)
\ No newline at end of file
diff --git a/lib/examples/testris.py b/lib/examples/testris.py
index ca92e9b6..7ad2ba4f 100644
--- a/lib/examples/testris.py
+++ b/lib/examples/testris.py
@@ -756,4 +756,4 @@ def _tick(_=None):
         app.request_quit()
 
 
-app.every(_tick, period=20, async_=app.timer_async)
\ No newline at end of file
+app.every(_tick, period=20)
\ No newline at end of file
diff --git a/lib/examples/tiny_hello.py b/lib/examples/tiny_hello.py
index 7e268303..9dcdac3e 100644
--- a/lib/examples/tiny_hello.py
+++ b/lib/examples/tiny_hello.py
@@ -140,5 +140,5 @@ def main():
     def _tick(_=None):
         poll()
 
-    app.every(_tick, period=1, async_=app.timer_async)
+    app.every(_tick, period=1)
 main()
\ No newline at end of file
diff --git a/lib/examples/tiny_toasters/tiny_toasters.py b/lib/examples/tiny_toasters/tiny_toasters.py
index de99eb7f..8f69e106 100644
--- a/lib/examples/tiny_toasters/tiny_toasters.py
+++ b/lib/examples/tiny_toasters/tiny_toasters.py
@@ -228,5 +228,5 @@ def _tick(_=None):
 
         gc.collect()
 
-    app.every(_tick, period=50, async_=app.timer_async)
+    app.every(_tick, period=50)
 main()
\ No newline at end of file
diff --git a/lib/examples/tower_climb/tower_climb.py b/lib/examples/tower_climb/tower_climb.py
index 9a6179e5..fed457c3 100644
--- a/lib/examples/tower_climb/tower_climb.py
+++ b/lib/examples/tower_climb/tower_climb.py
@@ -1230,7 +1230,7 @@ def main():
     else:
         _start_round()
 
-    app.every(_tick, period=16, async_=app.timer_async)
+    app.every(_tick, period=16)
 
 
 main()
\ No newline at end of file
diff --git a/lib/examples/widgets_energy_panel.py b/lib/examples/widgets_energy_panel.py
index 97d5f335..1b168012 100644
--- a/lib/examples/widgets_energy_panel.py
+++ b/lib/examples/widgets_energy_panel.py
@@ -255,6 +255,6 @@ def _on_spike(_s=None, _e=None):
 seg.set_change_cb(_on_seg)
 spike_btn.add_event_cb(pd.events.MOUSEBUTTONDOWN, _on_spike)
 
-app.every(_live_tick, period=500, async_=app.timer_async)
+app.every(_live_tick, period=500)
 
 screen.visible = True
\ No newline at end of file
diff --git a/lib/utils/console.py b/lib/utils/console.py
index 9a819d1e..55ed7f55 100644
--- a/lib/utils/console.py
+++ b/lib/utils/console.py
@@ -664,7 +664,7 @@ def _ensure_timer(self):
             self._subscription = self._app.every(self._refresh_ms, self._tick)
             return
         try:
-            from multimer import auto as multimer
+            import multimer
         except ImportError:
             return
         if not multimer.Timer:
diff --git a/lib/utils/tft_config.py b/lib/utils/tft_config.py
index 3319d6d7..cb1ddc5d 100644
--- a/lib/utils/tft_config.py
+++ b/lib/utils/tft_config.py
@@ -19,7 +19,7 @@
 if BUFFERED:
     from displaybuf import DisplayBuffer
 
-    from multimer import auto as timer
+    import multimer
 
 
 font_dir = sep.join(tft_text.__file__.split(sep)[:-1]) + sep + "fonts"
@@ -61,9 +61,9 @@ def show(area=None):
 
         display.show = show
         display.draw = display
-        tim = timer.Timer()
+        tim = multimer.Timer()
         tim.init(
-            mode=timer.Timer.PERIODIC,
+            mode=multimer.Timer.PERIODIC,
             period=33,
             callback=lambda t: display.show(),
         )
diff --git a/tools/README.md b/tools/README.md
index 1c7f9f6a..76e9dceb 100644
--- a/tools/README.md
+++ b/tools/README.md
@@ -68,96 +68,45 @@ concrete launcher used in automation.
 .venv/bin/python -m unittest discover -s tests
 ```
 
-### Preferred method (parallel interpreters, fail-fast, both timer modes)
+### Preferred method (parallel interpreters, fail-fast)
 
-For thorough verification (timer/multimer/interpreter changes, or “run the full
-matrix”), prefer **example-by-example**, **all selected interpreters in parallel**
-per example (`--jobs 0`, default), **`--fail-fast`**, and **both**
-`PYDEVICES_TIMER_ASYNC` modes as separate kit runs.
+For thorough verification (timer/multimer/interpreter changes, or "run the full
+matrix"), prefer **example-by-example**, **all selected interpreters in parallel**
+per example (`--jobs 0`, default) and **`--fail-fast`**. There is one timer
+mode: multimer delivers on every host by itself, so the old sync/async split
+(`PYDEVICES_TIMER_ASYNC`) is gone; the kit still accepts the variable and
+ignores it.
 
-| Mode | Interpreters |
-|------|----------|
-| Sync (`PYDEVICES_TIMER_ASYNC=0`) | **5** desktop SDL: `micropython`, `micropython.exe`, `circuitpython`, `cpython-venv`, `python.exe` |
-| Async (`PYDEVICES_TIMER_ASYNC=1`) | **7** — the five above plus `pyscript`, `jupyter` |
-| Android (opt-in) | `android` — `pydevices/bin/android.py` (or `~/bin/android.py` on PATH) + emulator/device + `org.pydevices.runner` APK; **not** in the default 5/7 lists (`--only-interpreter android`) |
+| Interpreters |
+|----------|
+| **7** — desktop SDL: `micropython`, `micropython.exe`, `circuitpython`, `cpython-venv`, `python.exe`; plus `pyscript`, `jupyter` |
+| Android (opt-in) | `android` — `pydevices/bin/android.py` (or `~/bin/android.py` on PATH) + emulator/device + `org.pydevices.runner` APK; **not** in the default list (`--only-interpreter android`) |
 
 Default timing is already short (`duration_s=2`, `timeout_s=15` in the
-interpreters/manifest defaults). After each example’s parallel wave finishes, if
+interpreters/manifest defaults). After each example's parallel wave finishes, if
 any cell failed, stop before the next example; fix the root cause, then resume.
 
 ```bash
-# PyScript needs the static server (async mode)
+# PyScript needs the static server
 python tools/serve.py   # separate terminal; reuse if already on :8000
 
 export SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy PYTHONUNBUFFERED=1
 mkdir -p /tmp/pydevices-examples-matrix
 
-SYNC_RT="micropython micropython.exe circuitpython cpython-venv python.exe"
-ASYNC_RT="$SYNC_RT pyscript jupyter"
+RT="micropython micropython.exe circuitpython cpython-venv python.exe pyscript jupyter"
 
 set -o pipefail   # keep kit exit status through tee
 
-# Sync — 5 interpreters concurrently per example
-PYDEVICES_TIMER_ASYNC=0 stdbuf -oL -eL \
+stdbuf -oL -eL \
   .venv/bin/python tools/example_test_kit.py --no-unit-tests --fail-fast \
-  --only-interpreter $SYNC_RT \
-  --results-json /tmp/pydevices-examples-matrix/sync.json \
-  2>&1 | stdbuf -oL -eL tee /tmp/pydevices-examples-matrix/sync.log
-
-# After sync is clean — async, all 7
-PYDEVICES_TIMER_ASYNC=1 stdbuf -oL -eL \
-  .venv/bin/python tools/example_test_kit.py --no-unit-tests --fail-fast \
-  --only-interpreter $ASYNC_RT \
-  --results-json /tmp/pydevices-examples-matrix/async.json \
-  2>&1 | stdbuf -oL -eL tee /tmp/pydevices-examples-matrix/async.log
-```
-
-Live log lines: `Running <example> @ N interpreter(s) in parallel...`, then
-`start` / `done` per interpreter. `--fail-fast` waits for the current example’s
-workers, then exits if any cell failed. Resume with `--only-example`
-(remaining ids) or by restarting that mode from the failed example. Use
-`--jobs 1` for fully serial interpreters when isolating races. See
-[Windows PE under WSL](#windows-pe-under-wsl) for PE window / quit notes.
-
-`--curated-only` is a smoke shortcut, not a substitute for the preferred gate.
-
-### Matrix commands (scoped / smoke)
-
-```bash
-# Curated set across available interpreters (smoke)
-.venv/bin/python tools/example_test_kit.py --curated-only
-
-# Scope (space-separated ids on one flag; see note below)
-.venv/bin/python tools/example_test_kit.py --only-example calculator --only-interpreter micropython
-.venv/bin/python tools/example_test_kit.py --no-unit-tests --only-interpreter cpython-venv micropython
-.venv/bin/python tools/example_test_kit.py --no-unit-tests \
-  --only-example calc_lvgl lv_test_timer --only-interpreter circuitpython
-
-# Order: --order examples (default) / --order interpreters
-# Broader: --all-except-harness
-```
-
-`--only-example` and `--only-interpreter` use `nargs="+"`: pass multiple ids
-space-separated after **one** occurrence of the flag. Repeating the flag
-silently keeps only the last list (`--only-interpreter circuitpython --only-interpreter
-python.exe` runs just `python.exe`). Same rule for `lv_timer_test_kit.py`
-`--only` / `--modes`.
-
-**Headless desktop** (dummy SDL — default for matrix/smoke):
-
-```bash
-SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy \
-  .venv/bin/python tools/example_test_kit.py --no-unit-tests --only-interpreter cpython-venv
+  --only-interpreter $RT \
+  --results-json /tmp/pydevices-examples-matrix/all.json \
+  2>&1 | stdbuf -oL -eL tee /tmp/pydevices-examples-matrix/all.log
 ```
 
 Unix subprocesses see that shell export. Windows `.exe` behavior is different —
 see [Windows PE under WSL](#windows-pe-under-wsl).
 
-**Async timers on desktop:** the kit forwards `PYDEVICES_TIMER_ASYNC` as wrapper
-`--timer-async` (uses `env_set`, works for Windows PE under WSL). Shell export
-is the preferred way to select mode for a full kit run (see Preferred method
-above). Semantics: [App and board config — timer_async](https://github.com/PyDevices/pydevices/blob/main/docs/app-and-board-config.md#timer_async-in-srclibboard_configpy).
-
 ### Windows PE under WSL
 
 `micropython.exe` and `python.exe` are Windows PE binaries launched from WSL.
diff --git a/tools/example_test_kit.py b/tools/example_test_kit.py
index b96a9fa3..2d81e16b 100755
--- a/tools/example_test_kit.py
+++ b/tools/example_test_kit.py
@@ -474,6 +474,8 @@ def run_subprocess_case(
     apply_sibling_env(env, repo_root=str(REPO))
     _ensure_user_micropy_lib(env)
     # Windows PE under WSL cannot read Linux-exported env; pass via argv + env_set.
+    # PYDEVICES_TIMER_ASYNC is retired (multimer has one timer model); it is
+    # still forwarded so old matrix invocations run, and the wrapper ignores it.
     timer_async = env.get("PYDEVICES_TIMER_ASYNC")
     if timer_async is not None:
         cmd.extend(["--timer-async", str(timer_async)])
diff --git a/tools/example_test_manifest.toml b/tools/example_test_manifest.toml
index 2adaab1c..44735ee0 100644
--- a/tools/example_test_manifest.toml
+++ b/tools/example_test_manifest.toml
@@ -4,8 +4,8 @@
 # kind: oneshot | loop | async | lvgl | pdwidgets | harness | legacy
 # quit: native_exit | poll | inject | pending | interactive
 # bootstrap: full (default) | headless — headless skips utils.path / display init
-# Timer mode for kit runs: host PYDEVICES_TIMER_ASYNC is forwarded as wrapper
-# --timer-async (board_config / displaydev.env_set). Examples do not read env.
+# There is one timer mode: multimer delivers on every host by itself, so the
+# old PYDEVICES_TIMER_ASYNC sync/async split is gone (it is still accepted).
 
 [defaults]
 duration_s = 2
@@ -146,7 +146,6 @@ deps = ["utils", "tft_config"]
 
 # --- LVGL timer smoke test (matrix) ---
 # Also covered by tools/lv_timer_test_kit.py (``lv_test_timer.py kit``).
-# Follows app.timer_async; does not set PYDEVICES_TIMER_ASYNC itself.
 
 [examples.lv_test_timer]
 import = "lv_test_timer"
diff --git a/tools/example_test_wrapper.py b/tools/example_test_wrapper.py
index f1e0fec7..de943f5f 100755
--- a/tools/example_test_wrapper.py
+++ b/tools/example_test_wrapper.py
@@ -699,8 +699,8 @@ def main(argv=None):
             key, value = item.split("=", 1)
             if key:
                 env_set(key, value)
-        if args.get("timer_async") is not None:
-            env_set("PYDEVICES_TIMER_ASYNC", args["timer_async"])
+        # --timer-async is accepted and ignored: multimer has one timer model
+        # on every host, and board configs no longer export timer_async.
 
     # Install the deadline hook AFTER bootstrap: it imports multimer, which is
     # only on sys.path once _setup_bootstrap has run. The hook drives quit for
diff --git a/tools/lv_timer_test_kit.py b/tools/lv_timer_test_kit.py
index 3105c163..0b988233 100755
--- a/tools/lv_timer_test_kit.py
+++ b/tools/lv_timer_test_kit.py
@@ -6,14 +6,13 @@
 checks, then an injected ``events.Quit``). Each child prints ``KIT_RESULT=`` on
 stdout; exit code 0 is expected on success.
 
-The example follows ``app.timer_async`` (it does not set env vars). This kit
-sets ``PYDEVICES_TIMER_ASYNC`` in the child environment so ``board_config``
-constructs sync or async timers; modes are ``sync`` and ``async``.
+multimer has one timer model on every host now, so the kit runs one mode,
+``sync`` (the name is kept so old result files still line up). Where a host
+owns an asyncio loop, multimer rides it by itself.
 
 From repo root:
     python tools/lv_timer_test_kit.py
     python tools/lv_timer_test_kit.py --only cpython-venv
-    python tools/lv_timer_test_kit.py --only cpython-venv --modes async
     python tools/lv_timer_test_kit.py --backend sdl2
 
 ``--backend`` forces one multimer backend through
@@ -67,7 +66,7 @@ def _temp_dir() -> Path:
 # Back-compat alias for docs/CLI that used ``cpython``.
 INTERPRETER_ALIASES = {"cpython": "cpython-venv"}
 
-MODES = ("sync", "async")
+MODES = ("sync",)
 
 sys.path.insert(0, str(TOOLS))
 from example_test_kit import load_interpreters, resolve_interpreter_exe  # noqa: E402
diff --git a/tools/prove_hostloop/_app.py b/tools/prove_hostloop/_app.py
index e068c226..7f8fb178 100644
--- a/tools/prove_hostloop/_app.py
+++ b/tools/prove_hostloop/_app.py
@@ -23,9 +23,9 @@ def quit(self):
         print("[app] display released")
 
 
-def make_app(timer_async=False):
-    app = App(displays=[Display()], timer_async=timer_async, refresh_period=0)
-    print("[app] strategy:", app.strategy, "async:", app.timer_async)
+def make_app():
+    app = App(displays=[Display()], refresh_period=0)
+    print("[app] strategy:", app.strategy)
     ticks = []
 
     @app.every(TICK_MS)
diff --git a/tools/prove_hostloop/demo_async.py b/tools/prove_hostloop/demo_async.py
deleted file mode 100644
index 9f40e0b7..00000000
--- a/tools/prove_hostloop/demo_async.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""Async timers, no app.run(). Needs hostloop's drive path."""
-
-from _app import make_app
-
-app = make_app(timer_async=True)
-print("-- script body ends here --")
diff --git a/tools/prove_hostloop/prove.sh b/tools/prove_hostloop/prove.sh
index 03262790..3cb059c7 100755
--- a/tools/prove_hostloop/prove.sh
+++ b/tools/prove_hostloop/prove.sh
@@ -21,7 +21,7 @@ run() {  # run <label> <cmd...>
     echo "    [rc=${PIPESTATUS[0]}]"
 }
 
-for scenario in noloop async run crash; do
+for scenario in noloop run crash; do
     echo
     echo "=================== $scenario"
     run "CPython / linux"       python3 demo_$scenario.py
@@ -32,7 +32,7 @@ done
 
 echo
 echo "=================== browser (wasm, ambient): host loop outlives the script"
-for scenario in noloop async run; do
+for scenario in noloop run; do
     run "MicroPython wasm / $scenario" node wasm_host.mjs demo_$scenario.py
 done
 
diff --git a/tools/prove_repl/demo_crash.py b/tools/prove_repl/demo_crash.py
new file mode 100644
index 00000000..a5a27ae1
--- /dev/null
+++ b/tools/prove_repl/demo_crash.py
@@ -0,0 +1,7 @@
+"""A script that raises must surface the error and exit, not enter the loop."""
+
+import multimer
+
+multimer.keepalive()
+multimer.every(20, lambda t: None, name="tick")
+raise ValueError("boom")
diff --git a/tools/prove_repl/demo_keepalive.py b/tools/prove_repl/demo_keepalive.py
new file mode 100644
index 00000000..e2b36c52
--- /dev/null
+++ b/tools/prove_repl/demo_keepalive.py
@@ -0,0 +1,24 @@
+"""Script mode: keepalive holds the process until the program says stop.
+
+No app.run(). The exit hook takes the main thread after the last line and
+delivers until the timer deinits itself, then the process exits.
+"""
+
+import multimer
+
+count = [0]
+
+
+def _tick(t):
+    count[0] += 1
+    if count[0] % 5 == 0:
+        print("[tick]", count[0])
+    if count[0] >= 15:
+        print("[demo] stopping at", count[0])
+        t.deinit()
+
+
+multimer.keepalive()
+tim = multimer.every(20, _tick, name="tick")
+print("[demo] strategy:", multimer.strategy())
+print("-- script body ends here --")
diff --git a/tools/prove_repl/demo_repl.py b/tools/prove_repl/demo_repl.py
new file mode 100644
index 00000000..9ee25500
--- /dev/null
+++ b/tools/prove_repl/demo_repl.py
@@ -0,0 +1,13 @@
+"""Hosts with no prompt to fall through to: multimer.repl() is the prompt.
+
+CircuitPython's supervisor resets the board when code.py returns, so the
+program holds the main thread itself and reads lines between deliveries.
+"""
+
+import multimer
+
+ticks = []
+fast = multimer.every(10, lambda t: ticks.append(multimer.ticks_ms()), name="fast")
+print("[demo] armed; source:", multimer.info()["source"])
+multimer.repl()
+print("[demo] repl returned with", len(ticks), "ticks")
diff --git a/tools/prove_repl/demo_timers.py b/tools/prove_repl/demo_timers.py
new file mode 100644
index 00000000..2deb3825
--- /dev/null
+++ b/tools/prove_repl/demo_timers.py
@@ -0,0 +1,25 @@
+"""No app.run(), no App: two timers, then the script ends.
+
+Under ``-i`` the prompt must come back with both timers still firing and
+inspectable; without ``-i`` the process may exit (no keepalive was asked
+for), like a daemon thread.
+"""
+
+import multimer
+
+ticks = []
+slow = []
+
+
+def _fast(t):
+    ticks.append(multimer.ticks_ms())
+
+
+def _slow(t):
+    slow.append(multimer.ticks_ms())
+
+
+fast = multimer.every(10, _fast, name="fast")
+slower = multimer.every(100, _slow, name="slower")
+print("[demo] armed; source:", multimer.info()["source"], "strategy:", multimer.strategy())
+print("-- script body ends here --")
diff --git a/tools/prove_repl/prove.py b/tools/prove_repl/prove.py
new file mode 100755
index 00000000..97fae3d9
--- /dev/null
+++ b/tools/prove_repl/prove.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Prove the REPL goal: a timer-driven script ends, the prompt comes back,
+the timers keep firing, and the program can be inspected at ``>>>``.
+
+Runs each interpreter's ``-i`` on a real pty (so CPython uses readline or
+``_pyrepl`` exactly as a person would), types statements after a delay, and
+checks that the tick count grew between two reads. Also runs script mode
+(keepalive holds the process until the program stops itself) and crash mode
+(an uncaught exception exits instead of entering the loop).
+
+usage: prove.py [--pd PATH] [--mp BIN] [--cp BIN] [--python EXE ...]
+
+Exit status is the number of failed checks. Every check is shown able to
+fail: ``--planted-fault`` runs the REPL check with ``MULTIMER_SOURCE=none``,
+and the input hook off (``MULTIMER_INPUTHOOK=0``), where a bare prompt
+cannot deliver, and expects the failure.
+"""
+
+import argparse
+import os
+from pathlib import Path
+import pty
+import re
+import select
+import subprocess
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+DEFAULT_PD = HERE.parent.parent.parent / "pydevices"
+
+
+def pty_run(argv, env, settle, statements, gap=0.6, total=15):
+    pid, fd = pty.fork()
+    if pid == 0:
+        os.environ.update(env)
+        os.environ["TERM"] = "dumb"
+        os.execvp(argv[0], argv)
+    out = b""
+
+    def drain(timeout):
+        nonlocal out
+        end = time.time() + timeout
+        while time.time() < end:
+            r, _, _ = select.select([fd], [], [], 0.05)
+            if r:
+                try:
+                    out += os.read(fd, 65536)
+                except OSError:
+                    return False
+        return True
+
+    drain(settle)
+    for s in statements:
+        if s is None:
+            drain(gap)
+            continue
+        os.write(fd, (s + "\n").encode())
+        drain(gap)
+    os.write(fd, b"\x04")
+    drain(1.0)
+    try:
+        os.kill(pid, 9)
+    except OSError:
+        pass
+    os.waitpid(pid, 0)
+    return out.decode(errors="replace")
+
+
+def check(label, ok, detail=""):
+    print(("PASS " if ok else "FAIL ") + label + ("" if not detail else "  -- " + detail))
+    return 0 if ok else 1
+
+
+def repl_goal(label, argv, env, expect_fail=False):
+    out = pty_run(
+        [*argv, "-i", str(HERE / "demo_timers.py")],
+        env,
+        1.5,
+        [
+            "print('COUNT1', len(ticks))",
+            None,
+            "print('COUNT2', len(ticks), 'SLOW', len(slow))",
+            "import multimer; multimer.report()",
+        ],
+    )
+    c = re.findall(r"COUNT1 (\d+)", out)
+    d = re.findall(r"COUNT2 (\d+) SLOW (\d+)", out)
+    grew = bool(c and d) and int(d[0][0]) > int(c[0]) + 30
+    slow_ok = bool(d) and int(d[0][1]) >= 1
+    reported = "multimer on" in out and "name='fast'" in out
+    if expect_fail:
+        return check(
+            label + " (planted fault: no wake source)", not grew, "counts %s -> %s" % (c, d)
+        )
+    fails = check(label + ": ticks grow at the prompt", grew, "counts %s -> %s" % (c, d))
+    fails += check(label + ": the 100 ms timer fired too", slow_ok)
+    fails += check(label + ": report() answers at the prompt", reported)
+    if fails:
+        print("---- transcript\n" + out + "\n----")
+    return fails
+
+
+def inloop_repl(label, argv, env):
+    """The in-loop line REPL: ticks grow between two reads, report() answers."""
+    out = pty_run(
+        [*argv, str(HERE / "demo_repl.py")],
+        env,
+        1.5,
+        [
+            "print('COUNT1', len(ticks))",
+            None,
+            "print('COUNT2', len(ticks))",
+            "multimer.report()",
+        ],
+    )
+    c = re.findall(r"COUNT1 (\d+)", out)
+    d = re.findall(r"COUNT2 (\d+)", out)
+    grew = bool(c and d) and int(d[0]) > int(c[0]) + 30
+    fails = check(
+        label + ": multimer.repl() keeps ticks growing between lines",
+        grew,
+        "counts %s -> %s" % (c, d),
+    )
+    fails += check(
+        label + ": report() answers inside repl()", "multimer on" in out and "name='fast'" in out
+    )
+    fails += check(label + ": Ctrl-D returns from repl()", "repl returned" in out)
+    if fails:
+        print("---- transcript\n" + out + "\n----")
+    return fails
+
+
+def script_mode(label, argv, env):
+    t0 = time.time()
+    p = subprocess.run(
+        [*argv, str(HERE / "demo_keepalive.py")],
+        env=dict(os.environ, **env),
+        capture_output=True,
+        text=True,
+        timeout=30,
+        check=False,
+    )
+    took = time.time() - t0
+    out = p.stdout + p.stderr
+    ok = "stopping at 15" in out and p.returncode == 0 and took < 5
+    return check(
+        label + ": keepalive holds the process until the program stops",
+        ok,
+        "rc=%d %.1fs" % (p.returncode, took),
+    )
+
+
+def crash_mode(label, argv, env):
+    t0 = time.time()
+    p = subprocess.run(
+        [*argv, str(HERE / "demo_crash.py")],
+        env=dict(os.environ, **env),
+        capture_output=True,
+        text=True,
+        timeout=30,
+        check=False,
+    )
+    took = time.time() - t0
+    out = p.stdout + p.stderr
+    ok = "boom" in out and p.returncode != 0 and took < 5
+    return check(
+        label + ": a crashing script exits instead of looping",
+        ok,
+        "rc=%d %.1fs" % (p.returncode, took),
+    )
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pd", default=str(DEFAULT_PD))
+    ap.add_argument("--mp", default=None, help="unix micropython binary")
+    ap.add_argument("--cp", default=None, help="unix circuitpython binary")
+    ap.add_argument(
+        "--python", action="append", default=[], help="CPython executable (repeatable)"
+    )
+    ap.add_argument("--planted-fault", action="store_true")
+    a = ap.parse_args()
+    pd = Path(a.pd)
+    paths = "%s:%s" % (pd / "lib", pd / "utils")
+    env = {"PYTHONPATH": paths, "MICROPYPATH": paths + ":.frozen"}
+    fails = 0
+    pythons = a.python or [sys.executable]
+    for py in pythons:
+        label = (
+            "CPython %s"
+            % subprocess.run(
+                [py, "-c", "import sys;print(sys.version.split()[0])"],
+                capture_output=True,
+                text=True,
+                check=False,
+            ).stdout.strip()
+        )
+        fails += repl_goal(label, [py], env)
+        if a.planted_fault:
+            fails += repl_goal(
+                label,
+                [py],
+                dict(env, MULTIMER_SOURCE="none", MULTIMER_INPUTHOOK="0"),
+                expect_fail=True,
+            )
+        fails += script_mode(label, [py], env)
+        fails += crash_mode(label, [py], env)
+    if a.mp:
+        fails += repl_goal("MicroPython unix", [a.mp], env)
+        if a.planted_fault:
+            fails += repl_goal(
+                "MicroPython unix",
+                [a.mp],
+                dict(env, MULTIMER_SOURCE="none", MULTIMER_INPUTHOOK="0"),
+                expect_fail=True,
+            )
+        fails += script_mode("MicroPython unix", [a.mp], env)
+        fails += crash_mode("MicroPython unix", [a.mp], env)
+    if a.cp:
+        # CircuitPython has no fall-through REPL: multimer.repl() is the prompt.
+        fails += inloop_repl("CircuitPython unix", [a.cp], env)
+        fails += script_mode("CircuitPython unix", [a.cp], env)
+        fails += crash_mode("CircuitPython unix", [a.cp], env)
+    print("failures:", fails)
+    return fails
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/prove_repl/prove_jupyter.py b/tools/prove_repl/prove_jupyter.py
new file mode 100755
index 00000000..cf60e380
--- /dev/null
+++ b/tools/prove_repl/prove_jupyter.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Prove the notebook case: timers armed in one cell keep firing between cells.
+
+Starts an IPython kernel with jupyter_client (no browser), runs a cell that
+arms two multimer timers and ends, waits, then reads the counts from a second
+cell and calls multimer.report() from a third. The kernel's asyncio loop is
+the wake source, so the cells return while the timers run.
+
+usage: prove_jupyter.py [--pd PATH]
+Exit status is the number of failed checks.
+"""
+
+import argparse
+import os
+from pathlib import Path
+import queue
+import re
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+DEFAULT_PD = HERE.parent.parent.parent / "pydevices"
+
+CELL_ARM = """
+import multimer
+ticks = []
+slow = []
+fast = multimer.every(10, lambda t: ticks.append(multimer.ticks_ms()), name="fast")
+slower = multimer.every(100, lambda t: slow.append(1), name="slower")
+print("SOURCE", multimer.info()["source"], "STRATEGY", multimer.strategy())
+"""
+CELL_COUNT1 = "print('COUNT1', len(ticks), len(slow))"
+CELL_COUNT2 = "print('COUNT2', len(ticks), len(slow))"
+CELL_REPORT = "multimer.report()"
+CELL_APP = """
+import board_config, appdev
+app = appdev.App(board_config)
+shows = []
+app.every(50, lambda t: shows.append(1), name="app.tick")
+print("APP", app.strategy, type(app.primary).__name__)
+"""
+CELL_APP_COUNT = "print('APPCOUNT', len(shows), app.primary.frame_clock.period_ms)"
+
+
+def run_cell(kc, code, timeout=30):
+    msg_id = kc.execute(code)
+    out = ""
+    while True:
+        try:
+            msg = kc.get_iopub_msg(timeout=timeout)
+        except queue.Empty:
+            break
+        t = msg["header"]["msg_type"]
+        c = msg["content"]
+        if t == "stream":
+            out += c["text"]
+        elif t == "error":
+            out += "\n".join(c["traceback"])
+        elif (
+            t == "status"
+            and c["execution_state"] == "idle"
+            and msg["parent_header"].get("msg_id") == msg_id
+        ):
+            break
+    return out
+
+
+def check(label, ok, detail=""):
+    print(("PASS " if ok else "FAIL ") + label + ("" if not detail else "  -- " + detail))
+    return 0 if ok else 1
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pd", default=str(DEFAULT_PD))
+    a = ap.parse_args()
+    pd = Path(a.pd)
+    from jupyter_client import KernelManager
+
+    env = dict(os.environ)
+    env["PYTHONPATH"] = os.pathsep.join(
+        [str(pd / "lib"), str(pd / "utils"), str(pd / "board_configs" / "jndisplay")]
+    )
+    km = KernelManager(kernel_name="python3")
+    km.start_kernel(env=env)
+    kc = km.client()
+    kc.start_channels()
+    kc.wait_for_ready(timeout=60)
+    fails = 0
+    try:
+        out = run_cell(kc, CELL_ARM)
+        src = re.findall(r"SOURCE (\S+) STRATEGY (\S+)", out)
+        fails += check(
+            "cell 1 arms timers on the kernel's loop",
+            bool(src) and src[0][0] == "asyncio" and src[0][1] == "ambient",
+            out.strip(),
+        )
+        time.sleep(1.0)
+        c1 = re.findall(r"COUNT1 (\d+) (\d+)", run_cell(kc, CELL_COUNT1))
+        time.sleep(1.0)
+        c2 = re.findall(r"COUNT2 (\d+) (\d+)", run_cell(kc, CELL_COUNT2))
+        grew = (
+            bool(c1 and c2)
+            and int(c2[0][0]) > int(c1[0][0]) + 50
+            and int(c2[0][1]) > int(c1[0][1])
+        )
+        fails += check("timers keep firing between cells", grew, "counts %s -> %s" % (c1, c2))
+        rep = run_cell(kc, CELL_REPORT)
+        fails += check(
+            "report() answers from a cell",
+            "source=asyncio" in rep and "name='fast'" in rep,
+            rep.strip()[:200],
+        )
+        out = run_cell(kc, CELL_APP)
+        app_ok = "APP ambient JNDisplay" in out
+        fails += check("an App on JNDisplay arms in a notebook", app_ok, out.strip()[-300:])
+        if app_ok:
+            time.sleep(0.6)
+            ac = re.findall(r"APPCOUNT (\d+) (\d+)", run_cell(kc, CELL_APP_COUNT))
+            fails += check(
+                "the App's timers ran between cells", bool(ac) and int(ac[0][0]) >= 5, str(ac)
+            )
+    finally:
+        kc.stop_channels()
+        km.shutdown_kernel(now=True)
+    print("failures:", fails)
+    return fails
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/prove_repl/prove_windows.py b/tools/prove_repl/prove_windows.py
new file mode 100644
index 00000000..afc23571
--- /dev/null
+++ b/tools/prove_repl/prove_windows.py
@@ -0,0 +1,399 @@
+"""Prove the REPL goal on Windows, in a real console (ConPTY).
+
+``prove.py`` forks a pty, which Windows has not got. This runs the same
+checks under a Windows pseudo console: the child sees a genuine console
+handle on stdin, so ``python.exe`` uses ``_pyrepl`` (or readline-less
+``input()``) exactly as a person at a terminal would, and ``micropython.exe``
+takes its ``ReadConsoleInput`` path with the console wait of overlay patch
+0015. Typed statements go in through the console's input pipe; what the
+program prints comes back through its output pipe, with the VT escapes
+stripped.
+
+Run it with Windows Python (from WSL, ``python.exe`` by its full path)::
+
+    python.exe prove_windows.py --pd \\\\wsl.localhost\\...\\pydevices ^
+        --python python.exe --mp C:\\...\\micropython.exe
+
+Checks, each shown able to fail (``--planted-fault`` runs the REPL check
+with no wake source and the input hook off, and expects the count to stand
+still):
+
+* the REPL goal: ``-i demo_timers.py`` keeps delivering at the prompt
+  (``len(ticks)`` grows by about 100 a second) and ``report()`` answers;
+* keepalive: ``demo_keepalive.py`` prints ``stopping at 15`` and exits 0;
+* crash: ``demo_crash.py`` exits nonzero with ``boom`` on its stderr, and
+  never enters the loop.
+
+Exit status is the number of failed checks.
+"""
+
+import argparse
+import ctypes
+import ctypes.wintypes as wt
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+import threading
+import time
+
+HERE = Path(__file__).resolve().parent
+
+k32 = ctypes.WinDLL("kernel32", use_last_error=True)
+PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE = 0x00020016
+EXTENDED_STARTUPINFO_PRESENT = 0x00080000
+CREATE_UNICODE_ENVIRONMENT = 0x00000400
+STARTF_USESTDHANDLES = 0x00000100
+_VT = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07]*\x07|\x1b[=>]|\r")
+
+
+class COORD(ctypes.Structure):
+    _fields_ = [("X", ctypes.c_short), ("Y", ctypes.c_short)]
+
+
+class STARTUPINFOW(ctypes.Structure):
+    _fields_ = [
+        ("cb", wt.DWORD),
+        ("lpReserved", wt.LPWSTR),
+        ("lpDesktop", wt.LPWSTR),
+        ("lpTitle", wt.LPWSTR),
+        ("dwX", wt.DWORD),
+        ("dwY", wt.DWORD),
+        ("dwXSize", wt.DWORD),
+        ("dwYSize", wt.DWORD),
+        ("dwXCountChars", wt.DWORD),
+        ("dwYCountChars", wt.DWORD),
+        ("dwFillAttribute", wt.DWORD),
+        ("dwFlags", wt.DWORD),
+        ("wShowWindow", wt.WORD),
+        ("cbReserved2", wt.WORD),
+        ("lpReserved2", ctypes.c_void_p),
+        ("hStdInput", wt.HANDLE),
+        ("hStdOutput", wt.HANDLE),
+        ("hStdError", wt.HANDLE),
+    ]
+
+
+class STARTUPINFOEXW(ctypes.Structure):
+    _fields_ = [("StartupInfo", STARTUPINFOW), ("lpAttributeList", ctypes.c_void_p)]
+
+
+class PROCESS_INFORMATION(ctypes.Structure):
+    _fields_ = [
+        ("hProcess", wt.HANDLE),
+        ("hThread", wt.HANDLE),
+        ("dwProcessId", wt.DWORD),
+        ("dwThreadId", wt.DWORD),
+    ]
+
+
+def _prototypes():
+    """Exact argument widths: SIZE_T and HANDLE are 64-bit, a bare int is not."""
+    k32.CreatePipe.argtypes = [
+        ctypes.POINTER(wt.HANDLE),
+        ctypes.POINTER(wt.HANDLE),
+        ctypes.c_void_p,
+        wt.DWORD,
+    ]
+    k32.CreatePseudoConsole.argtypes = [
+        COORD,
+        wt.HANDLE,
+        wt.HANDLE,
+        wt.DWORD,
+        ctypes.POINTER(wt.HANDLE),
+    ]
+    k32.CreatePseudoConsole.restype = ctypes.c_long
+    k32.InitializeProcThreadAttributeList.argtypes = [
+        ctypes.c_void_p,
+        wt.DWORD,
+        wt.DWORD,
+        ctypes.POINTER(ctypes.c_size_t),
+    ]
+    k32.UpdateProcThreadAttribute.argtypes = [
+        ctypes.c_void_p,
+        wt.DWORD,
+        ctypes.c_size_t,
+        ctypes.c_void_p,
+        ctypes.c_size_t,
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+    ]
+    k32.CreateProcessW.argtypes = [
+        wt.LPCWSTR,
+        wt.LPWSTR,
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+        wt.BOOL,
+        wt.DWORD,
+        ctypes.c_void_p,
+        wt.LPCWSTR,
+        ctypes.c_void_p,
+        ctypes.POINTER(PROCESS_INFORMATION),
+    ]
+    k32.ReadFile.argtypes = [
+        wt.HANDLE,
+        ctypes.c_void_p,
+        wt.DWORD,
+        ctypes.POINTER(wt.DWORD),
+        ctypes.c_void_p,
+    ]
+    k32.WriteFile.argtypes = [
+        wt.HANDLE,
+        ctypes.c_void_p,
+        wt.DWORD,
+        ctypes.POINTER(wt.DWORD),
+        ctypes.c_void_p,
+    ]
+    k32.WaitForSingleObject.argtypes = [wt.HANDLE, wt.DWORD]
+    k32.GetExitCodeProcess.argtypes = [wt.HANDLE, ctypes.POINTER(wt.DWORD)]
+    k32.ClosePseudoConsole.argtypes = [wt.HANDLE]
+    k32.CloseHandle.argtypes = [wt.HANDLE]
+    k32.TerminateProcess.argtypes = [wt.HANDLE, wt.UINT]
+
+
+def _check(ok, what):
+    if not ok:
+        raise OSError("%s failed: %s" % (what, ctypes.FormatError(ctypes.get_last_error())))
+
+
+class ConPty:
+    """A child process on a Windows pseudo console."""
+
+    def __init__(self, argv, cwd=None, env=None, cols=120, rows=40):
+        self.out = b""
+        self._lock = threading.Lock()
+        _prototypes()
+        in_r, in_w = wt.HANDLE(), wt.HANDLE()
+        out_r, out_w = wt.HANDLE(), wt.HANDLE()
+        _check(k32.CreatePipe(ctypes.byref(in_r), ctypes.byref(in_w), None, 0), "CreatePipe")
+        _check(k32.CreatePipe(ctypes.byref(out_r), ctypes.byref(out_w), None, 0), "CreatePipe")
+        self._hpc = wt.HANDLE()
+        rc = k32.CreatePseudoConsole(COORD(cols, rows), in_r, out_w, 0, ctypes.byref(self._hpc))
+        if rc != 0:
+            raise OSError("CreatePseudoConsole failed: 0x%08x" % (rc & 0xFFFFFFFF))
+        k32.CloseHandle(in_r)
+        k32.CloseHandle(out_w)
+        self._in_w, self._out_r = in_w, out_r
+
+        size = ctypes.c_size_t(0)
+        k32.InitializeProcThreadAttributeList(None, 1, 0, ctypes.byref(size))
+        attrs = ctypes.create_string_buffer(size.value)
+        _check(
+            k32.InitializeProcThreadAttributeList(attrs, 1, 0, ctypes.byref(size)),
+            "InitializeProcThreadAttributeList",
+        )
+        _check(
+            k32.UpdateProcThreadAttribute(
+                attrs,
+                0,
+                PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
+                self._hpc.value,
+                ctypes.sizeof(wt.HANDLE),
+                None,
+                None,
+            ),
+            "UpdateProcThreadAttribute",
+        )
+        six = STARTUPINFOEXW()
+        six.StartupInfo.cb = ctypes.sizeof(STARTUPINFOEXW)
+        six.lpAttributeList = ctypes.addressof(attrs)
+        # Our own std handles are pipes (this runs from a WSL shell or a CI
+        # runner). Without this flag CreateProcess duplicates them into the
+        # child, which then never sees the console; with it and null handles
+        # the child takes the pseudo console's, as node-pty does.
+        six.StartupInfo.dwFlags = STARTF_USESTDHANDLES
+        pi = PROCESS_INFORMATION()
+        cmdline = ctypes.create_unicode_buffer(subprocess.list2cmdline(argv))
+        full = dict(os.environ)
+        if env:
+            full.update(env)
+        block = "".join("%s=%s\0" % kv for kv in sorted(full.items())) + "\0"
+        envbuf = ctypes.create_unicode_buffer(block, len(block))
+        _check(
+            k32.CreateProcessW(
+                None,
+                cmdline,
+                None,
+                None,
+                False,
+                EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT,
+                envbuf,
+                cwd,
+                ctypes.byref(six),
+                ctypes.byref(pi),
+            ),
+            "CreateProcessW",
+        )
+        self.pid = pi.dwProcessId
+        self._hproc = pi.hProcess
+        k32.CloseHandle(pi.hThread)
+        self._reader = threading.Thread(target=self._pump, daemon=True)
+        self._reader.start()
+
+    def _pump(self):
+        buf = ctypes.create_string_buffer(65536)
+        n = wt.DWORD()
+        while True:
+            if not k32.ReadFile(self._out_r, buf, 65536, ctypes.byref(n), None):
+                return
+            with self._lock:
+                self.out += buf.raw[: n.value]
+
+    def write(self, text):
+        data = text.encode()
+        n = wt.DWORD()
+        _check(k32.WriteFile(self._in_w, data, len(data), ctypes.byref(n), None), "WriteFile")
+
+    def text(self):
+        with self._lock:
+            raw = self.out
+        return _VT.sub("", raw.decode("utf-8", "replace"))
+
+    def wait(self, timeout_s):
+        """Exit code, or None if still running. Everything printed is in text() after."""
+        rc = k32.WaitForSingleObject(self._hproc, int(timeout_s * 1000))
+        if rc != 0:
+            return None
+        code = wt.DWORD()
+        k32.GetExitCodeProcess(self._hproc, ctypes.byref(code))
+        # The console keeps the last lines in its own pipe until it closes:
+        # close it now and drain, or a program's final output is lost.
+        self._close_console()
+        return code.value
+
+    def _close_console(self):
+        if self._hpc is None:
+            return
+        k32.ClosePseudoConsole(self._hpc)
+        self._hpc = None
+        self._reader.join(3.0)
+
+    def close(self):
+        self._close_console()
+        if k32.WaitForSingleObject(self._hproc, 1000) != 0:
+            k32.TerminateProcess(self._hproc, 9)
+        k32.CloseHandle(self._hproc)
+        k32.CloseHandle(self._in_w)
+        k32.CloseHandle(self._out_r)
+
+
+def check(label, ok, detail=""):
+    print(
+        ("PASS " if ok else "FAIL ") + label + ("" if not detail else "  -- " + detail), flush=True
+    )
+    return 0 if ok else 1
+
+
+def repl_goal(label, argv, cwd, env, expect_fail=False, settle=2.0):
+    child = ConPty([*argv, "-i", str(HERE / "demo_timers.py")], cwd=cwd, env=env)
+    time.sleep(settle)
+    child.write("print('N1', len(ticks))\r\n")
+    time.sleep(1.0)
+    child.write("print('N2', len(ticks))\r\n")
+    time.sleep(0.6)
+    child.write("import multimer; multimer.report()\r\n")
+    time.sleep(0.8)
+    child.write("raise SystemExit\r\n")
+    child.wait(2.0)
+    out = child.text()
+    child.close()
+    nums = re.findall(r"^N([12]) (\d+)", out, re.M)
+    got = {k: int(v) for k, v in nums}
+    grew = "1" in got and "2" in got and got["2"] - got["1"] >= 40
+    source = re.search(r"source=(\S+)", out)
+    detail = "N1=%s N2=%s source=%s" % (
+        got.get("1"),
+        got.get("2"),
+        source.group(1) if source else None,
+    )
+    ok = (not grew) if expect_fail else (grew and source is not None)
+    rc = check(label, ok, detail)
+    if not ok:
+        print("---- transcript\n" + out + "\n----")
+    return rc
+
+
+def script_mode(label, argv, cwd, env):
+    child = ConPty([*argv, str(HERE / "demo_keepalive.py")], cwd=cwd, env=env)
+    code = child.wait(10.0)
+    out = child.text()
+    child.close()
+    ok = code == 0 and "stopping at 15" in out
+    rc = check(label, ok, "exit=%s" % code)
+    if not ok:
+        print("---- transcript\n" + out + "\n----")
+    return rc
+
+
+def crash_mode(label, argv, cwd, env):
+    child = ConPty([*argv, str(HERE / "demo_crash.py")], cwd=cwd, env=env)
+    code = child.wait(10.0)
+    out = child.text()
+    child.close()
+    ok = code not in (None, 0) and "boom" in out
+    rc = check(label, ok, "exit=%s" % code)
+    if not ok:
+        print("---- transcript\n" + out + "\n----")
+    return rc
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pd", required=True, help="pydevices checkout (Windows or UNC path)")
+    ap.add_argument("--python", action="append", default=[], help="a python.exe to test")
+    ap.add_argument("--mp", action="append", default=[], help="a micropython.exe to test")
+    ap.add_argument("--planted-fault", action="store_true")
+    ap.add_argument("--settle", type=float, default=2.0)
+    args = ap.parse_args()
+    pd = Path(args.pd)
+    cwd = str(HERE)
+    fails = 0
+    for exe in args.python:
+        env = {
+            "PYTHONPATH": os.pathsep.join([str(pd / "lib"), str(pd / "utils")]),
+            "PYTHON_BASIC_REPL": "",
+        }
+        env.pop("PYTHON_BASIC_REPL")
+        fails += repl_goal(
+            "CPython -i %s: ticks grow at the prompt" % exe, [exe], cwd, env, settle=args.settle
+        )
+        if args.planted_fault:
+            bad = dict(env, MULTIMER_SOURCE="none", MULTIMER_INPUTHOOK="0")
+            fails += repl_goal(
+                "CPython planted fault (no source, hook off): stands still",
+                [exe],
+                cwd,
+                bad,
+                expect_fail=True,
+                settle=args.settle,
+            )
+        fails += script_mode("CPython script mode: keepalive then exit 0", [exe], cwd, env)
+        fails += crash_mode("CPython crash mode: exits nonzero", [exe], cwd, env)
+    for exe in args.mp:
+        env = {"MICROPYPATH": os.pathsep.join([str(pd / "lib"), str(pd / "utils"), ".frozen"])}
+        fails += repl_goal(
+            "MicroPython -i %s: ticks grow at the prompt" % exe,
+            [exe],
+            cwd,
+            env,
+            settle=args.settle,
+        )
+        if args.planted_fault:
+            bad = dict(env, MULTIMER_SOURCE="none")
+            fails += repl_goal(
+                "MicroPython planted fault (no source): stands still",
+                [exe],
+                cwd,
+                bad,
+                expect_fail=True,
+                settle=args.settle,
+            )
+        fails += script_mode("MicroPython script mode: keepalive then exit 0", [exe], cwd, env)
+        fails += crash_mode("MicroPython crash mode: exits nonzero", [exe], cwd, env)
+    print("failed checks:", fails)
+    sys.exit(fails)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/prove_repl/wasm_host.mjs b/tools/prove_repl/wasm_host.mjs
new file mode 100644
index 00000000..fa9a4db2
--- /dev/null
+++ b/tools/prove_repl/wasm_host.mjs
@@ -0,0 +1,53 @@
+// Drive the direct MicroPython WebAssembly build the way a browser page does:
+// load the interpreter, mount the pydevices tree, run a timer script that ends,
+// then RETURN to the JS event loop. The page loop is the wake source; nothing
+// here pumps. Two reads a second apart must show the tick count growing, and
+// multimer.report() must answer.
+//
+// usage: node wasm_host.mjs [path/to/micropython.mjs]
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PD = process.env.PD || join(HERE, "../../../pydevices");
+const MJS = process.argv[2] || join(PD, "bin/micropython.mjs");
+const { loadMicroPython } = await import(MJS);
+
+let captured = "";
+const mp = await loadMicroPython({
+    stdout: (line) => { captured += line + "\n"; console.log(line); },
+    heapsize: 16 * 1024 * 1024,
+});
+
+function copyTree(src, dst) {
+    mp.FS.mkdir(dst);
+    for (const name of readdirSync(src)) {
+        if (name === "__pycache__" || name.startsWith(".")) continue;
+        const s = join(src, name), d = dst + "/" + name;
+        if (statSync(s).isDirectory()) copyTree(s, d);
+        else if (name.endsWith(".py")) mp.FS.writeFile(d, readFileSync(s));
+    }
+}
+copyTree(join(PD, "lib"), "/lib");
+copyTree(join(PD, "utils"), "/utils");
+mp.runPython(`import sys
+sys.path.insert(0, "/utils")
+sys.path.insert(0, "/lib")`);
+
+await mp.runPythonAsync(readFileSync(join(HERE, "demo_timers.py"), "utf8"));
+console.log("[host] script returned to the JS event loop; not pumping anything");
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+await sleep(1000);
+mp.runPython("print('COUNT1', len(ticks), len(slow))");
+await sleep(1000);
+mp.runPython("print('COUNT2', len(ticks), len(slow))");
+mp.runPython("import multimer; multimer.report()");
+
+const c1 = captured.match(/COUNT1 (\d+) (\d+)/), c2 = captured.match(/COUNT2 (\d+) (\d+)/);
+const grew = c1 && c2 && (+c2[1] > +c1[1] + 30) && (+c2[2] > +c1[2]);
+const reported = /multimer on micropython\/webassembly/.test(captured) && /name='fast'/.test(captured);
+console.log((grew ? "PASS" : "FAIL") + " wasm: ticks grow while the page loop idles");
+console.log((reported ? "PASS" : "FAIL") + " wasm: report() answers");
+process.exit((grew ? 0 : 1) + (reported ? 0 : 1));
diff --git a/tools/prove_repl/win_window_alive.py b/tools/prove_repl/win_window_alive.py
new file mode 100644
index 00000000..8f404e84
--- /dev/null
+++ b/tools/prove_repl/win_window_alive.py
@@ -0,0 +1,236 @@
+"""Prove a windowed app stays alive at the Windows REPL prompt.
+
+``python.exe -i -m examples.<app>`` opens its window (WinDisplay or SDL) and
+then sits at ``>>>``. With no ``app.run()``, the timers are all that pump the
+window's message queue, so if nothing delivers at the prompt Windows marks the
+window hung after a few seconds (``IsHungAppWindow``) and it stops repainting.
+This runs the app under a Windows pseudo console (the child sees a real
+console handle, so ``_pyrepl`` waits exactly as it does for a person), finds
+the child's window, samples ``IsHungAppWindow`` for a while, captures it with
+``PrintWindow`` (which a hung window cannot answer), and types into the REPL.
+
+Run it with Windows Python from the examples ``lib`` directory::
+
+    python.exe ..\\tools\\prove_repl\\win_window_alive.py -m examples.roku_remote
+
+Pass ``--pythonpath`` to test a checkout instead of the installed packages.
+Exit status is the number of failed checks: the window must never be hung once
+it is up, both captures must have content, and the REPL must answer.
+"""
+
+import argparse
+import ctypes
+import ctypes.wintypes as wt
+import os
+from pathlib import Path
+import re
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from prove_windows import ConPty  # noqa: E402
+
+u32 = ctypes.WinDLL("user32", use_last_error=True)
+g32 = ctypes.WinDLL("gdi32", use_last_error=True)
+u32.EnumWindows.argtypes = [ctypes.c_void_p, wt.LPARAM]
+u32.GetWindowThreadProcessId.argtypes = [wt.HWND, ctypes.POINTER(wt.DWORD)]
+u32.IsWindowVisible.argtypes = [wt.HWND]
+u32.IsHungAppWindow.argtypes = [wt.HWND]
+u32.IsHungAppWindow.restype = wt.BOOL
+u32.GetWindowTextW.argtypes = [wt.HWND, wt.LPWSTR, ctypes.c_int]
+u32.GetWindowRect.argtypes = [wt.HWND, ctypes.POINTER(wt.RECT)]
+u32.GetWindowDC.argtypes = [wt.HWND]
+u32.GetWindowDC.restype = wt.HDC
+u32.ReleaseDC.argtypes = [wt.HWND, wt.HDC]
+u32.PrintWindow.argtypes = [wt.HWND, wt.HDC, wt.UINT]
+u32.PrintWindow.restype = wt.BOOL
+g32.CreateCompatibleDC.argtypes = [wt.HDC]
+g32.CreateCompatibleDC.restype = wt.HDC
+g32.CreateCompatibleBitmap.argtypes = [wt.HDC, ctypes.c_int, ctypes.c_int]
+g32.CreateCompatibleBitmap.restype = wt.HBITMAP
+g32.SelectObject.argtypes = [wt.HDC, wt.HGDIOBJ]
+g32.SelectObject.restype = wt.HGDIOBJ
+g32.GetDIBits.argtypes = [
+    wt.HDC,
+    wt.HBITMAP,
+    wt.UINT,
+    wt.UINT,
+    ctypes.c_void_p,
+    ctypes.c_void_p,
+    wt.UINT,
+]
+g32.DeleteObject.argtypes = [wt.HGDIOBJ]
+g32.DeleteDC.argtypes = [wt.HDC]
+_ENUM = ctypes.WINFUNCTYPE(wt.BOOL, wt.HWND, wt.LPARAM)
+PW_RENDERFULLCONTENT = 0x00000002
+
+
+class BITMAPINFOHEADER(ctypes.Structure):
+    _fields_ = [
+        ("biSize", wt.DWORD),
+        ("biWidth", wt.LONG),
+        ("biHeight", wt.LONG),
+        ("biPlanes", wt.WORD),
+        ("biBitCount", wt.WORD),
+        ("biCompression", wt.DWORD),
+        ("biSizeImage", wt.DWORD),
+        ("biXPelsPerMeter", wt.LONG),
+        ("biYPelsPerMeter", wt.LONG),
+        ("biClrUsed", wt.DWORD),
+        ("biClrImportant", wt.DWORD),
+    ]
+
+
+def windows_of(pid):
+    found = []
+
+    @_ENUM
+    def cb(hwnd, _):
+        wpid = wt.DWORD()
+        u32.GetWindowThreadProcessId(hwnd, ctypes.byref(wpid))
+        if wpid.value == pid and u32.IsWindowVisible(hwnd):
+            buf = ctypes.create_unicode_buffer(256)
+            u32.GetWindowTextW(hwnd, buf, 256)
+            found.append((hwnd, buf.value))
+        return True
+
+    u32.EnumWindows(cb, 0)
+    # The console host's own window (if any) is not ours: prefer a titled one.
+    found.sort(key=lambda t: (t[1] == "", t[1]))
+    return found
+
+
+def capture(hwnd, path):
+    """PrintWindow into a bitmap; save PNG; return (ok, non_background_pixels)."""
+    rc = wt.RECT()
+    u32.GetWindowRect(hwnd, ctypes.byref(rc))
+    w, h = rc.right - rc.left, rc.bottom - rc.top
+    if w <= 0 or h <= 0:
+        return False, 0
+    hdc = u32.GetWindowDC(hwnd)
+    mdc = g32.CreateCompatibleDC(hdc)
+    bmp = g32.CreateCompatibleBitmap(hdc, w, h)
+    old = g32.SelectObject(mdc, bmp)
+    ok = bool(u32.PrintWindow(hwnd, mdc, PW_RENDERFULLCONTENT))
+    bi = BITMAPINFOHEADER()
+    bi.biSize = ctypes.sizeof(BITMAPINFOHEADER)
+    bi.biWidth, bi.biHeight, bi.biPlanes, bi.biBitCount = w, -h, 1, 32
+    buf = ctypes.create_string_buffer(w * h * 4)
+    g32.GetDIBits(mdc, bmp, 0, h, buf, ctypes.byref(bi), 0)
+    g32.SelectObject(mdc, old)
+    g32.DeleteObject(bmp)
+    g32.DeleteDC(mdc)
+    u32.ReleaseDC(hwnd, hdc)
+    raw = buf.raw
+    # Count pixels that are neither black nor white (a blank window is one of those).
+    px = memoryview(raw).cast("I")
+    content = sum(1 for v in px if (v & 0xFFFFFF) not in (0, 0xFFFFFF))
+    try:
+        from PIL import Image
+
+        Image.frombuffer("RGBA", (w, h), raw, "raw", "BGRA", 0, 1).save(path)
+    except Exception as exc:  # PIL missing: keep the numbers, skip the file
+        print("capture: no PNG written (%s)" % exc)
+    return ok, content
+
+
+def check(label, ok, detail=""):
+    print(
+        ("PASS " if ok else "FAIL ") + label + ("" if not detail else "  -- " + detail), flush=True
+    )
+    return 0 if ok else 1
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-m", dest="module", required=True)
+    ap.add_argument("--python", default=sys.executable)
+    ap.add_argument("--pythonpath", default="")
+    ap.add_argument("--cwd", default=os.getcwd())
+    ap.add_argument(
+        "--settle", type=float, default=8.0, help="seconds for the app to open its window"
+    )
+    ap.add_argument("--watch", type=float, default=12.0, help="seconds to sample IsHungAppWindow")
+    ap.add_argument("--out", default=str(Path(os.environ.get("TEMP", ".")) / "win_window_alive"))
+    ap.add_argument("--env", action="append", default=[], help="NAME=VALUE for the child")
+    args = ap.parse_args()
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    env = {"PYTHONDONTWRITEBYTECODE": "1"}
+    if args.pythonpath:
+        env["PYTHONPATH"] = args.pythonpath
+    for kv in args.env:
+        k, _, v = kv.partition("=")
+        env[k] = v
+    child = ConPty(
+        [args.python, "-i", "-m", args.module], cwd=args.cwd, env=env, cols=140, rows=50
+    )
+    print(
+        "child pid",
+        child.pid,
+        "cwd",
+        args.cwd,
+        "PYTHONPATH",
+        env.get("PYTHONPATH", "(installed)"),
+        flush=True,
+    )
+    fails = 0
+    deadline = time.time() + args.settle
+    wins = []
+    while time.time() < deadline and not wins:
+        time.sleep(0.5)
+        wins = windows_of(child.pid)
+    fails += check("the app opened a window", bool(wins), repr(wins))
+    if not wins:
+        child.write("raise SystemExit\r\n")
+        child.close()
+        print(child.text()[-2000:])
+        sys.exit(fails + 1)
+    hwnd, title = wins[0]
+    samples = []
+    t0 = time.time()
+    cap1 = cap2 = None
+    while time.time() - t0 < args.watch:
+        time.sleep(1.0)
+        hung = bool(u32.IsHungAppWindow(hwnd))
+        samples.append(hung)
+        el = time.time() - t0
+        if cap1 is None and el >= args.watch / 2 and not hung:
+            cap1 = capture(hwnd, str(out / "capture1.png"))
+    if not samples[-1]:
+        cap2 = capture(hwnd, str(out / "capture2.png"))
+    fails += check(
+        "the window is never hung while the REPL sits at the prompt (%d samples over %.0f s)"
+        % (len(samples), args.watch),
+        not any(samples),
+        "hung samples: " + "".join("H" if s else "." for s in samples) + "  title=%r" % title,
+    )
+    fails += check(
+        "PrintWindow captures content (a hung window cannot answer it)",
+        bool(cap1 and cap1[0] and cap1[1] > 100 and cap2 and cap2[0] and cap2[1] > 100),
+        "cap1=%r cap2=%r (ok, content pixels) -> %s" % (cap1, cap2, out),
+    )
+    # The REPL answers while the window lives.
+    child.write("import multimer; print('REPL-OK', 21 * 2)\r\n")
+    time.sleep(1.0)
+    child.write("multimer.report()\r\n")
+    time.sleep(1.5)
+    txt = child.text()
+    fails += check("the REPL answers with the window up", "REPL-OK 42" in txt)
+    still = bool(u32.IsHungAppWindow(hwnd))
+    fails += check("the window is still not hung after the REPL statements", not still)
+    src = re.search(r"source=(\S+) delivery=(\S+)", txt)
+    print("report:", src.group(0) if src else "(no report line)")
+    for line in txt.splitlines():
+        if line.strip().startswith("Timer("):
+            print("  " + line.strip())
+    child.write("raise SystemExit\r\n")
+    child.wait(5.0)
+    child.close()
+    print("failed checks:", fails)
+    sys.exit(fails)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/timing_bench/README.md b/tools/timing_bench/README.md
new file mode 100644
index 00000000..ad656662
--- /dev/null
+++ b/tools/timing_bench/README.md
@@ -0,0 +1,32 @@
+# The benchmark scripts and their raw results
+
+Two scripts, run the same way on the current multimer and on the redesign.
+The Numbers section of pydevices' `docs/timing-design.md` is made from the
+`.jsonl` files here. The `results-*.jsonl` files without a host suffix are the
+cloud session's (a 4-core container); files named `results-<host>.jsonl` were
+measured on Brad's bench by the local session, each row carrying its `host`.
+
+`bench_timer.py OLD|NEW idle|busy [period_ms] [duration_ms]` arms one
+periodic timer and records every callback. `OLD` uses `multimer.auto`
+(`MULTIMER_BACKEND` chooses the provider); `NEW` uses `multimer.Timer`
+(`MULTIMER_SOURCE` chooses the wake source). It prints one `BENCH=` JSON
+line. Runs were made with `PYTHONPATH`/`MICROPYPATH` pointing at the
+pydevices tree under test (`lib` and `utils`), `SDL_VIDEODRIVER=dummy`, one
+run at a time, nothing else running.
+
+`lv_pace.py` builds an LVGL screen with an arc moved by a 16 ms LVGL timer,
+records `REFR_READY` events for `PACE_MS` (3000) and prints one `PACE=`
+line. `PACE_API=OLD|NEW`, `PACE_STATIC=1` for the static-screen case. The
+path also has `lvgl-bindings/python` (the driver under test) and
+`pydevices/board_configs/desktop` on it. Both interpreters were run
+headless with SDL's dummy video driver.
+
+Results:
+
+- `results-current-multimer.jsonl`: the current layer, every provider this
+  host has, idle and busy.
+- `results-redesign.jsonl`: the redesign's `signal` and `pending` sources on
+  CPython, `signal` on unix MicroPython, `none` on CircuitPython.
+- `results-lvgl-pacing.jsonl`: the frame-pacing runs, including the ones
+  before the double-present fix (the earlier `NEW` MicroPython rows with
+  `cpu_pct` around 20 and no `"static"` key).
diff --git a/tools/timing_bench/bench_timer.py b/tools/timing_bench/bench_timer.py
new file mode 100644
index 00000000..672483a5
--- /dev/null
+++ b/tools/timing_bench/bench_timer.py
@@ -0,0 +1,166 @@
+"""Timer jitter / latency / CPU benchmark, same script on CPython and MicroPython.
+
+Runs a periodic timer for DURATION_MS at PERIOD_MS and records the callback
+times in microseconds. Two main-thread modes:
+
+  idle   the main thread waits in the provider's sleep_ms (what an app at a
+         REPL prompt or in its run loop looks like)
+  busy   the main thread spins in pure Python (what a script that never
+         yields looks like; only interrupt-style providers keep firing)
+
+Reports, in one JSON line prefixed BENCH=:
+  n           callbacks delivered
+  expected    DURATION_MS / PERIOD_MS
+  lat_p50/p99/max   NEW only: ms from the timer's deadline to the callback,
+                    read from the timer itself (callback latency).
+  jit_p50/p99/max   |interval - period| in us: interval jitter
+  cpu_pct     process CPU time / wall time, both threads counted
+  bursts      callbacks less than period/4 apart (catch-up storms)
+
+usage: bench_timer.py OLD|NEW idle|busy [period_ms] [duration_ms]
+  OLD uses the current multimer (multimer.auto, MULTIMER_BACKEND honoured).
+  NEW uses the redesign (multimer.Timer / multimer.sleep_ms).
+"""
+
+import sys
+
+try:
+    from time import ticks_diff, ticks_us
+except ImportError:
+    import time as _t
+
+    def ticks_us():
+        return _t.perf_counter_ns() // 1000
+
+    def ticks_diff(a, b):
+        return a - b
+
+
+try:
+    import json
+except ImportError:
+    import ujson as json
+
+
+try:
+    from time import ticks_diff as ticks_diff_ms
+    from time import ticks_ms as ticks_ms_host
+except ImportError:
+
+    def ticks_ms_host():
+        return (ticks_us() // 1000) & ((1 << 29) - 1)
+
+    def ticks_diff_ms(a, b):
+        d = (a - b) & ((1 << 29) - 1)
+        return ((d + (1 << 28)) & ((1 << 29) - 1)) - (1 << 28)
+
+
+def cpu_time_ms():
+    """Process CPU time (user+sys, all threads) in ms."""
+    try:
+        import time
+
+        return int(time.process_time() * 1000)
+    except (ImportError, AttributeError):
+        pass
+    try:
+        with open("/proc/self/stat") as f:
+            fields = f.read().split(")")[-1].split()
+        # utime, stime are fields 14 and 15 of the whole line; after ')' they
+        # are at index 11 and 12. Clock ticks at 100 Hz on Linux.
+        return (int(fields[11]) + int(fields[12])) * 10
+    except Exception:
+        return -1
+
+
+def run(api, mode, period_ms, duration_ms):
+    stamps = []
+    if api == "OLD":
+        from multimer import auto as timer
+
+        name = timer.name
+        Timer = timer.Timer
+        sleep_ms = timer.sleep_ms
+
+        def cb(_t):
+            stamps.append(ticks_us())
+
+        tim = Timer(-1)
+        tim.init(mode=Timer.PERIODIC, period=period_ms, callback=cb, hard=False)
+        deinit = tim.deinit
+    else:
+        import multimer
+
+        sleep_ms = multimer.sleep_ms
+        lateness = []
+
+        def cb(t):
+            stamps.append(ticks_us())
+            # The timer's deadline is on multimer's own clock, which is masked
+            # to 29 bits and need not share a base with time.ticks_ms (it does
+            # not on the windows port), so measure lateness on that clock.
+            lateness.append(multimer.ticks_diff(multimer.ticks_ms(), t._due))
+
+        tim = multimer.Timer(-1)
+        tim.init(mode=multimer.Timer.PERIODIC, period=period_ms, callback=cb)
+        name = multimer.info().get("source", "?")
+        deinit = tim.deinit
+
+    cpu0 = cpu_time_ms()
+    t0 = ticks_us()
+    if mode == "idle":
+        # Sleep in slices like an app loop does.
+        while ticks_diff(ticks_us(), t0) < duration_ms * 1000:
+            sleep_ms(5)
+    else:
+        n = 0
+        while ticks_diff(ticks_us(), t0) < duration_ms * 1000:
+            n += 1
+    wall = ticks_diff(ticks_us(), t0)
+    cpu1 = cpu_time_ms()
+    deinit()
+
+    expected = duration_ms // period_ms
+    out = {
+        "api": api,
+        "provider": name,
+        "mode": mode,
+        "period_ms": period_ms,
+        "n": len(stamps),
+        "expected": expected,
+        "cpu_pct": round(100.0 * (cpu1 - cpu0) * 1000 / wall, 1) if cpu0 >= 0 and wall else -1,
+        "impl": sys.implementation.name,
+    }
+    if len(stamps) >= 3:
+        per_us = period_ms * 1000
+        ints = [ticks_diff(b, a) for a, b in zip(stamps, stamps[1:])]
+        jit = sorted(abs(i - per_us) for i in ints)
+        bursts = sum(1 for i in ints if i < per_us // 4)
+        out.update(
+            {
+                "jit_p50": jit[len(jit) // 2],
+                "jit_p99": jit[min(len(jit) - 1, len(jit) * 99 // 100)],
+                "jit_max": jit[-1],
+                "bursts": bursts,
+                "missed": expected - len(stamps),
+            }
+        )
+        if api == "NEW" and lateness:
+            late = sorted(lateness)
+            n = len(late)
+            out.update(
+                {
+                    "lat_p50": late[n // 2],
+                    "lat_p99": late[min(n - 1, n * 99 // 100)],
+                    "lat_max": late[-1],
+                }
+            )
+    print("BENCH=" + json.dumps(out))
+
+
+if __name__ == "__main__":
+    api = sys.argv[1] if len(sys.argv) > 1 else "OLD"
+    mode = sys.argv[2] if len(sys.argv) > 2 else "idle"
+    period = int(sys.argv[3]) if len(sys.argv) > 3 else 10
+    duration = int(sys.argv[4]) if len(sys.argv) > 4 else 5000
+    run(api, mode, period, duration)
diff --git a/tools/timing_bench/lv_pace.py b/tools/timing_bench/lv_pace.py
new file mode 100644
index 00000000..13613b59
--- /dev/null
+++ b/tools/timing_bench/lv_pace.py
@@ -0,0 +1,149 @@
+"""Frame pacing and CPU for an LVGL app, old or new timing layer, same script.
+
+Builds a screen with an animated arc (a fresh frame every LVGL refresh) and
+records the time of every REFR_READY event for DURATION_MS. Reports the
+present-to-present intervals (p50/p99/max, in ms), how many frames LVGL
+refreshed, and process CPU. Also counts the timer callbacks LVGL's loop ran,
+where the layer exposes it.
+
+usage: lv_pace.py OLD|NEW [duration_ms]
+Needs board_config, display_driver, lvgl and multimer on the path.
+"""
+
+import os
+import sys
+
+try:
+    from time import ticks_diff, ticks_us
+except ImportError:
+    import time as _t
+
+    def ticks_us():
+        return _t.perf_counter_ns() // 1000
+
+    def ticks_diff(a, b):
+        return a - b
+
+
+try:
+    import json
+except ImportError:
+    import ujson as json
+
+
+def cpu_time_ms():
+    try:
+        import time
+
+        return int(time.process_time() * 1000)
+    except (ImportError, AttributeError):
+        pass
+    try:
+        with open("/proc/self/stat") as f:
+            fields = f.read().split(")")[-1].split()
+        return (int(fields[11]) + int(fields[12])) * 10
+    except Exception:
+        return -1
+
+
+argv = getattr(sys, "argv", [])
+api = argv[1] if len(argv) > 1 else (os.getenv("PACE_API") or "NEW")
+duration = int(argv[2]) if len(argv) > 2 else int(os.getenv("PACE_MS") or 5000)
+
+import board_config  # noqa: E402
+import display_driver  # noqa: E402
+import lvgl as lv  # noqa: E402
+
+if api == "OLD":
+    from multimer import auto as timer
+
+    sleep_ms = timer.sleep_ms
+else:
+    import multimer
+
+    sleep_ms = multimer.sleep_ms
+
+scr = lv.screen_active()
+arc = lv.arc(scr)
+arc.set_size(120, 120)
+arc.center()
+label = lv.label(scr)
+label.set_text("pace")
+label.align(lv.ALIGN.TOP_MID, 0, 8)
+
+angle = [0]
+
+
+def _step(_t):
+    # An LVGL timer, so the arc changes on LVGL's own schedule and every
+    # refresh has something to draw.
+    angle[0] = (angle[0] + 2) % 100
+    arc.set_value(angle[0])
+
+
+_lv_timer = None
+if not os.getenv("PACE_STATIC"):
+    _lv_timer = lv.timer_create(_step, 16, None)
+
+stamps = []
+disp = lv.display_get_default()
+wanted_hist = {}
+if api == "NEW":
+    _loop = display_driver.event_loop.current_instance()
+    _orig_next = _loop._next_delay
+
+    def _counting_next(wanted, work_ms):
+        d = _orig_next(wanted, work_ms)
+        wanted_hist[d] = wanted_hist.get(d, 0) + 1
+        return d
+
+    _loop._next_delay = _counting_next
+
+
+def _refr_ready(e):
+    stamps.append(ticks_us())
+
+
+disp.add_event_cb(_refr_ready, lv.EVENT.REFR_READY, None)
+
+cpu0 = cpu_time_ms()
+t0 = ticks_us()
+while ticks_diff(ticks_us(), t0) < duration * 1000:
+    sleep_ms(5)
+wall = ticks_diff(ticks_us(), t0)
+cpu1 = cpu_time_ms()
+
+out = {
+    "api": api,
+    "impl": sys.implementation.name,
+    "frames": len(stamps),
+    "duration_ms": duration,
+    "static": bool(os.getenv("PACE_STATIC")),
+    "cpu_pct": round(100.0 * (cpu1 - cpu0) * 1000 / wall, 1) if cpu0 >= 0 else -1,
+}
+if len(stamps) >= 3:
+    ints = sorted(ticks_diff(b, a) for a, b in zip(stamps, stamps[1:]))
+    n = len(ints)
+    out.update(
+        {
+            "int_p50": ints[n // 2] / 1000,
+            "int_p99": ints[min(n - 1, n * 99 // 100)] / 1000,
+            "int_max": ints[-1] / 1000,
+            "int_min": ints[0] / 1000,
+        }
+    )
+out["driver"] = getattr(display_driver, "__file__", "?")
+loop = display_driver.event_loop.current_instance()
+if api == "NEW" and loop is not None:
+    out["wanted_hist"] = dict(sorted(wanted_hist.items()))
+    out["passes"] = loop.passes
+    out["slow_passes"] = loop.slow_passes
+    out["lvgl_timer_fired"] = loop.timer.fired
+    drv = display_driver._driver_ref
+    out["presents"] = getattr(drv, "presents", None)
+    out["max_gap_ms"] = multimer.info()["max_gap_ms"]
+print("PACE=" + json.dumps(out))
+try:
+    display_driver.app.request_quit()
+except Exception:
+    pass
diff --git a/tools/timing_bench/results-current-multimer.jsonl b/tools/timing_bench/results-current-multimer.jsonl
new file mode 100644
index 00000000..08627a8a
--- /dev/null
+++ b/tools/timing_bench/results-current-multimer.jsonl
@@ -0,0 +1,16 @@
+{"label": "cpython-3.12/librt/idle", "api": "OLD", "provider": "librt", "mode": "idle", "period_ms": 10, "n": 491, "expected": 500, "cpu_pct": 1.6, "impl": "cpython", "lat_p50": 50042, "lat_p99": 90064, "lat_max": 90111, "jit_p50": 25, "jit_p99": 9835, "jit_max": 9861, "bursts": 0}
+{"label": "cpython-3.12/threading/idle", "api": "OLD", "provider": "threading", "mode": "idle", "period_ms": 10, "n": 468, "expected": 500, "cpu_pct": 2.0, "impl": "cpython", "lat_p50": 162852, "lat_p99": 320451, "lat_max": 321676, "jit_p50": 331, "jit_p99": 5554, "jit_max": 10614, "bursts": 0}
+{"label": "cpython-3.12/polling/idle", "api": "OLD", "provider": "polling", "mode": "idle", "period_ms": 10, "n": 418, "expected": 500, "cpu_pct": 11.0, "impl": "cpython", "lat_p50": 420433, "lat_p99": 810601, "lat_max": 820679, "jit_p50": 579, "jit_p99": 9952, "jit_max": 10025, "bursts": 0}
+{"label": "cpython-3.12/sdl2/idle", "api": "OLD", "provider": "sdl2", "mode": "idle", "period_ms": 10, "n": 493, "expected": 500, "cpu_pct": 2.2, "impl": "cpython", "lat_p50": 31986, "lat_p99": 62947, "lat_max": 63612, "jit_p50": 188, "jit_p99": 873, "jit_max": 1358, "bursts": 0}
+{"label": "micropython-unix/librt/idle", "api": "OLD", "jit_max": 10046, "jit_p99": 9997, "bursts": 0, "jit_p50": 14, "period_ms": 10, "cpu_pct": 4.6, "impl": "micropython", "mode": "idle", "expected": 500, "n": 452, "provider": "librt", "lat_p99": 479992, "lat_p50": 260017, "lat_max": 480008}
+{"label": "micropython-unix/threading/idle", "api": "OLD", "jit_max": 10606, "jit_p99": 10406, "bursts": 0, "jit_p50": 1361, "period_ms": 10, "cpu_pct": 8.199999999999999, "impl": "micropython", "mode": "idle", "expected": 500, "n": 336, "provider": "threading", "lat_p99": 1629288, "lat_p50": 808818, "lat_max": 1639322}
+{"label": "micropython-unix/polling/idle", "api": "OLD", "jit_max": 9785, "jit_p99": 9658, "bursts": 0, "jit_p50": 303, "period_ms": 10, "cpu_pct": 5.4, "impl": "micropython", "mode": "idle", "expected": 500, "n": 443, "provider": "polling", "lat_p99": 569171, "lat_p50": 269850, "lat_max": 570008}
+{"label": "micropython-unix/sdl2/idle", "api": "OLD", "jit_max": 1347, "jit_p99": 777, "bursts": 0, "jit_p50": 188, "period_ms": 10, "cpu_pct": 5.0, "impl": "micropython", "mode": "idle", "expected": 500, "n": 493, "provider": "sdl2", "lat_p99": 71716, "lat_p50": 35381, "lat_max": 73752}
+{"label": "cpython-3.12/librt/busy", "api": "OLD", "provider": "librt", "mode": "busy", "period_ms": 10, "n": 500, "expected": 500, "cpu_pct": 100.0, "impl": "cpython", "lat_p50": 4, "lat_p99": 51, "lat_max": 76, "jit_p50": 3, "jit_p99": 51, "jit_max": 74, "bursts": 0}
+{"label": "cpython-3.12/threading/busy", "api": "OLD", "provider": "threading", "mode": "busy", "period_ms": 10, "n": 0, "expected": 500, "cpu_pct": 100.6, "impl": "cpython"}
+{"label": "cpython-3.12/polling/busy", "api": "OLD", "provider": "polling", "mode": "busy", "period_ms": 10, "n": 0, "expected": 500, "cpu_pct": 100.0, "impl": "cpython"}
+{"label": "cpython-3.12/sdl2/busy", "api": "OLD", "provider": "sdl2", "mode": "busy", "period_ms": 10, "n": 493, "expected": 500, "cpu_pct": 100.7, "impl": "cpython", "lat_p50": 34727, "lat_p99": 63570, "lat_max": 63849, "jit_p50": 368, "jit_p99": 767, "jit_max": 1343, "bursts": 0}
+{"label": "micropython-unix/librt/busy", "api": "OLD", "jit_max": 76, "jit_p99": 30, "bursts": 0, "jit_p50": 2, "period_ms": 10, "cpu_pct": 100.0, "impl": "micropython", "mode": "busy", "expected": 500, "n": 500, "provider": "librt", "lat_p99": 32, "lat_p50": 4, "lat_max": 82}
+{"label": "micropython-unix/threading/busy", "api": "OLD", "jit_max": 584, "jit_p99": 540, "bursts": 0, "jit_p50": 170, "period_ms": 10, "cpu_pct": 104.0, "impl": "micropython", "mode": "busy", "expected": 500, "n": 500, "provider": "threading", "lat_p99": 627, "lat_p50": 301, "lat_max": 641}
+{"label": "micropython-unix/polling/busy", "cpu_pct": 99.8, "period_ms": 10, "impl": "micropython", "n": 0, "provider": "polling", "api": "OLD", "mode": "busy", "expected": 500}
+{"label": "micropython-unix/sdl2/busy", "api": "OLD", "jit_max": 1331, "jit_p99": 309, "bursts": 0, "jit_p50": 140, "period_ms": 10, "cpu_pct": 100.2, "impl": "micropython", "mode": "busy", "expected": 500, "n": 492, "provider": "sdl2", "lat_p99": 71681, "lat_p50": 36431, "lat_max": 72183}
diff --git a/tools/timing_bench/results-lvgl-pacing.jsonl b/tools/timing_bench/results-lvgl-pacing.jsonl
new file mode 100644
index 00000000..fd7b51a7
--- /dev/null
+++ b/tools/timing_bench/results-lvgl-pacing.jsonl
@@ -0,0 +1,20 @@
+{"api": "OLD", "impl": "cpython", "frames": 74, "duration_ms": 3000, "cpu_pct": 7.9, "int_p50": 39.996, "int_p99": 50.037, "int_max": 50.037, "int_min": 35.052}
+{"api": "NEW", "impl": "cpython", "frames": 91, "duration_ms": 3000, "cpu_pct": 18.5, "int_p50": 33.111, "int_p99": 34.124, "int_max": 34.124, "int_min": 32.254, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "wanted_hist": {"1": 56, "2": 62, "3": 56, "4": 49, "5": 39, "6": 61, "7": 30, "8": 23, "9": 25, "10": 110}, "passes": 511, "slow_passes": 0, "lvgl_timer_fired": 511, "presents": 90, "max_gap_ms": 6}
+{"lvgl_timer_fired": 524, "api": "NEW", "int_max": 34.357, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "wanted_hist": {"10": 102, "1": 58, "2": 65, "3": 24, "4": 89, "5": 46, "6": 42, "7": 39, "8": 41, "9": 18}, "cpu_pct": 20.3, "frames": 91, "impl": "micropython", "int_p50": 32.971, "passes": 524, "slow_passes": 0, "int_min": 32.566, "int_p99": 34.357, "duration_ms": 3000, "presents": 91, "max_gap_ms": 5}
+{"duration_ms": 3000, "impl": "micropython", "int_p50": 39.998, "frames": 75, "api": "OLD", "int_p99": 40.122, "cpu_pct": 10.3, "int_min": 39.831, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py", "int_max": 40.122}
+{"api": "NEW", "impl": "cpython", "frames": 91, "duration_ms": 3000, "static": false, "cpu_pct": 11.8, "int_p50": 33.124, "int_p99": 34.295, "int_max": 34.295, "int_min": 32.097, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "wanted_hist": {"1": 57, "2": 61, "3": 48, "4": 56, "5": 52, "6": 32, "7": 31, "8": 34, "9": 21, "10": 118}, "passes": 510, "slow_passes": 0, "lvgl_timer_fired": 510, "presents": 91, "max_gap_ms": 6}
+{"api": "OLD", "impl": "cpython", "frames": 75, "duration_ms": 3000, "static": false, "cpu_pct": 8.8, "int_p50": 40.01, "int_p99": 50.096, "int_max": 50.096, "int_min": 39.679, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py"}
+{"api": "NEW", "impl": "cpython", "frames": 2, "duration_ms": 3000, "static": true, "cpu_pct": 6.5, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "wanted_hist": {"2": 1, "8": 1, "10": 293}, "passes": 295, "slow_passes": 0, "lvgl_timer_fired": 295, "presents": 1, "max_gap_ms": 6}
+{"api": "OLD", "impl": "cpython", "frames": 2, "duration_ms": 3000, "static": true, "cpu_pct": 8.9, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py"}
+{"lvgl_timer_fired": 526, "api": "NEW", "max_gap_ms": 5, "int_max": 34.142, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "cpu_pct": 15.7, "frames": 91, "impl": "micropython", "int_p50": 32.992, "static": false, "passes": 526, "int_min": 32.551, "int_p99": 34.142, "duration_ms": 3000, "slow_passes": 0, "presents": 90}
+{"impl": "micropython", "int_p99": 40.26, "static": false, "frames": 75, "int_p50": 39.999, "int_max": 40.26, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py", "int_min": 39.748, "api": "OLD", "duration_ms": 3000, "cpu_pct": 10.7}
+{"lvgl_timer_fired": 301, "api": "NEW", "presents": 1, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "slow_passes": 0, "frames": 2, "impl": "micropython", "cpu_pct": 7.0, "static": true, "passes": 301, "duration_ms": 3000, "max_gap_ms": 5}
+{"driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py", "duration_ms": 3000, "cpu_pct": 10.0, "frames": 2, "static": true, "api": "OLD", "impl": "micropython"}
+{"api": "OLD", "impl": "cpython", "frames": 75, "duration_ms": 3000, "static": false, "cpu_pct": 7.6, "int_p50": 40.0, "int_p99": 49.848, "int_max": 49.848, "int_min": 34.92, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py"}
+{"impl": "micropython", "int_p99": 40.116, "static": false, "frames": 75, "int_p50": 39.999, "int_max": 40.116, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py", "int_min": 39.801, "api": "OLD", "duration_ms": 3000, "cpu_pct": 9.699999999999999}
+{"api": "NEW", "impl": "cpython", "frames": 91, "duration_ms": 3000, "static": false, "cpu_pct": 12.3, "int_p50": 33.117, "int_p99": 34.396, "int_max": 34.396, "int_min": 32.339, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "passes": 508, "slow_passes": 0, "lvgl_timer_fired": 508, "presents": 90, "max_gap_ms": 6}
+{"lvgl_timer_fired": 529, "api": "NEW", "max_gap_ms": 5, "int_max": 34.398, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "cpu_pct": 13.0, "frames": 91, "impl": "micropython", "int_p50": 33.015, "static": false, "passes": 529, "int_min": 32.632, "int_p99": 34.398, "duration_ms": 3000, "slow_passes": 0, "presents": 91}
+{"api": "OLD", "impl": "cpython", "frames": 2, "duration_ms": 3000, "static": true, "cpu_pct": 8.7, "driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py"}
+{"driver": "/tmp/claude-0/-home-user-workspace/8d2e8b24-a789-5075-be5d-8f8270f3b5df/scratchpad/dd_orig/display_driver.py", "duration_ms": 3000, "cpu_pct": 9.699999999999999, "frames": 2, "static": true, "api": "OLD", "impl": "micropython"}
+{"api": "NEW", "impl": "cpython", "frames": 2, "duration_ms": 3000, "static": true, "cpu_pct": 6.1, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "passes": 296, "slow_passes": 0, "lvgl_timer_fired": 296, "presents": 1, "max_gap_ms": 6}
+{"lvgl_timer_fired": 301, "api": "NEW", "presents": 1, "driver": "/home/user/workspace/lvgl-bindings/python/display_driver.py", "slow_passes": 0, "frames": 2, "impl": "micropython", "cpu_pct": 6.0, "static": true, "passes": 301, "duration_ms": 3000, "max_gap_ms": 5}
diff --git a/tools/timing_bench/results-redesign.jsonl b/tools/timing_bench/results-redesign.jsonl
new file mode 100644
index 00000000..d28fc9f5
--- /dev/null
+++ b/tools/timing_bench/results-redesign.jsonl
@@ -0,0 +1,10 @@
+{"label": "cpython-3.12/new-signal/idle", "api": "NEW", "provider": "signal", "mode": "idle", "period_ms": 10, "n": 500, "expected": 500, "cpu_pct": 2.3, "impl": "cpython", "jit_p50": 470, "jit_p99": 761, "jit_max": 780, "bursts": 0, "missed": 0, "lat_p50": 0, "lat_p99": 1, "lat_max": 1}
+{"label": "cpython-3.12/new-pending/idle", "api": "NEW", "provider": "pending", "mode": "idle", "period_ms": 10, "n": 501, "expected": 500, "cpu_pct": 3.8, "impl": "cpython", "jit_p50": 503, "jit_p99": 713, "jit_max": 890, "bursts": 0, "missed": -1, "lat_p50": 0, "lat_p99": 1, "lat_max": 1}
+{"label": "micropython-unix/new-signal/idle", "api": "NEW", "jit_p99": 391, "jit_max": 436, "bursts": 0, "jit_p50": 106, "missed": 0, "period_ms": 10, "impl": "micropython", "mode": "idle", "expected": 500, "n": 500, "provider": "signal", "cpu_pct": 4.8, "lat_p50": 0, "lat_max": 0, "lat_p99": 0}
+{"label": "circuitpython-unix/new-none/idle", "error": "no result"}
+{"label": "cpython-3.12/new-signal/busy", "api": "NEW", "provider": "signal", "mode": "busy", "period_ms": 10, "n": 500, "expected": 500, "cpu_pct": 100.0, "impl": "cpython", "jit_p50": 35, "jit_p99": 970, "jit_max": 972, "bursts": 0, "missed": 0, "lat_p50": 0, "lat_p99": 1, "lat_max": 1}
+{"label": "cpython-3.12/new-pending/busy", "api": "NEW", "provider": "pending", "mode": "busy", "period_ms": 10, "n": 500, "expected": 500, "cpu_pct": 100.6, "impl": "cpython", "jit_p50": 4739, "jit_p99": 5463, "jit_max": 5558, "bursts": 0, "missed": 0, "lat_p50": 5, "lat_p99": 6, "lat_max": 6}
+{"label": "micropython-unix/new-signal/busy", "api": "NEW", "jit_p99": 966, "jit_max": 967, "bursts": 0, "jit_p50": 35, "missed": 0, "period_ms": 10, "impl": "micropython", "mode": "busy", "expected": 500, "n": 500, "provider": "signal", "cpu_pct": 99.8, "lat_p50": 0, "lat_max": 1, "lat_p99": 1}
+{"label": "circuitpython-unix/new-none/busy", "error": "no result"}
+{"label": "circuitpython-unix/new-none/idle", "api": "NEW", "jit_p99": 547, "jit_max": 676, "bursts": 0, "jit_p50": 186, "missed": 0, "period_ms": 10, "impl": "circuitpython", "mode": "idle", "expected": 500, "n": 500, "provider": "none", "cpu_pct": 4.4, "lat_p50": 0, "lat_max": 0, "lat_p99": 0}
+{"label": "circuitpython-unix/new-none/busy", "cpu_pct": 99.8, "period_ms": 10, "impl": "circuitpython", "n": 0, "provider": "none", "api": "NEW", "mode": "busy", "expected": 500}