This is the full developer documentation for RocketSim # Environment Overrides > Toggle accessibility settings and Dark Mode directly from RocketSim's side window. Test Increase Contrast, Bold Text, Reduce Motion, and Dynamic Type instantly. Testing accessibility settings usually means navigating deep into Simulator Settings. RocketSim's Environment Overrides put all the important toggles right in the side window, so you can switch settings while looking at your app.  ## Accessibility toggles You get direct access to: Increase Contrast, Reduce Transparency, Bold Text, Reduce Motion, On/Off Labels, Button Shapes, Grayscale, Inverted Colors, and Differentiate without Color. Toggle any of them and see the effect immediately in your running app. ## Dark Mode Toggle between light and dark mode with a single click. No need to navigate through Simulator settings. Dark Mode is a Pro feature. ## Dynamic Type A slider lets you test every Dynamic Type size. RocketSim also shows the SwiftUI code for each size, so you can copy it directly into your previews. That makes it easy to verify your layouts at different text scales. # Toggles & Dynamic Text > Test accessibility toggles, Tinted Liquid Glass, and Dynamic Type sizes on the iOS Simulator without navigating through Settings. During app development, it's important to test your app's accessibility support to ensure it's usable by everyone. Xcode provides so-called Environment Toggles, but they're not easily accessible when you're focused on the Simulator. RocketSim's Side Window provides similar functionality and keeps accessibility toggles available whenever you need them:  ## Tinted Liquid Glass testing When Liquid Glass was introduced, many developers quickly ran into accessibility concerns. iOS later added a Tinted Liquid Glass mode to improve contrast, but that does not automatically guarantee your UI will remain readable in every case. Until recently, testing this mode usually required a physical device. With RocketSim's accessibility toggles, you can now enable Tinted Liquid Glass directly in the Simulator and compare both states while iterating on your app.  Even small visual changes can affect legibility, hierarchy, and overall usability. This comparison shows how a subtle difference can still have a meaningful impact for users who rely on accessibility features. ## Accessibility toggles and Dynamic Type Beyond Tinted Liquid Glass, RocketSim lets you quickly test settings like Increase Contrast, Reduce Transparency, Bold Text, Reduce Motion, On/Off Labels, Button Shapes, Grayscale, Inverted Colors, and Differentiate without Color. You can also adjust Dynamic Type sizes from the same side window, making it easy to verify layouts, spacing, and truncation without navigating away from your app. # VoiceOver Navigator > Visualize VoiceOver element order on the iOS Simulator with numbered overlays. Navigate elements with keyboard shortcuts and verify reading order without a device. ::::tip[Check accessibility faster] VoiceOver Navigator helps you verify reading order and activation flow without leaving the Simulator. :::: Testing VoiceOver used to mean grabbing a physical device, enabling VoiceOver, and swiping through your app. VoiceOver Navigator lets you stay in the Simulator: you get a visual overlay of the accessibility element order and keyboard-driven navigation, so you can verify reading order and rotor behavior without leaving your flow. ## Introduction to the VoiceOver Overlay When you open the **Voice Over** tab in RocketSim’s side window, you can turn on **Elements Overlay**. Numbered labels appear on each accessibility element in the same order VoiceOver would use on a real device, so you can see at a glance whether your reading order makes sense. The panel lists every element with its role, such as **Button**, **Heading**, or **StaticText**, plus the total count. Use the **Rotor** dropdown to filter by category or leave it on **All Elements**. **Refresh** updates the list after the app’s UI changes.  This view is read-only: you’re inspecting the tree and the overlay. When you’re ready to step through the experience the way VoiceOver would, use **Start Navigating**. ## Using the VoiceOver Navigator In navigation mode, the overlay stays on screen and the panel shows the same element list, but the current focus is highlighted. You move through the app using the keyboard: - **↑↓** — Move to the previous or next element in VoiceOver order - **←→** — Switch between rotor categories (like swiping on device) - **⏎ Enter** — Activate the focused element (for example, tap a button); the app navigates and the overlay updates - **Esc** — Exit navigation mode You can search for elements, change the rotor category from the dropdown, and turn the overlay on or off from the panel. When you’re done, **Stop Navigating** returns you to the overlay-only view.  No device, no gestures, no context switch. You get a much quicker loop for checking reading order, rotor groupings, and activation flow while you develop. # Agentic Development with RocketSim > Let AI coding agents inspect, navigate, and verify your running iOS Simulator app through RocketSim's version-matched CLI and Agent Skill. RocketSim helps AI coding agents inspect, navigate, and verify your running iOS Simulator app. The RocketSim Mac app stays connected to the Simulator, keeps useful state warm, and exposes a compact CLI that agents can use to read visible elements, tap controls, type text, capture screenshots, and confirm UI changes. RocketSim does not build, install, or launch your app from source. Start the app with Xcode or your normal build tooling first, then use RocketSim for fast Simulator inspection and interaction. With the RocketSim Agent Skill installed from **Settings → CLI & Agent**, your agent can: - Read visible accessibility elements, including common navigation and tab bar items - Tap, swipe, type, and navigate through your app reliably - Stay in a tight interaction loop without rebuilding context between steps - Use compact screen summaries to spend fewer tokens per UI read - Fall back to screenshots when accessibility data is not enough ## What you can do with it Agentic development with RocketSim is useful whenever you want an agent to work with a running app in the Simulator instead of just reading and writing code. ### Navigate and test app flows Ask your agent to move through multi-step flows like onboarding, login, settings, or purchase screens. RocketSim gives the agent a way to see what is on screen and interact with it step by step. Instead of relying only on screenshots or brittle coordinate taps, the agent can read accessibility elements and use semantic interactions whenever possible. That makes the loop much closer to how a developer would inspect the same screen manually. ### Validate UI after code changes After making a code change, launch the app from Xcode or ask your agent to use your normal build tooling. Once the app is running, ask the agent to navigate to the relevant screen with RocketSim and verify that the expected elements are visible. This is faster than switching to the Simulator yourself to check. ### Reproduce bugs in context Describe a bug and ask your agent to reproduce it in the Simulator. RocketSim lets the agent read each screen state along the way, so it can report exactly what it sees at each step. ### Automate repetitive QA flows If you find yourself tapping through the same screens repeatedly during development, let your agent handle those flows while you focus on the code. ## Example prompts Try these with any AI coding tool that has the RocketSim Agent Skill installed: > Use RocketSim to navigate through the onboarding flow in the Simulator > Use RocketSim to open the login screen, enter test credentials, and verify the home screen appears > Use RocketSim to inspect the visible elements on screen and tap the primary CTA > Use RocketSim to take a screenshot if the accessibility snapshot does not expose the web content clearly > Use RocketSim to navigate to settings and toggle the feature flag for dark mode > Use RocketSim to reproduce the crash described in this issue by navigating to the affected screen > Use RocketSim to walk through the purchase flow and verify each step shows the correct price ## Why RocketSim is especially effective for this ### Stateful by design RocketSim runs continuously alongside the Simulator. Because there is already a Mac app watching the active device, RocketSim can reuse state, cache expensive work, and optimize repeated agent loops in ways one-off commands cannot. In our internal research, RocketSim's CLI completed the same agent workflows about **19% faster, avoided wrong taps entirely**, and used about **63% fewer estimated tokens** than a popular alternative. ### Compact screen summaries RocketSim's `--agent` output format gives agents a focused, token-efficient snapshot of visible elements. Instead of processing a full JSON accessibility tree, agents get a compact summary with the element type, label, and coordinates they need to act. RocketSim also recovers many elements that are easy to miss in raw accessibility output, including top bars, navigation bars, tab bars, and visible controls that are needed to move through an app. ### Selector-based interaction Agents can target elements by label, type, or value instead of guessing coordinates. RocketSim uses semantic accessibility activation when possible, which is more reliable than coordinate-only approaches for buttons, toggles, and list rows. ### Agent-optimized protocol The CLI uses RocketSim's `rs/1` protocol for agent workflows. You do not need to learn the protocol details; the important part is that it is designed for compact, reliable interaction through the running RocketSim app. ### Version-matched automation RocketSim ships the CLI and Agent Skill inside the app. When RocketSim updates, the installed command and the skill instructions can update with it, so your agent keeps using guidance that matches the RocketSim version you have installed. ## How it works RocketSim's agentic development support has three layers: 1. **The RocketSim Mac app** keeps the live Simulator connection, caches state, and performs the optimized work. 2. **The RocketSim CLI** exposes that running app to agents through commands such as `elements`, `interact`, `wait`, `screenshot`, `video record`, and `doctor`. 3. **The RocketSim Agent Skill** teaches your AI coding tool how to use the CLI safely and consistently. Install both the command line tool and Agent Skill from **RocketSim → Settings → CLI & Agent**. RocketSim creates symlinks into your chosen folders, so the CLI and skill keep pointing at the latest installed app. For most AI coding tools, install the [RocketSim Agent Skill](/docs/features/agentic-development/agent-skill) as well. The skill teaches your agent when to read elements, when to wait, when to interact semantically, and when to fall back to a screenshot. ## Learn more - [RocketSim CLI](/docs/features/agentic-development/rocketsim-cli) — how agents inspect and interact with the Simulator - [Agent Skill](/docs/features/agentic-development/agent-skill) — how to install the recommended agent workflow - [CLI & Agent settings](/docs/settings/cli-and-agent) — how to install the CLI and skill from RocketSim # RocketSim Agent Skill > Install RocketSim's bundled Agent Skill so Cursor, Claude, Codex, Xcode, and other AI coding tools can navigate the iOS Simulator safely. The RocketSim Agent Skill is the recommended way to connect AI coding tools to RocketSim. It teaches your agent how to use the version-matched `rocketsim` CLI, when to read visible elements, when to interact, how to recover after screen changes, and when to use a screenshot fallback. Install it from **RocketSim → Settings → CLI & Agent**. ## Why the skill is recommended You can run the CLI yourself, but agents perform best when they have clear, tool-specific instructions. The RocketSim Agent Skill provides those instructions without requiring you to copy prompts into every project. Use the skill when you want Cursor, Claude, Codex, Xcode, or another coding agent to inspect a running Simulator app and perform real UI steps. The skill keeps the agent focused on RocketSim's safest interaction loop instead of inventing shell commands or guessing coordinates from screenshots. The skill helps agents: - Use RocketSim's compact `--agent` output before deciding what to do - Prefer semantic interactions over fragile coordinate taps when possible - Work with RocketSim's `rs/1` agent protocol without needing to know its internals - Recover when a screen changes between inspection and interaction - Use screenshots when accessibility data is sparse or incomplete - Run `rocketsim doctor` when setup needs to be checked In our internal research, RocketSim's CLI completed the same agent workflows about **19% faster, avoided wrong taps entirely**, and used about **63% fewer estimated tokens** than a popular alternative. ## Install from RocketSim 1. Open **RocketSim → Settings → CLI & Agent** 2. Install the **Command Line Tool** if `rocketsim` is not on your `PATH` yet 3. In **Agent Skill**, choose **General Agents** for broad support or **Agentic Coding in Xcode** for Xcode's built-in coding assistant 4. Click **Install** or **Repair** 5. Restart or refresh your AI coding tool if it does not discover new skills automatically RocketSim installs the skill as a symlink to the bundled skill inside `RocketSim.app`. When RocketSim updates, the skill keeps pointing at the latest installed app version.  ## Supported destinations We recommend **General Agents** for most setups. It installs the skill into the shared `.agents/skills` location, so multiple AI coding tools can use the same version-matched RocketSim skill instead of each tool needing its own copy. Choose **Agentic Coding in Xcode** when you use Xcode's built-in Claude Agent or Codex integration. Xcode keeps its coding assistant configuration in `~/Library/Developer/Xcode/CodingAssistant`, separate from Claude Code's `~/.claude/skills` folder. Restart Xcode after installing or repairing this destination. Use a tool-specific destination like **Cursor**, **Claude**, or **Codex** if that tool only scans its own skill folder. You can also choose a custom skill folder if your tool stores skills somewhere else. If RocketSim shows **Repair**, the existing symlink points somewhere unexpected or the app has moved. Repairing updates the symlink to the current RocketSim app. ## Why it stays up to date RocketSim ships the CLI and Agent Skill inside the app bundle. The installed files are symlinks, not copied snapshots. That matters because the CLI surface and skill instructions evolve together. After an App Store update, your `rocketsim` command and installed skill still resolve to the current app bundle. Agents get the guidance that matches the RocketSim version they are controlling. ## What the agent can do after setup Once the skill is installed and RocketSim is running, your agent can: - Read visible accessibility elements, including navigation and tab bar items - Tap, long-press, swipe, and type using labels or coordinates - Press simulator hardware buttons like Home, Lock, or Siri - Navigate multi-step app flows with fewer retries - Use compact screen summaries to spend fewer tokens per screen read - Capture a screenshot when visual context is needed ## How to verify it works First, check your setup: ```bash rocketsim doctor ``` Then open your AI coding tool and try: > Use RocketSim to navigate through `` in the Simulator If the skill is installed, RocketSim is running, and your app is already open in the Simulator, the agent should detect RocketSim, read the visible UI, and start interacting with the app based on what is on screen. ## Learn more - [RocketSim CLI](/docs/features/agentic-development/rocketsim-cli) — the commands agents use to inspect and interact with the Simulator - [Agentic Development with RocketSim](/docs/features/agentic-development/) — scenarios, example prompts, and why RocketSim is effective for agent-driven Simulator automation - [CLI & Agent settings](/docs/settings/cli-and-agent) — installing and repairing the CLI and skill # RocketSim CLI > Install and use RocketSim's built-in CLI to inspect visible elements, automate interactions, and give agents a fast path into your running Simulator. RocketSim includes a built-in CLI that lets agents inspect visible UI and interact with the Simulator through the running RocketSim Mac app. The app stays connected to the Simulator, keeps useful state warm, and exposes a compact command line surface for agents and local automation. For agentic development, we recommend installing both the CLI and [RocketSim Agent Skill](/docs/features/agentic-development/agent-skill) from **RocketSim → Settings → CLI & Agent**. The CLI works with the Simulator UI that is already running. It does not build, install, or launch apps from an Xcode project; use Xcode or your normal build tooling for that step, then let RocketSim inspect and interact with the app on screen. ## Installing the CLI 1. Open **RocketSim → Settings → CLI & Agent** 2. In **Command Line Tool**, click **Install Command Line Tool** 3. Choose the default selected folder if it is on your `PATH`, or pick another folder such as `/opt/homebrew/bin` or `/usr/local/bin` 4. Confirm the installation RocketSim creates a `rocketsim` symlink in that folder. The real executable stays inside `RocketSim.app`, so App Store updates keep the command up to date automatically.  This symlink setup is useful for both agents and CI scripts. Anything that runs `rocketsim` from `PATH` uses the same RocketSim version you have installed. ## The agent interaction loop The CLI gives agents a compact workflow: 1. Ask RocketSim which simulator is currently focused 2. Read the visible UI elements 3. Decide what to do next 4. Tap, swipe, type, or press a hardware button 5. Read the updated UI state 6. Repeat That loop is fast because RocketSim is already connected to the Simulator. There is no reconnection overhead between steps, and the running app can cache and optimize work across repeated commands. ## Why RocketSim is fast for agents RocketSim is not just a standalone command that starts from scratch every time. The CLI talks to the running Mac app, which can keep simulator state, reuse context between commands, and optimize repeated screen reads and interactions. The CLI uses RocketSim's `rs/1` protocol for agent workflows. You do not need to learn the protocol details; it is the compact, agent-optimized layer that lets RocketSim provide reliable screen reads, interaction feedback, and recovery paths while keeping output small. In our internal research, RocketSim's CLI completed the same agent workflows about **19% faster, avoided wrong taps entirely**, and used about **63% fewer estimated tokens** than a popular alternative. ## Key commands ### Doctor Checks whether the CLI install, RocketSim app, IPC connection, Simulator state, accessibility permission, and snapshot store are ready for agent workflows. ```bash rocketsim doctor ``` ### Focused simulator Returns the currently focused simulator as JSON, including name, runtime, and UDID. ```bash rocketsim simulator focused ``` ### Visible elements Returns the accessibility elements currently visible on screen. ```bash rocketsim elements [--udid ] [--agent] ``` The `--agent` flag is the recommended default for agent workflows. It returns a compact, pipe-delimited format that is easier and cheaper for agents to process. RocketSim's element pipeline is designed for real app navigation. It can include visible controls from top bars, navigation bars, tab bars, and other chrome that agents often need to move through a flow. When web content or other complex views expose limited accessibility data, RocketSim can add recovery hints so the agent knows when to use visual context. ### Screen summary and snapshots For agents that need a stable view of the current screen, RocketSim provides screen and snapshot commands: ```bash rocketsim screen rocketsim snapshot ``` These commands are optimized for agent workflows and help agents reason about whether the screen changed after an interaction. The JSON snapshot also includes `data.canvasSize` (`[width, height]` in device points), which describes the full screen the elements were laid out in. This is the union of every raw accessibility frame, including the full-screen application root, so it spans the true device bounds rather than just the box around the visible content. Use it to scale element frames onto a rendered screenshot or overlay without re-deriving the device size, which is especially important on scrollable screens where the visible content does not fill the screen. ### Screenshots When accessibility data is not enough, agents can request a plain PNG screenshot: ```bash rocketsim screenshot > screen.png ``` This is useful for visual fallback flows, sparse web content, or debugging what the agent sees. The raw PNG bytes are written to stdout, so redirect them to a file. Target a specific simulator with `--udid ` instead of the focused one. Screenshots can also be styled with the same options RocketSim uses for its capturing tools: ```bash rocketsim screenshot \ --bezel simulator \ --background "#0B1221" \ --device-shadow \ --ratio 16:9 > styled.png ``` | Option | Description | | ----------------------- | ------------------------------------------------------------------------------------------- | | `--background ` | Background color: `transparent`, a preset color, or `#RRGGBB`. | | `--bezel