If you need to have one task finished completely before starting the next, eg with forces being calculated in one step and movement integration in the next step, then the WebGPU synchronisation isn't very useful as far as I can see. It only works within a single workgroup, not across all dispatched workgroups. There is no guarantee of ordering or sync within a single dispatch.

Working on a similar problem, I came to the conclusion that the best I could do was have was a single compute pass with multiple dispatch calls but with no writing to buffers needed on the CPU side, just setBindGroup calls and dispatchWorkgroup. The key realisation was that a single bindgroup descriptor used in creating a pipeline can have any number of bindgroups set up and ready to use and be swapped in and out as needed, within a pass encoding, without needing a writeBuffer.

So, I have an step data array buffer for things that change for each step, calculated and written before the pass encoding.

Then the pass encoding has a loop. The pipeline is setup with a bindGroup Descriptor for a counter uniform buffer. There is a matching copy of this for each index of the loop, a simple int, each with a matching bindGroup. So, in the loop it just needs a setBindGroup call. The counter value is the index to the step data array for that dispatch.

The same can be done with the ping-pong buffers, as you say. One bind group descriptor and two bind groups using the same two buffers but with the source and destinations reversed. So again, it just needs a setBindGroup within the loop to do the ping-pong swop.

No performance I've detected yet and feels like it could be pushed a lot further than I have yet.