
Create 3D Game Models for Free: Opus 5.5 + Blender + Tripo (15 Steps)
A complete 15-step workflow for procedural Blender props, local or Tripo-generated characters, deterministic rigging, pose tests, code-authored clips, and game-engine export.
You can build game-ready 3D assets without paying a generator for every prop. Blender is free, and Opus 5.5 can write the Python that constructs measurable objects: weapons, crates, furniture, buildings, vehicles, and whole street blocks. For organic characters, the route changes. A local image-to-3D model can run on your own GPU, or Tripo can produce a textured multiview model for roughly $0.20 to $0.60. Rigging, weight repair, animation, validation, and export all remain inside Blender.
The word "free" needs a boundary. The Python prop route has no per-model generator fee, but it still requires a paid Claude plan for Opus or Sonnet. The local route still requires a capable GPU and electricity. Tripo still charges for successful generations. Only the narrow claim is true: once the authoring tools are available, procedurally generated props do not incur a separate charge for each model.
This guide also addresses the two failures readers ask about most often: why low-poly props made from an AI reference sheet turn into floating boxes, and why a Tripo character's clothes stretch as soon as the rig moves. Both have specific causes. Perspective reference images make coordinate guessing inevitable, and automatic weights cannot distinguish a coat from the torso when a generator has fused them into one shell.
What you need once
- Install Blender and Claude Code. Run each prompt below from the terminal while working in one project folder. Opus writes the Python, starts Blender in background mode, and opens the renders it produces.
- Tell Claude where the Blender executable lives. On macOS the path is
/Applications/Blender.app/Contents/MacOS/Blender. Put the invocation rule inCLAUDE.md:Run Blender as: blender -b file.blend --python script.py. - Save each stage as a reusable
.pyfile. A procedural object is worth keeping only if you can change one number and rerun the same build.
Terms used in the workflow
- Mesh: the 3D shape itself, made from vertices, edges, and triangles. GLB and FBX are container formats used to save and exchange it.
- Orthographic view: a flat, non-perspective view that preserves scale, like a technical blueprint.
- UV and texture: the flat image coordinates wrapped onto the mesh. A normal map is a texture that adds the appearance of small surface detail without adding geometry.
- Decimate: reduce the triangle count. Keep a high-detail source and derive lower-detail copies when needed.
- Armature or rig: the skeleton. Weights: the influence each bone has on each vertex.
- Rest pose: the pose in which the skeleton is built. An A-pose places the arms down at roughly 45 degrees.
- IK: inverse kinematics. The foot or hand stays planted while the leg or arm bends to reach that target.
The route at a glance
flowchart LR
A[Measurable prop, building, or vehicle] --> B[Orthographic views]
B --> C[Write dimensions and part list]
C --> D[Blender Python, one part per prompt]
D --> E[Assembly and export checks]
F[Organic character or creature] --> G{Generator}
G -->|Own NVIDIA GPU| H[Hunyuan3D local multiview]
G -->|Paid API| I[Tripo multiview]
H --> J[Clean and decimate GLB]
I --> J
E --> K[Unity or Roblox]
J --> L[Split shell into semantic parts]
L --> M[Place joints]
M --> N[Rule-based weights]
N --> O[Pose-test and repair seams]
O --> P[Write loops and action clips]
P --> Q[Numeric animation checks]
Q --> K
The decision rule is simple: use code for anything you could measure with a ruler; use a generator for anything you would otherwise have to sculpt.
Cost boundary: Claude access is a recurring tool cost. A local Hunyuan3D run requires suitable hardware. Tripo charges successful API tasks. Python-generated props are the only route with no additional fee per model.
Part 1: Pick the production route
Step 1. Pick the route by object type
Python in Blender is the strongest route for guns, crates, houses, city blocks, vehicles, and furniture. It gives exact dimensions, predictable topology, low triangle counts, and parameters you can edit numerically. It is weak at copying an organic silhouette from a picture. Ask Opus to build a human character purely from code and the result usually looks like a toy robot rather than the concept art.
A local GPU generator such as Hunyuan3D 2.0 can produce geometry and texture from a character sheet in a few minutes per model. The official requirement for shape plus texture is 16 GB of VRAM. A portable Windows build can run on an 8 GB laptop GPU, but the tradeoffs are softer faces, hands fused to objects they hold, and a practical cap around 40,000 faces. The licence excludes the European Union, the United Kingdom, and South Korea; verify the current licence before commercial use.
Tripo's API is the paid convenience route. One credit costs $0.01. A multiview model costs 20 to 30 credits as bare geometry, plus 10 to 30 for texture. A detailed textured result typically lands near 60 credits, or $0.60. Failed and cancelled tasks are not charged. Tripo also sells retopology for 10 to 40 credits and auto-rigging for 25 credits, but this workflow does both in Blender without those add-on charges.
| Route | Best input | Direct model cost | Main constraint |
|---|---|---|---|
| Blender plus Python | Measurable man-made objects | No per-model generator fee | Requires a Claude plan and code review; organic shapes are weak |
| Hunyuan3D local | Characters, creatures, sculptural shapes | No per-model API fee | 16 GB VRAM officially; 8 GB portable build is softer; regional licence limits |
| Tripo API | Fast textured multiview characters | Typically $0.20 to $0.60 | Credits, API integration, and view quality directly affect the result |
Part 2: Low-poly props in pure code
Step 2. Make a reference you can measure
A generic AI reference sheet shows the object in perspective, with shadows, reflections, and inconsistent views. A bipod may be folded in the side drawing and open in the three-quarter picture. Claude can inspect that image, but it cannot derive reliable dimensions from it. It guesses coordinates, and the guessed assembly develops gaps.
Generate flat orthographic front, side, top, and rear views whenever possible. Ask for the same scale in every view and no cropping. If only one image contains several views, cut it into separate files first. If a view is missing, state the missing dimension manually, such as "the stock is 5 cm wide."
Prompt 1 of 17: orthographic reference view
Orthographic side view of [object], exactly side-on, no perspective.
Plain white background, flat colours, no shadows, no reflections.
Same scale as the front and top views. Nothing cut off at the edges.
Step 3. Write the numbers before any geometry
Do not let the first modelling prompt invent dimensions while it also builds mesh. First produce a human-readable parts table. Every part needs a start and end along the object's length, its height and width, colour, and attachment target. Review that table before geometry exists. A wrong number costs one edit before modelling; discovering it after a procedural build costs a full rework.
Prompt 2 of 17: create the parts specification
Read side.png and front.png. Before modelling anything, write parts.json:
every part of the [rifle] with its start and end along the length in cm
(from the back end), its height, width, colour and which part it attaches to.
Show me the list and wait for my OK.
Step 4. Fix the rules, then build one part per prompt
Put persistent constraints in CLAUDE.md instead of repeating them in every part request. These rules define units, origin, forward axis, polygon budget, material policy, bevel size, render size, and the maximum number of automatic fix rounds.
Prompt 3 of 17: reusable prop rules
# Props rules
- Units: metres. Origin at the base centre. Forward is -Y.
- Budget: [2,000] triangles for the whole prop.
- Max 3 materials, flat colours, no image textures.
- Bevel hard edges 2 mm, 1 segment. Apply all modifiers before export.
- Renders: 768 px, orthographic, the same view as the reference, side by side with it.
- Max 3 fix rounds per part, then stop and show me.
Build one part per fresh session. A whole-prop brief causes every correction to rerender the complete object, and those images quickly consume the model's context window. Use Sonnet for simple boxes, barrels, and planks; reserve Opus for outlines and joints where geometric judgment matters more.
Prompt 4 of 17: model one part with bmesh
Build part "stock" from parts.json with bmesh in a Blender script.
For its outline: threshold side.png, trace the contour, simplify to about 30 points,
extrude to its width, bevel. Render next to the reference and list the differences
in cm. Fix and rerender, max 3 rounds.
Step 5. Check the assembly, then export
An assembly check should test geometric claims, not merely open a render. Print the gap between every part and the part it attaches to, require zero for mating surfaces, compare the assembled bounding box against parts.json, count triangles, and render front, side, and three-quarter views. Export both FBX and GLB with modifiers applied.
Prompt 5 of 17: assembly and export validation
Load all parts. For every part print the gap to the part it attaches to
(must be 0, no floating parts), the total triangle count and the bounding size
against parts.json. Render front, side and 3/4 views and open them.
Export FBX and GLB with modifiers applied.
For buildings and whole streets, request a generator rather than one-off models. A parameterized function can vary width, depth, floors, roof type, and colour, place windows and doors by rule, and produce ten seeded variants from one code path.
Prompt 6 of 17: procedural building generator
Write buildings.py: one function per building type (house, shop, tower) with
width, depth, floors, roof type and colour as parameters, windows and a door
placed by rule, flat colours. Build 10 variants from different seeds,
export each as GLB, render them in a row and open it.
Do not send long, thin street objects such as buses and fences to an image-to-3D generator. Those models often return an almost square footprint, so stretching the generated mesh to its real length flattens it. Their textures also become noisy where a procedural route can use clean flat colours and exact dimensions.
Part 3: Characters from a generator
Step 6. Draw the sheet for the generator
The character sheet should contain true front, right-side, and back views at the same scale and height, in an A-pose, with arms separated from the body and legs apart. Use an orthographic camera, flat even light, and no cast shadows. Draw empty hands. Anything held in a hand tends to melt into the generated hand, and the fused geometry cannot be cleanly separated afterward. Make weapons and props on separate sheets.
Image tools sometimes create a "left" view by mirroring the right view. That can move a strap, holster, or weapon to the wrong side. Send only anatomically consistent views.
Prompt 7 of 17: character turnaround sheet
Character turnaround sheet: front, right side, back. Orthographic, same height,
A-pose, arms away from the body, legs apart. Empty hands: no weapon, no lantern,
no bag in hand. Light grey background, flat even light, no shadows.
Name the colour of every piece of clothing.
Step 7. Put every view in its correct slot
Cut the sheet into view_front.png, view_right.png, and view_back.png. Each file should contain one view and preserve the same height. Tripo's multiview endpoint accepts up to four images in the order front, left, back, right. Front is required, and two views are the minimum. A side view placed in the wrong slot can produce a second face on the back of the head.
Tripo requires an API key from its developer platform and sufficient credits. Store the key in an environment variable. Ask Claude to write a small client from the current API documentation: upload the images, start a multiview task, poll the job, and download the GLB when it succeeds. Failed and cancelled tasks are not charged, but a bad front view wastes a successful run.
Prompt 8 of 17: submit a Tripo multiview task
Send view_front.png, view_right.png and view_back.png to Tripo multiview,
each in its own slot, left slot empty. Texture and PBR on.
When the model is ready, render it from the front and from the back
and tell me on which render the face is.
For a local Windows route with an NVIDIA GPU, run Hunyuan3D-2-WinPortable, which starts a local server on port 8080. Send the same validated views in multiview mode with texture enabled and save the GLB. On an 8 GB laptop GPU, the author measured about four minutes per character.
To reduce paid retries, inspect every input view before submission. For background characters that will be painted flat in the engine, skip expensive detailed texture generation. The earlier guide linked below contains a working client script and request body.
Related source: the earlier Tripo client walkthrough.
Step 8. Clean the mesh before adding a bone
Generated geometry needs a deterministic cleanup pass. Orient the model to the engine's forward axis, put the feet at zero, set the target height, apply transforms, merge coincident seam vertices, recalculate normals, identify holes and zero-length normals, and derive a decimated copy that preserves UVs and receives baked colour and normal maps.
Polygon budgets depend on the role. Roblox allows up to 20,000 triangles per mesh. A Unity hero can often afford 40,000 to 70,000. Crowd copies should sit near 3,000. Tripo GLBs arrive facing +X, so rotate them to the project's forward axis before export.
Merge vertices before weighting. Duplicated vertices along seams can receive different bone weights and tear apart under motion. The face-count reduction is not optional for crowds: the author rendered 238 full-resolution models at 9 fps, then introduced 3,000-triangle copies to restore usable performance.
Prompt 9 of 17: clean, validate, and decimate a GLB
Clean model.glb with a Blender script:
1. Turn it to face the engine's forward axis, feet on 0, height [1.15] m, apply transforms.
2. Merge vertices by distance and print the count of loose parts.
3. Recalculate normals; list flipped faces, holes and zero-length normals.
4. Decimate a copy to [budget] triangles, keep its UVs, and bake the base colour
and a normal map from the original onto it.
5. Render front, side and back with a 5 cm grid and open them.
| Use | Triangle target | Reason |
|---|---|---|
| Roblox mesh | Up to 20,000 | Platform limit per mesh |
| Unity hero character | 40,000 to 70,000 | Camera-facing detail |
| Crowd instance | About 3,000 | 238 full models ran at only 9 fps |
Part 4: Rig without stretching the clothes
A generator usually returns one fused shell. The coat is welded to the legs; the sleeves are welded to the hands. Automatic weights cannot infer that a surface is clothing rather than skin, so raising an arm pulls the coat and chest with it. The fix is not to paint weights more carefully over the original shell. Split the shell into semantic parts, define joints from measured positions, apply rules, and test the result numerically.
Step 9. Split the shell into parts
Tag every face as exactly one semantic part: head, torso, left and right arms, hands, legs, plus clothing such as coat, scarf, and belt. Use both texture colour and spatial position. Colour alone fails when, for example, a dark patch of coat shares the scarf's colour and is assigned to the scarf, leaving a hole in the back.
Where two parts merely touch, split the edge. A hand touching the coat must not share topology with the coat; a coat touching a leg must not share topology with the leg. Render a flat colour assignment from front and back before rigging so semantic mistakes are visible while they are still cheap to correct.
Prompt 10 of 17: split and label the fused shell
Tag every face as one part: head, torso, arm L/R, hand L/R, leg L/R, [coat, scarf, belt].
Use the texture colour and the position on the body.
Where two parts only touch (hand on coat, coat on leg), split the edge.
Render one flat colour per part, front and back, and open it.
Step 10. Read the joints from a measured grid
Place joints on an orthographic front and side render with a 5 cm grid and labelled axes. Write hips, spine, chest, neck, head, shoulders, elbows, wrists, knees, ankles, and toes into joints.json in metres. Draw the planned joint positions back onto the renders and inspect them before creating the armature. A shoulder three centimetres too high can stretch the entire sleeve.
Use Mixamo-compatible names such as Hips, Spine, and LeftArm. Unity's Humanoid importer can then map the rig automatically. Animals follow the same process with their own spine, tail, and four-leg joints, but import as Generic.
Prompt 11 of 17: define joints on a grid
Render the model orthographic, front and side, 5 cm grid, labelled axes.
Write hips, spine, chest, neck, head, shoulders, elbows, wrists, knees, ankles
and toes to joints.json in metres. Draw them as dots on the renders and open them.
Step 11. Set weights by rules
Automatic weights can provide a starting point, but semantic rules must correct the result. Torso and outerwear should have zero influence from every arm bone. The head bone should move only head and hair. Each hand should be fully weighted to its corresponding hand bone, and the head fully to Head. Belts, pouches, and sashes should follow Hips. A long coat below the hips should receive two dedicated cloth bones, front and back, parented to Hips.
Clamp each vertex to at most four bone influences, then normalize. Save the correction as a script so every later split or geometry change can rerun the same weighting policy.
Prompt 12 of 17: rule-based weighting
Build the armature on joints.json. Long cloth below the hips gets 2 bones of its own,
front and back, children of Hips. Bind with automatic weights, then fix in code:
- torso and [collar, scarf, coat] get 0 on every arm bone
- the head bone moves only head and hair
- each hand is 100% on its hand bone, the head 100% on Head
- belt, pouches and sash go 100% on Hips
- the coat skirt goes on the cloth bones
- max 4 bones per vertex, then normalize
Save it as a script you can rerun after every change.
If automatic weights fail on a generated mesh with holes, bind a voxel-remeshed watertight copy first, then transfer the resulting weights back to the real mesh. Never smooth weights across two semantic parts. Smoothing leaks the hand bone into the coat and can pull a sharp spike out of it. Smooth only around shoulders, elbows, and knees, and only inside one part.
These rules substantially improve clothing, but they are not universal. On the example model they made the head turn and step worse in two places: the collar, correctly weighted to the chest, intersected the turning head; and hip influence extended too far down the thighs. Those seams required step 12 and vertex-level repair.
Step 12. Test poses and measure the tears
Do not evaluate deformation by watching a single idle frame. Test an arm raise, a forward reach, a step on each leg, and a head turn. Render every pose from front and side. For each pose, compare edge lengths with the rest pose and print the longest stretched edge plus the ten worst vertices and their dominant bones. Fix only the offending region, then rerun. Stop after three rounds and report what remains.
Prompt 13 of 17: stress-test and score the weights
Pose test: arms up 90 degrees, arms forward 60, a step with each leg, head turned 60.
Render each pose front and side. For each pose print the longest stretched edge
against the rest pose and the 10 worst vertices with their bone.
Fix the weights there and rerun. Max 3 rounds, then show me what's left.
Keep shoulder turns near the rest pose for generated characters. The generator rarely creates enough armpit geometry for a large rotation, so a dramatic raise tears the upper arm no matter how clean the weights are. A 40-times edge stretch may become 16 times after rule-based repair, which is a major improvement but still not production-ready. The visual pass remains mandatory because a numerically improved seam can still be unacceptable.
Part 5: Clips and the game engine
Step 13. Write every clip on one rest pose
Store and reuse the exact rest pose for every animation. Define joint limits once: knees and elbows bend in one direction, wrists stop at 60 degrees, each spine bone stops at 30 degrees, and the head turns at most 70 degrees left or right. Build idle and walk clips at 30 fps. Keep feet planted with IK while they are on the ground and bob the hips by 2 cm. The last frame of a loop must match the first exactly.
Prompt 14 of 17: write idle and walk clips
Store the rest pose of this armature; every clip starts from it.
Limits: knees and elbows bend one way, wrists max 60 degrees,
spine max 30 degrees per bone, head max 70 left and right.
Write idle.py (2 s loop, breathing, small weight shift) and walk.py
(exactly two footsteps, 1 s, loop), 30 fps. Feet planted with IK while
on the ground, hips bob 2 cm. The last frame must match the first.
Render a frame sheet of each and open it.
For an action clip, author key poses first and obtain approval before filling in-between frames. Weapons should be attached to bones, not the mesh: a sword as a child of the right hand bone, a shield as a child of the left forearm. Keep feet locked with IK through the strike.
Prompt 15 of 17: author an attack clip
Same rest pose and limits. Write attack_1.py, 0.8 s. Sword is a child of the
right hand bone, shield of the left forearm. Key poses as joint angles: guard,
wind-up, strike, follow-through, guard. Feet locked with IK. Render the key poses
front and side and wait for my OK before adding in-betweens.
Never copy a clip onto a rig with a different rest pose. The animation transforms are interpreted relative to that rig, so the legs can twist immediately even though the source clip looked correct.
Step 14. Check every clip by numbers
Rendered frames do not expose every animation defect. For each clip, print foot slide while a foot is planted, the lowest vertex relative to the floor, the hips-height range, and the difference between the first and last frames of a loop. Mark every failed threshold and render a frame sheet. This catches issues that a flattering camera angle hides.
Prompt 16 of 17: numerical animation validation
For every clip print: foot slide while the foot is planted (cm), the lowest vertex
(must stay above the floor), the hips height range and the difference between
the first and last frame of loops. Render a frame sheet per clip. Mark every failure.
A pose that passes the numeric checks can still look wrong. Use the checks to locate likely problems, then inspect the animation with your own eyes.
Step 15. Export for the target engine
Export the mesh, armature, and clips as FBX. Leave Apply Transform off for a rigged mesh because Blender's own documentation identifies that option as broken with armatures; step 8 has already applied the required object transforms. Turn Add Leaf Bones off and use scale 1. Reimport into an empty scene, play every clip, and print bone count, triangle count, and height as a round-trip check.
Prompt 17 of 17: export and reimport validation
Export character.fbx: mesh, armature and all clips. Apply Transform off,
Add Leaf Bones off, scale 1. Import it back into an empty scene, play every clip
and print the bone count, triangle count and height.
For Unity, choose Humanoid for a two-arm, two-leg, one-head character and Generic for an animal with a named root bone. Set Loop Time on import because FBX does not carry that playback setting.
For Roblox, use File, then Import 3D, and select Rig type Custom for your own skeleton. Keep Zero Influence Bones enabled when using helper bones such as weapon sockets; it is off by default. Bones need scale 1, rotation 0, the root at (0, 0, 0), and no skin weight on Root. Keep at most four bones per vertex. Use 1024-pixel textures as the safe default and OpenGL normal maps. Place a small probe cube in the export and measure it after import because the importer can rescale the entire file.
Related source: the earlier guide covering engine import and animation details.
When it breaks
| Symptom | Cause | Fix |
|---|---|---|
| Prop parts float | The reference sheet was drawn in perspective, so coordinates were guessed | Use orthographic views and write the parts table first; steps 2 and 3 |
| Session limit is hit while modelling one prop | Every fix rerenders the whole prop and fills context with images | Build one part per fresh prompt and use 768-pixel renders; step 4 |
| A second face appears on the back of the head | A view was assigned to the wrong multiview slot | Put each view in the slot for the side it shows; step 7 |
| An extra tail or limb appears | The generator saw only the front and inferred the missing side | Send a true back view as well; step 7 |
| A prop melts into the hand | The prompt sheet showed the character holding the prop | Use empty hands and generate the prop on a separate sheet; step 6 |
| Clothes stretch when the arms move | Torso or coat vertices are influenced by arm bones | Remove arm-bone influence from torso and outerwear; step 11 |
| A spike shoots out of the coat | Weights were smoothed across semantic parts | Smooth only inside one part, near the intended joint; step 11 |
| The head or hips tear while turning | A rigid part meets another bone's weighted region at the seam | Inspect and repair those seam vertices; step 12 |
| Knees twist in a clip | The clip was copied from a rig with a different rest pose | Author every clip on the target armature and rest pose; step 13 |
| Boots point backwards | The generated feet face the wrong direction | Rotate each foot 180 degrees around the shin before rigging |
| White discs or black triangles appear | The surface contains zero-length or invalid normals | Recalculate normals and list flipped faces, holes, and zero-length normals; step 8 |
| Thin wires, text, or logos are missing | The image-to-3D generator dropped sub-pixel-scale features | Model those details procedurally and attach them to the generated asset |
What the complete run used
The girl in the main video came from one Tripo multiview generation costing $0.60. She contains 40,000 faces, 24 body bones plus two cloth bones, and five clips written as code. In Unity, she rows with hand IK attached to the oars.
The city characters in the GPU demonstration cost no per-model API fee: 15 models ran on an 8 GB laptop GPU at roughly four minutes each. Each production version uses about 40,000 triangles, with a 3,000-triangle crowd copy. The performance test is concrete: 238 full models on screen ran at 9 fps, which is why crowd derivatives are part of the pipeline rather than an optional optimization.
The combat clip in step 13 is an authoring pattern, not a clip produced specifically for these example builds.
The choice still comes down to the object. Measurable props, buildings, vehicles, and furniture belong in procedural Python. Organic characters need a generator, either local or paid. Every route should converge on the same deterministic Blender pipeline: cleanup, semantic splitting, joint placement, rule-based weights, stress tests, clips, numeric checks, and a round-trip export.
Source: Kensei, "Create 3D Game Models for Free: Opus 5.5 + Blender + Tripo (15 Steps)" on X, published November 6, 2026. Original thread: @0xKense1. This is a complete English adaptation with added cost and validation tables, a workflow diagram, and expanded troubleshooting; all videos and images are local copies of the source media. The linked earlier guides are Part 1 and Part 2.
Source:Kenseihttps://x.com/i/article/2118709069733105664