# 0.6.0

Released 10 November 2026.

Squiggle tells you whether a scroll or an animation is smooth, frame by frame, from a recording or live on the app, and a flow can fail when it isn't. `squiggle flow` gains checks for a screen's layout at every text size and width, for its gestures and springs, and for a busy JS thread, reordered responses and calendar dates. Flows and your agent can pinch, drag along a path and keep the on-screen keyboard up, your agent reads the app's console and changes the simulator's settings, and a web or Mac app your project declares opens by itself when a run needs it.

Some flows that loaded in 0.5.5 now stop with a parse error that names the mistake, instead of running a step that proves nothing: an `assert` with no check, a `pressKey` with no key, a `key` on any other step, a `delivery` other than `auto`, `real` or `runtime`, a `when:` with a key other than `visible`, `notVisible`, `route` or `true`, a `waitFor` `timeout` that isn't a whole number of milliseconds or `auto` (such as `10s`), and a `scrollUntilVisible` `maxScrolls` that isn't a positive whole number. An intent program with `config`, `secrets` or `tags` is refused. A `runFlow` file named inside a sub-flow is now found beside that sub-flow's file, not beside the flow the run started from, so fix any path written the old way. To name a step, use `note:`: a `label:` is the accessibility label of the control to act on whenever nothing else in the step names one. In a monorepo, `squiggle init` writes `.squiggle` at the workspace root: move a `.squiggle` folder an earlier init left in your app's folder.

## Desktop app

- **New**: the Devices list shows your project's web app as Not open before any window shows it, and choosing it opens Squiggle's window
- **New**: the Devices list and the device menu show your project's Mac app as Not running when it is stopped, and choosing it launches it with Squiggle
- **New**: Go to screen sits in the device panel, named by the screen the app is on: it lists every screen grouped the way the app nests them, with a search, and walks the app to the one you choose. It and the inspect-element button show only while the app is live. Reload JS moves to the device menu
- **New**: Tunings says what each record is, what it changes and how it went, and Preview a setting shows, on a screen Squiggle captured, which controls a setting moves as you drag it
- **New**: Settings has Connect your agents, which connects the coding agents it finds to the open project
- **Fix**: with several simulators booted and no `--udid`, a run of the project uses the device Studio shows
- **Fix**: Studio's window keeps the width its open side panels need, so the right panel no longer runs past the window's edge
- **Fix**: the Renders table's hover card opens over its row and holds still while the table scrolls, and Your code lists only your components
- **Fix**: Studio no longer freezes when it trims a large component graph
- **Fix**: Studio's findings for an app built with React Compiler no longer advise `useMemo`

## CLI

- **New**: `squiggle init` asks once to connect the coding agents it finds: Claude Code, Copilot, Codex and Cursor. `--yes` connects them all, `--agent claude,codex` names the ones to connect (`none` for none), and `--agents-only` connects them in any folder without setting up the app
- **New**: `squiggle device` changes the simulator from a terminal, like Studio's device menus: `appearance`, `contrast`, `text-size`, `status-bar`, `location`, `permission`, `button`, `shake`, and `keyboard on`, `off`, `default` or `status` to keep the on-screen keyboard showing while you type from the Mac
- **New**: `squiggle logs` prints the app's console lines your project saved, a worklet's `console.log` included. `--level`, `--text`, `--limit` and `--since` filter them, and `--follow` prints new ones until you press Ctrl+C
- **New**: `squiggle motion --video <file>` judges a screen recording, one of Squiggle's or any mp4: how far the content moved each frame, and each stall, dropped or repeated frame, jump, judder or reversal with its time and frame numbers. It exits 1 when the motion is janky. `--region` and `--ignore` choose what to measure, `--chart` draws speed over time with the bad frames marked, and `--against` compares with a baseline and exits 1 only when it got worse. On a Squiggle recording, each problem says what your app was busy with. When something else in the frame moves on its own, such as a spinner, it warns and names the `--region` or `--ignore` to pass. Needs ffmpeg
- **New**: `squiggle flow --breakpoints` finds where a screen's layout changes. On a web page it moves the width from 320 to 1280 px and lists each width where a control appears, disappears, moves to another row or changes how it grows; on an iOS simulator it runs the flow at each of the 12 text sizes; on a Mac app, or an iOS simulator with `--breakpoints-range`, it lays the app out at each width up to the screen's. `--breakpoints-prove` marks every width proven, falsified or inconclusive for controls that overlap or leave the screen, and `--breakpoints-save` saves and runs two flows either side of each web breakpoint
- **New**: `squiggle flow --matrix --predict` runs the flow once, predicts what the matrix would find at every text size, then runs the setups it flags and a sample of the rest to check the prediction, and says how many of your saved sessions each problem would reach. `--predict-widths`, `--predict-heights`, `--predict-expansion` (longer labels, as a translation makes them), `--predict-keyboard`, `--predict-breakpoints`, `--predict-steps`, `--predict-prove` and `--predict-funnel` predict more. Needs a debug build on an iOS simulator
- **New**: `--repair` works out the tunable values from the screen's layout and measures only those, instead of trying value after value; an app that can't capture its layout is searched the old way. `--repair-landing-check` checks each in-between state of a change that moves several tunables, and `--repair-control` measures what each search spends
- **New**: `--busy-js <ms>` runs the flow again with your app's JS thread held busy before every step (`--from-step` picks where it starts), and lists each step that breaks
- **New**: `--reorder` swaps the order in which each pair of in-flight requests answers, and lists each swap that fails the flow or changes its last screen
- **New**: `--clock` moves your app's clock (in a debug build) to each calendar landmark over the next 400 days (`--clock-days` sets another span), such as month and year ends, 29 February and daylight-saving changes, and finds where the screen's text changes
- **New**: `--confirm-jank` mutes the timer a periodic-jank finding names, runs the flow again, and says confirmed when the beat is gone
- **New**: `--gesture-map <testID>` finds, to the degree, where a drag on a control gives way to scrolling its list, and fails when a gesture has less than `--gesture-margin` degrees to spare
- **New**: `--scroll-sweep <testID>` and `--drag-sweep <testID>` (with `--drag-by`) list where each element's position bends or jumps as a list scrolls or a finger drags, and fail when an element jumps. A scroll sweep also fails when a sticky element lets go or an element is never wholly visible
- **New**: `--motion` runs the flow twice watching every view, fits each element's motion as a spring, and fails on a value that jumps or views from one line of your code that run different springs
- **New**: `--stub-delays <match=ms,…>` with `--stubs` answers chosen endpoints after the delay you give and prints each screen's time to ready beside the prediction, and `--cpu-throttle` with `--cliff` on a web page runs the sweep with the page's CPU slowed
- **New**: `--record-fps` sets a recording's frame rate (60 by default, 30 in a browser tab), and `--record-tail` keeps recording after the last step
- **New**: `squiggle bench --breaks` lists where a flow's time changed, and gives a slowdown between two commits with the `squiggle bisect` command for that range. A bench also compares each phase and step at the machine load of the run it is compared with, keeps each step's render count, and says how much render time a change in your components' renders adds or saves
- **New**: `squiggle card` has a layout row from the screen's last `--predict-prove` run, and its network row says how long a screen took at the latencies your real sessions measured. A screen budget's `network` entry (`readyMs`, `latencyUpToMs`) sets how fast the screen must be ready however slow your server gets, and the card checks it
- **New**: `squiggle contracts navigation` checks the navigation your project declares under `navigation` in `.squiggle/config.jsonc` against the screens Squiggle has recorded: each check proven, falsified with the shortest path that breaks it, or inconclusive. `--reproduce` saves each falsified answer as a flow and runs it
- **New**: `squiggle product screens --cost` ranks screens by what they cost your real sessions: dropped frames on the worst tap and time to interactive, times the share of sessions that open each screen. When a cliff's size names the state that holds it, `--cliff` and the card say how many real sessions reach it
- **Fix**: with several simulators booted and no `--udid`, a run uses the device your project's MCP session drives, else the one running your app
- **Fix**: `squiggle init` in a monorepo writes `.squiggle` at the workspace root, where `squiggle flow` and the MCP server read it. Before, the `squiggle flow smoke` it suggested failed with `E_NO_FLOW_FILE`
- **Fix**: an app in a yarn, pnpm or bun workspace is set up with that package manager, not npm
- **Fix**: `squiggle flow auth/login` runs the flow in the auth folder, the name `run_flow` and the library use, and a `.yml` flow runs by its name
- **Fix**: `squiggle doctor` checks the Metro that serves your app, not a fixed port 8082
- **Fix**: `squiggle up --url` gives the page its full 30 seconds to connect however long the browser takes to start, and a browser window Squiggle opens quits and leaves no profile behind when Squiggle stops
- **Fix**: `squiggle bisect` and `squiggle bakeoff` send the app back to the Metro it was on, whatever its port
- **Fix**: `squiggle probe --udid mac:<bundle id>` reads a Mac app running beside a simulator app on the same Metro
- **Fix**: Squiggle finds your app's Metro on any port, not only 8081 to 8090, for runs, `status`, `squiggle up` and the perf tools, and `metroUrl` in `.squiggle/config.jsonc` names one
- **Fix**: Squiggle never attaches to another project's app that dials its port, and `squiggle up` never opens another project's Metro that shares your Expo slug
- **Fix**: a relaunched app comes back on the Metro it was on, a stopped dev-client app comes back on its project's Metro rather than the launcher, and the launcher opens your app's Metro even when your config names no bundle id
- **Fix**: an app dialling a different port is found, named and moved to the run's port, instead of a silent wait. A stopped app is reported as stopped, and a port is blamed only when the app is running and dialling elsewhere
- **Fix**: port 7777 held by a Squiggle process that has stopped or is leaving comes free on its own, `squiggle up` hands it to an agent that asks, and `status` names who holds it, including a Studio too busy to answer
- **Fix**: a relaunch keeps network capture on, and the stubs a flow set survive a relaunch inside it
- **Fix**: a run that changed a browser tab's viewport puts back the configured one when it ends

## Agents & MCP

- **New**: the `motion` tool says whether a scroll or animation in a recording is smooth, frame by frame, as `squiggle motion --video` does. With `testID`, it follows that view on the running app at every frame the screen draws, around a tap or a scroll, with no recording. Each problem says what the app was busy with in those frames, `against` compares with a baseline, and `chart` adds a picture of speed over time that `publish_evidence` can attach
- **New**: `record_start { video: true }` films the steps you drive yourself to an .mp4 until `record_stop`. `fps` and `tailMs` set the frame rate and keep filming after the last step, on `record_start` and `run_flow { record }` alike
- **New**: the `logs` tool reads the app's console, a worklet's `console.log` included, filtered by `level` and `text`, and `since` returns only newer lines
- **New**: the `device` tool reads and changes the simulator settings in Studio's device menus: appearance, contrast, text size, status bar, location, permissions, hardware buttons, shake and the keyboard
- **New**: on an iOS simulator, the on-screen keyboard opens when your agent's field takes focus and stays up while it types, as it does for a person. `device { hideKeyboard: true }` puts it away, and `device { softKeyboard: false }` types as a hardware keyboard
- **New**: the `pinch` and `drag` tools pinch with two fingers about a control, and drag one touch along a path of up to 32 legs before lifting
- **New**: an `approvals` block in `.squiggle/config.jsonc` lets your agent go on past a blocked step without you: in `agent` mode a sign-out goes through, and a delete goes through when your agent says why it is safe or deletes something the run created. The `approvals` tool sets the mode for the rest of the session, and `approve_action { remember: "session" }` approves a control for the rest of it. The deny list and the production rule still hold
- **New**: `squiggle mcp --http <port>` serves the MCP server at `http://127.0.0.1:<port>/mcp`, so an agent that is already running connects by URL. `--http 0` takes a free port, and `--host` listens beyond this machine
- **New**: a drive tool launches your project's iOS app when it is installed but stopped, and its result says so. A Mac app your project declares is launched with Squiggle when a run or a tool needs it, with no `squiggle up` first
- **New**: a React web app opens in Squiggle's window when a flow, your agent or `squiggle up` needs it, and the window stays open until you close it. In CI, or with `SQUIGGLE_HEADLESS=1`, the window belongs to the run and closes when it ends
- **New**: `run_flow`, `library_list` and `library_save` take `root`, so an agent working in a git worktree runs and saves that worktree's flows
- **New**: when your app shows a red box after a Fast Refresh edit, every tool result and `status` say so at once, with the line it came from, and a flow step that meets it fails instead of timing out
- **New**: `renders { mounts: true }` also lists what mounted and what each mount cost, and perf.db keeps mounts
- **New**: `propose_fix { rank: "saving" }` lists the components whose memo misses and render storms cost the most render time, with what a fix would save, and `measure` records what it really saved
- **New**: `what_if` with `condition: layout` says what the screen does at another width, text size or tunable value, without touching the app, marked predicted or inconclusive
- **New**: `wait_for` waits for a control to appear (`visible`) or go away (`notVisible`), and `invariants { action: navigation }` checks your declared navigation
- **New**: `watch.mute` in `.squiggle/config.jsonc`, or `incidents { mute }`, keeps a detector or a component off your agent's notices
- **Fix**: `library_list` answers at once, and `run_flow` refuses an unknown flow name at once with `E_NO_FLOW` and the closest names, with no wait for an app
- **Fix**: `run_flow` with `waitMs` runs the flow in the background: `waitMs: 0` returns a run id at once, and `describe`, `screenshot`, `perf_profile` and `perf_heap` work while it runs
- **Fix**: performance findings no longer crowd tool results: one line per detector, told again only when a finding gets worse
- **Fix**: a `tap` or `input_text` sent while its target is still moving waits for it to stop, so a tap right after typing lands
- **Fix**: two identical controls can each be targeted: `nth` is accepted, and a refusal over an ambiguous match offers a `ref` and selector for each
- **Fix**: `inspect` reports where a component is drawn on screen, or why it has no frame
- **Fix**: `perf_insights` replies with a compact summary that fits the reply limit, folding repeats of one finding, with detail by index
- **Fix**: `perf_sql` waits for rows still being written and says when this server isn't the one recording the app
- **Fix**: `filmstrip` lays out up to 36 columns, each tile shows the frame at the time on its label, a second call renders its own sheet, and with no video named it reads only a recording made in this session
- **Fix**: `status` and `incidents` report only the incidents of the app your agent drives, not another app on the same simulator
- **Fix**: an MCP server started in a git worktree reads that worktree's flows and saves its app's data there, and `root` wins over `SQUIGGLE_PROJECT_ROOT`
- **Fix**: `launch_app { udid }` picks the simulator, and an agent whose app stops stays on that simulator and launches it there again, instead of asking which booted one to use
- **Fix**: `perf_profile` and `perf_heap` find your app's Metro, and say what React Native's "multiple hosts" refusal means
- **Fix**: a memo-miss finding no longer lists library components when Metro was down at the end of the session

## Flows & device

- **New**: `assert: { smooth }` takes `jankFrames`, `stallMs` and `smoothness`, read by following the element at every frame for `ms`, so a flow fails when its motion gets worse. An element that never moved fails the check
- **New**: a `pinch` step zooms in or out with two fingers, and a `doubleTap` lands as one double tap, so a photo viewer can be driven like a phone
- **New**: a `drag` step walks a path in one touch, so a sheet can be pulled down, back up and down again before it is let go
- **New**: a `hover` step runs a control's hover handlers on a web or Mac app, and `leave: true` moves off it
- **New**: a `showKeyboard` step opens the on-screen keyboard on an iOS simulator and keeps it up while text is typed
- **New**: a step takes the name and arguments of the MCP tool that does the same: `inputText` types, `wait` pauses, `waitFor` takes `timeoutMs`, and a step name Squiggle doesn't know names the closest one it does
- **New**: `waitFor: { ms }` pauses, and `scrollUntilVisible` takes a `timeout`
- **New**: an intent program can open a deep link with an `openLink` step
- **Fix**: a tap that puts a text field in focus counts as its reaction, so field taps are no longer sent twice and flagged "no graph reaction"
- **Fix**: a tap waits for what `onPress` did, not for the button's pressed style, and a `type` with `submit` waits for what Return does, so the next step reads the changed screen
- **Fix**: a tap that got no reaction because its target moved is pressed in the app on the retry, and the step says how it landed
- **Fix**: typing into a field that is still loading waits for it and types again, and fails as never ready instead of reporting every key dropped
- **Fix**: a tap by testID or ref on a header or toolbar item, including an iOS 26 bottom toolbar item, lands where iOS draws it, and the search field iOS draws in the navigation bar can be tapped and typed into
- **Fix**: a link wrapped in Expo Router's zoom transition can be tapped by its testID
- **Fix**: a selector means the same in a flow, an intent program and the MCP tools: `label` is the accessibility label everywhere, and `point` takes `"x, y"` (points or percentages) or `[x, y]` (fractions of the screen) on every surface
- **Fix**: a `${VAR}` is replaced in every string a step holds, so `waitFor: { visible }` and `when` guards find a testID built from a variable
- **Fix**: your app's own full-window overlay or modal hides the screen beneath it: `describe` no longer lists what it covers, and a tap there is refused
- **Fix**: a swipe runs as slowly as its `duration` asks instead of at most 1 second, takes a `point`, and never starts on a screen edge iOS keeps for itself
- **Fix**: `droppedFrames` reads only frames measured after the step began, so a cold launch's jank no longer fails the first tap
- **Fix**: `back` taps the header's back button when the edge swipe doesn't navigate, in flows and over MCP
- **Fix**: an `openLink` that reloads the app waits for it to reconnect, `waitFor` and `wait_for` keep waiting through a reload within their timeout, and iOS's "Open in …?" prompt is pressed for you
- **Fix**: `waitFor: { animationIdle: true }` settles while a text field has focus: the blinking cursor no longer counts as motion
- **Fix**: a run's first tap waits for a screen that mounts a beat after the prerequisite
- **Fix**: an inline flow's `runFlow` and `addMedia` paths start at the project folder, on the CLI, MCP and Studio alike
- **Fix**: a `network.stub` step no longer passes while the app runs without network capture, and `squiggle flows` turns capture on when any flow stubs or waits for the network
- **Fix**: network capture passes upload progress, authentication challenges and redirects back to your app
- **Fix**: your editor accepts every flow Squiggle accepts, including a `goal` written as a mapping and `delivery: runtime`, and flags what Squiggle rejects
- **Fix**: `onStuck: abort` is accepted everywhere and runs as `fail`
- **Fix**: a recording of a gesture that changed mid-touch replays what the finger did, and a recognizer that failed is no longer recorded as a tap

## Performance

- **New**: the periodic-jank finding names a JS thread that blocks on a beat, and what leads it: a timer with the line that scheduled it, a polled request or a garbage collection
- **New**: the idle-periodic-work finding names work your app repeats on a beat while nobody touches it, such as a timer, named by the line that scheduled it, or a spinner that keeps running where no one can see it
- **New**: a CPU profile names Squiggle's own frames `[squiggle] …` and reports their time apart from your app's, and Squiggle does less work in your app while a profile or heap snapshot records. Its own share of a render storm is 30% smaller

## Product analytics

- **New**: a near-miss friction finding marks a tap that reached nothing followed by a tap right beside it that worked

## SDK

- **New**: every session records the device it ran on: the model, the OS and its version, the window size and the appearance. Text size and locale are recorded only when the user's state consent allows it, and always in a development build
- **Fix**: Squiggle's agent no longer crashes an app that is reconnected to while it launches, and a relaunched dev-client app no longer stays black when a tool asks about it while it starts
- **Fix**: the SDK no longer holds on to stores, caches, components, sockets or motion captures your app has dropped, and hook timing no longer grows your app's memory on every render
- **Fix**: a screen that was popped mid-search no longer measures its content 116 pt below where iOS draws it
- **Fix**: a release build that keeps Squiggle sees every component and names itself, and a build without it says why
- **Fix**: Squiggle never adds a `.squiggle` folder or its `.gitignore` to a project nobody set up
- **Fix**: a relaunch after a simulated crash report is no longer recorded as "App crashed: XPC_EXIT_REASON_FAULT"
- **Fix**: Studio's CLI and the npm CLI carry the same agent for a version, so they no longer each relaunch your app to replace the other's

## Licensing

- **Fix**: `squiggle activate` with `SQUIGGLE_LICENSE_TOKEN` set checks the runner's CI place and claims no seat. A CI job doesn't need `squiggle activate`

## Everything else

- **Fix**: in a Niteshift task, the app connects when its launch file is pushed, `status` no longer shows a stale-agent blocker that no relaunch clears, and the Linux MCP server no longer warns about a missing agent
