Trompe: Code a Whitebox, Texture It with Image Models
The demo that made the rounds on X in late October 2026 was deceptively simple: a prompt goes in, and a textured 3D village comes out. Behind it sits a workflow worth studying more than the output. Trompe—published as an open repo at github.com/Patch-gg/trompe around October 25, 2026, with a demo drawing roughly 199 likes and 8.7k views—stacks three models in sequence: Claude Opus 5.5 builds a Blender whitebox, FLUX 3 Klein and Fibo 2 paint it. This page walks the pipeline step by step, explains why the decomposition works, and catalogs where it still breaks.
The pipeline, step by step
- Step 1: prompt to plan. The text prompt is turned into a scene description the coding model can act on—what the village contains, how it is laid out, what style the textures should target.
- Step 2: Opus 5.5 writes the geometry. Claude Opus 5.5 generates Python that drives Blender, constructing a whitebox/greybox village: buildings as primitive blocks, streets, layout. Because the output is code, iteration is cheap—regenerate the script, rerun, adjust scale or density—rather than sculpting by hand.
- Step 3: FLUX 3 Klein paints surfaces. For each surface to be textured, the image model generates views—walls, roofs, ground—consistent with the planned style.
- Step 4: Fibo 2 and multi-view projection. The multi-view images are projected onto the whitebox geometry, producing textured meshes. Projection is deterministic math, not model output, which is why this stage is reliable once the views are good.
- Step 5: inspect and iterate. Because every stage is code-driven, a bad pass is a rerun: adjust the prompt, the geometry script, or the texture views independently.
Why stacking models beats asking one model for everything
The interesting design decision in Trompe is what it does not attempt. It does not ask an image model to imagine 3D geometry, and it does not ask a language model to paint. Instead it assigns each stage to the model whose training distribution matches the task: coding models like Opus 5.5 are excellent at generating and debugging structured, executable artifacts; image models like FLUX 3 Klein are excellent at appearance; and the geometry-to-texture stitching is handed to deterministic projection plus Fibo 2's multi-view consistency rather than left to hallucination.
The pattern generalizes beyond villages. Any creative pipeline decomposes into structure, appearance, and assembly—and the teams getting real output from generative models are consistently the ones who stop trying to find one model that does all three. Our Claude Opus 5.5 code-driven animation page covers the same decomposition in video: the model writes the code, the renderer—not the model—makes the frames.
Trompe vs the alternatives
| Approach | Strength | Weakness |
|---|---|---|
| Trompe (whitebox + projection) | Editable geometry, regenerable textures, full pipeline in code | Seams and projection artifacts; geometry limited to whitebox detail |
| End-to-end image-to-3D models | One shot from image to mesh; no tooling required | Poor topology control; complex scenes degrade fast |
| Traditional 3D authoring | Full control, production-grade topology and UVs | Slow and skilled; the cost Trompe exists to avoid |
Where the workflow still breaks
- Seams. Where multi-view projections meet, disagreement shows up as visible texture discontinuities—the classic projection texturing artifact.
- Occlusion. Faces the generated views never saw get stretched or smeared backings. Interiors and deep alleys are the usual casualties.
- Baked lighting. Projected images carry their own light. Relighting the scene in a game engine can expose the mismatch.
- Detail ceiling. The pipeline textures structure; it does not sculpt it. Ornamentation finer than the whitebox's blockiness has to come from the texture alone.
- Project age. The repo was created around October 25, 2026. Expect setup friction, moving APIs, and sparse docs—read the README and issues before assuming anything.
Running it yourself
Clone the repo and read the README before anything else— young projects change fast and the instructions there supersede any summary, including this one. You will need Blender available for scripting and API access to the models the pipeline calls. The right first target is one building, not a village: keep the geometry trivial so any failure you see is a texturing or setup failure, not a scene-complexity failure. Budget for iteration—the pipeline is cheap per run, and the skill being learned is briefing each stage well. For what textured output feeds into, the open-weights MOSS-Image ecosystem shows how quickly community tooling wraps a promising image model, and agentic video editors like OpenKatana and GPT Video Vibe Editing are where scenes like Trompe's end up in motion.
Trompe FAQ
What is Trompe?
Trompe is an open workflow, published at github.com/Patch-gg/trompe with the repository created around October 25, 2026, that turns a text prompt into a textured 3D scene by stacking three models: Claude Opus 5.5 writes and runs code that builds a Blender whitebox/greybox village, then FLUX 3 Klein with Fibo 2 generates multi-view images that are projected onto that geometry as textures. A demo of the pipeline drew roughly 199 likes and 8.7k views on X.
Which models does the Trompe workflow use, and why those?
Three, each doing the job it is strongest at. Claude Opus 5.5 handles the structured, code-shaped work: generating and iterating on Python that constructs Blender geometry. FLUX 3 Klein generates the appearance—consistent multi-view images of each surface. Fibo 2 handles the multi-view consistency and projection side that stitches those images onto the whitebox. The insight is that no single model needs to do everything: structure from a coding model, appearance from an image model, and projection as deterministic math rather than model output.
Trompe vs end-to-end image-to-3D generators: which should you use?
End-to-end image-to-3D tools take one image and produce a mesh directly—fast, and good enough for casual assets, but geometry quality degrades quickly on complex scenes and you get whatever topology the model decides. Trompe's decomposition gives you explicit, editable geometry (a real Blender scene you can modify by hand or by code) and textures you can regenerate without touching the mesh. Use end-to-end tools for one-off props; use a decomposed pipeline like Trompe when you need control over layout, scale, or iteration on specific surfaces.
How do I run the Trompe pipeline myself?
Clone github.com/Patch-gg/trompe and read the README first—the repo is a young project created around October 25, 2026, so expect setup friction. Practically you need Blender available for scripting, API access to the models the pipeline calls (Anthropic for the Opus 5.5 code-generation stage, and access to FLUX 3 Klein and Fibo 2 for the texturing stage), and a low-ambition first target: a single building, not a village. Follow the repo for current setup instructions—details evolve quickly on projects this new.
What are the limits of the whitebox-plus-projection approach?
Projection texturing inherits the flaws of its inputs. Seams appear where multi-view projections disagree; occluded faces get stretched or smeared textures; fine geometric detail is capped by the whitebox's blockiness since the pipeline textures structure rather than sculpting it; and lighting is baked into the projected images, so relighting the scene in a renderer can look off. It is excellent for stylized environments and previz, not yet a replacement for hand-authored game-ready assets.
AIXList is an independent AI tools directory. This article summarizes the Trompe workflow based on the public GitHub repository (created around October 25, 2026) and the X demo post as of October 27, 2026; we are not affiliated with the project's authors, Anthropic, or Black Forest Labs. Pipeline details evolve quickly on young projects— verify setup and model requirements against the repository's README before running anything.