Box3D Physics Keep Hold - First Indie Spike Evening 2026

If you are searching box3d physics on August 11, 2026, 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. Weeks later, Discord still pastes “we’re evaluating Box3D” without a tag pin or samples screenshot — that is why this refresh keeps B1–B6 and adds an explicit Monday ritual plus Discord paste.

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). Mid-August is quieter on Twitter and louder in production: July notes still lack a dated Discord paste, and soft “swap Jolt this sprint” claims travel faster than B1–B6 honesty.

This evening is not Phaser Game Agent Box3D (prompt physics in Phaser AE). It is not Photon Fusion 2.1 (netcode). It is not the Godot 4.8-dev2 keep/hold (editor QoL + bundled Jolt bump). It is box3d physics — a throwaway Catto C++ spike with a receipt.

Time: about 60–90 minutes for clone → presets build → samples → HelloWorld skim (or the full Monday ritual). Longer if you wire FetchContent into a sandbox app.

Facts checked August 11, 2026: erincatto/box3d still frames v0.1.0 as alpha (release; announce). Confirm your checkout tag and CMake preset tonight—do not trust a July screenshot of someone else’s samples window. Phaser Agent “Box3D” is a different product (that evening).

Why this matters now (August 11, 2026)

August keep/hold: The June 30 announce is six weeks old. The useful question is no longer “did Catto ship 3D?”—it is whether your team can finish one tagged HelloWorld without turning HN FOMO into a Chaos/Jolt cutover. Soft “we’re evaluating Box3D” claims travel faster than B1–B6 honesty.

Three clocks still drive the evening this week:

1. The Box2D pedigree is still the Discord noun. Catto’s announce ties Box3D to production pain in The Legend of California, Rubikon-Lite heritage, and early adopters like s&box (announce). Partners will ask. You need a receipt, not vibes.
2. Alpha is still the honesty gate. Catto says the engine needs more testing and docs; PRs are currently disabled; v0.1 is a waypoint toward 1.0 (README). Spike skill ≠ ship cutover.
3. Name collision is live. Phaser Game Agent also says “Box3D.” That is prompt physics in a browser Agent — not this MIT C17 library. Do not merge receipts.

If you already filed a July note without a Discord paste or CapEx four-liner, re-run the Monday ritual before partner decks invent “physics swapped.”

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.

Monday ritual - August Box3D keep/hold (60–90 minutes)

Use this when a lead says “we already tried Box3D” but nobody can point at a v0.1.0 pin, a samples screenshot, or a named physics owner.

Standup checklist (ten minutes when you cannot spare the full ritual): Tag pinned? Samples ran? Ship unchanged? Discord paste?

Company CapEx four-liner (diligence zip cover)

When a producer asks “should we swap Chaos/Jolt because Catto shipped 3D?”:

1. Scope — throwaway CMake + HelloWorld only; not a ship-physics rewrite (announce).
2. Cost — MIT core, but integration + golden-scene time is the real line; July star-count screenshots are not an SLA (v0.1.0).
3. Evidence — B1–B6 + samples screenshot on your OS, not an HN GIF.
4. Owner — named physics lead who freezes Chaos/Jolt/PhysX until 1.0 policy exists.

Discord paste (copy)

Box3D physics — Aug 11 2026 Monday ritual (NOT Phaser Agent Box3D / NOT Fusion)
Tag: v0.1.0 (alpha) / other SHA ____
CMake preset: windows-release / linux-release / macos-release
Samples ran: yes / no
HelloWorld path reviewed: yes / no
Ship physics UNCHANGED (still on Chaos / Jolt / PhysX / ____)
Decision: HOLD (default) / keep / rewrite
Owner: ________  Receipt date: 2026-08-11

August physics-week cadence (after the first evening)

Once B1–B6 pass on one OS, do not auto-swap ship physics because “HN still loves Box3D.” Use a light loop:

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-08-11",
  "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)

Use the Monday ritual Discord paste above as the pin. This shorter standup line is the fallback when you only have thirty seconds:

Box3D spike (v0.1.0 alpha) Aug 11:
- CMake presets → samples ran
- HelloWorld path reviewed
- Ship physics UNCHANGED (still on ____)
- Decision: HOLD until 1.0 / golden scenes
- Receipt date: 2026-08-11
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.

Do I need to re-run if I already filed a July note?

Yes — if your only artifact is a July note without Discord paste, v0.1.0 pin, or B1–B6. Soft “we’re evaluating Box3D” still invents a ship swap. Alpha labeling did not make samples or a frozen Chaos/Jolt stack optional because the calendar flipped.

Is this the same as Phaser Game Agent Box3D?

No. Phaser Agent Box3D is prompt physics in a browser Game Agent. This URL is Erin Catto’s MIT C17 library. Different repo, different receipt. See Phaser Game Agent Box3D.

Key takeaways

1. box3d physics still matters on August 11, 2026 — run the Monday ritual before partner decks invent a Chaos/Jolt swap.
2. Box3D is Erin Catto’s MIT 3D physics engine — alpha v0.1.0, not a ship swap.
3. Spike with CMake presets → samples → HelloWorld; pin the tag in a receipt.
4. Default indie posture is hold on production Chaos/Jolt/PhysX.
5. Gates B1–B6 make the evening auditable for leads and partners.
6. Determinism/replay are design goals — measure before you netcode-brag.
7. Do not merge this with Phaser Game Agent Box3D or Fusion 2.1.
8. Godot teams should not confuse this with the 4.8-dev2 Jolt bump. Unity 2D teams evaluating Box2D v3 inside Unity 6.3 should use the separate Unity 6.3 LowLevelPhysics2D keep/hold - that is not this Box3D spike.
9. Unreal Chaos replacement is a custom integration story, not a plugin myth.
10. A July thumbs-up without a dated August 11 Discord paste does not clear CapEx diligence.
11. Pair the habit with BUILD_RECEIPT culture.
12. Cite the official announce and GitHub README before Discord arguments.

Related reading

• Unity 6.3 Box2D v3 Low-Level 2D Physics - What Changed and How to Try It — Unity 6.3 Box2D v3 2D API (not this 3D Box3D spike)
• How to Try Phaser Game Agent Box3D - First Indie Physics Prompt Spike 2026 — August cousin; Game Agent / Phaser AE prompt physics (not this Catto C++ library)
• How to Try Photon Fusion 2.1 - First Indie Shared Mode Spike 2026 — August cousin; netcode Shared Mode (not this physics solver)
• 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 still matters on August 11, 2026: a spike-bounded evening—v0.1.0 pin, CMake samples, HelloWorld, receipt—and “we swapped Chaos because Catto shipped 3D” claims that travel faster than B1–B6 honesty. Run the Monday ritual, paste Discord, and file the receipt before a content freeze invents a mid-milestone cutover. Hold ship physics until owners, golden scenes, and a rollback tag exist. Bookmark this keep/hold beside the official announce and v0.1.0.

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