Product definition

What is AXe?

AXe drives a running iOS Simulator from the command line: list the booted simulators, read the accessibility tree, tap an element by label, type text, send a key combination, drag, move a slider, and capture a screenshot. It exists for the case where a UI test target is more ceremony than the task needs — a shell script or an agent can operate a simulator directly. The repository states that it uses Apple's private accessibility APIs, which is the capability and also the risk: those interfaces carry no stability guarantee, and a system or Xcode update can break them. The developer states support for Xcode 26 and Xcode 27, and notes that under Xcode 27 automation goes through Device Hub rather than requiring Simulator.app.

Verified product facts

Type
developer utilityEditorially reviewed
Platform
macOS
Pricing
Open sourceDeveloper-stated
Open source
Yes
Relationship to Nuanyue
Third-party product — not published by NuanyueEditorially reviewed
Licence
MIT
Current version
1.8.0Developer-stated

Last updated , last reviewed . Facts marked developer-stated come from the developer and are not independently confirmed; editorially reviewed marks a Nuanyue judgement.

Key features

What AXe does at a glance.

  • List booted simulators and read their accessibility tree

  • Tap elements

    By accessibility label, and type text

  • Send key combinations and key sequences

  • Drag and slider gestures

    Built on the same HID primitives

  • Capture screenshots

    From a running simulator

  • Batch several steps

    In one invocation

Common tasks

What you can use AXe for

  • Driving a simulator from a shell script when a UI test target is more setup than the task needs
  • Reading a simulator's accessibility tree to find out what a screen actually exposes
  • Capturing screenshots of a specific app state during development
  • Letting an automated agent operate a simulator between builds
Audience

Who is AXe for?

  • iOS developers who want scriptable simulator control without writing XCUITest
  • People building automation that has to run outside the Xcode test runner
Not a fit

Who is AXe not for?

  • Anyone who needs a supported, documented API — this depends on private interfaces
  • Teams that need their automation to survive OS and Xcode upgrades without maintenance

Limitations

  • Built on Apple's private accessibility APIs, which Apple does not guarantee to keep stable
  • The developer states support for Xcode 26 and Xcode 27; other versions are not covered
  • A minimum macOS version is not stated in the sources Nuanyue tracks
  • Builds IDB from a pinned fork revision, so the automation surface follows that revision

Strengths and trade-offs

What AXe does well, and what to weigh before choosing it. Points marked developer-stated come from the developer’s own material and have not been independently confirmed.

Strengths

  • The developer describes it as a comprehensive CLI for interacting with iOS Simulators using Apple's HID functionality, with the repository description naming the private accessibility APIs as the mechanism.Developer-stated
  • Provides a command per operation — listing simulators, describing the UI, tapping by label, typing, screenshots and batch runs — rather than one opaque script runner.
  • The developer states compatibility with Xcode 26 and Xcode 27, and that Xcode 27 automation uses Device Hub so Simulator.app is not required.Developer-stated
  • Distributed through a Homebrew tap, which makes installation a two-line command rather than a manual download.

Trade-offs

  • Dependence on private accessibility APIs means an OS or Xcode update can remove the capability without notice, and no compatibility promise covers that.Derived
  • The developer states support for Xcode 26 and Xcode 27 only, so projects pinned to older toolchains are outside the tested range.Developer-stated
  • Automation runs against a booted simulator, so it sits on top of a running runtime rather than replacing it.Derived

Overview

Automating an iOS Simulator normally means writing a UI test target and running it through Xcode’s test runner. That is the right tool when you need assertions and a report, and the wrong one when you need to press a button on a simulator from a shell script.

AXe takes the second case. It is a command-line tool that operates a booted simulator directly: enumerate what is running, read the accessibility tree, tap an element by its label, type text, send key combinations, drag, and take screenshots. The repository describes the mechanism as Apple’s private accessibility APIs combined with HID input.

The Commands

The tool is organised as one command per operation rather than a single script runner. Listing simulators, describing the current UI, tapping, typing, screenshotting and batching several steps into one invocation are separate subcommands, each taking the target simulator’s identifier.

That shape matters for automation: a step that fails is a command that exited non-zero, and the surrounding shell decides what to do about it. There is no test-report abstraction in between.

The Trade-off

Private APIs are the whole capability and the whole risk. Element-level control of a simulator from outside Xcode is not something the public tooling exposes, which is why this works at all. The same fact means no stability promise: Apple can change an interface in a point release, and the tool follows or breaks.

The developer’s stated support is Xcode 26 and Xcode 27, with compatibility validated against specific builds of each. Under Xcode 27 the developer states that automation goes through Device Hub, so Simulator.app is not required.

If your automation has to survive upgrades without anyone watching it, that is the constraint to weigh — not the feature list.

Installation

Distributed through a Homebrew tap, which is a two-line install. The underlying IDB dependency is built from a pinned fork revision rather than tracking upstream, so the behaviour you get is tied to that revision rather than to whatever Meta ships next.

Who It Suits

Developers who want simulator control from a script, and people building automation that runs outside the Xcode test runner — including agents that need to operate a simulator between builds.

It is a poor fit for teams that need a supported interface, or for anyone whose toolchain is pinned to an Xcode version the developer does not list.

Questions about AXe

Does AXe replace XCUITest?

It covers a different case. XCUITest runs inside the test runner with assertions and reporting; AXe is a command-line tool for operating a booted simulator from outside it. For a scripted sequence or an agent driving a simulator, the CLI is the shorter path.Editorially reviewed

Why does it say it uses private APIs?

The repository description states that AXe interacts with simulators through Apple's private accessibility APIs, alongside HID input. That is what makes element-level control possible outside Xcode's own tooling, and it is also why the interface is not covered by any stability guarantee.Editorially reviewed

Which Xcode versions are supported?

The developer states Xcode 26 and Xcode 27, with compatibility validated against Xcode 26.5 and against an Xcode 27 beta at the time of writing.Editorially reviewed

Is it related to the axe accessibility product?

No. The repository states explicitly that the project is independent and not affiliated with Deque Systems or its axe accessibility products.Editorially reviewed

Get it

Sources

Facts on this page are checked against the sources below. Last updated , last reviewed .

How Nuanyue grades sources →