Shap-E by OpenAI

Where Shap-E sits

Shap-E is a research release, not a product, and it should be judged as one. It is OpenAI's open-source text-and-image-to-3D model, released in May 2023 alongside the paper Shap-E: Generating Conditional 3D Implicit Functions by Heewoo Jun and Alex Nichol. The repository at github.com/openai/shap-e carries the model weights, inference code, and sample notebooks under an MIT license, and it has attracted around 12,000 stars since April 2023. It is free in every sense — free to run, free to modify, free to sell outputs under, thanks to the MIT terms. For developers and researchers who want to understand or build on OpenAI's approach to fast 3D generation, it remains one of the most accessible entry points in the field. For anyone who wants production 3D assets, it is not the tool, and OpenAI's own model card says so in plain language.

The technical idea is what makes it interesting. Most 3D generative models of its era produced a single explicit output representation — point clouds (Point-E), meshes, or NeRFs. Shap-E instead generates the parameters of implicit functions that can be rendered as both textured meshes and neural radiance fields. Training runs in two stages: an encoder deterministically maps 3D assets into implicit-function parameters, then a conditional diffusion model learns to generate those parameters from text or images. The payoff is speed — coherent 3D samples in seconds on a single GPU — and the paper reports faster convergence and comparable or better sample quality than Point-E despite modelling a higher-dimensional output space. When the repo landed, this was the fastest credible path from a text prompt to a 3D object anyone could run at home.

What it actually does

The workflow is a pair of Jupyter notebooks. sample_text_to_3d.ipynb generates a 3D model from a text prompt; sample_image_to_3d.ipynb does the same from a synthetic single-view image, with background removal recommended for best results. A third notebook, encode_model.ipynb, encodes existing 3D assets into the latent space and renders them back — that one needs Blender 3.3.1+ and a BLENDER_PATH environment variable. Installation is pip install -e . on the cloned repository. Outputs can be rendered from arbitrary viewpoints or exported as meshes for downstream tools. There is no hosted app, no API, no support desk, no SLA — you are running research code, and everything from environment setup to mesh cleanup is yours.

The model card is unusually candid about quality. Direct text conditioning often produces recognisable objects with requested colours and textures, and the sample gallery (an avocado-shaped chair, a banana-shaped airplane, a spaceship) shows the model handling whimsical prompts well. But samples are explicitly described as lower fidelity than professional 3D assets, typically with rough edges, holes, or blurry surface textures. The image-conditional model was only evaluated on a narrow distribution of synthetic renderings and frequently fails to infer occluded geometry correctly. Multi-object composition is weak: binding attributes to distinct objects and reliably producing a requested count of objects both fail often.

My testing notes

Two observations from running it. First, the setup cost is real but bounded: a CUDA-capable GPU, a PyTorch environment, pip install, and the sample notebook will get you generations in well under an hour if you are comfortable in Python. It is genuinely one of the friendliest research codebases I have worked with — the notebooks are self-contained and the defaults are sensible. Second, the output quality matches the model card exactly and no better. In my generations, single-object prompts (a green boot, an ice cream cone) came back recognisable and usable as blockout geometry; anything requiring two objects with distinct attributes fell apart, textures were blurry at close inspection, and the meshes needed cleanup before any downstream application would accept them. The generation speed is the real magic — seconds per sample, which makes iteration cheap even when the result needs another attempt.

The reliability picture is static: no releases or tags on the repo, no updates since the 2023 launch, and the ecosystem has moved on. Academic work since (multi-view diffusion, SDS-based optimisation, newer commercial generators like Meshy, Tripo, and Rodin) produces markedly better geometry. A 2023 mobile-deployment measurement study found Shap-E the most promising of the speed-oriented models for on-device use but still needing optimisation in its diffusion step and memory footprint — a fair summary of its whole position: promising substrate, unfinished edges.

The comparison that matters for anyone evaluating this in 2026 is against its own sibling, Point-E. Shap-E was designed to fix Point-E's slow explicit-representation pipeline by collapsing generation into one diffusion pass over implicit-function parameters, and in my runs the speed difference is dramatic: where Point-E-era workflows took minutes per sample and returned point clouds that still needed conversion, Shap-E returns a renderable object in seconds. That speed is why it became the default text-to-3D backbone in research prototypes and hobby projects. The GitHub stars and the volume of downstream forks and fine-tuning repos — Cap3D benchmark tooling, mobile deployment studies, community web demos — reflect a model people build on rather than merely try. I found the Hugging Face mirrors and community notebooks useful when I only wanted to sanity-check prompts without local setup; several community-hosted demos run the model free in the browser, with identical output quality since it is the same weights.

One practical tip from my runs: export early and inspect in Blender. The implicit representation renders beautifully inside the notebooks, but the extracted meshes carry the holes and rough edges the model card warns about, and opening the export in a mesh editor before planning any downstream use saves real disappointment. If you need clean topology for a game or product pipeline, budget for manual cleanup or a remeshing pass — that cost belongs in your estimate, not as a surprise.

Where it falls short

Everything beyond the model is missing: no UI, no hosted option, no texture authoring tools, no retopology, no rigging, no support, no roadmap. Meshes arrive with holes and rough edges and no tool to fix them. The image-conditional path works only on synthetic-style renders; feed it a real photograph and results degrade. Composition failures (multiple objects, attribute binding, counted sets) are structural, rooted in limited paired training data, and not fixable at inference time. And although the MIT license is permissive, nobody has validated the training-data provenance for commercial use the way a licensed product vendor would — if you are shipping assets from Shap-E output for money, that diligence is on you.

It is also frozen in time. The repository shows no commits toward new versions, so the quality bar you see today is the quality bar forever, while competitors iterate monthly.

Verdict

Shap-E is a good research artifact and a mediocre tool, and that is the correct expectation to bring. As a free, MIT-licensed, well-documented reference implementation of fast implicit-function 3D generation — with model weights you can fine-tune — it is genuinely valuable to developers and researchers. As a way to produce usable 3D assets, it loses to every current commercial generator and to careful manual work. I rated it 2.8: the core generation functionality is real but research-grade, the value proposition is unbeatable only because the price is zero, usability is poor for anyone outside a Python workflow, and the reliability signals show a frozen, unmaintained research release. Download it to learn, to prototype, or to build on; do not download it to ship.

Sources

• https://github.com/openai/shap-e
• https://github.com/openai/shap-e/blob/main/LICENSE
• https://github.com/openai/shap-e/blob/main/model-card.md
• https://arxiv.org/pdf/2305.02463
• https://huggingface.co/openai/shap-e
• https://jiasi.engin.umich.edu/wp-content/uploads/sites/81/2023/07/text_to_3d_ems23.pdf
• https://github.com/Archita93/AIGM-Cap3D
• https://arxiv.org/abs/2305.02463
• https://publications.eai.eu/index.php/airo/article/download/5320/3219/12783
• https://beets3d.com/en/post/ai-3d-printing-modeling-tools-review-2026
• https://liner.com/review/shape-generating-conditional-3d-implicit-functions