Guides

The division of labor for authoring s&box animation with agents: the owner authors hero poses in the Animate studio, agents build the motion around them against a numeric definition of done, and the owner taste-gates frames, never live sessions. Covers the pose-to-pose synthesis pattern, numeric acceptance, and the sequence-time traps that break freeze-at-end logic.

The architecture for letting an agent (or CI) drive the live s&box editor: compile-gate, spawn, play, inject input, read telemetry, screenshot, assert, and gate a merge on the numbers, with no human at the keyboard.

The method for hanging custom models off the player rig -- gadgets, backpacks, held items -- with three mount styles off one skeleton, and a live slider panel that dumps C#-ready constants for paste-back.

The practical patterns for Sandbox.Decal: orienting the projection box to a hit normal, keeping a decal byte-identical across multiplayer peers, making paint follow an animated character, and scaling to thousands of decals without a performance cliff, plus the pitfalls that catch each one.

When the world is deterministically generated from a spec, a save is {version, spec, edits[]}, never a geometry snapshot. Load = validate → regenerate → replay edits. Same format works for save, co-op edit sync, and late-join replay.

The method for a CS/Rust-style two-view split off one player rig: third person shows the world model, first person hides it and shows a camera-attached viewmodel (arms + held item). Covers hysteresis, tag-based per-view exclusion, the ShadowRenderType correction, and viewmodel composition.

How to split reusable code out of a game into an s&box Library package, and how to consume one from a game, without silently losing content, binding the wrong types, or shipping divergent assets.

Two proven architectures on top of the engine networking primitives: replicate the generator spec (not the geometry) for deterministic worlds, and retrofit local-only gameplay systems to host-authority without breaking single-player.

The operational recipe for shipping player-hosted (P2P) multiplayer in s&box (lobby mechanics, invite codes, the join handshake liveness contract, replication traps, and the three-rung testing ladder), covering the layer the official docs don't document and where live multi-peer sessions actually break.

The method for feel-first traversal on a kinematic trace-based character: coyote-time jumps, double jump, mantle, slide, wall run, node climbing, and rope swinging, plus the ground-contact quality work that makes all of it read smooth.

The higher-order asset layer for kits of parts (vehicles, procedural buildings): the generator emits a manifest next to the meshes, code consumes ONLY the manifest, pivots sit at joints, collision comes from metadata, and assembly is transactional.

A disciplined method for answering "the game feels slow" in an s&box project without shipping speculative optimizations: environmental pre-checks, measurement tooling, an isolation matrix, and a verdict discipline that prevents wasted work.

The complete method for wiring s&box's built-in Voice component into a networked game (push-to-talk, 3D positional playback, custom falloff curves, speaking indicators, and lip-sync), with no third-party voice SDK.

The method for making a procedurally-rigged NPC crumple via engine physics: author a physics skeleton in the vmdl, toggle Sandbox.ModelPhysics at runtime, and hand bone control back for stand-up. No authored collapse clips needed.

The method for large runtime-generated terrain in s&box: a persistent cell grid as the single source of truth, chunked greedy meshing (tops + skirts), collision decoupled from render grain, palette-atlas UVs, and dirty-chunk remesh for a live terrain brush.

The build order for a fresh s&box project a coding agent can actually work in without corrupting itself on day one: skeleton, globals, compile gate, and the ownership discipline that keeps parallel agents from clobbering each other.

The method for vehicle engine audio that doesn't screech: two-layer RPM crossfade with narrow pitch bands, code-side looping, slip-driven skid feedback, and the persistent ConVar trap that ate two listen tests.

The proven architecture for driving games in s&box: raycast wheels on a single chassis Rigidbody, substepped slip-ratio/slip-angle tire physics with peaked curves, a torque-curve drivetrain, layered assists, and arcade dials on top of a sim core.

What "a 20k world" actually means (units vs meters vs Source-1 map folklore, and they are ~1550x apart), why s&box has no VBSP-style coordinate wall, and the real modern ceiling: fp32 position precision that coarsens with distance from origin. Measured numbers, the lore separated from the measurements, and the reproduction method.