Skip to main content
Glama

Driftcheck is a local MCP server. It captures the screen of an Android device or the iOS Simulator, compares it 1:1 with the Figma frame and gives your agent what it needs to close the gap:

  • What's different: position, size, text, font, colors, corner radius, borders, and missing icons or images, including layers with no text, found by how they look.

  • How to fix it, written with your framework's properties: Margin, android:layout_marginTop, Modifier.padding, .frame, EdgeInsets…

  • A fidelity score that tracks progress from one fix to the next, and an HTML report to share with your team.

It works with real-world design kits, where layers are called Frame or Text, and without a Figma token through the Driftcheck Figma plugin.

Quick start

You need the .NET 10 SDK, plus adb for Android or Xcode for the iOS Simulator. Install Driftcheck in one click:

VS Code asks for your Figma token; leave it empty to use the Figma plugin instead. In Cursor, add the token to FIGMA_TOKEN in the server's configuration afterwards.

Or add it to any MCP client by hand; dotnet dnx downloads it from NuGet the first time:

{
  "mcpServers": {
    "driftcheck": {
      "command": "dotnet",
      "args": ["dnx", "Driftcheck", "--yes"],
      "env": { "FIGMA_TOKEN": "<your Figma token>" }
    }
  }
}

With Claude Code:

claude mcp add driftcheck -e FIGMA_TOKEN=<your Figma token> -- dotnet dnx Driftcheck --yes

Then run your app and ask your agent:

Compare the app on the emulator with https://www.figma.com/design/…?node-id=… and fix the differences.

Related MCP server: ui-design-to-code-mcp

What your agent gets back

compare_screen answers with a report the agent can act on (excerpt from the demo):

**Fidelity: 75 %** — 15 of 20 elements as in Figma

| Element                    | Property   | Figma   | App     |
|----------------------------|------------|---------|---------|
| Nice to meet you           | height     | 31.5    | 25.5    |
| Text "Sign up with Google" | x          | 131.9   | 125     |
| Shape "Sign up"            | background | #DBC6F8 | #BAD1BB |

## How to fix it

- **Nice to meet you**
  - The glyphs don't measure the same as in Figma; check the font: in Figma it is Inter 32 weight 600.
    `FontFamily="Inter"`, `FontSize="32"`, `CharacterSpacing`
- **Shape "Sign up"**
  - `BackgroundColor="#9E56FF"` (it renders as #DBC6F8 in the design: the layer or a container has opacity)

## Design non-text layers not found in the app (1)

- Icon (x=108.2 y=392.3 w=20 h=20) — Missing a 20×20 dp icon (the Figma layer is 24×24)

Along with it come report.html (the interactive report above: slider, opacity, diff and side by side), side_by_side.png and diff.png.

Supported platforms

Device

How it reads the screen

Android emulator or device

adb: screencap + uiautomator dump (the AutomationId is the resource-id)

iOS Simulator (macOS)

simctl + an XCUITest helper that reads the accessibility tree (the AutomationId is the accessibilityIdentifier)

Fix suggestions are written for .NET MAUI, Android views, Jetpack Compose, UIKit, SwiftUI and Flutter, or in plain terms if you don't pass a framework. The comparison itself doesn't depend on the framework: it works from what's on the screen.

MCP tools

Tool

Use

list_devices

Connected Android devices and booted iOS simulators

get_design_specs

Sizes, colors, texts and fonts of the frame (before writing the UI code)

capture_screen

Capture + app elements with their AutomationId

compare_screen

Full design vs. app comparison: fidelity, differences, how to fix them and report.html

import_design

Imports a .driftcheck.json from the Figma plugin that ended up outside Downloads

How it works

Driftcheck downloads the frame once and keeps it in a local cache, recomputes Figma's auto layout, and matches layers to app elements by AutomationId, by visible text or by position. Texts are compared by their visible glyphs rather than their boxes, non-text layers are found in the screenshot by how they look, and a device slightly wider or narrower than the frame is handled by anchoring each element where it fits best. The full walkthrough is in How Driftcheck compares.

Figma API limits

Figma limits how many calls a token can make, and on some seat types the quota is very low: once it runs out, it responds 429 with waits of days. That's why:

  • The JSON and PNG of each frame are stored in a local cache and reused on every comparison. Pass refresh=true to get_design_specs or compare_screen to download a frame that changed in Figma.

  • If Figma responds 429, the error says how long to wait.

  • Without a token or quota, the Figma plugin in tools/figma-export-plugin exports the frame (JSON + 2x render) to a .driftcheck.json file without using the REST API. If it lands in Downloads, Driftcheck picks it up on its own from the frame link; if it lands in another folder, import it with import_design. See the plugin README.

Requirements

  • .NET 10 SDK

  • For Android: Android SDK with adb (detected from ANDROID_HOME, ANDROID_SDK_ROOT or the default paths on Windows and macOS)

  • For iOS: macOS with Xcode and a booted simulator. No idb or WebDriverAgent needed

  • A FIGMA_TOKEN environment variable with a Figma Personal Access Token (scope File content: Read-only), or the Figma plugin to work without the API

  • Optional: DRIFTCHECK_OUTPUT to change the output folder (default: driftcheck in the temp folder)

  • Optional: DRIFTCHECK_EXPORTS to change where plugin exports are looked up (default: Downloads)

Current limitations

  • iOS on the simulator only (not on physical devices).

  • Visible area only (no scrolling).

  • Doesn't measure font size in the app (uiautomator and XCUITest don't expose it); get_design_specs provides it as a reference.

Running from source

git clone https://github.com/wilsonvargas/Driftcheck.git
cd Driftcheck
dotnet build src/Driftcheck.Mcp

The .mcp.json at the root registers the server for MCP clients that read it when opening this folder. To use it from another project, add the server to your client's MCP configuration:

{
  "mcpServers": {
    "driftcheck": {
      "command": "dotnet",
      "args": ["<repo path>/src/Driftcheck.Mcp/bin/Debug/net10.0/Driftcheck.Mcp.dll"]
    }
  }
}

Repository layout

  • src/Driftcheck.Mcp — MCP server

  • tools/ios-accessibility-helper — UI test that dumps the iOS Simulator accessibility tree (copied next to the server on build)

  • tools/figma-export-plugin — Figma plugin that exports a frame without the REST API

  • samples/PayloMaui — MAUI test app with screens from the Paylo kit by Marvilo (CC BY 4.0) For the iOS Simulator: dotnet build -f net10.0-ios -p:TargetFrameworks=net10.0-ios (limiting TargetFrameworks avoids requiring the Mac Catalyst workload), then xcrun simctl install booted bin/Debug/net10.0-ios/iossimulator-arm64/PayloMaui.app and xcrun simctl launch booted com.companyname.paylomaui. The Xcode version must be the one the iOS workload asks for; if several are installed, pick it with DEVELOPER_DIR.

  • samples/PayloNative — the same sign-up screen with native Android views (Java, no MAUI or AndroidX), to check that the comparison doesn't depend on MAUI. ./build.ps1 builds it with the SDK tools (no Gradle) and installs it on the emulator

  • samples/PayloIos — the same screen with native iOS views (UIKit in Swift, no MAUI or storyboard). ./build.sh builds it with swiftc (no Xcode project) and installs it on the booted simulator

  • tests/Driftcheck.Tests — comparer tests with synthetic screens

  • docs — the detailed comparison walkthrough and the demo report published on GitHub Pages

To compare the sample apps, open the Paylo kit in the Figma Community, duplicate it to your drafts, select the frame Component 113 (the sign-up screen) and use Copy link to selection. Then run a sample on the emulator or simulator and ask your agent to compare it with that link.

Contributing

Issues and pull requests are welcome. See CONTRIBUTING.md for how to build, test and propose changes, and SECURITY.md to report a vulnerability privately.

License

Driftcheck is released under the MIT License. Third-party material in the sample apps keeps its own license: see THIRD_PARTY_NOTICES.md.

Available Tools

5 tools
capture_screenA

Takes a screenshot of the device (Android or iOS Simulator) and lists the visible elements with their AutomationId (resource-id on Android, accessibilityIdentifier on iOS), text and bounds in dp or pt. On iOS it takes a few more seconds: it reads the accessibility tree with a UI test, which is built the first time.

Inputs: deviceSerial.

compare_screenA

Compares the app's current screen on the device (Android or iOS Simulator) with a Figma frame. Matches Figma layers to app elements by visible text, name = AutomationId or position, and reports differences in position, size, text and background color. Non-text layers (buttons, fields, lines, icons, images) are found in the screenshot by how they look, comparing box, fill, corner radius, border and content. Reports fidelity (% of elements as in Figma, and how much it changed since the previous comparison) and how to fix each difference with the framework's properties. Generates report.html (interactive report to show the user), side_by_side.png and diff.png (in diff.png: green = matches, orange = differs, dotted blue = where Figma says it should be). Open the images for a visual review. If the screenshot doesn't look like the design (a loading screen), it waits and captures again up to 3 times.

Inputs: figmaUrl (required), refresh, framework, tolerance, +3 more.

get_design_specsA

Returns the measurements of the Figma frame: position, size, colors, texts and typography of every named layer. Use it BEFORE writing a screen's UI code. If deviceWidth is passed, values are scaled to that width in dp or pt.

Inputs: figmaUrl (required), refresh, deviceWidth.

import_designA

Imports a .driftcheck.json file exported with the Driftcheck plugin in Figma, to compare without the Figma API (no token or no quota). Exports in the Downloads folder are picked up on their own; this is for the ones that ended up in another folder. Then compare with the frame link, as usual.

Inputs: path (required).

list_devicesA

Lists the Android devices and emulators connected through adb and, on macOS, the booted iOS simulators.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 5 tools

    Disambiguation4/5

    Each tool has a clear primary purpose, but capture_screen and compare_screen could be mistaken at a glance since compare_screen internally captures and analyzes the screen. get_design_specs and import_design also both deal with Figma source data, though their descriptions clearly distinguish API vs offline export use.

    Naming Consistency5/5

    All tools follow a consistent snake_case verb_noun pattern: list_devices, compare_screen, capture_screen, get_design_specs, import_design. No mixed conventions or vague standalone verbs.

    Tool Count5/5

    Five tools is well-scoped for a visual design comparison server. Each tool covers a distinct step in the workflow: device discovery, screenshot capture, Figma spec retrieval, offline design import, and comparison.

    Completeness4/5

    The core workflow is covered: discover devices, get design specs or import design data, capture the current UI, and compare it against Figma with reports. Minor gaps exist around explicit device selection or app navigation/state control, but agents can likely work around these.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Local MCP server for Android and iOS mobile automation and performance telemetry, enabling device control (screenshot, tap, swipe, input, app launch) and metric collection (CPU, memory, launch time) via ADB, simctl, and WebDriverAgent with SQLite session history.
      14 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol (MCP) server for iOS Simulator automation. Enables AI assistants to visually interact with iOS apps running in the simulator.
      39 npm
      1
      MIT