Here's a number that should stop you cold: a search of Hugging Face for "text-to-image" returns over 90,000 models. That's not a toolbox, that's a landfill — and somewhere in it are the handful of tools that will actually transform how you visualize a building. Good luck finding them by scrolling.
So I went looking, specifically for architecture and 3D work, and the genuinely good news is that the list that matters is short. Six models. But before I name them, you need the one idea that organises the whole field, because it's the thing nobody tells you on day one.
"Making a render" and "making a 3D model" are two completely different AI problems. One generates a flat, beautiful image of a building from your words or sketch. The other generates actual 3D geometry — a mesh you can rotate, light, and drop into your scene. Different math, different models, different winners. And there's a third problem squatting between them that architects can't ignore: control, because we are not the kind of users who can shrug and accept whatever geometry the AI felt creative about today. The walls go where we drew them.
Get that three-way split — generate the image, control the geometry, generate the 3D model — and the six tools sort themselves into a workflow. Let's walk it.
Part 1 — Generating the image
1. FLUX.1 [dev] — the quality king
If you want the single best-looking architectural render an open model can produce, this is it. FLUX.1 [dev], from Black Forest Labs (the team behind the original Stable Diffusion), is a 12-billion-parameter rectified-flow transformer, and it has overtaken SDXL on most quality benchmarks. Photorealism, compositional accuracy, and — unusually for these models — readable text, which matters the moment you want a legible sign or a labelled diagram.
The benefit: raw output quality. Feed it a detailed prompt and you get a render that needs less rescue work in Photoshop afterward.
The catch is two-fold, and both matter. First, 12 billion parameters isn't free — this is a heavy model that really wants a strong GPU with plenty of VRAM, not a laptop. Second, and this is the one that bites professionals: FLUX.1 [dev] is released under a non-commercial license. You can explore with it, but you cannot legally use its output in paid client work. The fix is its sibling, FLUX.1 [schnell], which is Apache 2.0 — fully commercial, and faster, at some cost to fidelity. Read the license before you put a FLUX render in a fee proposal, not after.
2. Stable Diffusion XL (SDXL) — the workhorse
If FLUX is the prestige option, SDXL from Stability AI is the one most architects should actually start with — and the reason isn't the base model, it's the ecosystem around it.
SDXL runs a UNet roughly three times larger than the original Stable Diffusion, with two text encoders, and it produces solid images on a consumer GPU (think 8–12 GB), not a data-center card. But the real prize is everything built on top of it: thousands of community fine-tunes and LoRAs trained specifically for interior design, exterior visualization, and architectural styles, plus — crucially — the deepest library of ControlNets (which is Part 2). Under a permissive OpenRAIL license, it's commercial-friendly out of the gate.
The benefit: accessibility and an ecosystem nothing else matches. The path of least resistance for real archviz.
The catch: the base model's quality sits below FLUX. SDXL shines because of its fine-tunes — out of the box, it's good; loaded with the right architectural LoRA and a ControlNet, it's a powerhouse.
Part 2 — Controlling the geometry
3. ControlNet — the architect's non-negotiable
Here's where the previous two models go from "fun toy" to "actual design tool," and it's the most important entry on this list for anyone who builds real things.
ControlNet, by the researcher lllyasviel, isn't an image generator at all — it's a steering layer that bolts onto SDXL (or FLUX). The mechanism is elegant: it locks a frozen copy of the pretrained model so all that visual knowledge stays intact, then adds a small trainable copy connected through "zero convolutions" — connections that start at zero and learn to nudge, never to shout over the original. The result is a model that obeys a visual instruction without losing its mind.
For architecture, one variant matters above the rest: M-LSD (sd-controlnet-mlsd), a straight-line detector. Hand it a floor plan, a massing study, or a room layout, and it holds the lines while the model restyles everything around them. Your geometry survives. There's also Canny (edges) for keeping a building's outline, and depth for honest spatial relationships.
The benefit: fidelity. This is the difference between "an AI made a building vaguely like mine" and "the AI rendered my building, walls exactly where I put them."
The catch: it's an add-on, not a standalone app, so there's real setup, and you have to learn which control type fits which job. Worth every minute. (If you want the deeper dive, I've written a full guide to ControlNet.)
Part 3 — Generating the 3D model
Now the harder frontier: turning a single image into actual 3D geometry. These three trade off the same way every engineering decision does — speed versus quality — so I've ordered them by where they sit on that curve.
4. TripoSR — the fast one
TripoSR, a collaboration between Stability AI and Tripo, is a feed-forward model: it makes one fast pass over your image and outputs a mesh, with no slow iterative refinement. On a GPU that's a matter of seconds, sometimes under one.
The benefit: speed and freedom. It's MIT-licensed — fully open, fully commercial — and light enough to run almost anywhere. Perfect for rapid massing studies and "what does this roughly look like in 3D" iteration where you want twenty answers, not one perfect one.
The catch: that single fast pass is exactly why fine detail suffers. TripoSR gives you the gist of a form, not a polished asset.
5. Hunyuan3D-2 — the balanced workhorse
Tencent's Hunyuan3D-2 is the sweet spot most people should reach for, because it nails the quality-per-hardware ratio. It generates a textured mesh from a single image in roughly 10–25 seconds, runs shape generation on as little as 6 GB of VRAM — within reach of most mid-range GPUs — and measurably outperforms TripoSR on geometric accuracy (it wins on Chamfer Distance and F-score, the standard metrics for "how close is this mesh to the real shape").
The benefit: the best balance of fidelity, speed, and accessible hardware on this list. If you can only learn one image-to-3D tool, learn this one.
The catch: it's slower than TripoSR, and its license has commercial conditions worth reading rather than assuming.
6. TRELLIS.2 — the heavyweight
When you need the best 3D result and have the compute to pay for it, Microsoft's TRELLIS.2 is the high end. It's a 4-billion-parameter flow-matching transformer built on a novel sparse "O-Voxel" structure, and it handles complex topologies, sharp features, and — this is the headline for architecture — full PBR materials, including transparency and translucency.
Stop on that last point. Glass. A model that can generate physically-based glass and translucent materials is enormous for buildings, where curtain walls and glazing are half the design. Generation runs from about 20 seconds to 4 minutes depending on resolution.
The benefit: top-tier fidelity, genuinely complex geometry, and real materials you can drop straight into a rendering engine.
The catch: it's the slowest and most compute-hungry option here. This is the tool you reach for when the asset matters, not when you're iterating.
How to actually choose
Don't pick one. Build a stack, because these tools answer different questions:
| Your job | Reach for |
|---|---|
| Best-looking 2D render, strong GPU | FLUX.1 (commercial? use [schnell]) |
| Practical archviz on a normal PC | SDXL + a good architectural LoRA |
| Keep my exact geometry while rendering | ControlNet (M-LSD for plans/lines) |
| Fast rough 3D for massing | TripoSR |
| Quality 3D on mid-range hardware | Hunyuan3D-2 |
| Best 3D, real materials (glass!) | TRELLIS.2 |
A realistic pipeline for most practices looks like this: render your concept with SDXL + ControlNet (or FLUX if you've got the hardware and the right license), then push the result through Hunyuan3D-2 or TRELLIS.2 to get a 3D model you can actually light and place. Two problems, the right tool for each.
The part worth slowing down for
Two honest cautions, because this space is loud with hype and quiet about the fine print.
First, the licensing trap is real and specifically dangerous for professionals. The most impressive model here, FLUX.1 [dev], is the one you legally can't sell work from. A model being free to download is not the same as being free to use commercially, and "I didn't know" is not a defence a client's lawyer will accept. Check every license against how you actually intend to use the output.
Second, the deeper one. These tools will hand you a watertight-looking 3D mesh and a photoreal render with total confidence — and confidence is exactly the thing to be suspicious of. A generated mesh is an approximation, not a buildable model; it has no idea what a structural member is or whether a wall can hold a roof. So, yes — we can now generate a building's 3D geometry from a single photo in under a minute. We genuinely can. Whether the thing that comes out is something you can hand a contractor, or just something that looks like you could, is — uh... the question the impressive 20-second demo is very careful not to linger on. Use these six as the extraordinary accelerators they are, and keep the architect — the one who knows the difference between a mesh and a building — firmly in charge.
For the broader landscape of AI tools in practice, see the rise of AI tools in architecture; for getting these models under control, the ControlNet guide goes deeper.