Create anything. Locally.

Images. Video. 3D. Audio. Chat. Just enough. Nothing more.

Download — Free View on GitHub Machines · Enriching · Regular · Experiences
Agent-assisted install

Paste this into Claude or Codex.

Let your agent download the DMG, mount it, install the app, expose the CLI in your home directory, add the optional use-mere-run skill, pull the starter image model, and open the first generated PNG.

  • No sudo, no shell-profile edits, no silent CLI install.
  • The CLI lands at ~/.local/bin/mere.run.
  • Only the end-user use-mere-run skill is copied.
agent-install-prompt.txt 
You are helping me install mere.run locally on this Mac.

Rules:
- Do not use sudo.
- Do not edit shell profiles unless I ask.
- Prefer user-local install paths.
- Stop and explain if the download or DMG mount fails.

Steps:
1. Download the latest DMG to a temporary folder:
   work_dir="$(mktemp -d)"
   dmg_path="$work_dir/mere-run.dmg"
   curl -fL "https://mere.run/releases/v0.5.1/mere-run.dmg" -o "$dmg_path"
2. Mount the DMG, or reuse it if it is already mounted:
   hdiutil attach -nobrowse -readonly "$dmg_path"
   volume=""
   for candidate in "/Volumes/mere.run" /Volumes/mere.run* /Volumes/MereRun* "/Volumes/Mere Run"*; do
     if [ -d "$candidate" ] && [ -x "$candidate/.mere-run/install.sh" ]; then
       volume="$candidate"
       break
     fi
   done
   if [ -z "$volume" ]; then
     echo "Mounted the DMG, but could not find the mere.run volume."
     hdiutil info
     exit 1
   fi
3. Verify the mounted volume contains MereRun.app plus .mere-run/install.sh:
   test -d "$volume/MereRun.app"
   test -x "$volume/.mere-run/install.sh"
4. If /Applications/MereRun.app is missing, copy the app there:
   if [ ! -d "/Applications/MereRun.app" ]; then
     ditto "$volume/MereRun.app" "/Applications/MereRun.app"
   else
     echo "/Applications/MereRun.app already exists. Leaving it in place."
   fi
   If the copy is denied, tell me to drag MereRun.app to Applications, then continue with CLI and skill setup.
5. Install the CLI to ~/.local/bin/mere.run:
   mkdir -p "$HOME/.local/bin"
   MERERUN_INSTALL_BIN_DEST="$HOME/.local/bin/mere.run" "$volume/.mere-run/install.sh"
6. Install the bundled use-mere-run Codex skill if it exists:
   skill_source=""
   for candidate in "$volume/MereRun.app/Contents/Resources/skills/use-mere-run" "$volume/.mere-run/skills/use-mere-run"; do
     if [ -d "$candidate" ]; then
       skill_source="$candidate"
       break
     fi
   done
   if [ -n "$skill_source" ]; then
     mkdir -p "$HOME/.codex/skills"
     rm -rf "$HOME/.codex/skills/use-mere-run"
     ditto "$skill_source" "$HOME/.codex/skills/use-mere-run"
   fi
7. Verify the CLI:
   "$HOME/.local/bin/mere.run" --help
   "$HOME/.local/bin/mere.run" model capabilities --recommended
8. Pull the starter image model:
   "$HOME/.local/bin/mere.run" model pull image-zimage-nano
9. Generate and open the first image:
   "$HOME/.local/bin/mere.run" image generate --model image-zimage-nano --prompt "a ceramic mug in soft morning light on a walnut desk" --width 1024 --height 1024 --steps 8 --seed 2026 --output "$HOME/Desktop/mere-first-image.png"
   open "$HOME/Desktop/mere-first-image.png"

At the end, tell me where the app, CLI, skill, model store, downloaded DMG, mounted volume, and image are.
The Gallery

Made with Mere

Every image generated locally on Apple Silicon. No cloud. No waiting.

klein-nano · 1280×720 · 8 steps
klein-nano · macro · seed 4242
klein-nano · architectural · seed 5555
klein-nano · cinematic · seed 7777
klein-nano · portrait · seed 1234
Capabilities

One toolkit. Your Mac.

Images, video, music, voice, chat, code, OCR, embeddings, and local API serving — everything runs locally on Apple Silicon.

CREATE
Images

Two model families. LoRA adapters. Image-to-image. Custom styles.

mere.run image generate --prompt "a portrait in oil paint style"
CREATE
Video

Text-to-video and image-to-video. Native LTX pipeline on Metal.

mere.run video generate "timelapse of clouds over peaks"
CREATE
Music

Generate tracks, remix, cover vocals. ACE-Step with lyrics and BPM.

mere.run music generate "upbeat groove" --bpm 120
INTERACT
Chat

122B-parameter LLM running locally. Code generation. Multi-turn.

mere.run text chat --prompt "explain diffusion models"
INTERACT
Voice

Text-to-speech with voice cloning. Save and reuse voice profiles.

mere.run speech synthesize "Hello world" --output hello.wav
INTERACT
Listen

Transcribe and translate audio. Streaming ASR. Timestamps.

mere.run speech transcribe recording.wav --backend auto
MANAGE
Models

List capabilities. Pull managed models. Inspect installs. Repair manifests.

mere.run model capabilities
UNDERSTAND
Vision & OCR

Describe images. Extract text. Caption datasets for training.

mere.run vision inspect photo.jpg "what is this?"
SERVE
API Server

OpenAI-compatible endpoint. Drop into Cursor, VS Code, any client.

mere.run api serve --engine text-chat-gemma4
mere.

Every capability at your fingertips. One command away.

~/projects · zsh
$ mere.run image generate --prompt "an astronaut painting on the moon" image-zimage-nano · 1024x1024 · → astronaut_moon.png
$ mere.run video generate "timelapse of a flower blooming" video-ltx-av · 768x512 · → flower_bloom.mp4
$ mere.run speech synthesize "Welcome to Mere" --output welcome.wav speech-tts-qwen3-nano · → welcome.wav
$ mere.run text chat --prompt "explain fine-tuning diffusion models" text-chat-gemma4 · streaming response...
$ mere.run music generate "rainy neon diner rockabilly" --bpm 90 music-acestep · → rain_walk.wav
$ mere.run api serve --engine text-chat-gemma4 OpenAI-compatible local API running at http://127.0.0.1:8080
AGENT NATIVE

Built for humans.
Built for agents.

Mere is a first-class tool for AI agents. Claude Code, Cursor, and any OpenAI-compatible client can invoke every capability — image generation, video, music, TTS, chat — through a single CLI or API endpoint. Your Mac becomes an AI compute layer that both you and your agents share.

  • mere.run agent onboard — configure local agent workflows
  • mere.run api serve — OpenAI-compatible local API for editor and agent clients
  • CLI-first — every command is scriptable and composable
claude code · session
CLAUDE CODE
> Generate a hero image for the landing page
Using /mere-run to generate image...
$ mere.run image generate --prompt "minimal product hero,
clean composition, studio lighting" --width 2048 image-zimage-max · 2048x1024 → hero_landing.png saved
Image generated. Adding to page layout.
Mere apps

Apps can ask for what they need.

The public Mere CLI can now orchestrate this runtime for Mere apps. It resolves an existing mere.run binary, builds from source, or installs a verified DMG, then pulls the local models requested by an app.

  • mere setup mere-run prepares the runtime.
  • mere setup mere-run models --app media pulls Media's ASR and embedding models.
  • Execution still happens locally on the user's Mac.
mere apps · setup
$ npm install -g @merekit/cli installs the public Mere command plane
$ mere setup mere-run --json runtime ready · existing binary, source build, or verified DMG
$ mere setup mere-run models --app media --json speech-asr-parakeet · text-embed-qwen3-0.6b
$ mere media process ./interview.m4a --transcribe --embed transcript + searchable segments generated locally
Mac Native · Swift

A Swift binary.
SwiftUI ready.

Mere is a single Swift CLI. Every Mac app — yours or one your agent vibe-codes mid-conversation — can drop it in via Process. Spark, below, is a real SwiftUI app. Claude wrote it in one prompt.

Spark — idle
Spark.app idle state — empty canvas with a prompt field. empty state · resolves mere.run on $PATH
Spark — generated · 9.2s
Spark.app showing a generated cozy reading nook image. image-klein-nano · 1024×768 · on this Mac
MereClient.swift ~24 lines 
import Foundation
import AppKit

enum MereClient {
    static func generate(prompt: String) async throws -> NSImage {
        let bin = URL(fileURLWithPath: "/usr/local/bin/mere.run")
        let out = URL(fileURLWithPath: NSTemporaryDirectory())
            .appendingPathComponent("spark-\(UUID().uuidString.prefix(8)).png")

        let proc = Process()
        proc.executableURL = bin
        proc.arguments = [
            "image", "generate",
            "-m", "image-klein-nano",
            "-p", prompt,
            "-W", "1024", "-H", "768",
            "-s", "8",
            "-o", out.path,
        ]
        try proc.run()
        proc.waitUntilExit()

        guard proc.terminationStatus == 0,
              let img = NSImage(contentsOf: out)
        else { throw MereError.generationFailed }
        return img
    }
}
$ swift build -c release && open Spark.app no SDKs · no dependencies · no API keys
Source: demo-app/ in this repo · vibe-coded by Claude in a single prompt · runs against the local mere.run CLI

Local-first.

Near-zero operating cost. No cloud. No subscription fatigue.

Nothing leaves your Mac.

No server. No upload. No telemetry. Your prompts are yours.

Free. Forever.

MIT licensed. Built in Prince Edward Island. For the people who keep the world running.

The Showcase

One scene.
Every modality.

From a single creative seed — a 1950s American roadside diner, just before midnight, in heavy rain — Mere generated text, a photograph, open-vocabulary object detection and segmentation, narration, a full-production song with lyrics, two cinematic videos, working Swift code, and embeddings. All locally on a MacBook. In about four minutes.

$ bash ~/mere/run/demo.sh ⟶ 9 modalities · 13 artifacts · 0 cloud calls · ~4 min on M-series
Image + Vision · klein-nano + Falcon Perception
Generated 1950s diner scene with Falcon Perception object detection and segmentation overlays.
waitress · 0.95 jukebox · 0.92 neon sign ×3
Text · Creative gemma4 · 0.85t
"The door exhales a draft of ozone and wet asphalt, yielding to a sanctuary of humming neon and scorched lard. Inside, the air is a thick, amber suspension of tobacco smoke and percolating coffee…"
— mere.run text chat · 512 tokens $ mere.run text chat --prompt "describe a 1950s diner…"
Video · LTX 768×512 · 65f · 24fps

Establishing shot, dolly-in

Native LTX pipeline on Metal. Text-to-video from the same scene description.

Video · Image-to-Video 33f · seeded by hero

The still comes to life

Animated directly from the generated photograph — steam, headlights, jukebox glow.

Music · ACE-Step G major · 88 BPM · 60s

"Honey, stay one more song with me"

Full vocal production. Vintage rockabilly, brushed snare, twangy reverb-soaked Telecaster, doo-wop backing vocals, a soft tenor sax solo. Written and arranged from a single prompt + lyrics file.

Honey stay one more song with me
Underneath the chrome and the canopy
Red vinyl shining in the smoky light
Save me from the lonely night
Speech · TTS → ASR qwen3-nano · parakeet

The text, spoken back.

Synthesized in a deep documentary voice, then transcribed with timestamps. Round-trip never leaves the machine.

[00:00 → 00:08] The door exhales a draught of ozone…
[00:08 → 00:18] Inside, the air is a thick, amber suspension…
[00:18 → 00:27] Outside, the rain hammers the plate glass…
Code · Swift qwen3-coder · streamed
mandelbrot.swift 
/// Computes the Mandelbrot set for a given grid of complex points.
func generateMandelbrotSet(
    width: Int,
    height: Int,
    bounds: ComplexPlaneBounds = .default,
    maxIterations: Int = 100
) -> [[Int]] {
    var mandelbrot: [[Int]] = .init(repeating: .init(repeating: 0, count: width), count: height)
    let xStep = (bounds.right - bounds.left) / Double(width - 1)
    let yStep = (bounds.bottom - bounds.top) / Double(height - 1)
    for y in 0..<height {
        for x in 0..<width {
            let cx = bounds.left + Double(x) * xStep
            let cy = bounds.top + Double(y) * yStep
            mandelbrot[y][x] = iterate(cx: cx, cy: cy, max: maxIterations)
        }
    }
    return mandelbrot
}
compiled · rendered · 0.30s
Mandelbrot overview rendered locally
Seahorse Valley zoom rendered locally
Vision · Falcon Perception grounding + masks

Knows what it sees.

The same image fed back into Mere's vision stack: open-vocabulary object grounding with pixel-perfect masks.

waitressbox (0.61, 0.28) → (0.74, 0.68) jukeboxbox (0.84, 0.28) → (0.96, 0.65) neon sign3 detections · masks saved
$ mere.run vision ground hero.png --query "waitress"
Embeddings · qwen3-0.6b cosine similarity

Same Mac. Semantic search ready.

Three sentences embedded locally. The two diner-related sentences cluster together; the cat sits alone.

"rainy 1950s American diner late at night"
↔ "neon-lit chrome counter and red vinyl booths"
cosine0.510
"neon-lit chrome counter and red vinyl booths"
↔ "a cat sitting on a windowsill"
cosine0.351
"rainy 1950s American diner late at night"
↔ "a cat sitting on a windowsill"
cosine0.293
Every artifact above was generated by ~/mere/run/demo.sh · no cloud · no edits · the script is in the repo.