Box3D Physics Keep Hold - First Indie Spike Evening 2026

If you are searching box3d physics, you do not need another “finally we have more than Jolt” thread. You need a Monday path: clone the MIT repo, CMake-build the samples, run HelloWorld until a dynamic box rests on a ground slab, then decide keep / hold / rewrite before anyone rips Chaos, PhysX, or Godot’s Jolt integration out of the Steam ship branch.

Erin Catto — the author of Box2D — announced Box3D as an open-source 3D rigid-body engine with a C17 API, continuous collision, joints, character mover hooks, and cross-platform determinism goals (Announcing Box3D). The code lives at github.com/erincatto/box3d under MIT. Tag v0.1.0 (June 30, 2026) is explicitly alpha (Initial Release). A follow-up engineering post on wide SIMD for SAT edge tests shows the repo is still moving hard after announce week (SIMD for Collision).

This evening is not the Epic Lore VCS spike (version control). It is not the Godot 4.8-dev2 keep/hold (editor QoL + bundled Jolt bump). It is not Fab free-asset claim night. It is box3d physics — a throwaway spike with a receipt.

Time: about 60–90 minutes for clone → presets build → samples → HelloWorld skim on a throwaway machine. Longer if you wire FetchContent into a sandbox app.

Why this matters now

Three clocks make box3d physics worth an evening this month:

1. The Box2D pedigree just went 3D in public. Catto’s announce ties Box3D to production pain in The Legend of California (Chaos gyro/trees/broad-phase), Valve-adjacent Rubikon-Lite heritage, and early adopters like s&box, Esoterica, and a large multiplayer title (announce). Partners will ask “are you evaluating Box3D?” You need a receipt, not vibes.
2. HN and GitHub made it a Discord noun. The announce hit Hacker News hard; the repo crossed thousands of stars while still labeled alpha. That is demand — and also peer pressure to “just swap.”
3. Alpha is the honesty gate. Catto says the engine needs more testing and docs; PRs are currently disabled; v0.1 is a waypoint toward 1.0 (announce, README). Spike skill ≠ ship cutover.

Godot teams already debating “should we chase Box3D instead of Jolt?” should read the Godot forum thread for integration cost honesty — and still keep 4.8-dev2 Jolt retest as a separate receipt.

Glossary - plain words

What Box3D actually claims (true summary)

From the announce, README, and docs overview:

• MIT, C17 core, C API, portable; samples need C++20.
• Collision: CCD, contact events, convex hulls / capsules / spheres / triangle meshes / heightfields, filters, ray/shape casts, sensors, character mover.
• Physics: Soft Step solver, continuous physics, island sleep, common joint set with limits/motors/springs, movement/sleep events.
• System: Data-oriented, multithreading hooks, SIMD, large piles, cross-platform determinism, recording and replay.
• Docs: Hello World in docs/hello.md; Doxygen manual in progress.
• Integration: FetchContent / add_subdirectory / find_package(box3d) — pin GIT_TAG v0.1.0 for spikes.
• Honest limits from author: alpha; more testing/docs needed; character movement enhancements and ghost-collision work still on the wish list; PRs disabled for now (file issues).

Do not invent soft-body, cloth, or “drop-in Unreal Chaos replacement” claims. The announce is explicit that Unreal replacement was a custom studio path with scripting/ECS shortcuts — not a one-click plugin.

Keep / hold / rewrite - Monday decisions

Default indie posture: hold on ship physics; keep the spike skill so you can promote when 1.0 + bindings + your golden scenes match.

Prerequisites

• git and CMake on PATH (README).
• Compiler with C17 (library) and C++20 (samples).
• A throwaway folder — never your Steam ship checkout.
• Optional: Visual Studio 2026 bat / Xcode / Emscripten if those are your native loops.
• Current engine physics still intact for production — this evening does not touch it.

Pair diligence culture with BUILD_RECEIPT evenings — different artifact, same “write it down” habit. If your pain is large binary VCS rather than solvers, use the Epic Lore spike on a different night.

Beginner path - first Box3D loop (under ~90 minutes)

Follow the official README build presets — summarized here with indie keep/hold notes.

1) Clone a throwaway tree

git clone https://github.com/erincatto/box3d.git
cd box3d
git checkout v0.1.0

Pin the tag in your receipt. If you follow main for curiosity, record the commit SHA — alpha moves.

2) Configure + build with presets

Windows:

cmake --preset windows
cmake --build --preset windows-release

Linux:

cmake --preset linux-release
cmake --build --preset linux-release

macOS:

cmake --preset macos
cmake --build --preset macos-release

If presets fail (old CMake), fall back to mkdir build && cd build && cmake .. && cmake --build . --config Release as documented.

3) Run the samples app

From the Box3D root:

• Windows: .\build\bin\Release\samples.exe
• Linux: ./build/bin/samples
• macOS: ./build/bin/Release/samples

Click through a pile / joint / character demo. Screenshot the window title + one scene. That is B2 proof — not a Discord “it builds.”

4) Skim HelloWorld (console path)

Open docs/hello.md. Mentally walk:

1. b3DefaultWorldDef → b3CreateWorld
2. Static ground hull via b3MakeBoxHull + b3CreateHullShape
3. Dynamic cube with density + friction
4. b3World_Step(worldId, 1/60, 4) for ~90 frames
5. Print position until rest ≈ y = 1
6. b3DestroyWorld

You do not need a renderer tonight. Console fall-to-rest is enough for B3.

5) Write the Discord one-liner

“Spiked Box3D v0.1.0 — samples run, HelloWorld path understood, ship still on [Chaos/Jolt/PhysX]. Alpha keep/hold. Receipt in lab/box3d/.”

That sentence prevents a producer from hearing “we’re on Box3D now.”

Working-dev path - gates B1–B6

Suggested receipt (box3d_spike_receipt_v1.json)

{
  "schema": "box3d_spike_receipt_v1",
  "date": "2026-07-27",
  "box3d_tag": "v0.1.0",
  "git_sha": "RECORD_AFTER_CHECKOUT",
  "cmake_preset": "windows-release",
  "samples_ran": true,
  "helloworld_path_reviewed": true,
  "determinism_claim_read": true,
  "determinism_measured_matrix": false,
  "ship_physics_stack": "Chaos|Jolt|PhysX|other",
  "ship_physics_swapped": false,
  "decision": "hold",
  "promote_after": [
    "v1.0 or studio-approved alpha policy",
    "golden scenes pass on our platforms",
    "binding/integration owner named"
  ],
  "owners": {
    "engineering": "NAME",
    "producer": "NAME"
  }
}

Store it next to BUILD_RECEIPT culture — same folder tree habit, different schema.

FetchContent sketch (sandbox only)

From the README — pin the tag:

include(FetchContent)
FetchContent_Declare(box3d
  GIT_REPOSITORY https://github.com/erincatto/box3d.git
  GIT_TAG v0.1.0)
FetchContent_MakeAvailable(box3d)

target_link_libraries(my_sandbox_app PRIVATE box3d::box3d)

Rules:

• Link into a sandbox target, not the Steam shipping target.
• Do not dual-simulate 10k bodies “for fun” on the fest branch.
• Prefer vendored submodule only after B1–B6 and a restore drill for the ship physics.

Box3D vs Jolt vs Chaos - honest table

Godot maintainers already flagged soft-body gaps and solo-maintainer risk in community discussion (forum). Treat that as diligence input, not drama.

Why Box3D exists (trend body - what changed)

Catto’s announce is unusually concrete about why now:

1. Chaos pain in a survival title — missing gyroscopic torque early, erratic falling trees on triangle mesh, broad-phase risk for hundreds of thousands of entities (announce).
2. Rubikon-Lite fork path — Dirk Gregorius’s hobby Rubikon lineage + Box2D v3 optimizations collapsed into Box3D; some Rubikon-Lite code remains in hull generation/collision paths.
3. Knowledge continuity — open-sourcing 3D work so it survives job changes the way Box2D did for 2D.
4. Early production users — s&box, Esoterica, a 1000-player space game — proof of life, not a warranty for your genre.

The July SIMD for Collision post then shows the engineering still iterating on SAT edge-edge quadratic cost for complex hulls, with SSE2 vs scalar numbers on a boulder pile (SIMD post). That is the opposite of a dead announce — and still not a green light for mid-milestone swaps.

Determinism, replay, and netcode honesty

Box3D lists cross-platform determinism and recording/replay as system features (README). For your spike:

• Read the claim (B4 pass as “understood”).
• Do not mark B4 as measured until you run the same input stream on at least two of {Windows, Linux, macOS} builds you actually ship.
• Netcode teams: determinism is necessary but not sufficient — serialization bandwidth, rollback, and authority model still own the hard parts (Gaffer on Games timestep remains required reading for the HelloWorld fixed-step advice).

HelloWorld itself recommends fixed 1/60 with 4 sub-steps — do not tie b3World_Step to raw frame delta on day one (hello.md).

Company / diligence signals

When a publisher or partner asks about physics middleware:

Do not claim SOC2 or “Valve certified.” Rubikon heritage is historical context, not a compliance stamp.

Common mistakes

1. Swapping Chaos/Jolt on the fest branch the same night you clone. Fail B6 on purpose? No — spike folder only.
2. Pinning main in CI without SHA. Alpha moves; use v0.1.0 or a locked commit.
3. Assuming Box3D is “Box2D with a Z.” 3D joints, quaternions, hull SAT, and mesh/heightfield paths are new failure modes — read hello.md before Discord debates.
4. Skipping samples because “we only care about the library.” Samples catch GPU/driver/sokol issues that unit tests miss.
5. Promising soft-body cloth or full MetaHuman characters. Character mover exists; soft-body is not the v0.1 pitch.
6. Godot teams treating Box3D as a drop-in Jolt replacement. Integration cost and maintainer risk are real (forum).
7. Ignoring SIMD disable flags for exotic targets. README documents BOX3D_DISABLE_SIMD for Web/odd CPUs — log it if you use it.
8. LLM-generated bindings committed without a golden scene. Catto’s own LLM note covers tests/samples/migrations — your bindings still need human review (README LLM section).

Creator Discord brief (copy/paste)

Box3D spike (v0.1.0 alpha) tonight:
- CMake presets → samples.exe runs
- HelloWorld path reviewed (ground + falling cube)
- Ship physics UNCHANGED (still on ____)
- Decision: HOLD until 1.0 / golden scenes
- Receipt: lab/box3d/box3d_spike_receipt_v1.json
Owners: eng ____ / producer ____

Creators can paste that without learning SAT edge-edge theory. Devs keep the gates; leads keep the owners line.

Schedule - one evening

If configure eats the night, stop at a failed build log in the receipt — that is still better than a silent “we’ll finish later” with a half-swapped submodule.

Internal links - first-half cluster

Already used above: Epic Lore spike, Godot 4.8-dev2, BUILD_RECEIPT. Add MonoGame 3.8.5 keep/hold if you are on a custom C# stack evaluating native physics interop — different engine, same “spike don’t ship-swap” discipline.

Advanced stretch (optional)

Only after B1–B6:

1. Emscripten build with samples off (emcmake path in README) — log SIMD flags.
2. Record/replay sample if present in the samples menu — attach clip to receipt.
3. Minimal C HelloWorld compiled as a unit test target mirroring docs/hello.md.
4. Compare one golden pile against Jolt in a throwaway harness — numbers in a table, not vibes.
5. Read SIMD post and note whether your content uses complex hulls (destruction) vs boxes (SIMD for Collision).

Stop before writing a custom Unreal Chaos replacement. The announce already warned that path needed custom scripting/ECS hooks.

FAQ

Is Box3D production-ready for a Steam demo?

No. Author and release notes treat v0.1.0 as alpha. Spike and learn; keep ship physics on the stack you already trust (v0.1.0).

Is Box3D a fork of Box2D?

Think sibling architecture, not a git rename. The announce describes Box2D structures and algorithms extended for 3D plus Rubikon-Lite collision heritage (announce).

Should Godot switch from Jolt to Box3D?

Not tonight. Jolt is battle-tested in Godot’s recent defaults; Box3D integration would be a multi-milestone project with soft-body and maintainer tradeoffs (forum). Re-test Jolt on 4.8-dev2 separately.

Does Box3D replace Unreal Chaos out of the box?

No. Catto’s own Unreal path used custom scripting, Esoterica animation, and a custom ECS hook — not a FAB one-click (announce).

What license is Box3D?

MIT (README). Still read NOTICE/attribution for your ship legal folder.

Can I send pull requests?

Not currently — README says PRs are disabled; file issues or use Discord/Discussions (README).

Where is HelloWorld?

docs/hello.md in the repo — console ground + falling cube, fixed 1/60 step, four sub-steps.

What about Web builds?

Emscripten path exists; SSE2 is used with WASM unless you define BOX3D_DISABLE_SIMD (README). Treat as stretch after desktop samples.

How is this different from Epic Lore?

Lore is version control for code + binaries. Box3D is physics simulation. Different evenings, different receipts — see Lore spike.

What should promote us from hold to keep?

Studio-approved maturity (toward 1.0), golden scenes green on your platforms, named integration owner, and a rollback plan that keeps last-known-good engine physics tagged.

Key takeaways

1. Box3D is Erin Catto’s MIT 3D physics engine — alpha v0.1.0, not a ship swap.
2. Spike with CMake presets → samples → HelloWorld; pin the tag in a receipt.
3. Default indie posture is hold on production Chaos/Jolt/PhysX.
4. Gates B1–B6 make the evening auditable for leads and partners.
5. Determinism/replay are design goals — measure before you netcode-brag.
6. Godot teams should not confuse this with the 4.8-dev2 Jolt bump.
7. Unreal Chaos replacement is a custom integration story, not a plugin myth.
8. July SIMD collision work proves the project is alive — still alpha.
9. Pair the habit with BUILD_RECEIPT culture.
10. Cite the official announce and GitHub README before Discord arguments.

Related reading

• How to Try Phaser Game Agent Box3D - First Indie Physics Prompt Spike 2026 — Game Agent / Phaser AE prompt physics (distinct from this Catto C++ Box3D spike)
• How to Try Phaser Spine Mesh2D - First Indie Slot Object Spike 2026 — HTML5 Spine Mesh2D / slot-object keep/hold (distinct from this C++ physics spike)
• How to Try Epic Lore Version Control - First Indie Spike Evening 2026
• Godot 4.8 Dev 2 - VCS Diffs and Play Scene QoL
• Your First BUILD_RECEIPT.json and Upload Log
• MonoGame 3.8.5 Upgrade Keep Hold
• How to Claim Fab Free Assets Before They Expire
• Official: Announcing Box3D · GitHub erincatto/box3d · v0.1.0 · Docs · SIMD for Collision · Phoronix

Conclusion

Box3D physics is the rare open-source 3D solver launch with Box2D-level authorship and early real-game users — and it is still alpha. Clone it, build the samples, walk HelloWorld, fill B1–B6, then leave your ship physics alone until maturity and golden scenes say otherwise. Bookmark this keep/hold beside the official announce and keep the receipt where producers can find it.

If your team splits nights between middleware spikes, put physics on this URL and binary VCS on the Epic Lore evening — never both cutovers in the same sprint without dual owners and rollback tags.