Build mobile apps with AI that can see and use your app.
Claude Code running in a cloud macOS or Linux VM with your full project: repo, dependencies, backend, database, iOS Simulator. It reads code, writes code, builds, runs, and tests against the live app. You chat with Claude, review every diff, and ship pull requests from any device.
Portions of this video are sped up, because you shouldn't waste your life watching spinners spin while compiling.
iOS · Simulator + code
Cross-platform
Android · Simulator coming soon
The Simulator
An iOS Simulator in the cloud. Claude at the controls.
Wallfacer boots a macOS VM with Xcode and the iOS Simulator. Claude builds the app, installs it in the simulator, and interacts with it: tapping, scrolling, typing, navigating between screens. It sees the result of every change and iterates on its own.
The simulator streams live to the Wallfacer app or any browser. Tap and control it directly, or watch Claude work. Code with Claude, see the results immediately in the simulator, and skip the local pull-build-test cycle entirely.
Live streaming
The simulator streams to the Wallfacer app or any browser with interactive touch input and device controls.
Multi-touch
Pinch, rotate, and swipe with up to 10 simultaneous touch points.
Device controls
Switch between dark mode and light mode, change orientation, set GPS coordinates, and simulate Face ID.
Full Environment
Run every service your app depends on.
Claude starts your backend, database, API server, and any other services your app needs inside the VM. macOS VMs include the full Apple toolchain. Linux VMs include Docker and full package management. Real requests against real services, not mocked endpoints or placeholder data.
platform: macos
setup:
- name: Install services
run: brew install postgresql@15 redis
- name: Install dependencies
run: pip install -r requirements.txt
services:
- name: postgres
run: pg_ctlcluster 15 main start
- name: redis
run: redis-server
- name: api
run: python manage.py runserver 0.0.0.0:8000
ports:
- 8000
healthcheck:
command: curl -f http://localhost:8000/health
interval: 2s
timeout: 60s
post_setup:
- name: Run migrations
run: python manage.py migrate
ios:
bundle_id: com.mycompany.myapp
build: xcodebuild -scheme MyApp -destination "id=$IOS_SIMULATOR_UDID" buildRunning in Wallfacer VM
macOS VMs
Apple Silicon, Xcode, iOS Simulator, CocoaPods, and Swift Package Manager.
Linux VMs
Debian-based with Docker, full package management, and sudo access.
Any service
Backend servers, databases, API gateways, MCP servers, and message queues all run inside the VM.
Setup commands
Run any shell commands before your services start. Install dependencies, run migrations, seed data, configure the environment. They run sequentially and retry automatically on failure.
Persistent services with healthchecks
Background services stay running for the entire session. Define healthchecks so Wallfacer knows when each service is ready before moving on. If a service crashes, the logs are captured automatically.
One-line app builds
Define your build command and Wallfacer handles the rest. Xcodebuild, Expo, Flutter, React Native, or any custom script. The simulator UDID and bundle ID are injected as environment variables.
Mobile-First
Ship from your phone.
Wallfacer is a native app on iPhone, iPad, Android, and web. The full workflow from GitHub issue to pull request without opening an IDE: plan the work, write the code, review diffs, preview in the simulator, and publish. Chat or dictate to steer Claude's work from anywhere.
Instant & Persistent
Two-second boot. No setup. Pick up where you left off.
Wallfacer snapshots a fully provisioned VM with the repo cloned, dependencies installed, and services running. Future sessions restore from that snapshot in seconds. Conversations persist across VM restarts, and Claude resumes with full context.
Claude auto-generates the environment config by analyzing the codebase and testing it against a real VM. It is fully customizable.
Snapshot restore
A fully provisioned VM boots in about two seconds with the repo, dependencies, and services ready.
Persistent context
Conversations survive across VM restarts. Claude resumes with the full history of the session.
Auto-configured
Claude analyzes the codebase, generates the environment config, and tests it by booting a real VM. Customize it if you need to.
Workflow
From exploration to pull request.
Explore the codebase with Claude and turn the conversation into a GitHub issue. Pick up an existing issue from your backlog and start implementation in one tap. When the work is done, open a PR with an auto-generated description linked back to the original issue. Every step happens inside Wallfacer, on any device.
How does the auth middleware handle token refresh?
The auth middleware in src/middleware/auth.ts checks the JWT expiry and calls refreshToken() when the token is within 5 minutes of expiring...
Create an issue to add retry logic for failed refreshes
When refreshToken() fails due to a network error, the middleware should retry up to 3 times with exponential backoff before logging the user out.
Implementation: Wrap the refreshToken() call in src/middleware/auth.ts with a retry helper. Add exponential backoff (1s, 2s, 4s). After 3 failures, call logout() and redirect to /login.
Claude is editing src/middleware/auth.ts
async function refreshWithRetry(
token: string,
attempt = 0
): Promise<string> {
try {
return await refreshToken(token);
} catch (err) {
if (attempt >= 3) throw err;
const delay = 1000 * 2 ** attempt;
await sleep(delay);
return refreshWithRetry(
token, attempt + 1
);
}
}Claude is editing src/utils/retry.ts
@@ middleware/auth.ts @@
- const newToken = await refreshToken(token);
+ const newToken = await refreshWithRetry(token);
@@ utils/retry.ts (new) @@
+ export async function refreshWithRetry(
+ token: string, attempt = 0
+ ): Promise<string> {
Wraps refreshToken() in a retry helper with exponential backoff (1s, 2s, 4s). After 3 failures, the user is logged out and redirected.
Closes #142
Under the Hood
Purpose-built infrastructure for AI coding.
Wallfacer is not a wrapper around existing cloud VMs. We built a dedicated control plane that provisions, snapshots, and destroys isolated development environments across a fleet of Linux and macOS bare-metal servers.
Real macOS, real Simulator
The iOS Simulator runs natively inside a macOS VM on Apple Silicon hardware. The screen is captured and streamed as H.264 video to your device in real time. This is not an emulator. This is not a screenshot service. This is Xcode and the iOS Simulator running on dedicated Apple hardware in the cloud, with Claude operating the controls.
Server Fleet
VM
macOS 26+
VM
macOS 26+
Real macOS VMs on Apple Virtualization.framework. Each runs Xcode, the iOS Simulator, and your full project. All hardware uses Apple's M4 processor or newer.
VM
Debian 12+
VM
Debian 12+
VM
Debian 12+
Micro-VMs with hardware-level isolation. Each VM boots in seconds with full Docker support.
How It Works
Snapshot and restore
We capture the full state of a running VM, including memory, disk, and all processes. When a new session starts, the VM restores from that snapshot in about 2 seconds. Your repo is already cloned, dependencies are installed, and services are running.
Destroy on idle
When a session goes idle, the VM is destroyed and all resources are reclaimed. When the engineer comes back, a fresh VM boots from the snapshot with the full conversation history restored. No idle VMs sitting around burning money.
Tenant isolation
Every VM gets a unique SSH keypair generated at boot. Password auth is disabled. Network firewalls block VM-to-VM traffic at both the host and guest level.
Enterprise deployments
Run Wallfacer on your own hardware or in your own cloud. Custom server fleets, private networking, dedicated macOS hosts, and full control over where your code runs. Everything described above ships as a single binary that self-registers with your fleet.