System Requirements
Supported platforms
Section titled “Supported platforms”- macOS 12 (Monterey) or later — Apple Silicon only (M1, M2, M3, M4 and later). Intel Macs are not supported.
- Windows 10 or later — 64-bit (x86_64)
- Linux — 64-bit (x86_64), glibc 2.35 or newer. Ships as an AppImage; tested on Ubuntu 22.04+, Fedora 36+, Arch, and Debian 12+.
Hardware
Section titled “Hardware”| Minimum | Recommended | |
|---|---|---|
| RAM | Depends on your sensor — see below | 16 GB up to ~24 MP; 32 GB at 40 MP and above |
| Disk | SSD, with scratch space sized to your stacks — see below | SSD with 50+ GB free |
| CPU | Any modern CPU (2015+) | 6+ cores |
| GPU | Not required — falls back to CPU | Discrete GPU with current drivers (integrated works too) |
RAM and disk both scale with the resolution of your camera, not with a single fixed number, so the two sections below are worth reading rather than skimming the table.
Memory (RAM)
Section titled “Memory (RAM)”Sensor resolution is what drives memory use, not frame count. This surprises people: a 12-frame stack from a 45 MP camera is a much harder job than a 60-frame stack from a 20 MP one.
The reason is that most of the memory goes into full-resolution working buffers — pyramids, accumulators, blend intermediates — which are sized by the pixel dimensions of one frame and reused across the stack. Each additional frame adds only about 10–13 MB at 20 MP, or 25–30 MB at 45 MP. Doubling your frame count barely moves the peak; doubling your megapixels roughly doubles it.
Rough guidance by sensor:
| Sensor | Workable | Comfortable |
|---|---|---|
| 16–24 MP | 8 GB (reduced-memory mode — slow) | 16 GB |
| 40–50 MP | 16 GB (often reduced-memory) | 32 GB |
| 60 MP+ | 16 GB, with swap headroom and patience | 32 GB or more |
To put a number on it: on a 45 MP camera, the blend phase alone has measured around 6 GB at its most conservative setting and about 10 GB running at full width — on a 12-frame stack. That is why 8 GB is no longer a realistic minimum on a high-resolution body, even for small stacks.
What actually matters at stack time is free RAM, not installed RAM, so closing other applications genuinely helps.
When memory is tight
Section titled “When memory is tight”Macro Studio measures available memory before each stack and degrades in stages rather than crashing:
- Reduced-memory mode. It narrows its internal worker pools to fit. You’ll see an amber advisory banner — “Running in reduced-memory mode — stacking will be slower” — often naming a target like free up about 4 GB. It clears itself after about 20 seconds. This is advisory, not an error: the stack is running, just slower. One field measurement had the narrowest setting adding around 67% to the run, so it’s a real slowdown worth acting on. If you already know why and don’t want telling every time, the banner can be switched off — see Show performance notices. The staging below still happens either way.
- GPU work moves to the CPU. If the GPU path’s memory cost won’t fit, the blend is demoted to the CPU before the stack starts. Same image, longer wait.
- The stack is refused. If even the CPU path can’t fit, Macro Studio declines up front with a message telling you roughly how much the stack needs, how much is available, and what to do — close other applications, or stack fewer frames at once. This is deliberate: refusing in advance beats being killed by the operating system twenty minutes in.
Swap / pagefile
Section titled “Swap / pagefile”Swap is a genuine requirement, not an optional extra.
Macro Studio’s memory check counts free RAM plus free swap as its budget. A machine with no swap has no cushion when memory runs low, which is exactly what turns a tight stack into a hard kill by the operating system. When swap is effectively absent, the refusal message says so explicitly — on Linux, Windows and macOS alike.
- Windows and macOS manage the pagefile / swap automatically. Leave it on. Don’t disable it to “free up disk space”.
- Linux commonly ships with little or no swap. On a low-swap Linux system Macro Studio shows a one-time dialog recommending a 16 GB swap file, with copy-paste terminal commands to create it and make it survive a reboot.
Scratch disk space
Section titled “Scratch disk space”The “disk space” that matters for stacking is not install space — the application itself is a few hundred MB. It’s scratch space: the temporary working files a stack writes while it runs, on whichever volume the scratch folder points at.
Frames are stored as 16-bit RGB, so each one costs about 6 bytes per pixel on disk, plus a margin for the overlap between processing stages and a fixed 2 GB of overhead. Worked through, that’s roughly:
| Sensor | Per frame | 30 frames | 60 frames |
|---|---|---|---|
| 20 MP | ~155 MB | ~7 GB | ~11 GB |
| 45 MP | ~350 MB | ~13 GB | ~23 GB |
| 60 MP | ~470 MB | ~16 GB | ~30 GB |
Macro Studio checks this before it starts aligning — a fraction of a second in, as soon as it knows your frame size — so a volume that can’t hold the stack fails fast with a clear message instead of dying several minutes later. That message names the volume, tells you how many GB to free, and mentions how many of your frames would have fit. It also states plainly that this is disk space and not memory, because that is the single most common misreading.
By default scratch goes to your system temporary folder. If your system drive is small, redirect it: Preferences → Advanced → Scratch folder for stacking. Use a fast local drive — network and removable drives are a bad choice here. See Preferences.
Graphics (GPU)
Section titled “Graphics (GPU)”Stacking is GPU-accelerated and uses your hardware automatically — there’s nothing to switch on. With no usable GPU, stacking falls back to the CPU: you get the same image, it just takes longer.
There is one switch, and it only turns the GPU off: Preferences → Advanced → Disable GPU acceleration. It exists for troubleshooting a graphics driver that appears to be corrupting stacks, not for everyday use.
For the GPU to be used at all, Macro Studio needs an OpenCL driver from your graphics vendor. macOS provides this itself, and on Windows it comes with the graphics driver — which is why keeping drivers current matters there. On Linux you may need to install your vendor’s OpenCL package separately. Without one, the app finds no OpenCL devices and runs on the CPU.
Discrete and integrated GPUs both work, including the GPU built into Apple Silicon Macs. If your system has both, the discrete card is preferred.
GPU use isn’t all-or-nothing, and a stack can move between GPU and CPU on its own:
- The memory check can demote the GPU blend to the CPU before a stack starts (see above).
- The GPU alignment path monitors its own throughput and steps back to the CPU if it turns out slower on your hardware.
- Disable GPU acceleration in Preferences → Advanced takes the GPU out of every stage at once. This one is yours, not automatic.
- On Windows, the AI subject-mask model builds its DirectML session behind a guarded probe. Some driver versions hang during that build; the probe runs it in a separate killable process and leaves a marker so that if it ever does hang, the next launch quietly uses the CPU instead of freezing again.
None of this needs your attention — it’s listed so that a stack that ran on the GPU yesterday and the CPU today isn’t a mystery. See Stacking for more.
Licensing
Section titled “Licensing”Each license activates on up to 3 machines (e.g. your desktop and laptop). Activations on a 4th machine will be refused — contact support if you need to move a license to a new machine.
The version you buy is yours to keep. Future major versions may be released as optional paid upgrades; the version you own continues to receive bug fixes and feature improvements for the lifetime of that version line.