SilbercueSwift

SilbercueSwift

[](https://github.com/silbercue/SilbercueSwift/releases) [](https://github.com/silbercue/SilbercueSwift#free-vs-pro) [](https://polar.sh/silbercueswift) [](https://opensource.org/licenses/MIT) [](https://registry.modelcontextprotocol.io) []() [](https://swift.org) [](https://glama.ai/mcp/servers/Silbercue/SilbercueSwift)

The fastest, most complete MCP server for iOS development. One Swift binary, 58 tools, zero dependencies. SilbercueSwift has the most complete toolset of any alternative out there.

Built for Claude Code, Cursor, and any MCP-compatible AI agent.

> Looking for an alternative to existing iOS MCP servers? SilbercueSwift covers the full feature set of XcodeBuildMCP, Appium-MCP, and iosef in a single binary — plus xcresult parsing, UI automation, code coverage, and up to 75x faster screenshots. [See comparison below](#comparison-with-other-mcp-servers).

Why SilbercueSwift?

Every iOS MCP server has the same problem: raw xcodebuild output is useless for AI agents. 500 lines of build log, stderr noise mistaken for errors, no structured test results. Agents waste minutes parsing what a human sees in seconds.

SilbercueSwift fixes this. It parses .xcresult bundles — the same structured data Xcode uses internally — and returns exactly what the agent needs: pass/fail counts, failure messages with file:line, code coverage per file, and failure screenshots.

| What you get | XcodeBuildMCP | Appium-MCP | iosef | SilbercueSwift | |---|---|---|---|---| | Screenshot latency | ~1127ms | ~77ms | ~83ms | ~316ms( ~15ms, 75x) | | View hierarchy | ~259ms | ~938ms | ~44ms | ~31ms( ~5ms) | | Find element | — | 76ms | 50ms | 31ms( ( 4ms) | | Swipe | 1284ms | 2685ms | 262ms | ~250ms | | Build for simulator | Yes | — | — | Yes | | Build + Run in one call | Yes (sequential) | — | — | Yes (parallel, ~9s faster) | | Structured test results | Partial | — | — | Full xcresult JSON | | Failure screenshots from xcresult | — | — | — | Auto-exported | | Code coverage per file | Basic | — | — | Sorted, filterable | | Build error diagnosis | stderr parsing | — | — | xcresult JSON with file:line | | Navigate (find + tap + verify) | — | — | — | 1 call (~380ms) | | Double tap | — | — | — | ~60ms | | Drag & drop | — | Coordinates only (3 calls) | — | Element-to-element (1 call) | | Scroll to element | — | Manual swipe loop | — | SmartScroll (1 call) | | Alert handling | — | Single alert | — | 3-tier search + batch acceptall | | iOS 18 ContactsUI dialog | — | — | — | Supported | | Batch UI automation | — | — | — | runplan: multi-step plans with adaptive decisions | | Log filtering | Subsystem only | — | Partial | Topic-filtered: 90% fewer tokens | | Console log per failed test | — | — | — | Optional | | Wait for log pattern | — | — | — | Regex + timeout | | Visual regression | — | — | — | Baseline + pixel diff | | Multi-device check | — | — | — | Dark Mode, Landscape, iPad | | Cross-platform (Android) | — | Yes | — | — | | Tools | 77 (Rust) | 61 (Node.js + Appium) | 15 (Swift) | 58 (Native Swift, 8.5MB) | | Cold start | ~400ms | ~1000ms | ~100ms | ~50ms** |

Where SilbercueSwift really shines

> Screenshots up to 75x faster — ~316ms ( ~15ms)

Free tier screenshots (~316ms) are faster than XcodeBuildMCP (~1127ms) and most alternatives. Pro brings latency down to ~15ms — 5x faster than Appium, 75x faster than XcodeBuildMCP. Agents can take screenshots freely without penalty at either tier.

> Structured test results from xcresult bundles — zero guesswork on failures

When a test fails, the agent gets the error message, the exact file:line, a screenshot of the failure state, and optionally the console output — all parsed from Apple's .xcresult format. No guessing from 500 lines of xcodebuild stderr. This is the difference between "agent knows what broke" and "agent guesses what broke".

> Single binary, zero dependencies — 58 tools, install in 10 seconds

brew install silbercueswift — done. 8.5MB native Swift binary. No Node.js, no npm, no Appium server, no Python, no Java, no Rust toolchain. Cold start in ~50ms. The fastest way to get an iOS MCP server running.

> Agent reads only what matters — 90% fewer tokens, zero wasted calls (topic filtering )

Free tier already strips noise: 15 known noise processes are excluded at capture time, and duplicate lines are collapsed (79% I/O reduction). Pro adds topic filtering — read_logs categorizes lines into 8 topics and shows only app + crashes by default, with a menu: network(87) lifecycle(12) springboard(8). The agent opens specific topics in one call — no guessing, no iteration.

> One call to dismiss all permission dialogs — 3 alerts in 1 roundtrip

Every app shows 2–3 permission dialogs on first launch. Other servers require the agent to screenshot → find button → click, per dialog. handle_alert(action: "accept_all") clears them all in a single call, searching across SpringBoard, ContactsUI, and the active app. Free tier handles alerts individually with accept / dismiss.

> Drag & drop with element IDs — 1 call instead of 3

"Drag item A above item B" is a single call: drag_and_drop(source_element: "el-0", target_element: "el-1"). The competition only supports raw coordinates, forcing the agent to find both elements, extract their frames, and build a W3C Actions sequence — 3 calls minimum.

> Auto-scroll to off-screen elements — no more manual swipe loops

find_element(using: "accessibility id", value: "Save", scroll: true) scrolls automatically until the element appears. SmartScroll handles UIKit, SwiftUI, and lazy-loaded lists — no guessing scroll direction.

> View hierarchy in ~31ms (Free) / ~5ms (Pro) — up to 188x faster element inspection

get_source returns the full UI tree in ~31ms (Free) or ~5ms (Pro). The fastest competitor takes 44ms, most take 250ms+. This makes element inspection practically free for agents.

> Navigate in one call — find + tap + settle + screenshot in ~380ms

navigate(to: "Settings") finds the element, taps it, waits for the screen to settle, and returns a verification screenshot — all in a single call. No competitor offers this. Agents save 3-4 tool calls per navigation step.

> Batch UI automation — run_plan executes multi-step plans with adaptive decisions

run_plan takes a sequence of UI steps and executes them server-side. When a step needs a decision (unexpected dialog, element not found), it falls back through 4 tiers — from MCP sampling to pause & resume. No more "one tool call per tap" overhead.

Quick Start

Install via Homebrew

brew tap silbercue/silbercue
brew install silbercueswift

Or build from source

git clone https://github.com/silbercue/SilbercueSwift.git
cd SilbercueSwift
swift build -c release
cp .build/release/SilbercueSwift /usr/local/bin/

Configure in Claude Code

One command — installs globally for all projects:

claude mcp add --scope user SilbercueSwift /opt/homebrew/bin/SilbercueSwift

> Note: Use the full path (/opt/homebrew/bin/SilbercueSwift). Claude Code starts MCP servers without a full shell PATH, so bare command names won't be found.

Configure in Cursor

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "SilbercueSwift": {
      "command": "/opt/homebrew/bin/SilbercueSwift"
    }
  }
}

Configure in other MCP clients (Cline, Continue, etc.)

Any client that supports stdio MCP servers: point to /opt/homebrew/bin/SilbercueSwift with no arguments.

Uninstall

claude mcp remove --scope user SilbercueSwift
brew uninstall silbercueswift
brew untap silbercue/silbercue

Free vs Pro

SilbercueSwift ships 49 tools for free — build, test, simulate, automate UI, capture logs, and take screenshots. No time limit, no signup.

Pro adds 9 tools and faster internals for teams and power users who need the full picture.

| | Free | Pro | |---|---|---| | Build, test, sim management | 49 tools | 58 tools | | Screenshot | ~316ms | ~15ms (75x faster) | | Structured test results (xcresult) | Yes | Yes | | Find element | 31ms | **

## 58 Tools in 14 Categories

### Build (5 tools)

| Tool | Description |
|---|---|
| `build_sim` | Build for iOS Simulator — returns structured errors + caches bundle ID & app path |
| `build_run_sim` | Build + boot + install + launch in one call — parallel 2-phase pipeline, ~9s faster than sequential |
| `clean` | Clean build artifacts |
| `discover_projects` | Find .xcodeproj/.xcworkspace files |
| `list_schemes` | List available schemes |

### Testing & Diagnostics (4 tools)

| Tool | Description |
|---|---|
| `test_sim` | Run tests + structured xcresult summary (pass/fail/duration) |
| `test_failures` | Failed tests with error messages, file:line, and failure screenshots |
| `test_coverage` | Code coverage per file, sorted and filterable |
| `build_and_diagnose` | Build + structured errors/warnings from xcresult |

### Simulator (12 tools)

| Tool | Description |
|---|---|
| `list_sims` | List available simulators |
| `boot_sim` | Boot a simulator |
| `shutdown_sim` | Shut down a simulator |
| `install_app` | Install .app bundle |
| `launch_app` | Launch app by bundle ID |
| `terminate_app` | Terminate running app |
| `clone_sim` | Clone an existing simulator |
| `erase_sim` | Erase simulator content and settings |
| `delete_sim` | Delete a simulator |
| `set_orientation` | Rotate device (PORTRAIT, LANDSCAPE_LEFT, LANDSCAPE_RIGHT) via WDA |
| `sim_status` | Simulator state (booted/shutdown, device type, runtime) |
| `sim_inspect` | Detailed simulator info (data path, log path, UDID) |

### UI Automation (16 tools)

Native input for gestures, WDA for element queries and alerts — no Appium, no Node.js, no Python.

| Tool | Description | Latency |
|---|---|---|
| `handle_alert` | **Accept, dismiss, or batch-handle system & in-app alerts** | ~200ms |
| `find_element` / `find_elements` | Find elements by accessibility ID, predicate, class chain. **`scroll: true` auto-scrolls** until the element appears (SmartScroll — 3 fallback strategies) | **31ms**( **( **~4ms**) |
| `double_tap` / `long_press` | Double tap or long press at coordinates | **~60ms** / **~1000ms** |
| `swipe` | Directional swipe | **~250ms** |
| `pinch` | Zoom in/out | ~400ms  |
| `drag_and_drop` | **Drag from source to target** — element-to-element, coordinates, or mixed. Smart defaults for reorderable lists, Kanban boards, sliders | **~1.3s** |
| `navigate` | **Find + tap + settle + screenshot in 1 call** — saves 3-4 roundtrips | **~380ms** |
| `type_text` / `get_text` | Type into or read from elements | ~100-300ms |
| `get_source` | Full view hierarchy (JSON/XML) | **~31ms**( **~5ms**) |
| `wda_status` / `wda_create_session` | WDA health check & session management | ~50-100ms |

#### handle_alert — the smartest alert handler

```bash
# Accept a single alert with smart defaults
handle_alert(action: "accept")

# Dismiss with a specific button label
handle_alert(action: "dismiss", button_label: "Not Now")

# Batch-accept ALL alerts after app launch (unique to SilbercueSwift)
handle_alert(action: "accept_all")

3-tier alert search — finds alerts across:

1. Springboard — system permission dialogs (Location, Camera, Tracking)
2. ContactsUI — iOS 18+ Contacts "Limited Access" dialog (separate process)
3. Active app — in-app UIAlertController dialogs

Smart defaults — knows which button to tap:

• Accept: "Allow" → "Allow While Using App" → "OK" → "Continue" → last button
• Dismiss: "Don't Allow" (handles Unicode U+2019) → "Cancel" → "Not Now" → first button

Batch mode — accept_all / dismiss_all loops through multiple sequential alerts server-side. One HTTP roundtrip instead of N. Returns details of every handled alert.

These capabilities go beyond what other iOS MCP servers currently offer.

Screenshots (1 tool)

| Tool | Latency | |---|---| | screenshot | Free: ~316ms / Pro: ~15ms |

Logs (4 tools)

| Tool | Description | |---|---| | start_log_capture | Smart-filtered os_log stream — 3 modes: smart (default, topic filtering enabled), app (tight stream, auto-detected), verbose (unfiltered). Deduplicates repetitive lines. | | stop_log_capture | Stop capture | | read_logs | Topic-filtered reading — default: app + crashes only. Response includes topic menu with line counts. Add topics via include parameter. | | wait_for_log | Wait for regex pattern with timeout — eliminates sleep() hacks |

Smart Log Filtering — 4 layers, zero config

# Start capture (default: smart mode — broad stream, topic filtering enabled)
start_log_capture()

# Read logs — default shows only app logs + crashes + topic menu
read_logs()
# → --- 230 buffered, 42 shown [app, crashes] ---
# → Topics: app(35) crashes(2) | network(87) lifecycle(12) springboard(8) widgets(0) background(3) system(83)
# → Hint: include=["network"] to add SSL/TLS + background transfer logs
# → ---
# → [42 filtered lines]

# Agent sees network(87) and wants SSL details — one call:
read_logs(include: ["network"])

# Narrow stream for production monitoring:
start_log_capture(mode: "app")

# Bypass mode logic with explicit predicate:
start_log_capture(subsystem: "com.apple.SwiftUI")

4 filter layers:

1. Stream-side noise exclusion — 15 known noise processes + subsystem/category exclusions removed before buffering. Server-side filtering in logd — 79% I/O reduction.
2. 3 capture modes — smart (default, broad stream for topic filtering), app (tight, auto-detected bundle ID + process name), verbose (unfiltered).
3. Read-time topic filtering — read_logs categorizes every buffered line into 8 topics (app, crashes, network, lifecycle, springboard, widgets, background, system). Default shows only app + crashes. Agent adds topics as needed — stateless per call.
4. Buffer deduplication — 60 identical heartbeat lines become 2: the line itself + ... repeated 59x.

8 topics with LLM-optimized menu: | Topic | Matches | Use case | |---|---|---| | app (always on) | subsystem == bundleId OR process == appName | Your app: os_log, print(), NSLog() | | crashes (always on) | fault-level logs | Crashes from any process | | network | trustd, nsurlsessiond | SSL/TLS certs, background transfers | | lifecycle | runningboardd, com.apple.runningboard. | Jetsam, memory pressure, app kills | | springboard | SpringBoard | Push notifications, app state | | widgets | chronod | WidgetKit timeline, refresh budget | | background | com.apple.xpc.activity. | BGTaskScheduler, background fetch | | system | everything else | WARNING: high volume |

Console (3 tools)

| Tool | Description | |---|---| | launch_app_console | Launch app with stdout/stderr capture | | read_app_console | Read console output | | stop_app_console | Stop console capture |

Git (5 tools)

| Tool | Description | |---|---| | git_status / git_diff / git_log | Read operations | | git_commit / git_branch | Write operations |

Visual Regression (2 tools)

| Tool | Description | |---|---| | save_visual_baseline | Save a screenshot as a named baseline | | compare_visual | Compare current screen against baseline — pixel diff + match score |

Multi-Device (1 tool)

| Tool | Description | |---|---| | multi_device_check | Run visual checks across multiple simulators (Dark Mode, Landscape, iPad) — returns layout scores |

Accessibility (1 tool)

| Tool | Description | |---|---| | accessibility_check | Render screens across Dynamic Type content size categories — detects truncation and layout issues |

Localization (1 tool)

| Tool | Description | |---|---| | localization_check | Render screens acro

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Silbercue
• Source: Silbercue/SilbercueSwift
• License: MIT
• Homepage: https://registry.modelcontextprotocol.io

Install and usage instructions live in the source repository linked above.