A box of simulated particles that the project camera films like any other object in the scene — dust drifting through a title, snow falling behind footage, a fountain of embers, a plume of smoke, out-of-focus bokeh lights. The same solver also dissolves a layer into its own pixels: pick an image, text or shape layer and it comes apart into specks that keep the colours they were made of.
The solver runs on the GPU and carries up to 8,000,000 particles. It has grown a fluid grid, force emitters, particle-to-particle packing, colliders and a proximity effector, so this page is the hub: the parts that live in their own articles are linked where they come up.
Add a solver
Open the Scene (or Camera) split button in the timeline toolbar and click Particle Solver. It lands at the playhead on its own channel, six seconds long, already selected and named for its preset (Dust Solver).
It lives in that menu rather than under Add Layer because a solver is a volume in the set — filmed by the same camera as your 3D models and the Scene Rig, not a flat card.
The layer behaves like every other layer otherwise: opacity, blend modes, filters, masks, adjustment layers, parenting, and Position / Rotation / Scale keyframes all work, and the box travels with them.
The panel
The solver’s inspector is split into nine tabs, and the split says which edits cost a re-simulation:
| Tab | Holds |
|---|---|
| Solver | Preset, the Solver Box, particle count, preview engine, and the artwork each particle stamps |
| Emitter | Where particles come from, when they are allowed to exist, and how spawn sites are spread |
| Look | How a particle is drawn. Nothing here ever re-simulates. |
| Motion | The forces that move it, the path it follows, turbulence and vortex |
| Collision | What a particle may not pass through — a layer’s artwork, and each other |
| Effectors | Another layer’s shape driving size, colour, rotation and motion |
| Fluid / Smoke | The grid physics field |
| Force Emitters | Pushers with no particles of their own: jets, vortices, sources |
| Layer Options | This layer’s own sections — transform, effects, timing |
Everything in Look (and the colour ramp with it) is evaluated while drawing, so it updates instantly. Everything else is part of the simulation.
Presets
PRESET offers Dust, Stars, Snow, Sparks, Bokeh, Rising Smoke, Cigarette, Ink Drop, Ember Swirl and Shockwave. Clicking one writes a complete system sized to your composition, so the same preset fills a 16:9 and a 9:16 project instead of being tuned for one of them. Nothing stays linked to the preset afterwards — every value is yours to change, and a future app version can never restyle a saved project.
- Seed — the whole simulation comes from this one number. Reroll seed gives you a different arrangement of the same look.
- Density — draws a stable seeded subset (100% / 65% / 40%) so a heavy system stays comfortable to edit. It thins which particles are drawn, never reshuffles them, and the export always uses the full count.
Two engines, and where the line is
The solver has two runtimes, and Max particles decides which one a layer gets.
- Up to 50,000 particles the system is baked. The whole clip is simulated in advance from the seed at a fixed step, and every frame you see is a read-out of that result — never a step forward from the last frame you happened to watch. Scrubbing backwards costs nothing, and a scrub, a range render and a full export show exactly the same frame.
- Above 50,000 the WebGPU engine owns the layer. It simulates as it plays instead of caching a bake: scrubbing backwards re-simulates from the nearest checkpoint, and the exported result can differ very slightly between machines.
The threshold is a routing decision, never a cap. A machine with no WebGPU keeps the full 50,000-particle bake.
Measured on an Apple M-series at 1920×1080, through the whole chain:
| Particles | Cost per frame | In the editor |
|---|---|---|
| 1,000,000 | 6.1 ms | Comfortably 60 fps |
| 4,000,000 | 17.2 ms | ~58 fps, just over the line |
| 8,000,000 | 34.1 ms | ~29 fps — export and offline only |
The panel says which side of that you are on rather than presenting eight million as though it were free. Above 1,000,000 it warns that the preview will not hold 60 fps and gives the frame cost for the count you actually set. The export is unaffected — it renders every frame however long each one takes.
Graphics memory is shared across every particle layer in the project against one budget, a particle costs 116 bytes, very large systems work on cards that cannot address the whole pool in one go, and deleting a particle layer hands its memory straight back.
Preview
Preview picks how the editor shows the solver. It is not a simulation input — it changes what you look at, never what renders.
- Auto — live on the GPU while it holds 60 fps, falling back to the bake when it cannot.
- Live — always simulate live on the GPU. Edits show within a frame.
- Baked — always show the bake: the exact frames an export renders.
The status line under it reports what is actually happening — live at n ms per step with n particles alive, reading the cache, starting up, or showing the bake and why.
Solver Box
The box is the world the particles live in. It is the layer: move, rotate, scale, parent or keyframe the layer and the whole volume goes with it.
- Box size — width, height and depth in composition pixels.
- At bounds — what happens at a wall. Kill ends the particle, Wrap re-enters it on the opposite side, Bounce turns it around keeping most of its speed. (A wrap is a teleport and is never interpolated across; a bounce stays continuous, so it reads cleanly at any frame rate.)
- Pre-roll — seconds simulated before the clip starts, so the box is already populated on frame 0 instead of visibly filling up while the viewer watches. Ambient looks want roughly one full lifetime here; a dissolve wants zero.
- Max particles — a hard ceiling, and the switch between the two engines. At the cap, emission throttles: particles already on screen keep their full lifetime and new ones are skipped. The panel warns you when Rate × Lifetime exceeds the cap.
- Fade out / Shrink — how a particle leaves: seconds of fade, and how far it also shrinks over that window (1 shrinks to nothing). Both are drawn, not simulated, so changing them is instant. Because a baked clip is simulated in advance, a particle knows a wall is coming for it and can start leaving before it is removed rather than blinking out mid-flight.
On the baked engine the panel also reports what the last bake cost — time, memory, snapshot count, and how many particles ended by age versus at the bounds — and warns when a long clip pushes the snapshot cache past 250 MB. The cost of a bake is particles × clip length, so halving either halves the memory. On the GPU engine there is no bake and no snapshot cache; the cost there is graphics memory, which does not grow with clip length at all.
Emitters
A system has one emitter, and that emitter can fire from up to four layers at once. Emitter shapes, spawn distribution, several sources and the layer-dissolve recipe are covered in Particle Emitters and Distribution.
The short version: Emit is Continuous (a rate for the whole clip) or Static (fill once, one cloud born together); Emit from picks Point, Box, Sphere, Cone, Ring, Path, Block or A layer; Rate, Pulses, Lifetime, Speed, Spread and Direction shape the stream.
Forces
Gravity and Wind are accelerations in composition pixels per second squared, per axis. Drag bleeds speed away — it is what stops a wind from accelerating for ever.
TURBULENCE is the field that makes a cloud swirl instead of drifting in a straight line. Pattern — Smooth, Billow, Ridged, Swirl or Wave — is gain-matched, so switching one keeps the amount of motion and changes only its character; Strength never has to be re-tuned. Scale is the size of the pattern in composition pixels (smaller is finer), Evolution how fast the field itself changes (0 freezes it, so particles flow through a still pattern), Complexity octaves of detail, and Direction which way a wavefront travels.
VORTEX is a second field with its own shape: Vortex, Orbit, Twist, Attract or Repel, around a chosen Axis, with Strength, Radius (a falloff, not a boundary) and Lift (how much of the pull also travels along the axis).
Beyond these there is a real fluid grid, a gusting draft and standalone force emitters — see Particle Forces, Fluid and Smoke.
Follow path puts a spline in the box and has particles seek it: Attract pulls toward the nearest point, Flow pushes along its tangent, Path swirl braids the stream into a helix around it, and Proximity is how far from the path the forces still reach.
Collision
Particles can be stopped by a layer’s artwork and by each other. A system carries up to four colliders, each of which can follow its source layer, fit to it, and open one side on a timeline schedule; Packing is the particle-to-particle half, off by default. Both are covered in Particle Collisions and Packing.
Effectors — another layer’s shape drives the cloud
Effectors ▸ Proximity measures each particle’s distance to another layer’s silhouette — not to its centre — and drives up to fifteen properties from it. A word, a logo or a moving shape can swell the particles that touch it, recolour them, spin them, push them away, freeze them onto its outline or shorten their lives.
Up to four source layers, combined with max, add, average or min. Measure picks which distance feeds the falloff curve:
| Measure | What it reads |
|---|---|
| Shape | Distance to the silhouette, outside only — solid inside. The default. |
| Edge | Absolute signed distance: a band that peaks on the contour, on both sides. |
| Inside | Measured inward from the contour; invert it for the core alone. |
| Centre | Radial distance to the source’s origin. |
| X / Y | Distance along one axis. |
The seven look properties — Size, Opacity, Colour, Rotation, Brightness, Stretch, Twinkle — are read at draw time and never re-simulate. The eight motion properties — Attract / Repel, Surface flow, Orbit centre, Drag +, Speed ×, Turbulence ×, Freeze on shape, Lifetime × — are part of the simulation, and editing one re-bakes. The panel prints that badge on every row, so “why did my system just re-simulate” is answered before it is asked.
Range, Falloff and Depth, and every driven amount, take keyframes as ordinary px: tracks — the stopwatch, the graph editor, custom easing, HOLD and the ƒx expressions all work on them. The source layer’s own pose is read every frame rather than stored, so a moving source costs nothing: keyframe the source layer and the field follows it.
Particle look and colour
PARTICLE LOOK covers the dot itself: Sprite (Soft disc, Star or Spark — procedural, so nothing to load and sharp at any size), Blend (alpha or additive), Size start / Size end / Size random, Twinkle, Stretch (elongates a particle along its own velocity) and Opacity.
PARTICLE COLOUR has a gradient editor (up to 16 stops) and a Colour by switch:
- Age — the ramp, read at how far through its life the particle is.
- Source — each particle keeps the colour of the pixel it was emitted from (layer emitters only). With a video source, Following the video re-reads the frame playing now so the cloud is the moving picture, while Frozen at birth keeps the colour each particle was emitted with.
- Speed — a second gradient, read at how fast it is going, between the Slowest and Fastest speeds you set.
Alpha always comes from the life ramp, whichever mode you pick — it is the envelope that lets a particle arrive and leave, so set its end stops transparent to fade particles in and out.
Everything in these two sections is evaluated while drawing, so it all updates instantly and never re-simulates.
Particle objects — stamp your own layers
Set Particle is to Layers in PARTICLE OBJECT and pick up to twelve image, text, shape or video layers from the timeline. Each particle then stamps one of them instead of a sprite: falling leaves, logos, snowflakes, words.
- Share, Size × and Spin × tune one object against the others; Pick chooses between Cycle and Random.
- Facing — Billboard (always square to camera), Tumble (fakes a third axis, so cards catch less light edge-on) or Velocity (leans into its travel).
- Object size, Size random, Spin, Keep ratio and Tint (multiply the artwork by the colour ramp).
- A video object is the one kind that is not a still snapshot: with Play on it is a live texture, so the film runs inside every particle. Still stamps one frame like any other object.
Objects never re-simulate — the solver moves anonymous points and what gets stamped at each one is decided while drawing, so adding, removing and resizing objects is instant. The artwork is copied when you add the layer, and Update artwork from layer re-takes it later.
The first time a sprite system takes objects, its density is thinned to an object-appropriate count: 1,600 stamped logos is a wall, where 1,600 dots is a haze.
Particle Activation
Immediately is the normal behaviour: every particle emits on schedule, and rate and pulses decide everything.
Grow Points hands the emission sites to the same arrival bake Grow Fill uses, so a front travels through the artwork and switches particles on as it passes. Because it travels through the picture and not across the frame, a letter’s far side comes apart after its own stem — which is what makes it read as the thing falling apart rather than a wipe passing over it. It needs a layer emitter; a box has no artwork for a front to travel through.
- Inactive — Don’t move is the dissolve most people mean: every particle exists from the first frame, standing on the pixel it came from, so the layer reads as the artwork until the front releases it (and its lifetime starts at release, so the far end does not die of old age before it moves). Don’t appear is the same sweep in reverse — nothing exists until the front arrives, and the layer builds up out of nothing.
- Start (where the front already is on frame one) and Speed (%/s — at 0 it never moves), with Direction to run the sweep backwards.
- Softness dithers the front into a band instead of a cut line.
- Ignition — a flare on a particle that has just been released, so the sweep has a leading edge of light. Ignition size, and Ignition paint to choose a flash, a solid colour, or a gradient across the flare’s own life. It is drawn, not simulated: tuning it never re-runs the solve.
Growth Field
Shown once Grow Points is on, this shapes where the front starts and how it travels:
- From — Left / Right / Top / Bottom edge, Centre, or Scattered — plus Points (how many places it starts from) and Stagger (the delay between them). You can also place up to eight points by hand.
- Speed map — Uniform, or Turbulent with Noise scale, Contrast and Noise seed, so the front eats through the artwork unevenly.
- Bridges — lets the front jump to a detached piece, with Reach (how far) and Slowness (what crossing a gap costs). Reach has to clear the gap between letters, or each one is its own island and only the seeded one ever activates.
In the 3D world view
Open the 3D world view and the solver draws its own chrome: the Solver Box as a wireframe, each emitter’s shape, an arrow for the direction it fires, arrows for gravity and wind, and a handle on every force emitter you can drag to move it. They exist only in that view — nothing there can reach a render.
Depth of field focuses on where the particles actually are, not on the box centre, so a fountain living in the bottom of a tall box or a cloud that has drifted downwind still pulls focus correctly.
Editing and rendering
Edits split cleanly in two, and the panel is ordered by which is which: everything above PARTICLE LOOK re-runs the simulation, everything in PARTICLE LOOK and PARTICLE COLOUR is free.
When a solver edit does need a new simulation it runs in a worker while the previous one keeps drawing, and swaps atomically when it lands — the panel says Updating the simulation… while that is happening, so nothing flickers under your hand. Re-simulations are cancellable, debounced and progressive rather than a freeze.
Exports wait for the particle runtime and bake before the first frame is encoded, so a cold render matches the preview from frame one. Particles render correctly into a transparent WebM + Alpha file as well as into MP4, and on either graphics engine.
What it does not do yet
- One emitter per system. A single emitter fires the whole system — it can take several layer sources, several shapes and any distribution, but there is no second emitter with its own rate and lifetime.
- Solver values other than the Proximity effector’s are not keyframable. The layer’s own Position / Rotation / Scale animate as usual, and the effector’s
px:tracks animate, but wind, rate, turbulence and the rest hold one value for the clip. - The layer a solver dissolves does not disappear on its own — see Emit from a layer in Particle Emitters and Distribution.
Where to go next
- Particle Emitters and Distribution — emitter shapes, several sources, eleven scatter modes, dissolving a layer
- Particle Forces, Fluid and Smoke — the fluid grid, smoke, force emitters and the draft
- Particle Collisions and Packing — colliders, containers, opening a side, particle-to-particle contact
- Camera Layer — the camera that films the solver, and the 3D world view
- Scene Rig — the lights, backdrop and environment the set is built from
- 3D Model Layers — real 3D objects in the same space
- Grow Fill — the arrival sweep Particle Activation borrows
Leave a Reply