iFarm vs a self-hosted Appium device farm

The verdict

Choose an Appium-based farm if your team writes UI tests in code and runs them in CI. Appium is the established open-source standard for this: it automates iOS, Android and other platforms, with tests written in languages like JavaScript, Python, Java, Ruby and .NET. Appium Device Farm and GADS add device pools, parallel sessions and dashboards on top.

Choose iFarm if you test iPhone apps and want a device lab without writing code or running servers. You record a flow by using the phone, replay it on every iPhone size, schedule it, and get a report with a screenshot of every check. It's one Mac app, iPhone only.

You can use both: coded tests in CI, and iFarm for hands-on checks, App Store screenshots and bug reproductions on real iPhones.

Side by side

As of November 2026, from each project's own pages and iFarm's documentation.

	Appium Device Farm	GADS	iFarm
What it is	An Appium 2 plugin that manages driver sessions on connected devices	A self-hosted device farm for remote control and Appium test execution	A Mac app that runs real iPhones from one Mac
License	Apache License 2.0	AGPL-3.0, with a proprietary hub-ui	Free, closed source
Platforms	Android, iOS and tvOS: real devices, emulators and simulators	iOS and Android, plus some smart TVs for automated testing	iPhone only (iOS 16 or later)
How you write tests	Code, through Appium clients	Code, through Appium	No code: record, or edit steps in a list
Live remote control	Removed in version 12.0.0 ("stay on 11.x")	Web UI with live video, tap, swipe, text input	Native live view and grid, click to tap
Scale	Hub/node across machines, parallel tests	Hub plus providers	One Mac: 5–30 phones depending on memory
Extra infrastructure	Appium server	MongoDB, Go build, hub and provider	None: no servers, no database
Reports	Dashboard, logs and video recording	Not described as test reports	Pass/fail HTML report per run with screenshots
CI integration	Yes	Via Appium / Selenium Grid	Not designed for CI; runs on schedules in the app

Code and CI vs record and replay

Appium is a framework for automated tests. You write a test in code, point it at a device through the Appium server, and run it from CI on every commit. Appium Device Farm's README lists parallel execution across devices and CI/CD integration; GADS offers per-device Appium endpoints and optional Selenium Grid 4 registration.

iFarm doesn't run test code. You open a phone in iFarm, press Record and use your app through the live screen. Taps, swipes, holds, buttons, typed text and pauses are saved as steps you can edit: tap text, wait, swipe, wait for text, if text is on screen, repeat. For each tap iFarm remembers the text under your finger, so replays find the same button on other iPhone sizes. Automations export and import as JSON.

Turn on Test mode and every "Wait for text" step becomes a check that must pass, popups are left to your steps (so you can test permission prompts), and each run writes an HTML report with every check, a screenshot of each, the phone and iOS version, your app's version and build, the timing and the full log.

Setup and infrastructure

Both kinds of tool drive iPhones through WebDriverAgent, which has to be built and signed with an Apple developer team in Xcode. Appium Device Farm documents this in its iOS signing guide, and the XCUITest driver docs cover managing WebDriverAgent and provisioning profiles for real devices.

On top of that, an Appium farm is a set of services. Appium Device Farm runs as a plugin inside an Appium server, with a hub/node layout for scaling. GADS needs a MongoDB instance (v6.0 recommended), a hub and providers, and network links between them; its page lists full support on macOS hosts and limited iOS support on Linux and Windows.

iFarm is one Mac app. A setup guide checks Xcode, your signing team and each phone, then downloads WebDriverAgent (checksum verified), builds it with your team and installs it as an app called "iFarm". No Appium, no database, no Docker. Setup takes about 20 minutes, mostly waiting for Xcode to download.

Manual control

GADS includes a web UI for remote control with live video, tap, swipe, text input, screenshots and app installation. Appium Device Farm's README says manual device control and live streaming were removed in version 12.0.0, and users who need them should stay on 11.x.

iFarm is built around live control: click to tap, drag to swipe, hold for a long press, and Home, volume, lock and wake buttons. The All phones grid shows every phone live and Mirror repeats your taps and swipes on all checked phones, scaled to each screen.

Android and scale

If you need Android, Appium-based farms are the answer; iFarm is iPhone only. Appium farms also spread across machines (Appium Device Farm's hub/node, GADS's providers). iFarm runs on one Mac: 5–10 phones on 8 GB of memory, 10–20 on 16 GB, 20–30 on 32 GB or more, limited by USB hubs. The Health page shows "Room for about N more phones".

Tip: iFarm's helper and Xcode's own UI tests (XCUITest) can't drive the same phone at the same time. Give each its own phone, or stop iFarm on that phone while those run.

Frequently asked questions

Is iFarm built on Appium?

No. iFarm uses WebDriverAgent, the same open-source helper Appium's iOS driver uses, but it drives it directly from a Mac app. You don't install or run Appium.

Can I run iFarm tests in CI?

iFarm isn't designed for CI pipelines. It runs tests from the app, by hand or on schedules (for example nightly), and keeps reports in ~/Library/Application Support/iFarm/Reports.

Is a self-hosted Appium farm free?

The software is open source: Appium Device Farm under Apache 2.0, GADS under AGPL-3.0 with a proprietary UI component. You provide the machines, devices and Apple developer team. iFarm is free too, but closed source.

Does iFarm support Android?

No. iFarm runs real iPhones only.

Related