EntangledSingularity/worldparticle-sand-goop

WorldParticle Sand & Goop

_{Sand in the rotating mixer. Orange arrows are the external force F that the predictor integrates analytically; cyan arrows are the blade's boundary velocity. Every sequence in this dataset ships the fields driving both.}

The twelve combinations in this dataset

sand · pile drop Collapses to a repose angle set by internal friction.	goop · pile drop Slumps as one cohesive mass; yield stress arrests the spread.
sand · slope flow 0-25 degrees. Past the angle of repose it runs.	goop · slope flow 0-6 degrees. Creeps rather than runs.
sand · dam break Front runs out, reflects off the far wall.	goop · dam break Cohesive front stays together.
sand · obstacle drop Flow splits around a hard edge.	goop · obstacle drop Same obstacle set, viscoplastic response.
sand · funnel drain At friction 0.88 it JAMS: 0% drained.	goop · funnel drain At viscosity 131 it DRAINS: 100%. Same 35 mm throat.
sand · mixer Thrown clear of the open bowl; ~71% retained.	goop · mixer Shoved aside, stays in; 100% retained.

The funnel and mixer rows are the sharpest material contrast in the corpus: identical geometry, opposite outcome.

Also rendered: water, snow and elastic solids — supported by the generator, not included in this release (16 more videos)

water · dam break Newtonian fluid, no yield stress.	snow · pile drop Compacts as it packs; hardening.	elastic · drop Tet solid. Watch the bounce -- energy return is what rest topology buys.
water · funnel Drains freely.	snow · mixer Packs against the bowl.	elastic · stack Body-to-body contact.

Full set in videos/: water_* and snow_* across all six MPM scenarios, elastic_* across four. Ask if you want these generated as data.

---

2,700 Lagrangian particle-dynamics trajectories — granular sand and non-Newtonian goop — across six scenarios each, generated with the Material Point Method in NVIDIA Newton.

Physical SI units. True solver velocities, not finite differences. Authored boundary geometry with exact analytic normals.

sequences	2,700
materials	sand, goop (non-Newtonian viscoplastic)
scenarios	pile drop, slope flow, dam break, obstacle drop, funnel drain, rotating mixer
particles per sequence	7,686 – 11,671
frames per sequence	250 (goop) / 400 (sand) / 1,600 (both mixers)
total size	214 GiB
simulation time to produce	7.6 GPU-hours on one RTX 5090
format	HDF5, one file per sequence
schema version	2.0 (static entries) / 2.2 (both mixers) — see What changed
units	SI — metres, kilograms, seconds

---

What changed in this revision

If you downloaded sand_mixer or goop_mixer before this revision, re-pull them. Both entries were regenerated. The other ten are untouched, byte for byte.

Two defects were found in the original mixer export by an independent audit on the consuming side. Neither was a physics error — both were properties of how the trajectories were written out, and both passed every structural check (shapes, finiteness, energy and volume drift, penetration).

1. The capture cadence outran the model's kernel radius. The solver integrates at 0.00125 s; the exporter was keeping every 4th step. Per-step displacement at the p95 was 1.25–2.99 d0 against a usable limit of 0.7 for a model that reads neighbours within R_s = 2.5 d0 — a jump to a neighbourhood no window ever contained. Every clip of both materials failed. The mixers now export every solver substep: 1,600 frames at dt = 0.00125 s instead of 400 at 0.005 s. Measured p95 after: 0.356–0.802 (sand), 0.286–0.782 (goop) — mean 0.53.

   Read this before training on the mixers. 270 of 300 clips are under 0.7; the remaining 30 (13 sand, 17 goop) sit between 0.7 and 0.802, and they are exactly the fastest blade speeds — p95 correlates with blade_rpm at 0.97–0.995 and crosses 0.7 at roughly 210–226 rpm against a sampled range of 60–240. No clip exceeds 1.0, the threshold above which a clip is not evidence about contact either way. Pushing that tail under 0.7 would mean halving the solver timestep, which changes the physics; we chose to publish the tail and label it rather than quietly alter the simulation or quietly drop the fastest and most interesting sequences in the entry. Per-clip numbers are in mixer_audit.json at the dataset root, so you can filter on the exact value rather than on this summary.

2. The ground plane was in the simulation and in no file. The bowl is open-topped, and above ~200 rpm sand is thrown clear of it — 149 of 150 clips, out to 2.15 m from a 0.18 m bowl. That material came to rest on a floor the solver had and the exporter never sampled, because a plane has no mesh to sample: 0.0% of ejected particles had any boundary sample within R_s, and up to 22.3% of a clip sat below the lowest boundary point in its own file. The floor is now sampled from the footprint the material actually covered, at 0.5 d0. Ejected coverage after: 99.5%.

The physics did not change. Regenerating a sequence and comparing against the original, same seed, gives new.X[::4] bitwise identical to old.X, and likewise for V — the new files add the three intermediate frames between each old frame and nothing else. The demo videos below are unaffected.

Sampling a floor at that density is only affordable if static samples stop being repeated once per frame — 60k of them cost 4.0 GB per sequence stored per-frame and 186 MB stored once — so the mixer entries now split their boundary into boundary/static/* and boundary/moving/*, and carry no boundary/X_b key. See storage convention 3. Their C also gained a 17th all-zero thickness column, appended; columns 0–15 are unchanged.

---

Why this exists

This dataset was produced for an independent evaluation of WorldParticle (Wang et al.).

That paper proposes a single transformer architecture that simulates cloth, elastic solids, Newtonian and non-Newtonian fluids, granular materials and molecular dynamics -- one model family, one input format, where only the training data changes. We are reproducing it and evaluating that claim, and this corpus is the data we use to do it.

It is generated with the same simulator the paper used. Its appendix states that granular sand and non-Newtonian fluids were both produced with the Material Point Method in NVIDIA Newton. Using the same generator removes a confound that would otherwise sit under every result: is a given finding real physics generalization, or an artifact of having switched solvers?

We are releasing it publicly so that anyone else evaluating the same architecture -- or training any Lagrangian particle simulator -- can start from data rather than from a solver setup.

Why sand and goop specifically

They are the cleanest matched pair for testing whether one set of weights can hold more than one constitutive family. Both are continuum materials on the same solver, at the same scales, in the same scenarios — so a difference in a result is attributable to the constitutive model and not to the setup.

The contrast is sharp and physical. In the funnel, sand at friction 0.88 jams the throat completely (0% drained) while goop at viscosity 131 drains fully (100%) through the same 35 mm aperture. In the mixer at the same blade speed, sand is thrown clear of the open bowl (~71% retained) while goop is shoved aside and stays in (100%).

---

What a model needs this data for

WorldParticle models one timestep as predict, then correct.

The predictor carries no weights. It integrates only the known external force:

Ṽ = V + Δt·M⁻¹F          X̃ = X + (Δt/2)(V + Ṽ)

The corrector takes that intermediate state and predicts residual updates (ΔX, ΔV), through a particle tokenizer (local particle–particle, particle–boundary and topology neighbourhoods), a super-token encoder, and a super-token decoder.

Inputs a domain does not have are zero-filled, which is what keeps one fixed architecture across every material — and which makes the dataset the entire specification. Every field below exists because some branch of that architecture consumes it.

---

Dataset structure

worldparticle-sand-goop/
├── README.md                     this card
├── DATASHEET.md                  auto-generated at production time
├── metadata.json                 machine-readable corpus index
├── _manifest.jsonl               one line per sequence (generation bookkeeping)
├── _run.json                     run timings and interruptions
├── videos/                       28 demo renders, MP4 (see below)
│
├── sand_pile_drop/
│   ├── train/00000.h5 … 00359.h5
│   ├── valid/00360.h5 … 00379.h5
│   └── test/ 00380.h5 … 00399.h5
├── sand_slope_flow/    train|valid|test
├── sand_dam_break/     train|valid|test
├── sand_obstacle_drop/ train|valid|test
├── sand_funnel_drain/  train|valid|test
├── sand_mixer/         train|valid|test
├── goop_pile_drop/     train|valid|test
├── goop_slope_flow/    train|valid|test
├── goop_dam_break/     train|valid|test
├── goop_obstacle_drop/ train|valid|test
├── goop_funnel_drain/  train|valid|test
└── goop_mixer/         train|valid|test

Splits are contiguous and frozen before sequence 0 ran — "the first 360" means the same thing here as in any downstream budget.

The Hugging Face dataset viewer will not render this. The payload is HDF5, not Parquet or CSV. Each sequence is a set of multi-dimensional arrays with a time axis; flattening that to tabular rows would destroy the structure a particle simulator consumes. Load it with h5py — see below.

The twelve entries

entry	material	scenario	seqs	train/valid/test	particles	frames	size
sand_pile_drop	sand	pile_drop	400	360/20/20	9,829–10,054	400	23.3 GiB
sand_slope_flow	sand	slope_flow	250	226/12/12	9,817–10,052	400	15.6 GiB
sand_dam_break	sand	dam_break	200	180/10/10	9,504	400	10.3 GiB
sand_obstacle_drop	sand	obstacle_drop	200	180/10/10	9,841–10,056	400	12.4 GiB
sand_funnel_drain	sand	funnel_drain	150	136/7/7	11,537–11,671	400	12.5 GiB
sand_mixer	sand	mixer	150	136/7/7	7,693–8,227	1,600	44.6 GiB
goop_pile_drop	goop	pile_drop	400	360/20/20	9,804–10,058	250	16.9 GiB
goop_slope_flow	goop	slope_flow	250	226/12/12	9,815–10,052	250	10.4 GiB
goop_dam_break	goop	dam_break	200	180/10/10	9,504	250	8.3 GiB
goop_obstacle_drop	goop	obstacle_drop	200	180/10/10	9,825–10,048	250	8.6 GiB
goop_funnel_drain	goop	funnel_drain	150	136/7/7	11,534–11,660	250	7.6 GiB
goop_mixer	goop	mixer	150	136/7/7	7,686–8,241	1,600	44.0 GiB

Particle count varies within an entry because particle spacing is held constant across the corpus (it is a discretization constant the MPM transfer depends on); what varies is the sampled object volume.

---

What is inside one HDF5 file

Every file is one complete trajectory. With T frames and N particles:

Arrays

path	shape	dtype	meaning
X	[T, N, 3]	float32	particle positions, metres
V	[T, N, 3]	float32	particle velocities, m/s — true solver values
F	[1, N, 3]	float32	known external force, newtons. Leading axis is 1 because the force is constant in time; see the storage conventions below
C	[N, 16]	float32	per-particle attributes, one row per particle. 17 on the mixer entries — one appended all-zero thickness column; columns 0–15 are identical
boundary/X_b	[1, N_b, 3]	float32	boundary particle positions — static-geometry entries only
boundary/C_b	[1, N_b, 7]	float32	boundary attributes, one row per boundary sample
boundary/static/X_b	[1, N_s, 3]	float32	static samples (bowl + ground) — mixer entries only
boundary/static/C_b	[1, N_s, 7]	float32
boundary/moving/X_b	[T, N_m, 3]	float32	the blade, one row per stored frame
boundary/moving/C_b	[T, N_m, 7]	float32

topology/T_adj and topology/X0 (rest adjacency and rest positions) are absent from this release: sand and goop are continuum materials with no rest connectivity. The fields exist in the schema for cloth and elastic solids and should be zero-filled by a loader, exactly as the architecture expects.

C — per-particle attribute columns

Column order, fixed for every file:

#	column	sand	goop
0	mass	per-particle, kg	per-particle, kg
1	radius	half the particle spacing, m	same
2	density	1000	1000
3	friction	varied 0.20–1.00	0.0
4	young_modulus	1.0e15	varied 9–15
5	poisson_ratio	0.3	0.3
6	yield_pressure	1.0e15	1.0e10
7	yield_stress	0.0	varied 1e2–1e3
8	tensile_yield_ratio	0.0	1.0
9	hardening	0.0	0.0
10	dilatancy	0.0	0.0
11	viscosity	0.0	varied 50–200
12	stretch_stiffness	0.0	0.0
13	area_stiffness	0.0	0.0
14	bending_stiffness	0.0	0.0
15	damping	0.0	varied 60–90

Columns 12–15 are shell and solid parameters, zero for both materials here. Every material writes every column, zero where it does not apply. A fixed architecture needs a fixed layout, and the point of the corpus is that one model can read every material in it. The column names are also stored on the dataset itself as f["C"].attrs["channels"].

mass is column 0 deliberately: the predictor needs M⁻¹ before anything else.

C_b — boundary attribute columns

#	column	meaning
0–2	normal_x/y/z	outward unit normal, pointing out of the collider, into the material
3	friction	Coulomb friction of that surface
4–6	velocity_x/y/z	surface velocity, m/s. Non-zero only on the mixer blade

The velocity columns are an extension beyond the source paper, whose boundary particles have no time index. The mixer needs them, and static scenes cost nothing for carrying them as zeros.

File attributes

Read with f.attrs[...]:

attribute	example	meaning
dt	0.005 (0.00125 on the mixers)	physical timestep between stored frames, seconds
R_s	0.0268	spatial kernel radius, metres (2.5 × d0)
d0	0.0107	mean nearest-neighbour distance measured on frame 0
m_bar	0.00463	mean particle mass, kg
gravity	[0, 0, -9.81]	m/s²
bounds	per-axis [lo, hi]	scene extent, metres
material / scenario	sand / pile_drop
material_family	mpm	solver family
type_code	6 (sand), 7 (goop)	categorical material id, GNS-style
material_params	JSON	the exact parameters drawn for this sequence
geometry	cube	source shape for the initial condition
seed	int	reproduces this sequence alone
num_frames, num_particles, substeps, voxel_size
solver	newton.SolverImplicitMPM
newton_version	1.6.0
schema_version	2.0, or 2.2 on the mixers
boundary_layout	flat or static+moving	which boundary layout this file uses
boundary_kind	ground_plane, slope_5.31deg, …
force_is_constant	True	see below

type_code is kept out of C on purpose. C is continuous by construction, and a model that infers material from local dynamics rather than reading a label is a stronger result than one that reads the label. It is in the attributes for anyone who wants it.

Two storage conventions that will bite you

1. F has a leading axis of 1, not T. The external force is gravity × mass, constant over the sequence, so storing it per frame would waste ~50 MB per file repeating the same vector 400 times. Broadcast it, or index F[0]. force_is_constant records this.
2. X_b and C_b always carry a leading time axis, length 1 for static geometry. Do not assume X_b[t] is valid — clamp the index, or check X_b.shape[0].
3. The mixer entries have no boundary/X_b key at all. Their boundary is split into boundary/static/* (stored once) and boundary/moving/* (one row per frame); check the boundary_layout attribute, or test for the static group. Reaching for boundary/X_b on those files raises KeyError, and that is deliberate — an alias holding only half the geometry would let a loader run against a mixer with no blade in its boundary, silently.

---

Loading it

With nothing but h5py:

import h5py, json, numpy as np

with h5py.File("sand_pile_drop/train/00000.h5") as f:
    X  = f["X"][...]                 # [T, N, 3] positions, metres
    V  = f["V"][...]                 # [T, N, 3] velocities, m/s
    C  = f["C"][...]                 # [N, 16]
    # Boundary, in whichever layout this file uses. The mixer entries split
    # it; everything else is flat. See storage convention 3 below.
    split = "static" in f["boundary"]
    if split:
        Xs, Cs = f["boundary/static/X_b"][0], f["boundary/static/C_b"][0]
        Xm, Cm = f["boundary/moving/X_b"], f["boundary/moving/C_b"]
    else:
        Xb = f["boundary/X_b"][...]  # [T_b, N_b, 3]; T_b == 1 when static
        Cb = f["boundary/C_b"][...]  # [T_b, N_b, 7]

    channels = json.loads(f["C"].attrs["channels"])
    friction = C[:, channels.index("friction")]

    dt   = float(f.attrs["dt"])      # never feed this to a network
    R_s  = float(f.attrs["R_s"])
    d0   = float(f.attrs["d0"])
    prms = json.loads(f.attrs["material_params"])

    # F is constant in time -> broadcast rather than index by frame
    F = np.broadcast_to(f["F"][0], X.shape)

    def boundary_at(t):
        if split:
            return (np.concatenate([Xs, Xm[t]]), np.concatenate([Cs, Cm[t]]))
        i = 0 if Xb.shape[0] == 1 else t   # static -> clamp, do not index by frame
        return Xb[i], Cb[i]

Streaming a single entry without pulling 149 GiB:

from huggingface_hub import snapshot_download

path = snapshot_download(
    repo_id="EntangledSingularity/worldparticle-sand-goop",
    repo_type="dataset",
    allow_patterns=["sand_pile_drop/*", "metadata.json", "README.md"],
)

---

Units, and the non-dimensionalization you probably want

The store is physical SI. Each sequence records d0 (mean nearest-neighbour distance on frame 0) and m_bar (mean particle mass), so the standard scaling is derivable and exactly invertible:

x̂ = x / d0                    v̂ = v · dt / d0              m̂ = m / m_bar
F̂ = F · dt² / (m_bar · d0)    R̂_s = R_s / d0   (≈ 2.5 throughout)

Why bother: without it, a sand→goop transfer failure is ambiguous between a physics limit and a units mismatch. With it, the failure means something.

dt never enters a model. It belongs to the explicit prediction step. A wrong dt silently hands a learned corrector a constant to absorb — the one job the prediction step exists to take off it.

---

Demo videos

videos/ holds 28 MP4 renders, 15 s each at 30 fps, 1280x800. Twelve are the gallery at the top of this card; sixteen more cover water, snow and elastic solids, which the generator supports but this release does not contain.

Reading the arrows

• Orange -- the external force F. Uniform and constant by construction, because F is mass x g in every scenario here. It confirms the channel is populated and pointing the right way; there is nothing to watch evolve.
• Cyan (mixer only) -- the boundary velocity of the rotating blade.

The blade is deliberately not in F. F is integrated analytically before the network runs, so it must be knowable before the step. Gravity is; a contact force is not, since it depends on the state being predicted -- putting it in F would leak the answer into the input. The blade reaches a model through X_b(t) and its velocity columns instead.

---

How it was generated

Each sequence: sample a geometry, fill its interior with particles on a jittered lattice at fixed spacing, draw the material parameters, build the colliders, run Newton's implicit MPM, capture every frame.

solver	newton.SolverImplicitMPM (NVIDIA Newton 1.6.0, Warp 1.17.0)
hardware	one NVIDIA RTX 5090, sm_120
transfer scheme	APIC
grid	sparse, voxel 0.05 m (0.02 m for funnel and mixer)
particle spacing	voxel size / 3, held constant across the corpus
sand	dt 0.005 s, 2 substeps, tolerance 1e-4
goop	dt 0.01 s, 4 substeps, tolerance 1e-6
mixer	dt 0.005 s, 4 substeps, collider_velocity_mode = backward
wall clock	7.6 GPU-hours across two runs

Sequence seeds derive from the corpus seed and the entry id, so the whole corpus is reproducible and so is any single sequence on its own. The complete generating config is embedded in metadata.json.

The mixer blade is a kinematic body whose pose is rewritten every substep, with the solver finite-differencing its surface velocity. Its boundary trajectory is computed analytically rather than captured, because a prescribed rotation is known before the first step.

---

Known limits — read before you train on this

• These are simulations, not measurements. Fidelity is that of Newton's implicit MPM, not of a physical experiment.
• Velocities are exact, so do not mix corpora. Newton exports true solver velocities. A model trained here has learned solver velocities; data whose velocities were finite-differenced from positions is a different distribution and does not belong in the same head.
• Material parameters are sampled independently per sequence. Coverage of a range is statistical, not a grid, except where an entry pins endpoints (both slope-angle extremes are guaranteed per geometry).
• On the ten static entries, peak per-step displacement reaches ~1.13 particle spacings. An external audit of four sand_pile_drop sequences flagged this against a CFL-style threshold of 1.0. It is the impact-moment tail, not typical: median per-step displacement is 0.0012 spacings and the 95th percentile is 0.84. With a neighbour radius of R_s = 2.5 d0 a particle still cannot outrun its own neighbourhood in one step, but size your radius knowing this.
• On the two mixer entries, 30 of 300 clips have a p95 between 0.7 and 0.802 d0. All of them are the highest blade speeds. None exceeds 1.0. See What changed and mixer_audit.json for the per-clip numbers.
• Boundary sample spacing on the static entries is ≈ 2.45 d0, about 0.98 × R_s. Particles adjacent to a wall find boundary neighbours, but not many. The same audit flagged this against a stricter threshold. Denser boundary sampling there is a config change and a regeneration, not a fix to the files. The mixer entries were regenerated and now sample at 0.51–0.95 d0.
• funnel_drain ground sampling is coarse — a fixed ~2.4 m plane under a pile ~0.2 m across gives roughly 7 d0 spacing. The footprint-clipping sampler written for the mixers fixes this, but applying it means regenerating those entries, which has not been done yet.
• Boundary samples are a point cloud with normals, not an exact surface. Near a thin or sharply curved collider the nearest-sample normal is approximate — most relevant around the mixer blade.
• No rest topology. Sand and goop have none. If you are exercising the architecture's topology branch, you need cloth or elastic data, which this release does not contain.
• Cloth is not included and is not ready. The generator supports it, but over a full-length sequence the sheet stretches several times past its rest size while staying finite and slow — so it passes every structural check. It is excluded deliberately rather than shipped broken.

---

Citation

The architecture this data targets:

@article{wang2026worldparticle,
  title   = {WorldParticle: Unified World Simulation of Lagrangian Particle
             Dynamics via Transformer},
  author  = {Wang, Caoliwen and Guo, Minghao and Chen, Siyuan and others},
  journal = {arXiv preprint arXiv:2605.15305},
  year    = {2026}
}

The simulator:

@misc{newton2025,
  title  = {Newton: GPU-accelerated physics simulation for robotics and
            simulation research},
  author = {{The Newton Contributors}},
  year   = {2025},
  url    = {https://github.com/newton-physics/newton}
}

This dataset:

@misc{worldparticle_sand_goop_2026,
  title     = {WorldParticle Sand \& Goop: Lagrangian Particle Dynamics Trajectories},
  author    = {EntangledSingularity},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/EntangledSingularity/worldparticle-sand-goop}
}

---

License

Released under CC BY 4.0. Generated with NVIDIA Newton, which is Apache-2.0; no Newton assets are redistributed here — every trajectory is produced from procedural geometry defined in the generating config.