Hi,

I’ve spent an entire day trying to get a simple particle simulation to loop cleanly.

I’m getting pretty frustrated because the Labs Make Loop node specifically made for particles simply doesn’t work.

What surprises me the most is that, after more than 20 years of Houdini, I find it pretty crazy that there still doesn’t seem to be a simple and reliable SOP solution for looping a particle simulation.

I’ve gone through quite a few resources: ODForce, YouTube, documentation, and various artist setups. Most of the solutions I found are either outdated or only work for specific cases.

Does anyone have a robust method for looping a particle simulation regardless of the particles’ life and age?

At the moment, the only working solution I’ve found is to cut the usable simulation duration in half, then overlap two time-offset versions and crossfade between them using pscale.

It works, but it’s definitely not ideal.

It isn't clear here whether you actually need a simulation. For simple cases, you don't need a simulation—procedural particle movement suffices, making it easy to loop. You can see emitters like this in various software packages. The concept involves defining a particle's position using a formula that depends on a normalized parameter, *t* (acting as a substitute for time), where 0 is the start of the path and 1 is the end. Many modifiers in various programs—including Houdini—work this way. You then animate this parameter over time (using something like `$T`), causing the particle to move from start to finish. However, since you need a loop, you cycle the value from 0 to 1—essentially taking the fractional part of `$T` or `$F` divided by the cycle duration (e.g., `frac($T)`). Hopefully, the idea is clear. Your particle will then move in a loop. But you need multiple particles; by applying a random offset to the scale—resulting in something like `frac($T + @offset)`—your points will loop endlessly along their paths. You immediately get the full volumetric distribution in the very first frame. This isn't a simulation. The path itself can be quite complex—linked to intricate calculations or other elements—provided it can ultimately be expressed via a normalized parameter ranging from 0 to 1. Once you do this once, it will all make perfect sense. You can significantly increase the complexity of the visibility logic and the trajectories.
A true simulation, however, relies on calculations based on previous frames rather than a formula; anything can happen—forces, collisions, and so on—making it impossible to pre-calculate the result. Consequently, the final outcome is unpredictable, and looping is fundamentally impossible. Looping requires identical positions and an identical number of points in the first and "last" frames. So, in a true simulation, this isn't possible in the general case; in a specific scenario, you have to define the initial state—including the number of points and their positions. At the end of the simulation, you take that state and introduce a transition phase where you must match the particle count, synchronize based on a specific parameter, and smoothly interpolate toward the final paths to ensure a natural look. In my opinion, this is quite difficult, not always feasible, and not always even worthwhile. You would need a very compelling reason to do this instead of using a non-simulation procedural approach. But that is just my personal view.

Hello. I believe particle simulations are not loopable because it must know starting and ending positions of the particle for it to loop. A simulation frame is only aware about what happened on a previous one.
It's definitely possible to scatter points inside a bounding object and advect them with periodic noises or sin/cos functions. Con is that it doesn't support colliders nor volume advection.

But it's absolutely doable with a slight workaround. I appended a custom HDA that you can install. The idea behind it is to make a POP sim, preferably with a linear/flowing motion, and particles must have high life expectancy so they stay alive throughout any frame range (like 99999).
Good point of reference are, for example, falling leaves or sparkles on animated desktop wallpapers. We need to make sure our starting frame and end frame match up. We obviously can't use frame 1 as our start frame because it won't loop, that's why we split the frame range in half and we basically discard the first half as preroll. Then we're basically filtering points by age, and after a certain threshold we're moving them to their, now shifted by half of frame range, first frame.
To put this in perspective, if our total frame range is 1-600, we check each particle's age. Once a particle hits max age threshold (in this case 300 frames), we "spawn" it back in right away, to their starting position. In the wrangle I wasn't actually deleting those points but just teleporting them back to their starting position.

Once you install my HDA, just copy this simple setup from the video reference. HDA is set up to work plug and play. The only thing that you will want to modify is DOP network and File Cache nodes which is why I left them editable. Set up your custom forces and custom save path to disk. I left some notes inside the HDA as well. To preview the loop, play the second half of timeline (frames 300-600).

I hope this helps!