Make every Mac
render.
Turn the Apple Silicon already on your desks into one coordinated LTX-2.3 video pipeline. No NVIDIA. No cloud. No per-render cost.
macOS 11+ · Apple Silicon · open source · runs entirely on your own hardware
THE SAME BOARD / NATIVE + BROWSER / LIVE FROM THE SHARE
Near-linear. Each Mac renders a different clip.
No cloud GPU bill. The hardware is already on the desks.
Models hardlink onto the share instead of copying.
Gigabit is plenty — only job files and MP4s cross the wire.
You cannot bolt four Macs together into one big GPU — tensor-parallel diffusion needs NVLink speeds, and ethernet is about a thousand times too slow. So the farm parallelises the way that actually pays:
Three Macs or thirty — each takes a different clip, and nothing crosses the network mid-render: a ~1KB job file on the way in, an MP4 on the way out. Throughput scales with the chips you plug in — four Macs is about 4× the clips per hour, on a $20 switch.
Every job is priced before a Mac may claim it. A heavy render holds out for the 64GB machine while the smaller Macs clear proofs and drafts — and a memory kill comes back asking for a bigger Mac, not as a dead job.
A Mac that goes quiet at 2am gets its job requeued, a one-off flake gets one retry, and a genuine failure streak pauses the queue instead of burning the rest of the night. Every decision is written down for the morning — and it works the same with eight office Macs under one rack as with three on a desk.
One app, two front doors. It lives in the menubar with a ping sound as each job moves, and it serves the same interface over HTTP — so the producer watches the board from their own desk, or a phone, without mounting anything.
Drag or scroll through the app
01 / 06Queued → rendering → done → failed, read straight off the shared folder. Drag to reorder what renders next — claim order is filename order, so a drag genuinely re-prioritises the farm. Every card says who asked for it and roughly how long it takes on your Macs.
Proof stills render in seconds. Lay them out, pick the framing that works, and Render hero spends real farm time on that exact seed. Approve or send back — the decision lives on the share, so the whole team sees it.
Prompts × delivery sizes × takes, queued as one named run. It prices the night before you commit it — jobs, and roughly how long that is across however many Macs are actually up.
What landed, what failed (as cards you can act on), who rendered what, and what got approved. Autopilot’s overnight decisions sit in the log next to it.
Every Mac running the app publishes itself to the share: the person at it, the model, the RAM, the profile, and what it’s rendering this second. A Mac with the app but no worker gets flagged, so “online” never quietly means “idle”.
Reap stalled jobs, pause the queue, and edit farm.conf for every Mac at once — validated before it’s written, because that file is sourced by bash on every worker.
Autopilot handles the farm-wide night. Each person still has Play, Pause and Stop on their own Mac: Pause drains the current clip; Stop releases renderer resources within 30 seconds and requeues it.
A worker that dies at 2am shouldn’t cost you the clip.
One flake shouldn’t end a shot.
Asks for a bigger Mac if the farm has one, otherwise re-queues it smaller. Retrying an OOM at the same size just dies again.
A broken setup would otherwise burn the remaining six hours failing two hundred times.
An unattended system that can’t explain its night isn’t trustworthy.
Price the job, then claim it — never the other way around.
90% of installed RAM, and PERF=auto gates the heavy profile to 64GB machines.
Every finished render records its peak. The app shows how many blew their budget — that’s the number you retune against.
This policy came from a real four-Mac OOM: MLX memory is not represented by the usual free-memory number, so jobs are now priced before they are claimed and every completed render records its peak.
There is no server, no queue daemon and no database. The shared folder is the queue, and an atomic file move is the whole locking story.
Turn on File Sharing, share ~/RenderFarm. That folder is the entire database — queue, running, done, failed.
Keep Wi-Fi above Ethernet in Service Order, so the internet goes over Wi-Fi and farm traffic goes over the switch. The switch never needs internet.
The coordinator publishes ~87GB of models to the share by hardlink, not copy. Workers pull them over the switch in minutes instead of days from HuggingFace.
A worker moves a job file into running/. The mv is the lock — only one Mac can win it. No server, no scheduler, no collisions.
the entire claim protocol
# priority lane first, then the normal queue
for cand in "$QUEUE"/hi/*.job "$QUEUE"/*.job; do
claimed="$RUNNING/$(basename "$cand").$HOST.$$"
mv "$cand" "$claimed" 2>/dev/null && break # only one Mac can win this
doneBecause claim order is byte order on the filename, reordering the queue in the app is a rename — not a request to a scheduler that might disagree with the folder.
Workers can’t see the queue, or "Farm folder not found" during setup.
Guide →Renders crawling over office Wi-Fi, or Macs on the switch losing internet.
Guide →HuggingFace throttled to <100 KB/s, or every Mac downloading the same 87GB.
Guide →"Apple could not verify…" blocking the scripts, or a Mac that shows online but never claims work.
The app checks every step of this for you, per Mac, with the exact fix and a button that performs it. Nobody has to reverse-engineer the network from a README.
on the coordinator · publish the models to the share (hardlinks, seconds)
FARM_ROOT=~/RenderFarm ./seed_farm_assets.sh on every render Mac · Homebrew, uv, LTX2-MLX, mflux — mostly unattended
./setup.command then · joins the farm and starts claiming jobs
./start_worker.command queue work from any Mac · or just use the app
./enqueue.sh --id hail_hero --prompt "storm clouds over a QLD roof" --seed 8804 Stuck on any step — Gatekeeper warnings, a Mac that won’t claim work, memory kills, stalled jobs? There’s a fix-first guide for each: browse the docs — or jump straight to memory & OOM, stalled jobs, queueing jobs or the headless gateway.
A headless Mac in a cupboard runs the gateway on its own:
ltx-mac-farm --serve It still shows up in everyone’s Team view, still publishes its presence, and can still be set up from a browser.
Approved renders come off the farm with their prompt, seed, size, model, render time and peak memory attached — so a win is reproducible, not a lucky screenshot.
Four Macs, a $20 switch and one shared folder. The app handles the rest — and it’s free.
built by Aidxn Design · Design engineering studio, Gold Coast