@ref on a private field compiles with only a CS0649 warning — the ref stays null at runtime. Bind to a property instead.

Two-stage flow: Blender headless emits Y-up OBJ, then pure Python writes vmats/vmdls and a C# model catalog.

Census tris × instances before decimating; prefer BoxCollider over ModelCollider for decorative props.

Org/ident rules, every store-page field is launch-blocking, AI thumbnails demoted — verify as a player after publish.

Disjoint file ownership, serialize hot files, report-don't-fix foreign errors, resume after interrupts — the concurrency rules that keep agent waves shippable.

Angles uses .pitch/.yaw/.roll (lowercase) and Vector3 uses .x/.y/.z — capitalized sightings in a codebase belong to unrelated component properties.

global using Sandbox + your razor namespace in Assembly.cs — without it, panels and game types don't resolve across the assembly.

MP3 + JSON .sound beside it — no wav/ffmpeg; Distance is in inches; copy schema from addons/menu box_open.sound.

bpy.ops.wm.obj_export can reorder face lines across runs on the same mesh — diff the manifest, not the raw OBJ bytes.

No native drag helper exists for PanelComponent sliders — use the engine's SliderControl pattern: MousePanelEvent.LocalPosition over track width, with pointer-events routing.

One ScreenPanel host, static UIState for modals, self-closing panels, toast stack — BuildHash every flag the markup reads.

Deriving a visual's facing from horizontal velocity causes 180-degree snaps on any momentum reversal — lock facing to an attach-time azimuth for pendulums and oscillators.

Published game boots with error.vmdl placeholders; engine may rewrite prefab refs — no auto-retry; restart editor + republish.

BoxCollider is cheap and follows WorldScale; Capsule/ModelCollider don't scale with WorldScale and ModelCollider is costly on clutter.

Set Sequence.Blending = true once — per-clip fade_in/fade_out times in the vmdl shape the blend; no AnimGraph required.

Census tris × instances first — silhouette fails before UVs; inject usemtl after scripted OBJ export.

ModelRenderer.CastShadows doesn't exist as a settable property — use renderer.SceneObject.Flags.CastShadows instead.

Headless dotnet build is green while the in-editor compiler emits SB1000 — Environment/IO/Process/reflection are banned in game code.

Jump() helpers clamp against rising velocity, eating the second impulse. Set Velocity.z directly for a reliable double jump.

GameObject.Destroy() in edit mode is deferred; a query fired right after returns the previous build's objects.

Razor HUD emoji and dashes die under Get-Content/Set-Content — edit with byte-safe UTF-8 APIs or a real editor.

Two screenshots of byte-identical geometry differ by tens of percent because editor auto-exposure adapts over wall-clock frames — settle the viewport and exposure-normalize before comparing.

Editor-embedded play mode pins at exactly 60 fps regardless of cvars. The cap is the compositor's vsync on the editor window, not the engine frame sync.

The engine ships its built-in [McpTool]s as full C# source, not compiled DLLs — check addons/tools/Code/Mcp/*.cs for canonical patterns before inventing your own.

Failed package compile leaves the editor running the last-good hotload — multi-symptom 'regressions' are often stale code.

A front-flip rotation uses _baseRot.Forward (not .Right) when FacingYawOffset is ±90° — the offset swaps which local axis is perpendicular to travel.

Folders → sbproj → Assembly.cs → 4-object scene → green dotnet build → tagged logs on Play — then optional art tools.

A flex-grow slider track holding a normal-flow fill child sized by width:N% balloons wider as the value increases — take the fill out of flow with position:absolute.

Foot-slide happens when PlaybackRate is tied to movement top speed instead of the clip's own authored stride distance.

Forge delivery job errors out but the build stage's previewGlbUrl stays downloadable — recover the GLB through Blender into your standard delivery shape instead of re-spending.

A runtime-generated world root torn down with GameObject.Destroy() keeps rendering in edit mode because the deferred queue isn't flushed — use DestroyImmediate and sweep all matching roots.

.sbproj + Assets/Code/ProjectSettings/tools layout, 4-object scene + Bootstrap, dotnet build before anything else.

Per-cell dither or contour-wander in a greedy voxel mesher turns cliff skirts into vertical stripes — detect walls and key strata on raw height bands with dither neutralised.

An idempotent ground-snap jitters on curved terrain because the slope curves away within each step — ease the downward snap at a bounded glue rate.

dotnet build reports 0 errors on .razor files the in-editor compiler rejects — the headless build doesn't surface the Razor errors the live editor's Roslyn compiler flags.

GameTask.RunInThreadAsync for parse/math; main thread only for engine objects; Yield every N items for loading UI.

A near-white chalky sky stays mid-grey or blue — fixing the sky texture alone isn't enough because the default tonemapping curve crushes highlights.

Top model plans and reviews; cheaper agents execute on disjoint files; telemetry-driven feel tuning — whitelist and stale-assembly traps included.

CC0 kits import like any OBJ+vmdl; city kits share colormap.png, nature kits need per-color vmats, and facing is a per-model yaw guess.

WASD as Forward/Backward/Left/Right feeds AnalogMove; new Input.config actions need an editor restart — dotnet build is not enough.

Whitelist divergence, loose Resource Files, and silent cloud-asset failures after publish.

Standalone export hangs if PackageReferences still need sbox.game to resolve — don't accumulate cloud package deps casually.

Converting euler poses per-key can land on q vs -q — the interpolation takes a violent 360-degree detour. Negate the quat if dot(prev, new) < 0.

Always handle tr.StartedSolid — ignore that frame so an overlapped body can walk free; slide-trace the wish onto the hit plane.

PNG/WAV/MP3/JSON must be listed in Project Settings → Resource Files without an assets/ prefix — #1 editor-vs-publish break.

Scene holds four GameObjects; Bootstrap OnStart builds the world in code — hotloads better, no scene/code drift.

Per-instance Tint on a flat-color vmat (white PNG + g_vColorTint) rotates hue or crushes random instances to black — use scale/yaw jitter instead.

Play full path WITH .sound or bare filename only — partial paths like impact/boing never resolve; compiled assets can still be invisible mid-session.

OfType<IInteractable> on GetAllComponents<Component> returns nothing — enumerate concrete types and union them.

RenderMeshFile alone compiles clean with zero physics — ModelCollider needs PhysicsMeshFile/PhysicsHullFile in the vmdl.

Blender +X becomes world −Y after OBJ import; yaw +90° faces +X — and Blender +Y rotation tips the +X edge down.

BuildHash() is the only re-render trigger — hash everything the markup reads, including collection contents and flags.

CapsuleCollider and ModelCollider ignore WorldScale; BoxCollider follows it — bake scale into import_scale instead.

A newly created .razor.scss file is not picked up by a running editor session — the panel component works but is unstyled until the next restart.

GamepadCode-bound trigger actions are read as digital threshold presses only — there's no smooth 0..1 analog read per action. Use stick axes for continuous control.

Disabling a collider does nothing for a hand-integrated kinematic controller — noclip must be a movement state that skips traces, gravity, and ground-snap entirely.

Rotation.FromYaw alone leaves a decal flat on the floor — build a rotation that aligns the thin axis to the surface normal, then offset along it.

[Sync] owner→proxies, IsProxy early-out; FromHost for shared truth — don't NetworkSpawn scene-wide singletons.

OnAfterTreeRender(bool) is a Panel hook — on a PanelComponent it fails with CS0115; use parameterless OnTreeBuilt() or OnTreeFirstBuilt().

A per-cell white-noise hash for terrain shade choice reads as a 50/50 checkerboard — use a smooth low-frequency noise field instead, confining the hash to threshold-edge dithering.

Ident is org.package — two lowercase segments; keep Org local until real; never put TODO placeholders in Org or the editor won't boot.

PhysicsShapeList + PhysicsJointList in the vmdl + ModelPhysics toggle — no collapse clips, no SetBoneTransform.

Transfer rest-delta rotations parent-relative (not world) — avoid the forward-hunch bug and never transform_apply scale on Mixamo armatures.

Bone-heat auto-weights fail on AI meshes — use scripted geodesic (along-surface) weights, then FBX + animated vmdl.

Rigidbody API verified across multiple projects — Gravity, MassOverride, Velocity, ApplyForce, and the recipe for a dynamic pushable prop.

s&box ships Roboto Mono (all weights) — JetBrains Mono and Consolas only resolve on dev machines with those system fonts.

Rotation.FromYaw(+angle) is a LEFT (CCW) turn — get the sign right or steering, AI, and autopilot spiral the wrong way.

SCSS background-image only resolves asset paths — runtime Texture objects must be assigned via Panel.Style.BackgroundImage in OnTreeBuilt.

FlatBox/Prop/Deco/Wire helpers plus Obstacle records as plain data beat physics queries for build validity.

OnAwake runs synchronously inside Components.Create — set singletons there; derive from [Property] in OnStart after spawn helpers assign.

Assets / Code / Editor / ProjectSettings / tools — the template every project follows.

1 m = 39.37 engine units — design in SI, convert once at the engine boundary, and audit every consumer.

Scenes never load raw OBJ/GLB — always wrap with a .vmdl and remap materials under both bare and .vmat names.

DTOs + one spawn path + deterministic static world — guard restored defaults; keep enums append-only.

A component with Enabled = false is invisible to GetAllComponents — search returns null even though the component exists.

Sound playback is a static call, not a component. Use Sound.Play() for 2D and Sound.Play(pos) for 3D, and handle missing events gracefully.

If sbox-launcher.exe stays open during a Steam update, files vanish mid-install — validate via steam://validate/590830.

Preview as of 2026-07: Valve approval + Facepunch license; full .NET, lose platform services; clean PackageReferences or startup hangs.

Use TextEntry with onsubmit and OnTextEdited — standard Blazor input bindings compile but are not how the engine UI works.

An untyped or expression-bodied lambda on TextEntry.OnTextEdited fails with CS8917 or CS0029 — use an explicit param type plus a block body.

Model compiler rewrites upper_arm.L → upper_arm_L; physics KV3 that still says .L makes limb bodies unknown while the torso works.

Default −Z/Y axes, bake_space_transform, no leaf bones, X/Z bone axes, mesh FBX + per-clip armature FBX; scale via ScaleAndMirror 0.3937.

Razor classes get a RootNamespace/folder-derived namespace — declare @namespace and global using or C# can't find your panels.

static Instance set in OnAwake, cleared in OnDestroy — everything reads Foo.Instance with null-guards, no inspector wiring.

SoundEvent has no Looping property — loop via compiled vsnd import options, or re-trigger from code when SoundHandle finishes.

StartupScene is what Play loads; Org must be a valid lowercase ident — placeholders break editor bootstrap, not just publishing.

Many selectors declaring font-size in one SCSS file can make text render as solid filled rectangles — carry hierarchy via font-weight/color instead.

A hand-integrated trace mover has no collider component — ITriggerListener and OnTriggerEnter never fire. Use distance-polling instead.

No paid storefront — revenue is clamped player-hours from a daily pool; retention is the monetization feature.

Shader field support is unknown and no .shader source exists — check the install's templates/ folder for authoritative syntax instead of grepping sibling projects.

AI mesh generators (Tripo, Meshy, Rodin) deliver textured OBJ+vmdl — but modeldoc32 headers, ~1m normalize, corrupt textures, bare texture paths, and missing colliders will ERROR the asset until patched.

Source engine convention: Forward = +X, Left = +Y, Right = -Y. Using Vector3.Right for '+X' silently slides geometry the wrong way.

C# hotloads on alt-tab in ms; scene changes and new Input.config actions need Play/editor restart; failed compile keeps the last-good assembly.

Literal spaces adjacent to a tag or @-expression boundary vanish in Razor markup — use a single interpolated string or CSS margin instead.

SetIk is AnimGraph-gated; SetBoneTransform is unsound on clip-keyed bones — use proxy props, whole-visual motion, or commit to AnimGraph.

Get-Content/Set-Content re-encodes BOM-less UTF-8 as ANSI; CRLF files break \n-only search-replace — use byte-safe APIs.

Stats.Increment/SetValue, Leaderboards.GetFromStat, Achievements.Unlock — cheap platform polish; total achievement score capped at 1000.