Download Mockarty

Name: Mockarty
Author: Mockarty

Choose your platform and component

All releases on GitHub

Ecosystem products

Everything in one place — install and you're working. Local, no cloud.

Mockarty Desktop

The full product in one window — mocks, tests, load. Local, offline, zero setup.

Download

How to install

Download, open, done. The first launch starts a local server and UI — no dependencies, the database and cache are built in.

Companion Android

Android companion for the device grid: scenario recording, input and capture without root.

Download APK

How to install

Just install the app and you're ready: download the APK (or scan the QR with your phone), allow install from this source, open the app and pair with Mockarty by code/QR — the device shows up in the grid.

Browser extension

Capture, record and rewrite traffic right in Chrome. Collections, mocks, HAR — offline.

Download .zip

How to install

Download and unzip. Open chrome://extensions, enable Developer mode, click 'Load unpacked' and pick the folder.

Device Console & runners

Device host (farm) plus load / functional / browser / mobile runners. Push, pull, CI.

Download

How to install

Two ways: run the console on a machine with devices — it advertises its inventory and Mockarty dispatches tasks — or plug a phone in over USB with debugging enabled to use it directly. Runners support push, pull and ephemeral CI (--once).

No Releases Available

Check back soon for new releases.

Mockarty is a set of components. Pull the official images from Docker Hub and assemble the federation you need.

Docker Hub images

docker pull mockarty/mockarty:latest         # Admin node + Web UI
docker pull mockarty/resolver:latest         # Mock resolver
docker pull mockarty/runner:latest           # Load / functional tests
docker pull mockarty/generator:latest        # Server generator
docker pull mockarty/browser-runner:latest   # UI / browser (Playwright)
docker pull mockarty/mobile-runner:latest    # Mobile (needs a device/emulator)
docker pull mockarty/chaos-operator:latest   # Kubernetes chaos
docker pull mockarty/redteam-runner:latest   # Security: red-team
docker pull mockarty/exploit-runner:latest   # Security: exploits

A server federation — admin, resolver and runners over shared PostgreSQL + Redis:

docker-compose.yml

services:
  postgres:
    image: postgres:16-alpine
    environment: { POSTGRES_DB: mockarty, POSTGRES_USER: mockarty, POSTGRES_PASSWORD: changeme }
    volumes: [ pgdata:/var/lib/postgresql/data ]
    healthcheck: { test: ["CMD-SHELL", "pg_isready -U mockarty"], interval: 5s }

  redis:
    image: redis:7-alpine
    healthcheck: { test: ["CMD", "redis-cli", "ping"], interval: 5s }

  mockarty:                       # admin node + Web UI + coordinator
    image: mockarty/mockarty:${VERSION:-latest}
    ports: ["5770:5770", "5772:5772", "5773:5773"]
    environment:
      DB_USE: pg
      DB_DSN: postgres://mockarty:changeme@postgres:5432/mockarty?sslmode=disable
      REPO_REDIS_HOST: redis
      REPO_REDIS_PORT: "6379"
    depends_on:
      postgres: { condition: service_healthy }
      redis: { condition: service_healthy }

  resolver:                       # serves your mocks at scale
    image: mockarty/resolver:${VERSION:-latest}
    environment:
      COORDINATOR_ADDR: mockarty:5773
      API_TOKEN: ${RESOLVER_API_TOKEN}    # create in admin UI -> API tokens
      DB_DSN: postgres://mockarty:changeme@postgres:5432/mockarty?sslmode=disable
    depends_on: [mockarty]

  runner:                         # perf / functional tests
    image: mockarty/runner:${VERSION:-latest}
    environment:
      COORDINATOR_ADDR: mockarty:5773
      API_TOKEN: ${RUNNER_API_TOKEN}      # create in admin UI -> API tokens
      CAPABILITIES: api_test,performance
    depends_on: [mockarty]

volumes: { pgdata: {} }

Start: core first, then runners with tokens

# 1) core — admin + DB + cache
docker compose up -d postgres redis mockarty
# 2) open http://localhost:5770, create API tokens
# 3) bring up the runners with the tokens
RESOLVER_API_TOKEN=... RUNNER_API_TOKEN=... docker compose up -d

The full federation with security runners is in docker-compose.distributed.yml in the releases repo.

Mobile tests — two ways. Real devices (or an emulator on your machine) attach via the Device Console (card above) — it lends the phone to the grid. For a fully standalone CI run, build an image with a bundled Android emulator from our binary:

Dockerfile + entrypoint.sh

# place the downloaded mockarty-mobile-runner-linux-amd64 next to this Dockerfile
FROM eclipse-temurin:17-jdk-jammy
ENV ANDROID_SDK_ROOT=/opt/android-sdk
ENV PATH="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/platform-tools:$ANDROID_SDK_ROOT/emulator:$PATH"
RUN apt-get update && apt-get install -y --no-install-recommends \
      curl unzip android-tools-adb libpulse0 libgl1 libnss3 libxcomposite1 libxcursor1 libxi6 \
    && rm -rf /var/lib/apt/lists/*
RUN mkdir -p $ANDROID_SDK_ROOT/cmdline-tools \
    && curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o /tmp/c.zip \
    && unzip -q /tmp/c.zip -d $ANDROID_SDK_ROOT/cmdline-tools \
    && mv $ANDROID_SDK_ROOT/cmdline-tools/cmdline-tools $ANDROID_SDK_ROOT/cmdline-tools/latest
RUN yes | sdkmanager --licenses >/dev/null \
    && sdkmanager "platform-tools" "emulator" "system-images;android-30;google_apis;x86_64" >/dev/null \
    && echo no | avdmanager create avd -n mockarty -k "system-images;android-30;google_apis;x86_64" --force
COPY mockarty-mobile-runner-linux-amd64 /app/mockarty-mobile-runner
COPY entrypoint.sh /app/entrypoint.sh
RUN chmod +x /app/mockarty-mobile-runner /app/entrypoint.sh
WORKDIR /app
ENTRYPOINT ["/app/entrypoint.sh"]

# ---- entrypoint.sh ----
#!/usr/bin/env bash
set -e
emulator -avd mockarty -no-window -no-audio -no-boot-anim -gpu swiftshader_indirect &
adb wait-for-device
until [ "$(adb shell getprop sys.boot_completed 2>/dev/null | tr -d '\r')" = "1" ]; do sleep 2; done
exec /app/mockarty-mobile-runner

Build & run (KVM host)

docker build -t mockarty-mobile-emulator .
docker run -d --device /dev/kvm \
  -e MOCKARTY_ADMIN_URL=http://YOUR_ADMIN:5770 \
  -e MOCKARTY_RUNNER_TOKEN=YOUR_TOKEN \
  mockarty-mobile-emulator

The emulator needs /dev/kvm (hardware acceleration). GitHub Linux runners support it — add udev perms for /dev/kvm. Without the emulator the runner drives a real device over local adb or a remote one: RUNNER_ADB_ENDPOINTS=tcp:host:5555.

Create a Dockerfile next to the downloaded binary:

Dockerfile

FROM alpine:3.20

RUN apk add --no-cache ca-certificates tzdata curl

WORKDIR /app
COPY mockarty /app/mockarty
RUN chmod +x /app/mockarty

EXPOSE 5770 5772 5773

HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost:5770/health/live || exit 1

ENTRYPOINT ["/app/mockarty"]

Build & Run

docker build -t mockarty .
docker run -d --name mockarty \
  -p 5770:5770 -p 5772:5772 -p 5773:5773 \
  -e DB_DSN="postgres://user:pass@host:5432/mockarty?sslmode=disable" \
  -e HTTP_PORT=5770 \
  mockarty

Full stack with PostgreSQL and Redis:

docker-compose.yml

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: mockarty
      POSTGRES_USER: mockarty
      POSTGRES_PASSWORD: changeme
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U mockarty"]
      interval: 5s

  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s

  mockarty:
    build: .
    ports:
      - "5770:5770"    # HTTP / Web UI
      - "5772:5772"    # MCP
      - "5773:5773"    # Coordinator gRPC
    environment:
      DB_DSN: "postgres://mockarty:changeme@postgres:5432/mockarty?sslmode=disable"
      REDIS_ADDR: "redis:6379"
      REPO_TYPE: "composite"
      HTTP_PORT: "5770"
    depends_on:
      postgres: { condition: service_healthy }
      redis: { condition: service_healthy }

volumes:
  pgdata:

Start

docker compose up -d

Run binary directly (no Docker):

Linux / macOS

chmod +x ./mockarty
export DB_DSN="postgres://user:pass@localhost:5432/mockarty?sslmode=disable"
./mockarty

SQLite mode (no PostgreSQL)

chmod +x ./mockarty
export DB_USE=sqlite
./mockarty

Web UI available at http://localhost:5770/ui/ after start