speedrun v0.2.7

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• A failed flow's debug output explains what happened. Next to commands.json and the screenshot, a failed flow's folder now has logs/debug.log. It holds the end of what SPEEDRUN_DEBUG=1 prints, without having to rerun with it:

  • each command's start and end;
  • where each tap landed and which elements were there;
  • how the screen settled;
  • the screen's texts each time they changed.

  A failure that comes once in many runs can be read from the zip of that folder. Lines carry the local time, as the iOS agent's log does.

• iOS: the agent's log in the debug output covers more time. XCTest logs a line for every read of the screen, about 20 a second while a step waits. So the last 400 lines of logs/ios-agent.log covered only the last 22 s. Runs of those lines are now written as one line with a count, and the log covers the whole failing step.

• iOS: reads of the app without any text are looked into. v0.2.6 logged a read of the app with no elements under it. On the CI run it was made for, the app did have elements, just none with any text, so nothing was logged. The check now fires on a read with no text, label or id anywhere. Once that has lasted 2 s, Speedrun reads the app again through a fresh connection and continues with it if it has text. Every 5 s, the agent's log gets a speedrun: empty read of … line describing:

  • what the app holds;
  • what a touch would reach at four points of the screen;
  • which apps XCTest sees.

  Launch screens and transitions end before the 2 s and are left alone.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.6

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• iOS: when a read of the app comes back empty, Speedrun tries again and records why. On one CI run, with iOS 26's "Save Password?" sheet up over a busy React Native screen, every read of the app for a minute held nothing but the app itself: neither the sheet nor the screen behind it, though both were showing. We haven't been able to reproduce it yet. Such a read is now repeated through a fresh connection to the app, and Speedrun continues with that one if it returns the screen. Either way, the agent's log (logs/ios-agent.log in a failed flow's debug output) gets a speedrun: empty read of … line every 5 s while it lasts, with what XCTest sees: the app's state and process, the apps it lists as on screen, and what SpringBoard and those apps contain. If you hit this, please send us that log. Normal runs never read empty and are unchanged.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.5

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• Android: taps wait for a press the app handles late. React Native handles a press on its JavaScript thread. When that thread is busy, for example while a screen that just opened is still rendering, the press takes effect up to a second later. Speedrun could take the screen as settled before that and send the next tap to the screen the first press was about to change: a second Back press reached the screen that was closing and did nothing, and a tab press landed on a modal that was closing. After a tap, if the screen still shows the same elements with the same text, Speedrun now waits up to a second for it to change, as it already did after a tap that redrew nothing. Taps that change the screen right away don't wait, and in Speedrun Bench's Android suite no tap does.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.4

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• Android: inputText types the whole text on a slow device. Android drops a key event that waits more than 10 s. Speedrun sent the whole text in one burst, so when the app took longer than that (a busy CI emulator, an app just installed), the end of the text was lost and the step still passed. Keys now go in small chunks, each key stamped as it is sent, sized to the app's pace. Typing on a normal device is as fast as before. eraseText had the same problem and is fixed too. (#7)
• Android: a scroll that starts on a text field scrolls. React Native's TextInput holds on to a touch until the finger moves, then hands it back to the scroll view. Speedrun's drag sent the rest of its movement at once, too early for the scroll view to use it, so scrollUntilVisible on a form could drag again and again without moving. The drag now waits for the scroll view to take over. (#6)
• Regular expressions: a long pattern works, or fails with a clear error. A pattern too large for Speedrun's regex engine (a list of more than about a hundred alternatives) was matched as plain text, with no message: assertVisible failed and assertNotVisible passed. Such a pattern is now split into parts that the engine can handle, and the rare one that still can't be split fails with an error naming it. Patterns can also use more than 10 groups. (#5)
• Faster lookups on deep screens. Finding an element by text or id checked each element of the screen several times. It now checks each one once.

Thanks to @dextorer for #5 and #7, @elyonz for #6, and @daentech for the analysis and patch in #7. Each issue came with a precise diagnosis and a repro.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.3

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• Android: Jetpack Compose screens are read as they are. Compose sends test tools no accessibility events, so on a Compose screen with more than ~50 elements, Speedrun could keep seeing an element that was gone (an extendedWaitUntil: notVisible timed out) or an old text. While a Compose screen shows, each read now asks the app for every element again. That makes reads slower there (~100 ms against ~10 ms on a 134-element screen); View-based and React Native apps keep their speed. (#2)
• Android: runs on several devices at once. Each run used to forward the same port of this machine (7777) to its device's agent, so parallel --device runs could take each other's connection, and the first to finish cut the others off. Each run now gets a free port of its own from adb. --port still sets the agent's port on the device. (#3)
• YAML: a double-quoted string continued with \ at the end of a line no longer gets an extra space where the lines join, as YAML 1.2 says (Jackson writes long strings this way). (#4)
• iOS: taps wait for an overlay the screen does not list yet. An overlay that fades in takes touches before it shows up in the accessibility tree. Before every tap, Speedrun now asks iOS what a touch at the element would reach, as XCTest's isHittable does, and waits briefly when something else would take it. It used to ask only while a spinner showed.
• iOS: the agent no longer drops out mid-run. An accessibility error that XCTest recorded as a test failure ended the agent, and the run had to restart it. Such errors are now logged and the agent carries on.

Thanks to @dextorer for #2, #3 and #4: each came with a precise diagnosis, and #2 with a repro app and a patch.

Speedrun Bench gained a screen in each platform's own toolkit, Jetpack Compose on Android and SwiftUI on iOS, with a flow covering the cases above. The suite now has 20 flows, passing on both platforms.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.2

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• Android: screens that never stop moving. An animation that never ends (an Animated loop, on the native or the JS driver, a ticking counter) draws a frame every few milliseconds, and Speedrun's wait for the screen to settle ran to its 10 s timeout on most taps there. It now leaves out the few elements that change on every read while the rest of the screen holds still, as it already did on iOS. Those taps take 1.4 s, and Speedrun Bench's animations flow 35 s instead of 81–148 s.
• Disabled buttons: a tap on a disabled element waits at most 3 s for it to turn on (it waited up to 17 s), then taps anyway. A flow that taps a button that stays off, to check that nothing happens, no longer waits out the full lookup time.

Speedrun Bench's suite with this release: Android 355 s (8.7x Maestro on the flows both pass), iOS 573 s.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.1

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• Memory: waiting for an element (every lookup, assertion and extendedWaitUntil) no longer grows Speedrun's memory. The regex engine's scratch was kept until the run ended, ~9 MB per screen read: a 17 s wait for a missing element on Android went past 17 GB, and three passing iOS flows reached 1.4 GB. Both now stay under 15 MB. Thanks to @stromae666 for the report, its diagnosis and a patch (#1).
• Faster on iOS: a tap no longer waits for a change elsewhere on the screen to end (a banner growing in a feed held a tab bar tap 1.2 s), and a step no longer reads the screen a second time (~0.2 s on a busy screen). Speedrun Bench's iOS suite runs in 588 s instead of 684 s.

To update: speedrun update, or brew upgrade speedrun if you installed with Homebrew.

speedrun v0.2.0

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• One binary. The iOS agent is now built into speedrun (4.7 MB), and the first iOS run unpacks it into ~/Library/Caches/speedrun. Nothing has to sit next to the binary any more: put it anywhere on your PATH, /usr/local/bin included.
• Homebrew: brew install hubastard/tap/speedrun (macOS on Apple silicon, Linux x86_64), and brew upgrade speedrun to update. Installed that way, Speedrun's new-release line and speedrun update point to brew upgrade.
• The install script installs the binary alone (SPEEDRUN_DIR=<folder> picks where), removes an earlier release's agent/ folder only once it has checked it is Speedrun's, and leaves your shell profile alone when the folder is already on your PATH.
• speedrun --licenses prints Speedrun's license and those of the code built into it.

From 0.1.x: speedrun update (or the install script) replaces the binary and removes the old agent/ folder next to it.

speedrun v0.1.15

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• Security: the agents answer only Speedrun. The Android agent listened on the device's localhost, where any app installed on the device could connect and run shell commands as the shell user; the iOS agent likewise answered any program on the Mac. Each connection now starts with a random token Speedrun makes at every start, and the agents close any other.
• Security: sessions. The session's token is no longer on the command line (other users of the Mac could see it with ps), the session folder and its files are readable by you alone, and a session drops a request that is oversized or never comes, instead of waiting on it.
• Security, the rest: flow scripts' http takes http and https only, redirects included (no file://); temp files are created privately, under random names; the HTML report loads Bootstrap pinned by its hash; the default debug output (~/.speedrun/tests) is readable by you alone.
• Releases carry their SHA-256, which install.sh and speedrun update check: a download that does not match is not installed.
• Speedrun says when a newer release is out, at the end of speedrun test, speedrun session start and speedrun --version. It asks GitHub at most once a day, in the background, never on CI; SPEEDRUN_NO_UPDATE_CHECK=1 turns it off.
• iOS: typing that loses keys is typed again. A React Native field lost keys on CI's simulator ("sneaker" came out "saker"); since 0.1.10 Speedrun caught keys that arrived out of order, and now it catches lost ones too.

speedrun v0.1.14

macOS arm64 and Linux x86_64, Android and iOS simulators (the iOS agent was built with Xcode 27.0).

• iOS: screens with shimmering skeletons settle reliably fast. Speedrun stops waiting for an element that moves endlessly (a shimmer, a marquee, a carousel), but a highlight that slides out of its clipped block holds still for a moment, and that pause made Speedrun wait for the whole screen to finish loading instead (2.3-3.9 s instead of 1.1 s on Speedrun Bench's feed, about two times in three). A short pause no longer counts. Speedrun's iOS time in the agent-tools benchmark went from 12.0 s to 9.4 s.
• Speedrun Bench's device flow no longer fails when the iOS photos prompt shows up.