simless

Check SwiftUI screens and run your iOS tests without the iOS Simulator. Built for AI coding agents, fast enough for CI, and nothing to set up beyond Xcode.

simless runs your real iOS app natively on a Mac, as an invisible host. An agent can render any screen as a compact accessibility tree in milliseconds, hot-reload the views it edits in about 2 seconds, and run your unit tests and your existing XCUITest UI tests. No simulator boots, no window opens, and many agents can work in parallel on one Mac.

$ simless render Settings --png out/
Settings · light · iphone 402×874 · 131 ms
  traits: compact/regular size class, idiom pad, safe area top 62 bottom 34
  switch  "Push notifications" = "1"  @16,208.5 370×58
  switch  "Weekly summary" = "0"  @16,266.5 370×58
  button  "Theme, System"  @32,397.5 338×34.5
  button  "Text size: 3, Decrement" = "3" #Decrement  @276,462 47×32
  button  "Text size: 3, Increment" = "3" #Increment  @323,462 47×32
  button  "Sign out"  @16,544 370×52
  header  "Notifications"  @16,168 370×40.5
  header  "Appearance"  @16,342 370×40.5
  text    "Version 1.0 (demo)"  @16,596 370×30
  header  "Settings"  @16,119 133×40.5
  png: out/Settings-iphone.png
  issues (1):
    ⚠ button "Theme, System" tap target 338×34 is smaller than 44×44

The agent reads the tree on the left, about 150 tokens per screen. The PNG on the right is only made when it's asked for.

At a glance

Quick start

# Install (once per machine)
git clone https://github.com/abacusai/simless && cd simless
swift build -c release
ln -s "$PWD/.build/release/simless" ~/.local/bin/simless    # any directory on your PATH
simless skill install                                       # optional: the Claude Code skill

# Set up your app (once per repository)
cd <your-app-repo>
simless init        # writes .simless.json, the render host kit and a fixtures file
simless up          # builds the app and starts its host

# Use it
simless render all --matrix     # every screen, light and dark, iPhone, small iPhone and iPad
simless reload --render Settings    # after an edit: hot reload and render in about 2 s
simless test all                # unit tests, local packages included
simless test ui                 # your XCUITest UI tests

Why

Coding agents check UI changes by building for the iOS Simulator, installing, launching and taking a screenshot. Every agent pays for its own booted simulator (we measured about 2.2 GB of private memory and 210 processes per simulator running a real app) plus its own xcodebuild. With 4 or 5 agents in parallel, a 32 GB Mac starts swapping and everything slows to a crawl.

simless replaces that loop:

• No simulator. The app's iOS build runs natively on Apple Silicon. It's your real app target, with your views and dependencies, at about 30 MB per host.
• No signing. simless tags the iOS binaries for Mac Catalyst, signs them ad hoc and starts the app directly. Nothing is installed or registered.
• Headless. No windows, no Dock icons and no focus stealing, test runs included. It doesn't need a window server session either.
• Text first. Agents read an accessibility tree, plus automatic checks for unlabeled controls, off-screen elements, small tap targets and overlaps.
• Hot reload. Only the edited files are compiled into a patch, which loads into the running host.
• Built for many agents. One host per git worktree, coordinated with file locks, and everything is cleaned up automatically.

Results

Measured on a production SwiftUI app (about 280 Swift files and several large Swift packages) on an M2 Pro MacBook Pro with 32 GB of RAM. Legacy means one iOS Simulator per agent, with an incremental xcodebuild, install, launch and screenshot for every check.

The legacy loop gets slower with every agent you add, simless stays at about 2 s per edit. The test rows come from a second production app (about 2,200 unit tests across 41 targets, most of them in a local Swift package), against an iPhone 17 simulator on iOS 26.5, with the same result for every test. One CPU-heavy test target sets the time of the whole unit suite, because the Mac's Swift runtime runs it slower than the simulator does (see Unit tests). Full method, caveats and how to reproduce it: docs/benchmarks.md.

Faster without signing (0.6.0)

Since 0.6.0 hosts run unsigned. Compared with the signed "Designed for iPad" install of earlier versions, on the second production app with every host stopped between runs (M-series Mac, 10 cores):

Every test has the same outcome as before and the renders are the same. PNGs also line up with the tree's frames exactly now. Part of the warm up gain is that simless no longer changes the test bundles Xcode built: it signs a clone of each, so Xcode doesn't link all 40 package test bundles again on every build, and nothing needs signing again when nothing changed.

Does it look the same?

Mostly. Here are screens from the demo app, rendered by the iOS Simulator and by simless:

8 of 14 demo renders (7 screens, light and dark) match within 2 pt. The rest differ in the row heights of List and Form, line breaks in long centered text, and system accent colors. docs/fidelity.md shows every screen side by side, and simless calibrate --png <dir> makes the same comparison for your own app.

Requirements

• An Apple Silicon Mac with Xcode 26 or later. A VM works too, and so does a GitHub-hosted macOS runner. The iOS SDK that ships with Xcode is enough, no simulator runtime is needed.
• A SwiftUI iOS app in an .xcodeproj, at the repository root or in a subfolder such as ios/. Views can live in the app target or in local Swift packages, and both hot-reload. Swift 5 and Swift 6 language modes are supported, with or without MainActor default isolation. A unit-test target is optional: simless test runs it when there is one.

That's all. Older versions ran the app as a signed "Designed for iPad" install, which needed an Apple Development certificate and a wildcard profile that includes the Mac. That mode is still there ("mode": "dfi", see Options), but nothing needs it.

Set up an app

simless init creates:

• .simless.json
• <App>/Simless/SimlessKit.swift: the render host. It's generated, #if DEBUG only, and does nothing unless simless launches the app.
• <App>/Simless/SimlessFixtures.swift: your screens.

It also adds one call to your @main App's init() (pass --no-hook to skip that):

#if DEBUG && os(iOS)
SimlessHost.startIfRequested()
#endif

Some fixtures come for free. root is the app's first window, as its @main App builds it, and every #Preview block (and PreviewProvider) is a fixture named <File>.<preview name or number>, like LoginView.Error or NoteRow.2. simless up compiles them against the build, and simless render all lists them after yours. A preview that can't be built outside Xcode is left out, and up says whi