Free 3D asset generator for coding agents. Your agent writes TypeScript; ts23d compiles it to game-ready glTF — for Unity, Unreal, Godot, three.js, Babylon, or anything that reads glTF.
Gallery · npm · Docs · Changelog (per release) · Maintenance · llms.txt · Roadmap · Security · Issues
Bun runs the CLI (t3d); the library imports under Node ≥ 22. Published from CI with npm provenance. Built and maintained by AI agents under developerz.ai.
![]() tiger_1 · Tiger I |
![]() loco_440 · 4-4-0 “Jupiter” |
![]() station_halt · Station halt |
![]() eiffel_tower · Eiffel Tower |
![]() orc_head · Orc bust (sculpt) |
![]() goblin_head · Goblin bust (sculpt) |
![]() mountain_range · Eroded mountains |
![]() oak · Oak |
![]() water_tower · Water tower |
![]() boxcar · USRA boxcar |
![]() signal_gantry_4 · Signal gantry |
![]() t34 · T-34/76 1943 |
![]() asteroid · Asteroid |
![]() cargo_container_scifi · Sci-fi cargo pod |
![]() boulders · Boulders (SDF) |
![]() dropship · VTOL dropship |
Every image above is a real render: the committed hero.png next to each recipe, made on the CPU by t3d hero (regenerate with bun run shots <name>). Click one for its recipe, reference dossier and contact sheet.
Bodies beyond four legs. Sharks, fish, snakes, an octopus and a many-necked hydra, built from bone chains with defineBodyPlan. Their swim, slither, reach and strike clips are baked from published biomechanics numbers and checked by QA.
![]() great_white · Great white shark |
![]() bluefin_tuna · Atlantic bluefin tuna |
![]() common_octopus · Common octopus |
![]() king_cobra · King cobra |
![]() hydra · Five-necked hydra |
Model tier: characters and creatures. The same recipe loop with a model in it: an image-to-3D body (a local GPU model or Meshy), finished by headless Blender steps the recipe writes (retopology, UVs, bake to albedo / normal / ORM, skinning, LODs), then held to real scale, a sourced skeleton, baked clips, budgets and the same QA gate. Each one ships as a skinned GLB with its own textures on three LODs (about 30–39k / 10–12k / 4–5k triangles, 1 draw call); the model outputs are committed with their licence, so builds and CI replay them without a GPU or a key.
![]() ranger · Woodland ranger (Meshy) |
![]() dragon_hybrid · Emberwing drake (Pixal3D + UniRig) |
![]() bear_hybrid · Brown bear (Pixal3D + UniRig) |
![]() wolf_hybrid · Grey wolf (Pixal3D + UniRig) |
Rendered on the CPU by t3d hero like every other asset. In the gallery these open on the Model tier; the switch shows the CPU tier, which builds without a model. Known limits and measured cost are in each recipe's README.
Pairs well with Meshy. Use Meshy for the image-to-3D body and rig, then let a recipe finish the result: headless Blender steps clean it, rebuild its topology, UVs and baked maps, keep its rig and clips, and write three LODs, with ts23d QA on the final GLB. recipes/ranger is a worked example. Local GPU models use the same path.
Open the gallery → Every asset compiles live in your browser: orbit it, switch LOD0/1/2, toggle wireframe, play its motion or stage it in a scene, check its measures against the real thing, and download the GLB.
Use the LLM you already pay for to write the assets your project needs (vehicles, buildings, props, whole streets), optimised by construction. ts23d ends at the GLB, its textures and a manifest. The engine is yours.
Each asset is a TypeScript module. t3d build compiles it, deterministically, to GLB. Free: no GPU, no credits, no service. Browse the asset gallery: every recipe, compiled in your browser, with its source.
- Named, pivoted, animatable parts.
turret,gun,road_wheel_l_0: your engine code binds to node names. - Families. One typed build, many assets:
family.variant({ name, params })turns T-34 1941 into 1943 with one key;extendderives new families. Plain functions all the way down, no plugin API. - Sockets and surfaces.
ctx.socketexports seats, mounts, cameras and spawn points as named nodes. A part can beopaque,cutout,glassortranslucent; a GLB holds at most 4 materials over one texture set (a shampoo bottle is 2 draw calls). - Emitters and motion.
ctx.emitterexports smoke, steam, dust, muzzle and fire sources as named nodes your engine's particles bind to; partsspin,slide,sway,orbit(coupling rods) or run as a slider-crank (crankrod,piston). - 3 LODs from one source. The recipe reads
ctx.lodand drops detail. Nothing is decimated. - One shared material, batched geometry. Every asset maps into one trim sheet, and the exporter merges static geometry into its nearest pivot. Draw calls = one per moving pivot (plus one for the merged static body): a static prop or building is 1; a tank with independently spinning road wheels is one per wheel plus turret, gun and hull. Cap it with
budget.draws;t3d buildfails onT3D_QA_DRAW_CALLS. - A QA gate. Exit 1 on: a part not in surface contact with anything grounded (2 cm), a moving part that cuts through another anywhere in its motion, a blown triangle budget (and
budget.drawswhen declared), non-finite or inside-out geometry, degenerate (zero-area) triangles, hidden parts, an LOD that grows instead of shrinks. Every finding carries a stableT3D_QA_*code, afix:line and, where it applies, the gap and nearest part (gate list). - Code-level checks. The recipe states its physical intent and QA enforces it at every LOD:
checks: [clear('track_*', 'hull_*'), noOverlap('road_wheel_l_*'), touches('turret_body', 'hull_top'), symmetric('_l', '_r', 'y')]. "The track hits the frame" becomes a failing build. - Textures from code. A procedural albedo / normal / ORM trim sheet (bricks, planks, plates, slate, foliage), written once and shared by every GLB, plus three.js TSL and Godot shader sources.
- Spec-sheet fidelity. Declare
real: { length, width, height, measures }withsources. QA holds the overall size to ±5% and each named dimension (driver diameter, gauge, wheelbase) to ±2%. Fix the model, never the spec. - A contact sheet. One PNG, six labelled orthographic views on a metre grid, rendered on the CPU in the asset's base colours (trim-sheet albedo × vertex colour, glass see-through). A vision-capable agent reads it once, sees what's wrong and fixes it.
- A beauty render and an AI review pack.
t3d herorenders a textured, lit, soft-shadowed 3/4 product shot on the CPU (the images above).t3d reviewwrites hero, sheet, close-ups, an LOD strip, a checklist prompt for a vision agent and image metrics: QA with pictures, no GPU. - Organic modelling.
sdf(surface nets / marching cubes) withsd.*combinators andsculpt, an ordered add / subtract / paint edit list with smooth blends: busts, rocks, asteroids. - Draw → 3D. An agent writes SVG (drawing as text) and ts23d builds from it:
extrudeSvg(holes, chamfered edges),latheSvg(half profile), andvisualHull, a front + side (+ top) silhouette block-out you refine with sculpt edits (svg_showcase). - Terrain. Seeded noise (
fbm,ridged, domainwarp,terrace), droplethydraulicErosionandthermalErosion, andterrainColorby altitude, slope and flow. - Architecture and hulls.
roof(gable, hip, mansard, gambrel, …),openingwindow/door kits forfacade, true-scale masonrymass, lofted vesselhull;tiled,cellandlattice(Warren / Pratt / Howe trusses) primitives,box({ bevel }), andtextlettering as geometry (5 × 7 pixel font, or smooth Hersheysans,serif,scriptandgothicstroke faces, flat or raised). - An optimiser on by default. Weld, degenerate removal, vertex-cache and vertex-fetch order (tiger_1 LOD0: 15.4 → 6.3 MB, ACMR 2.88 → 1.16), weighted normals, baked per-vertex AO.
- Lights, glow and provenance in the GLB.
KHR_lights_punctualfrom light sockets, emissive glow materials, licence / creators / sources asKHR_xmp_json_ld. Zero glTF-Validator warnings. - Physics and sound. Per-part colliders (box, sphere, capsule, cylinder, capped convex hull), mass, centre of mass and inertia from volume × density, friction and restitution per material, exported as
KHR_physics_rigid_bodies(toGlb(asset, { physics: true })); amasscheck againstreal.mass.@developerz.ai/ts23d/audiosynthesises deterministic impact, engine, mechanism and UI WAVs from material, size and motion, placed withKHR_audio_emitter(sound_demo). - Import and faces.
importGlbbrings in scans and CC0 base meshes (simplifyandbakeNormalsfor those only; code-built geometry is never decimated);importModelkeeps a model's UVs, PNG textures, skin and clips whole as a textured part on every LOD (ADR 016);warpTPSwarps a CC0 base head onto landmarks so faces come from code (import_demo). - Tuning.
t3d tunefits a recipe's declaredtune.paramsto objectives (silhouette IoU against an SVG or PNG mask, spec measures, art metrics, triangle budget, custom) and writestune.jsonthe recipe reads back (tune_demo). - AI finish (optional).
t3d finishprojects model-painted views onto LOD0 as one extra texture layer, masked per part; geometry, names and motion stay the recipe's; QA flags palette drift and mask leaks. Mock or local HTTP endpoint, cached by hash (finish_demo). - Real data.
@developerz.ai/ts23d/data:bun run data wikidata <QID>→realFromdimensions,bun run data dem --centre lat,lon --size m→terrainFromDEM; fetched once, sha256-pinned, offline builds (real_valley). - Test helpers.
@developerz.ai/ts23d/testing:assertQaPass,assertBudget,assertParts,assertMeasure,assertMotionClear,assertDeterministic,snapshotHashfor your own recipe tests.
The goal: high-definition detail up close, cheap to draw everywhere. One texture set, batched static geometry, LODs, compact core-glTF buffers (u16 indices and colours), welded, cache-optimised meshes.
No Blender for most hard-surface asset production. For vehicles, buildings, props and whole scenes, the LLM writes TypeScript that does the modelling, LODs, UVs onto the trim sheet, batching, QA and export. Stylised organic shapes (busts, rocks, terrain) are code too, through sculpt and sdf; realistic sculpts come in through importGlb (scans, CC0 base meshes) or, optionally, a model of your choice through a NeuralAdapter.
Realistic animals and people are model-first and Blender-first (As of 2026-11). Bodies sculpted from code primitives did not read as animals or people, so a creature or humanoid takes an image-to-3D body (a local GPU model, or Meshy as a hosted, paid option) and finishes it with an ordered list of headless Blender steps written in the recipe: shell retopology, UVs, bake to albedo / normal / ORM, bind or keep the model's rig, LODs, review renders. The body stays whole with its textures on all three LODs (ADR 016); code keeps real scale, skeleton, clips, budgets and QA (model, skin, deform, gait). Shipped: ranger (a humanoid through Meshy; its README lists the measured cost, time and known flaws) and the quadrupeds wolf_hybrid, bear_hybrid and dragon_hybrid (Pixal3D mesh and UniRig joints on one local RTX 3090, skinned to a sourced skeleton with idle, look and walk clips). Without Blender, a GPU or a key the CPU tier still builds every asset (a stand-in, not the model's look). Honest limits: fused fingers, sculpted-clump hair, no jaw or blink on a fused head. Workflow: creature-artist and character-artist skills, playbook.
bun add @developerz.ai/ts23dThen give your agent the loop:
| Agent | Copy into your project |
|---|---|
| Claude Code | cp -r node_modules/@developerz.ai/ts23d/.claude/skills/author-recipe .claude/skills/ (the loop) and .claude/commands/new-recipe.md (the /new-recipe command), both shipped in the package |
| Codex, others | Point your AGENTS.md at node_modules/@developerz.ai/ts23d/CLAUDE.md and …/docs/ (details) |
/new-recipe Tiger I, mid-production 1943, fully stowed
/new-recipe 4-4-0 steam loco with tender, wheels and rods animated on a loop
/new-recipe 1940s city street with townhouses and gas lamps (townhouse, lamp, street recipes: landing)
The agent looks up real dimensions and photos into recipes/<name>/README.md, writes recipes/<name>/<name>.ts, builds until QA PASS, reads the contact sheet, and fixes the worst thing until two shots in a row find nothing (the loop).
out/<asset>/lod0.glb (and lod1, lod2) are plain glTF 2.0; out/<asset>/<asset>.glb holds all three in one file (LOD0 in the scene, LOD1/2 as MSFT_lod alternates with screen-coverage switch hints; viewers without the extension show LOD0 only; --lods split|single|both, default both). The hooks your engine code can use:
| Hook | In the GLB |
|---|---|
| Movable parts | Named nodes with pivots at the hinge: turret, gun, wheel_*, door_* |
| Attachment points | Socket nodes with extras.ts23d.socket (seat, mount, camera, …) |
| Particle sources | Emitter nodes with extras.ts23d.emitter (smoke, steam, dust, muzzle, …) |
| Baked loop | Clip run (after a static rest clip) when built with t3d build |
| Everything else | out/<asset>/manifest.json: pivots, sockets, emitters, triangles, draw calls |
three.js, as an example:
const gltf = await new GLTFLoader().loadAsync('out/t34/lod0.glb');
const turret = gltf.scene.getObjectByName('turret'); // rotate about its local Z
const run = THREE.AnimationClip.findByName(gltf.animations, 'run');
const emitters = [];
gltf.scene.traverse((o) => o.userData.ts23d?.emitter && emitters.push(o));Godot: node names import unchanged, and extras are available as node metadata when that import option is on. Unity (glTFast), Unreal and Babylon read the same names. ts23d ships no engine code; per-engine notes are in glb-production.md.
Each ts23d row names how it's verified. The image-to-3D column cites only what vendors' own pages state, as collected in docs/landscape.md (as of Oct 2026). Image-to-3D is the better tool for organic and sculpted shapes; for those, see the optional NeuralAdapter tier below.
| Property | ts23d | How it's verified | Typical image-to-3D output (per vendor docs) |
|---|---|---|---|
| Draw calls per asset | Static assets: 1. Vehicles: one per movable part (one shared material; static geometry batched into its pivot) | toGlb merges static parts by default (mergeToPivots); counts measured by bun run bench |
One PBR material per generated model (e.g. Meshy: albedo / normal / metal / rough) |
| LODs | 3 from the same source | t3d build writes lod0/1/2 plus one MSFT_lod file holding all three, each under its own triangle budget |
One mesh per generation; polycount presets or a low-poly mode (Rodin, Meshy) |
| Named, pivoted, animatable parts | Yes | part-names gate; clashes gate sweeps every moving part |
Usually one mesh; part-based output reported for CSM (3rd-party source) |
| Deterministic rebuild | Byte-identical | scripts/recipes.ts builds every recipe twice and compares hashes, in CI |
Not stated |
| Real-world dimensions | Gated: ±5% overall, ±2% per measure | proportions and measures gates |
Not stated |
| Parts that float or clash | Gated | floating-parts (surface contact, 2 cm), clashes (1 cm) |
Not stated |
| Cost per asset or variant | $0 | MIT, runs locally, a variant is a new seed | Credits, e.g. Meshy ~20–25 credits per generation; Rodin $1.50/credit pay-per-result |
| GPU needed | No | CPU compile and CPU contact sheet | Hosted: no. Self-hosted open weights: yes (TRELLIS.2 ≥ 24 GB) |
| Editable by an LLM | A TypeScript diff | Code review, bun run verify |
A binary mesh; edit by regenerating or in a DCC tool |
| Repair / retopo step | None for code-built assets: authored with pivots, units and budgets. Model-tier assets run a gated Blender retopo / lods step on the model's mesh (As of 2026-11) |
QA gates fail the build instead | Remesh / retopology tools offered (Meshy Smart Topology, quad remesh; CSM AI retopology, 3rd-party) |
| Texture memory per asset | Shares one trim sheet: with --sheet external every GLB references the same three PNGs. Exception: a model-built part carries its own declared texture set (budget.textureSets, ADR 016) |
out/trim_sheet_*.png written once per build |
Own texture set per asset, up to 4K (TRELLIS.2) |
bun run bench --write fills the block below (triangles per LOD, compile + QA time, GLB size, parts, draw calls per gallery recipe) from real runs. Nothing in it is typed by hand; empty means not yet run.
Measured by bun run bench on 1.4.4 (Bun).
| asset | tris LOD0 / 1 / 2 | GLB size LOD0 / 1 / 2 | parts | animated | draw calls (1 material) | compile + QA, 3 LODs | QA |
|---|---|---|---|---|---|---|---|
bluefin_tuna |
32.3k / 4k / 476 | 1.08 MB / 150 KB / 26 KB | 8 | 0 | 1 | 375 ms | PASS |
common_octopus |
134k / 13.4k / 2.09k | 6.2 MB / 729 KB / 142 KB | 6 | 0 | 2 | 3.25 s | PASS |
eiffel_tower |
188k / 21.8k / 1.05k | 16.5 MB / 1.78 MB / 85 KB | 28 | 0 | 1 | 6.7 s | PASS |
great_white |
61k / 7.03k / 680 | 2.1 MB / 269 KB / 35 KB | 7 | 0 | 1 | 795 ms | PASS |
hydra |
348k / 38.8k / 7.16k | 13.7 MB / 1.43 MB / 303 KB | 9 | 0 | 2 | 21.2 s | PASS |
king_cobra |
62k / 3.85k / 584 | 5.02 MB / 146 KB / 33 KB | 1 | 0 | 1 | 1.1 s | PASS |
loco_440 |
45.3k / 18.1k / 1.4k | 2.42 MB / 967 KB / 106 KB | 84 | 14 | 18 | 798 ms | PASS |
material_swatches |
27.3k / 778 / 778 | 2.24 MB / 70 KB / 70 KB | 132 | 0 | 3 | 454 ms | PASS |
oak |
13.9k / 3k / 159 | 745 KB / 166 KB / 10 KB | 6 | 1 | 2 | 8.42 s | PASS |
palm |
5.57k / 2.33k / 205 | 407 KB / 196 KB / 19 KB | 6 | 1 | 2 | 891 ms | PASS |
pine |
23.7k / 5.74k / 306 | 1.16 MB / 295 KB / 36 KB | 6 | 1 | 2 | 10.2 s | PASS |
t34 |
48.2k / 10.4k / 1.58k | 2.63 MB / 684 KB / 163 KB | 28 | 18 | 19 | 1.26 s | PASS |
t34_1941 |
46.6k / 10k / 1.55k | 2.54 MB / 660 KB / 162 KB | 28 | 18 | 19 | 1.23 s | PASS |
tiger_1 |
72.2k / 17.4k / 3.41k | 4.36 MB / 960 KB / 288 KB | 39 | 24 | 25 | 2.31 s | PASS |
Draw calls column: static assets (the Eiffel Tower) are 1; vehicles are one per movable part. Trim-sheet painting: 512² ≈ 0.22 s, 1024² ≈ 0.8 s, 2048² ≈ 2.95 s. The predecessor's reference loco (below) is about 16k triangles at LOD0.
Asset production needs nothing else between "describe the asset" and "a GLB your engine imports". Honest status per stage:
| Stage | Module | Status (2026-10) | Replaces |
|---|---|---|---|
| Geometry | primitives, kinds |
Shipped: box (bevel), lathe, prism, beam, planar, sweep, loft, tiled, cell, lattice, text, heightfield, sdf + sculpt, warpTPS (landmark warp of a CC0 base head), importGlb + simplify + bakeNormals, terrainFromDEM, terrain + erosion, facades with openings, roofs, hulls, vehicles, Weber–Penn trees. creature() (six skeletons) with bones as named parts, fur and hair cards, skinned export with named clips (walk, trot, gallop; head blink/talk/breathe) and morph targets; vector-displacement stamps; hybrid recipes. Planned: feather cards, fur shells (cards instead: glTF cannot express shells) |
Blender modelling |
| Materials and textures | material (generator) |
Shipped: procedural albedo / normal / ORM trim sheet, embedded or shared PNGs, palettes, grime. KTX2 export profile planned (the Basis Universal tool adapter ships, as of 2026-11) |
Substance / texture tools |
| Optimisation | passes/optimize, export |
Shipped: weld, degenerate removal, Forsyth vertex-cache + vertex-fetch order (ACMR reported), weighted normals, baked AO, u16 indices and colours, batching. Planned: opt-in web profile (quantisation + meshopt) |
meshoptimizer / gltfpack |
| LODs | ctx.lod |
Shipped | Decimators |
| QA | qa |
Shipped: budget, surface-contact floating parts, motion clashes, names, proportions, spec measures, non-finite, winding, hidden parts, degenerate triangles, cross-LOD triangles; opt-in z-fighting, LOD silhouette and pivots. /testing helpers |
Manual review |
| Renders and photo match | render |
Shipped: contact sheet (cutout cards alpha-tested), beauty hero render (raster, or --quality path CPU path tracing; glow parts emit), per-asset hero view (hero: { azDeg, elDeg, fovDeg } or { eye, target } on defineAsset; --az / --el / --fov override), review pack for a vision agent, photoMatch with a camera solve, silhouetteIoU gate |
— |
| GLB export | export |
Shipped: faces +Z, seamless loops, trim-sheet textures, punctual lights, emissive glow, XMP provenance, 0 glTF-Validator errors and warnings (tested) | — |
| Engine import adapters | threeMaterialSource (TSL), godotShaderSource |
Shipped: shader sources with wind, window glow, wear. Planned, M3: import settings and collision naming per engine, as hooks, not runtime | — |
Every stage has zero runtime dependencies (ADR 005).
Status: early (0.x). The core loop works: write, build, QA, shot, hero, review, with textures, trees, sculpt, terrain and the gallery's passing recipes. Still declared and throwing
T3D_NOT_IMPLEMENTED(As of 2026-11): none in/neural. Flagship realism is in progress: calibrated critique scores sit near 6 of 10 (target 8.5, floor not yet enforced); hybrid heads are in progress; the wolf, bear and dragon model tiers ship (no wing motion, gallop, jaw or blink yet). Shipped neural-module pieces:importGlb,importModel,refine,t3d finish --model http, neural adapters (http, ComfyUI, OpenAI-compatible images, kubeez.com, Meshy, mock), theblenderstep task, the committed recipe cache with local outputs andlocalGenerator. See the roadmap. Expect breaking changes.
import { axle, box, defineAsset, palettes } from '@developerz.ai/ts23d';
const { paint, iron, trim } = palettes.victorianRail;
export const handcart = defineAsset({
name: 'handcart',
kind: 'vehicle',
budget: { triangles: [2000, 800, 300] }, // LOD0 / LOD1 / LOD2 ceilings, enforced by QA
build(ctx) {
for (const [i, x] of [0.8, -0.8].entries()) {
axle(ctx, { name: `axle_${i}`, at: [x, 0, 0.35], radius: 0.35, gauge: 1.2,
width: 0.08, color: iron, rps: 1 }); // wheels spin in the baked clip
// a fixed beam between the wheels (1 cm running clearance each side) carries the bed
ctx.part(`beam_${i}`, box({ size: [0.08, 1.1, 0.08], at: [x, 0, 0.31], color: iron }));
}
ctx.part('bed', box({ size: [2.4, 1, 0.12], at: [0, 0, 0.39], color: trim, strip: 'wood' }));
const posts = ctx.lod === 2 ? 2 : 6; // LOD drops detail; it never decimates
for (let i = 0; i < posts; i++) {
const x = -1.1 + (2.2 * i) / (posts - 1);
ctx.part(`post_${i}`, box({ size: [0.08, 0.08, 0.5], at: [x, 0.46, 0.51], color: paint }));
}
},
});Metres, Z up, +X is the front. Loops, functions and types, because a recipe is code, not data (why).
t3d shot recipes/tiger_1/tiger_1.ts → out/tiger_1/sheet.png, from recipes/tiger_1/tiger_1.ts. Every recipe folder commits its sheet, hero render and manifest under out/:
Header: name, bounding box in metres, grid step, LOD. Row 1: 3/4 front, front (+X), side (−Y).
Row 2: top, 3/4 rear, LOD2 at distance. Layout: docs/idea/05-agent-loop.md.
t3d hero adds the beauty shot, and t3d review packs hero, sheet, close-ups, an LOD strip and a
checklist prompt into out/<asset>/review/ for a second, fresh-eyes vision pass.
One shared 2048² trim sheet holds 24 physically based materials: oak, pine, weathered and painted
wood; rusty, cast, painted and galvanised iron and steel; brass, copper, aluminium, chrome; rubber,
canvas, leather, plastic; plus brick, stone, slate, concrete and glass. Each has its own roughness and
metalness, so chrome mirrors and wood stays matte. Projects add their own with defineMaterial, or
pull a CC0 photo set from Poly Haven with bun run textures (hash-pinned, credited in the GLB). See
materials.md.
Needs Bun ≥ 1.4.4: the CLI (t3d) runs on Bun. The library (compile, runQa, toGlb, …) also imports under Node ≥ 22 (As of 2026-11; the pack smoke test proves both). Write assets in your project, e.g. assets/<name>/<name>.ts.
bun add @developerz.ai/ts23d
bunx -p @developerz.ai/ts23d t3d build assets/<name>/<name>.ts # GLB × 3 LODs + sheet + manifest per asset; exit 1 on a QA finding
bunx -p @developerz.ai/ts23d t3d shot assets/<name>/<name>.ts # sheet + manifest only: the fast look
bunx -p @developerz.ai/ts23d t3d hero assets/<name>/<name>.ts # beauty render: textured, lit, soft shadows (1600×900)
bunx -p @developerz.ai/ts23d t3d review assets/<name>/<name>.ts # AI review pack: hero, sheet, close-ups, LOD strip, review.md
bunx -p @developerz.ai/ts23d t3d tune assets/<name>/<name>.ts --evals 400 # fit tune.params to objectives → tune.json, tune-report.md, tune-strip.png
bunx -p @developerz.ai/ts23d t3d finish assets/<name>/<name>.ts --endpoint URL --prompt "…" # optional AI texture layer on LOD0
bunx -p @developerz.ai/ts23d t3d list assets/*/*.ts --json # the assets each module exports (one JSON envelope)
bunx -p @developerz.ai/ts23d t3d --version # also: t3d <command> --help| Flag | Effect |
|---|---|
--out <dir> |
Output directory (default out) |
--no-shot |
build without rendering the contact sheet |
--sheet external|embed|none |
Trim-sheet textures. external (default): out/trim_sheet_{albedo,normal,orm}.png written once, every GLB references ../trim_sheet_*.png; an asset whose material sits on a row the shared sheet already shows another material on (this run or an earlier one into the same --out, recorded in trim_sheet_owners.json) gets its own out/<asset>/trim_sheet_*.png. embed: inside each GLB. none: vertex colour only |
--sheet-size 512|1024|2048 |
Sheet resolution (default 1024) |
--lods 0,1,2 |
Which detail levels to build (default all three). --lods 0 = hero mesh only, --lods 0,2 = near + far. QA and the manifest cover exactly what was built |
--no-animations |
Skip the baked run clip. t3d build bakes it by default so viewers (e.g. VS Code glTF Tools) show play controls |
--json |
One envelope on stdout: { ok: true, data } or { ok: false, error: { code, message, fix } } (a multi-recipe run with failures also carries data). Errors go to stdout in this mode |
--timeout <s> |
finish only: seconds to wait for the model endpoint (default 300) |
Output, one folder per asset (stable paths for agents and pipelines):
out/
├── index.json every asset built in this run, with its QA verdict
└── <asset>/
├── lod0.glb lod1.glb lod2.glb
├── hero.png the beauty render
├── sheet.png the contact sheet
└── manifest.json files (paths relative to the manifest) and `lods`; triangles + draw
calls per LOD; pivots, emitters, sockets, surfaces; real + measures
with measured values; sources; QA
Library calls differ on one default: toGlb(asset) exports no animation unless { animations: true }. manifestOf shares that default: pass { animations: true } as its last argument when the GLBs were exported with it.
Every exported asset in a module is built (defineAsset or family.variant). Every CLI error (missing file, throwing recipe, unknown flag, duplicate asset name) prints a stable T3D_* code and its fix:; exit 0 = ok, 1 = QA finding or build error, 2 = usage error (errors).
t3d is a convenience. Everything it does is a function call: compile, QA, export, render.
A plain script builds exactly what you want, and the same code runs in Node ≥ 22 (against the
built dist/), in a browser, or in a Web Worker (the asset gallery
compiles every recipe in a worker).
// build.ts → bun build.ts
import { compile, contactSheet, DEFAULT_SHEET, runQa, sheetFor, toGlb } from '@developerz.ai/ts23d';
import { tiger_1 } from './recipes/tiger_1/tiger_1.ts';
const lods = ([0, 2] as const).map((lod) => compile(tiger_1, { lod })); // only the detail levels you need
const sheet = sheetFor(lods, { ...DEFAULT_SHEET, size: 512 }); // this asset's own trim sheet
for (const asset of lods) {
const findings = runQa(asset); // gate it your way, or skip it
if (findings.length) throw new Error(findings.map((f) => `${f.message} — fix: ${f.fix}`).join('\n'));
await Bun.write(`out/tiger_1.lod${asset.lod}.glb`, toGlb(asset, { sheet, animations: true }));
}
await Bun.write('out/tiger_1.png', contactSheet(lods[0] ?? compile(tiger_1), { sheet })); // for your agent's eyesRunnable copy: examples/build-with-bun.ts — executed in CI, so this path can't rot.
| Building block | What it gives you |
|---|---|
compile(asset, { lod, seed }) |
the compiled parts for one LOD (deterministic) |
runQa(compiled) / single gates / inspect(compiled) |
findings with fixes; geometry queries for your own checks |
toGlb(compiled, { sheet, animations, keepParts }) |
GLB bytes (Uint8Array) — write them anywhere |
mergeToPivots(compiled) |
the batched part list the GLB uses (draw calls = movable parts) |
contactSheet(compiled, { far, cell, sheet }) |
six-view PNG bytes; with sheet in the hero's base colours, without it vertex colour only |
sheetFor(compiled, recipe) + sheetPngs(sheet) |
the asset's own texture set (albedo / normal / ORM) as RGBA or PNG |
threeMaterialSource(hints) / godotShaderSource(hints) |
shader source strings for your engine |
manifest data |
build it from compiled.parts (pivots, emitters, sockets) — see src/cli/manifest.ts |
The docs ship inside the package, versioned with the code, readable offline. After bun add, everything an agent needs is at node_modules/@developerz.ai/ts23d/: CLAUDE.md (the agent brain; the repo's AGENTS.md is a symlink to it and is not in the tarball), llms.txt, docs/, recipes/ (worked examples; the model recipes' neural/ outputs stay in git: from the package ranger and human_head build their CPU tier, and bear_hybrid, wolf_hybrid and dragon_hybrid, which have no CPU build, stop with T3D_NEURAL_MISSING and a fix: that says to clone the repo), CHANGELOG.md and .claude/{skills,agents,commands}.
Point your agent at them. Add to your project's CLAUDE.md or AGENTS.md:
3D assets: @developerz.ai/ts23d. Read node_modules/@developerz.ai/ts23d/CLAUDE.md first;
docs in node_modules/@developerz.ai/ts23d/docs/, example recipes in …/recipes/.Claude Code skill (and the /new-recipe command):
mkdir -p .claude/skills .claude/commands
cp -r node_modules/@developerz.ai/ts23d/.claude/skills/author-recipe .claude/skills/
cp node_modules/@developerz.ai/ts23d/.claude/commands/new-recipe.md .claude/commands/Works with any agent that writes TypeScript and can run a shell: Claude Code, Codex, Cursor, Aider, a local model. If it can read images, it closes the loop on its own. No skill files? Paste this:
Using @developerz.ai/ts23d, write recipes/<name>/<name>.ts: a <thing>, real dimensions in metres,
Z up, +X front. Put the sources in `sources` and the key dimensions in `real.measures`.
Block out the masses, then details. Name every part that moves (axle_*, door_*, rotor_*)
and pivot it where it hinges. Loop until done:
1. bunx -p @developerz.ai/ts23d t3d build recipes/<name>/<name>.ts (fix every finding until it prints QA PASS;
a measures finding means rebuild the part, never edit the spec)
2. Read out/<name>/sheet.png (build writes it).
3. Name the single biggest error, fix it, go to 1.
Stop when two consecutive shots show nothing worth fixing. Never use Math.random; use ctx.rng.
The CLI with --json is the interface; everything else is optional. Each step is one command that prints one JSON envelope ({ ok, data } or { ok: false, error: { code, message, fix } }) and writes PNGs your agent opens:
- Write
assets/<name>/<name>.tsexportingdefineAsset({...}): real sizes in metres, Z up, +X front. bunx -p @developerz.ai/ts23d t3d build assets/<name>/<name>.ts --json: fix every finding (each has afix:) until QA PASS.bunx -p @developerz.ai/ts23d t3d shot …: readout/<name>/sheet.png, name the single worst error, fix it, rebuild.bunx -p @developerz.ai/ts23d t3d hero …/blueprint …: the textured look and the measured drawing.bunx -p @developerz.ai/ts23d t3d review …: readreview/*.png, followreview.md. Thenbunx -p @developerz.ai/ts23d t3d critique ….- Add LOD-gated detail; stop when two looks in a row find nothing worth fixing.
Skills ship in the package as plain markdown: node_modules/@developerz.ai/ts23d/.claude/skills/<skill>/SKILL.md: author-recipe (the loop) and the artist workflows (creature-artist, character-artist, hard-surface-artist, architect, prop-artist, rigger-animator, technical-artist, blender-artist, …). Read them in place, or copy one into your agent's skills folder.
Several agents on one machine take turns. Heavy commands queue machine-wide through ticket files under $TS23D_HOME/queue/ (default ~/.ts23d; no daemon): cpu is weighted tokens (three quarters of the cores; a build takes 1, hero --quality path takes 8), blender and gpu run one job at a time, first come, first served. A waiting command prints t3d queue: waiting for cpu … · running: pid 4242 "t3d hero …" on stderr and then runs; that line is not a failure, so give queued commands a long timeout instead of wrapping them in sleep loops.
| Do | Command |
|---|---|
| See who runs and who waits (per class, plus Blender sessions, GPU lease, load, RAM) | t3d queue status (--json) |
| Queue any other command | t3d queue run [--cpu <n|all>] [--blender] [--gpu] -- <command…> (exit code = the command's) |
| Run alone once the machine has drained | t3d queue hold -- <command…> |
| Drop tickets (ends no process) | t3d queue clear --stale | --pid <n> | --all |
| Refuse instead of waiting | --no-wait or T3D_QUEUE=fail → T3D_QUEUE_BUSY (the machine is busy; the code is not wrong) |
Wait at most <s> seconds (default 1800) |
--max-wait <s> or T3D_QUEUE_MAX_WAIT=<s> → T3D_QUEUE_TIMEOUT, naming who is ahead |
| Switch it off | T3D_QUEUE=off (it is off whenever CI is set) |
A dead or killed command frees its place by itself; a queue that cannot be written prints one warning and the command runs unqueued. Machine settings: $TS23D_HOME/queue.json, e.g. {"capacity":{"cpu":12},"weights":{"pathHero":4}}. t3d doctor has a queue group. Why it works this way: ADR 017.
Optional: MCP server. t3d mcp serves the same steps over stdio (MCP 2025-06-18) as tools: build, shot, hero, blueprint, review, critique, list_recipes, explain_error. Renders come back as images the agent sees inline (downscaled to 1024 px; extra review images listed by path). Tools read and write only inside the project root and its output folder (--root, --out); errors come back as T3D_* code + fix and the server stays up.
bun add @developerz.ai/ts23d
claude mcp add ts23d -- bunx -p @developerz.ai/ts23d t3d mcp # Claude Code, from the project rootOther MCP clients (Claude Desktop, Cursor, …): command bunx, args ["-p", "@developerz.ai/ts23d", "t3d", "mcp", "--root", "/path/to/project"]. Use -p: a bare bunx t3d outside a project with the package installed fetches an unrelated npm package named t3d.
Optional GPU tier: any model plugs in through a NeuralAdapter for the tasks image, mesh, texture, rig, motion, hair, score. Shipped adapters: http (the t3d-neural/1 protocol), comfyAdapter (your ComfyUI workflow), openaiImage (any OpenAI-compatible images endpoint) and mockAdapter. Name them in t3d.config.ts:
import { defineConfig, http } from '@developerz.ai/ts23d';
export const config = defineConfig({ neural: { mesh: http('http://gpu:8190', 'pixal3d') } });t3d neural ls lists the models; t3d neural run recipes/oak/oak.ts runs what the recipe asks for and commits the outputs to recipes/oak/neural/<key>/ with a record.json (model, licence, weights hash, request, output hashes; 12 MB of committed bytes per recipe, big intermediates kept local with { keep: 'local' }: git-ignored, only their sha256 is committed, so a fresh clone still resolves the chain). A chain (image, mesh, rig, Blender) fills over up to 5 rounds of t3d neural run; a request that only appears after the fifth is listed as T3D_NEURAL_MISSING (run again to go on). Builds and CI never call a model: a hit replays the committed bytes, a miss falls back to the CPU path with a T3D_NEURAL_MISSING notice (an error with --require-neural). Every output is validated before use. Licences are recorded, never gated for your builds.
No GPU? For the image task, ts23d ships an adapter for kubeez.com, a hosted image-generation service. Disclosure: we work with Kubeez as a partner; any other adapter works the same way.
import { defineConfig, kubeezAdapter } from '@developerz.ai/ts23d';
export const config = defineConfig({ neural: { image: kubeezAdapter({ apiKey: process.env.KUBEEZ_API_KEY }) } });The key stays in your environment: it is sent only as a request header, never written to record.json, the cache, logs or errors. Outputs are recorded with licence own and the Kubeez terms. Kubeez is billed per image: t3d neural run prices each job at the model's listed cost and refuses a run above 50 credits, or one it cannot price, without --yes-spend.
For the mesh task without a GPU, meshyAdapter({ apiKey: process.env.MESHY_API_KEY }) runs image-to-3D (or text-to-3D from a prompt) on meshy.ai, a hosted service billed in credits; the key is handled the same way. The same adapter runs the rig task (rigging, plus library animation clips by name) and the texture task (retexture); t3d neural run prints the credit balance and an estimate per request and refuses a run estimated above 50 credits without --yes-spend. The ranger's chain cost 44 credits (30 mesh, 14 rig and three clips; measured 2026-11-16). API keys come only with paid plans, whose outputs you own: records carry licence own, the Meshy terms and the credits Meshy charged. A created task id is kept in $TS23D_HOME/meshy/pending.json until its GLB is downloaded, so a rerun after a timeout resumes the same task instead of paying again.
Details: docs/idea/08-neural-adapters.md, ADRs 014 and 015.
As of 2026-11. All CPU, deterministic, no model needed unless stated.
| Command | What it does |
|---|---|
t3d init --engine godot|three|unity|unreal|babylon |
Scaffolds assets/, style.ts, PLAN.md, t3d.config.ts in a game project; never overwrites |
t3d plan check |
assets/PLAN.md vs recipes: missing, extra, over budget |
t3d build --watch |
Rebuilds changed recipes (and dependants) on save; keeps running on a failing recipe |
t3d hero --quality path |
Deterministic CPU path-traced beauty render (subsurface skin, hair lobes, denoise); slower than the raster default |
t3d finish --hero |
Hero texture tier: bakes normal, AO, height and ORM from the sculpt field onto a lighter LOD0 (ADR 012) |
t3d concept <recipe.ts|brief.md> |
Silhouette sheet and concept images from the configured image model (needs an image adapter); prompts and seeds land in concept.ts |
t3d blender session start --mesh <glb> |
Keeps one Blender open: run <batch.json> chains steps, undo goes back a batch, finish --out <program.json> writes the steps for a clean t3d neural run replay, stop ends it |
t3d blender review <recipe.ts> --out <dir> |
Runs the recipe's Blender step program with a review step and writes clay, wire, weights, poses and turnaround PNGs plus review.md (needs Blender; t3d setup tools; never cached, never in a build); or --mesh <glb> --program <json> |
t3d neural run --allow-bad-input |
Sends mesh input images that fail the input-image rules anyway; the override is recorded in record.json |
Creatures export a skinned skeleton (weights from the sculpt's own bone fields, at most 4 influences) with walk, trot and gallop clips; the skin, deform and gait gates fail a build whose joints tear or feet slide. The gallery shows a "CPU tier / Model tier" switch for assets that have a committed model tier (textured parts included), with model and licence credits read from record.json.
Nothing here is needed to build assets. Three commands install and run the tools and models on your own machine:
bunx -p @developerz.ai/ts23d t3d doctor # what is here, what is missing, the exact fix for each (--json for agents)
bunx -p @developerz.ai/ts23d t3d setup gpu-full # or: tools (no GPU) · gpu-min (8 GB+); --dry-run prints the plan first
bunx -p @developerz.ai/ts23d t3d server start # the reference model server on 127.0.0.1:8190 (status · stop)| Profile | Needs | Installs |
|---|---|---|
tools |
nothing | bpy 5.2.4 (Blender as a module), Godot 4.7.2 headless, basisu 2.50 (built from source), gltfpack 1.3, Material Maker 1.8 |
gpu-min |
NVIDIA, 8 GB+ | TRELLIS.2 GGUF through ComfyUI (low VRAM), DINOv2 scoring |
gpu-full |
NVIDIA, 24 GB+ | Pixal3D, TRELLIS.2, DINOv2 on torch 2.6 + CUDA 12.4 (local toolkit, no root); optional video-motion, UniRig, UniMate, HairDeck |
The Blender step task runs on the bpy module or a Blender app (4.5 LTS, 5.2 LTS or 5.3 accepted; the step ops were run on 5.3.0 and bpy 5.2.4); review renders need a machine with a GPU (checked on one RTX 3090 only). Everything lands in ~/.ts23d (or $TS23D_HOME); uninstall is deleting that folder. No sudo, nothing system-wide; every step checks what is already there, so a re-run is a no-op and an interrupted run resumes. Downloads are version- and hash-pinned. Weights go to $HF_HOME (default ~/.ts23d/hf); HF_TOKEN is read from your shell and never stored or printed; gated licences are listed with their URLs. GPU profiles write a t3d.config.ts pointing at the local server when the project has none. Linux and WSL2 today; macOS (tools only) is planned. No GPU: t3d doctor points the image task at kubeez.com (partner, see above); mesh, rig and motion stay on the CPU tier. The installer and server live in examples/neural-server/ (from a clone; set TS23D_SERVER_DIR when using the npm package).
As of 2026-10. Full matrix: docs/idea/07-what-fits.md.
| Fit | Asset categories |
|---|---|
| Strong | Hard-surface props, architecture (facades, towers), vehicles (tracked, wheeled, rail), modular kits, anything with real dimensions or repeated parts |
| Shipped, early | Vegetation: Weber–Penn trees (oak, pine, palm, birch, willow); LOD2 is the tree's own crown as card clumps over the trunk (oak, pine and palm hold 0.8 of the near silhouette; birch and willow less) |
| Shipped, early | Stylised organic: sculpt busts, SDF rocks and asteroids, eroded terrain. Boats: lofted hull |
| Shipped, early | Stylised creatures: creature() over a skeleton with per-family biology (recipes/wolf); animal research |
| Shipped, early | Model-first humanoids: recipes/ranger, an image-to-3D body with the rig service's skin and clips, finished by Blender steps (As of 2026-11: QA PASS; no finger bones, no blink or jaw, hair as sculpted clumps) |
| Planned | Model-first creatures that move more: recipes/wolf_hybrid, recipes/bear_hybrid and recipes/dragon_hybrid ship on the model tier (As of 2026-11); wing bones, gallop, jaw and blink on a model body are planned |
| Weak | Realistic people and animals as pure code. Use the model tier (a model on your own GPU or a hosted one through a NeuralAdapter, finished by Blender steps, t3d neural run), with the result committed to the recipe's cache; or an image-to-3D tool on its own |
Not a replacement for AI mesh generators: a different approach with different strengths. Neutral comparison: docs/landscape.md.
https://developerz-ai.github.io/ts23d/: every recipe in recipes/, filterable by category (vehicles, railway, architecture, nature and terrain, characters, sci-fi). The grid shows the committed renders; opening an asset compiles it in your browser with an orbit viewer, LOD switch, wireframe, its motion, a scene, named parts, measures against the real spec, the recipe source and GLB downloads.
Each recipe is a folder: recipes/<name>/<name>.ts (the asset), README.md (the reference dossier: sources, specs, photo links) and out/<asset>/ (committed hero.png, sheet.png, manifest.json).
| Read | For |
|---|---|
| docs/README.md | The index |
| docs/idea/ | Vision, DSL, IR, materials, agent loop, QA, kinds |
| docs/decisions/ | Why: ADRs with the rejected options |
| docs/architecture/ | Module tiers, adding a primitive or kind, error codes |
| docs/plans/roadmap.md | M0–M6 |
| CONTRIBUTING.md | bun run setup, bun run verify |
| kubeez.com | Partner. Generate reference and concept images, decals and texture source images. The sheet painter's image-stamped cells will consume them (planned) (materials) |
| developerz.ai | 100% AI-managed software engineering. ts23d is built and maintained by AI agents |
ts23d is maintained by AI: by developerz.ai, the way a human maintainer
looks after an open-source project, and built to run that way for years with no human in the loop.
The agent works publicly as developerz-ai[bot] and marks everything it posts as bot-made. Its
policy is committed in .dz/maintainer/maintainer.yml, and
CLAUDE.md binds it: no policy line relaxes a rule there.
| What arrives | What happens |
|---|---|
| an issue | triaged; asked for a reproduction when one is missing; a real bug is fixed from a failing test and released |
| a pull request | reviewed, driven to a green verify (lint, types, boundaries, determinism, tests, every recipe's QA, pack smoke), merged |
| a recipe change | merged only with its refreshed contact sheet and hero; QA failures are fixed in the geometry, never by loosening a gate |
| Dependabot | driven to green and merged; every bump waits 14 days after upstream publishes it (security updates excepted) |
| an outside change to CI, release or publish automation | declined: the npm OIDC pipeline is the maintainers' |
a change that breaks a rule in CLAUDE.md (game code, runtime deps, decimation, non-determinism) |
declined with the rule quoted |
Scheduled checkups, briefs in .dz/briefs/: daily health catches what nothing
announces (red main, a gallery that did not deploy, a release npm does not serve); daily
security-release ships a confirmed advisory fix the same day; weekly release-due judges whether
users get something and cuts the release; monthly improve lands up to three evidenced
improvements; monthly cleanup sweeps branches, stale plans, weight, links, dead code, moves the
Bun pin and, each January, reviews what a year wears out. docs/maintenance.md
lists what decays over a decade and which lane catches each.
MIT. Outputs are yours: no attribution, no licence conditions on generated assets.
Third-party data in the library: the vector lettering faces (text({ font: 'sans' | 'serif' | 'script' | 'gothic' })) embed the Hershey fonts. The Hershey Fonts were originally created by Dr. A. V. Hershey while working at the U. S. National Bureau of Standards; the format of the font data was originally created by James Hurt, Cognition, Inc. The acknowledgements travel with the data in src/primitives/font-hershey-*.ts, as their licence asks; the CC0 MakeHuman hm08 head mesh behind recipes/_lib/face is credited the same way. Both are listed in NOTICE.




























