System requirements

Premation renders every frame on the GPU — the viewport, the library previews, the export. That single fact decides what hardware matters. A fast CPU with no usable GPU will not run it; a modest laptop with a working WebGPU driver will.

Read this page before you install. It ends with a two-minute check you can run in a browser to find out exactly which tier your machine lands on.

The short answer

	Minimum	Recommended
GPU	Any GPU with a working WebGL2 driver	Dedicated NVIDIA/AMD card, or Apple silicon (M1 or newer), with WebGPU
RAM	8 GB	16 GB or more
OS	Windows 10 (x64)	Windows 11, macOS 13+, or a modern Linux
Disk	~1 GB for the app	Plus room for exports — a PNG sequence is large
Display	1440 × 900	1920 × 1080 or wider; a second monitor for popped-out panels
Node.js	Only if you build from source: Node 20+	—
ffmpeg	Optional; needed for MP4, WebM, GIF and ProRes export	Bundled or on your `PATH`

If you are shopping for a laptop specifically to run this: any machine sold in the last four years with a discrete GPU, or any Apple silicon MacBook, is comfortably enough. The thing to avoid is a very old integrated GPU with drivers that never got WebGL2.

The GPU, in detail

The engine picks a tier at startup and tells you which one it landed on in the viewport header.

WebGPU — preferred

Used when the whole adapter → device → configure path succeeds. This is the fast path and the one to aim for. You get it from Apple silicon, from recent NVIDIA and AMD drivers, and from Intel Iris Xe and newer with up-to-date drivers.

WebGL2 — fallback

If WebGPU cannot initialise, the engine steps down to WebGL2 automatically. Most things work; heavy compositions will simply be slower.

No software renderer

There is deliberately no CPU fallback. If both tiers fail, the app tells you so, with a reason. It does not hand you a blank stage and let you find out at export time.

Outdated graphics drivers are the single most common cause of a machine that “should” work but doesn’t. Update them from the GPU vendor (NVIDIA / AMD / Intel) rather than relying on Windows Update, then check again.

What each class of hardware gets you

Hardware	Expected tier	Realistic use
Apple silicon (M1–M4)	WebGPU	Everything, including 3D and particles at 1080p
Discrete NVIDIA / AMD (2020+)	WebGPU	Everything; comfortable at 4K compositions
Intel Iris Xe / AMD Radeon integrated, current drivers	WebGPU or WebGL2	Fine for 2D timeline work at 1080p; 3D and heavy particles will drag
Older integrated graphics	WebGL2	Light compositions only
No WebGL2 at all	—	The app will not start rendering, and will say so

Memory

Memory scales with composition resolution and with how many pre-comps are being cached, not with the length of the timeline. 8 GB is workable for 1080p work. 16 GB is the point at which a 4K composition with several nested pre-comps stops being a consideration.

Export is not the memory-hungry part: on the desktop, frames are written to a temp directory and encoded in a child process, so peak memory during an export is one frame, not the whole render. A multi-gigabyte MP4 never passes through the app’s memory.

Operating systems

Platform	Status
Windows 10 / 11, x64	Available — `.exe` installer
macOS (Apple silicon and Intel)	Coming soon — `.dmg`
Linux (x64)	Coming soon — `.AppImage`

Building from source works on all three today; only the prebuilt installers are staggered. See Installing Premation.

ffmpeg

ffmpeg is optional, and it only affects export formats.

Without ffmpeg	With ffmpeg
PNG sequence, JPEG sequence, still frame, Lottie, project export	Everything above, plus MP4 (H.264), WebM (VP9), GIF and MOV (ProRes 4444)

The app looks for it in this order:

$FFMPEG_PATH, if set and pointing at the executable
<app resources>/ffmpeg/ffmpeg[.exe], if it was bundled with the build
ffmpeg on your PATH

Video export tells you plainly when ffmpeg is missing rather than failing vaguely. Full detail: ffmpeg and codecs.

Running in a browser

There is a browser build of the renderer (npm run dev) that is useful for trying the interface out. It is not the full app:

no native menus,
no local file access,
no MP4 or ProRes export — the browser path encodes WebM through WebCodecs instead.

Browser versions that support WebGPU: Chrome 113+, Edge 113+, Safari 17+.

Check your machine in two minutes

Check WebGPU

Open your browser’s developer console on any page and run:


const ok = !!navigator.gpu && !!(await navigator.gpu.requestAdapter())
console.log(ok ? 'WebGPU: available' : 'WebGPU: not available')

If this prints available, you get the fast tier.

Check WebGL2

Still in the console:


const gl = document.createElement('canvas').getContext('webgl2')
console.log(gl ? 'WebGL2: available' : 'WebGL2: NOT available')

If this prints NOT available, Premation cannot render on this machine until the graphics drivers are updated.

Check ffmpeg

In a terminal:


ffmpeg -version

A version banner means MP4, WebM, GIF and ProRes export will work. command not found means you get the still-image and Lottie formats only, until you install it.

If you are building from source

You additionally need:

Node.js 20 or newer, and npm.
Git.
A C++ toolchain for the native SQLite index used by the project dashboard — though the app falls back to an in-memory index if the native driver is unavailable, so this is not a hard blocker.