Last updated: September 2026.

The state of AI 3D model generation in September 2026: Microsoft's TRELLIS.2 (released 16 December 2025, MIT licence) is still the best model you can download and run, Meshy 7 (12 August 2026) and Tripo's H3.1 and P1.0 (announced 9 March 2026) are the newest hosted engines, and Tencent's Hunyuan3D 3.x family, the most capable geometry engine on paper, remains hosted-only with the last open weights at version 2.1 from June 2025. Below is every major release in this field with its date, maker, open-weights status and licence, checked against the GitHub release notes, Hugging Face model cards and vendor announcements on the day this page was written.

This page is a changelog, not a review. We update it monthly (this revision is 6 September 2026) and the roundup of the best AI 3D model generators is where we say which one to use and why. Where a date is an announcement rather than a weights release, the table says so.

Quick answer

• The release that matters most for a game project right now: TRELLIS.2, 16 December 2025. It's a 4B-parameter image-to-3D model under the MIT licence with native PBR materials and GLB export, and it's the only frontier-quality model whose licence has no territory, revenue or user-count clause.
• The newest hosted engines: Meshy 7 (12 August 2026, built around image alignment) and Tripo P1.0 and H3.1 (9 March 2026, native 3D diffusion with a two-second low-poly mode). Both are closed, both need a paid plan to download.
• Best geometry, hosted only: Rodin Gen-2.5 (26 May 2026, ten-million-polygon raw output) and Tencent's Hunyuan 3D 3.1 (28 January 2026 on the global platform, 1536³ geometry).
• The licence to read twice: every Tencent Hunyuan3D open release (2.0, 2.1, Omni, Part) ships under a Community License that does not apply in the EU, UK or South Korea.
• Try two of the open models without a GPU: Cinevva's 3D Model Generator runs Hunyuan3D and TRELLIS.2 in the browser.

Before the full table, here is the shape of the last two years on one line. The open releases cluster in 2025, and 2026 so far has been a hosted year with Pixal3D the single open exception.

Release timeline

Newest first. "Open weights?" means downloadable checkpoints, not just a paper or demo. Dates are from the primary source named in the notes column, and "announced" flags a hosted or press release where no weights shipped.

Q4 2025: the open-weights ceiling moved

The quarter had three releases that changed what an indie could run on their own hardware. TRELLIS.2 landed on 16 December 2025 with a 4B-parameter model, an O-Voxel representation that handles open surfaces and internal structure, and PBR textures to 4096², all under MIT. The catch is the 24 GB VRAM requirement, which puts it on a 3090, 4090 or a rented A100 rather than a laptop.

Meta's SAM 3D pair on 19 November 2025 solved a different problem: reconstruction of a real object from one photo, with occlusion, outputting Gaussian splats rather than a mesh. The SAM License allows commercial use with the usual Meta exclusions around military end uses. For a game pipeline it's a reference capture tool, not a prop generator.

Tencent spent the quarter going the other way. Hunyuan3D-Omni (25 September) and Hunyuan3D-Part (28 September) shipped weights for controllable generation and native part decomposition, both useful for game assets where you want a door that's a separate mesh from the wall. But the 3.0 engine announced on 16 September and the global platform that launched on 26 November stayed hosted, and the open releases carry the Community License that does not apply in the EU, UK or South Korea. If your studio or your players are in those territories, that clause decides the question for you.

On the hosted side, Rodin Gen-2 (1 October) introduced recursive part-based generation at 10B parameters, and Meshy 6 Preview (16 October) pushed sculpt-level detail. Both were previews of where 2026 would go: bigger models, more part structure, and download rights tied to a subscription.

Q1 2026: hosted engines went production-grade

Three vendors shipped their "for pipelines, not demos" release within ten weeks of each other. Meshy 6 went GA on 18 January with a Low Poly Mode aimed at game developers. Tencent put Hunyuan 3D 3.1 on the global platform on 28 January, hosted only, twenty free generations a day. Tripo announced P1.0 and H3.1 on 9 March for GDC, and P1.0 is the interesting one: a native 3D diffusion architecture that resolves the whole object at once and produces low-poly, engine-ready output in about two seconds. That is a different bet from the "generate dense, then remesh" pattern everyone else uses. Tripo's API had already been serving a v3.1-20260211 version string a month before the announcement.

For topology this was the quarter the vendors stopped pretending. Meshy's Low Poly Mode, Tripo's P1.0, and Rodin's quad options all exist because raw diffusion output has no edge loops and everyone knows it. None of them produce the concentrated loops a face or shoulder needs for deformation. They produce evenly distributed quads or a clean low-poly shell, which is exactly right for props and exactly not enough for a hero character.

Nothing open of comparable weight shipped this quarter. The gap between the hosted 3.x-class engines and the open 2.x-class weights widened.

Q2 2026: detail on the hosted side, alignment on the open side

Rodin Gen-2.5 on 26 May 2026 is the high-water mark for raw geometric detail: more than 10 million polygons in the top tier, four-second drafts at the bottom, and three output types (raw triangles, quads, Smart Low-Poly). Two months earlier, on 31 March, Hyper3D shipped Gen-2 Edit, which lets you mask a region of an existing mesh and change it with a prompt. Region editing is the feature that turns a generator into an iteration tool, and it's still rare.

Meshy launched its 3D Agent beta on 4 June, a chat flow from concept through reference image to downloadable model. It's the same two-step pattern (image model first, image-to-3D second) that every serious pipeline already uses, packaged for people who don't know that.

The open release of the quarter was Pixal3D from Tencent ARC in May 2026, under MIT: a pixel-aligned image-to-3D method that back-projects image features into 3D for reconstruction-level fidelity, with training code and a TRELLIS.2-backbone variant in the same month. It's the first significant open model built on top of TRELLIS.2 rather than alongside it, which is how open ecosystems compound.

Q3 2026: Meshy's texture and alignment quarter

Meshy shipped four releases in seven weeks: native 8K base-colour textures on 22 July (paid tiers), a multiview upgrade on 7 August that uses up to four reference views for both geometry and texture, then Meshy 7 and Meshy 6 Lite in August. Meshy 7 is the one to understand. Instead of claiming "better", Meshy published alignment scores against held-out reference models: 81.0% overall proportion, 79.7% spatial distribution, 59.8% surface details. That surface-detail number is the honest one. Proportion and layout are close to solved for single objects, fine detail isn't, and only Pro and above can download Meshy 7 output.

For PBR textures, this quarter made 8K the marketing number. For a browser game, it's irrelevant: you'll ship 1K or 2K compressed to KTX2, and the win is that downsampling from a clean 8K source gives you fewer baked-in lighting artefacts than a 2K source did. Bake-in in the albedo is still the most common texture defect across every tool on this page.

On the open side, Pixal3D added multi-view inference in September. No new frontier-scale open weights shipped in Q3, and none of the hosted vendors released a model. The 2.1-era Hunyuan weights remain the newest open Tencent shape model, fifteen months on.

What you can run yourself

Eight of the models above have downloadable weights and a licence that permits commercial use, at least somewhere. VRAM figures are from each project's own README.

The same numbers as a chart, sorted by the memory you need for the full model, with the licence terms as the colour.

Three things the table can't show. First, "open weights" for Hunyuan3D 2.1 includes full training code, which none of the MIT models offered until TRELLIS.2 and Pixal3D shipped theirs, so it's still the model to fine-tune on your own art style if the territory clause doesn't rule you out. Second, Sparc3D is not on this list because its weights were never released, despite the GitHub repo and the Hugging Face demos. Third, if you don't own a 24 GB card, the practical route is renting inference by the second, or using a hosted front end for one of these models.

What this means for a game project

The pipeline for a static prop is settled. Generate a reference image, feed it to an image-to-3D model, check the triangle count in a GLB viewer, decimate and compress with the GLB optimizer, and ship. Every hosted tool and every open model above produces something usable for a rock, a crate, a lamp or a stylised item after that pass. The choice between them is licence and cost, not quality.

Cinevva's 3D Model Generator is the way to try the two open models that matter without installing anything. The tool page describes it as a workbench that generates reference images from a text prompt (or takes an uploaded image or URL), reconstructs the one you pick into a textured mesh, then lets you rig, animate, inspect and export it as GLB without moving files between services. Generating and previewing uses the credits shown in the workbench, your first GLB export is free, and further exports come with the Standard and Pro plans. The mesh engine picker on that workbench offers Hunyuan3D and TRELLIS.2, so you can compare the Tencent and Microsoft models on the same reference image, and for characters the character option keeps the references in a riggable pose (deep link: /tools/hunyuan3d#prompt=<text>&character=1).

For characters, the release that matters isn't a generator at all. UniRig (April 2025, MIT) showed that skeleton prediction and skinning could be a learned step, and every hosted vendor now bundles auto-rigging. Cinevva's Auto Rigger takes a GLB, FBX or OBJ up to 50 MB, rigs humanoids on its Fast engine, and returns a GLB with up to six baked animations, with the first rigged character free to download. Standard and Pro remove the cap and add the Pro engine for quadrupeds. If you rig often in Blender, the Blender add-on runs the same engine locally with no per-rig charge for a one-time $29 at the launch price. Whichever rigger you use, the topology caveat from Q1 applies: auto-rigged AI meshes hold up as background characters, and close-up hero characters still need a retopology pass first.

On licences, the one-line version: TRELLIS.2 and Pixal3D output has no strings from the model side, Hunyuan3D 2.x output is fine outside the EU, UK and South Korea, Stability's models are fine under $1M revenue, PartPacker output can't ship at all, and every hosted tool ties download or commercial rights to a paid plan. Read the game asset licences guide before you build a pipeline around any of them.

Common Questions

What's the latest news in AI 3D asset generation in 2026?

The newest releases are Meshy 7 and Meshy 6 Lite (August 2026), Rodin Gen-2.5 (26 May 2026), Tripo P1.0 and H3.1 (announced 9 March 2026), Tencent's Hunyuan 3D 3.1 on the global platform (28 January 2026), and Meshy 6 GA (18 January 2026). The most significant open release of 2026 is Pixal3D (May 2026, MIT), built on the TRELLIS.2 backbone.

When was Hunyuan3D 3.0 released, and is it open source?

Tencent announced Hunyuan 3D 3.0 on 16 September 2025 at its Global Digital Ecosystem Summit and launched it worldwide on the hosted platform at 3d.hunyuanglobal.com on 26 November 2025, followed by 3.1 on 28 January 2026. Neither 3.0 nor 3.1 has released weights. The newest open Hunyuan3D shape model is still 2.1 from 13 June 2025.

What is the TRELLIS 2 release date and licence?

Microsoft released TRELLIS.2 on 16 December 2025 (the "Init Release" commit and the Hugging Face paper date agree). It's a 4B-parameter image-to-3D model under the MIT licence, needs an NVIDIA GPU with at least 24 GB of memory, and exports GLB with PBR textures up to 4096².

When did Meshy 6 and Meshy 7 come out?

Meshy 6 launched as a preview on 16 October 2025 and reached general availability on 18 January 2026. Meshy 7 followed on 12 August 2026, alongside a lighter Meshy 6 Lite, and Meshy 5 was discontinued the same month. Meshy 7 output can only be downloaded on Pro and above.

When did Tripo 3 and Rodin Gen-2 release?

Tripo's API served version v3.0-20250812 from 12 August 2025, with the 3.0 beta announced on 20 August 2025, and v3.1-20260211 from 11 February 2026 ahead of the P1.0 and H3.1 announcement on 9 March 2026. Rodin Gen-2 was announced by Hyper3D on 1 October 2025 and Gen-2.5 on 26 May 2026.

Is there an open source text-to-3D generator?

Yes. TRELLIS.2 (MIT), Pixal3D (MIT), Hunyuan3D 2.1 (Community License, excludes the EU, UK and South Korea), Direct3D-S2 (MIT) and Step1X-3D (Apache 2.0) all have downloadable weights. Most are image-to-3D, so text-to-3D means generating a reference image first, which is what the hosted tools do internally too. TRELLIS also ships dedicated text-conditioned models.

What is Sparc3D and can I download it?

Sparc3D is a May 2025 paper from the team behind Hitem3D (now Hi3D) describing 1024³ watertight geometry generation. The GitHub repo and several Hugging Face demos exist, but the trained weights were never published and stayed behind the commercial product, which the repo's own open issues complain about.

Related

• Best AI 3D Model Generators in 2026: the roundup, which tool to pick and why
• Best AI Asset Generators for Games: the full AI asset pipeline beyond meshes
• Best Open-Source Generative AI Models for Games: the open model picture across image, audio and 3D
• Game Asset Licenses Explained: what each licence in the table lets you ship
• Free Character Animations and Auto-Rigging: what to do with the mesh once you have it
• Best Free 3D Model Sites for Games: when searching beats generating

Last updated: September 2026.

The best AI video generator for a game trailer in 2026 is Kling 3.0 if you need one character to look the same across every shot, Google Veo 3.1 if you want the most polished hosted clips with sound and can pay $0.40 a second for them, and Wan 2.2 or LTX-2.5 if you want open weights you can run yourself and use commercially. Whatever you pick, the AI footage belongs in the mood intro, the cutscenes and the social cuts, not in the part that shows what the player does. Steam's own guidance is that the first trailer should be mostly gameplay, and your distribution agreement says the game has to match its marketing.

This is the decision guide: what a trailer needs, which model fits which job, what each costs per second as of September 2026, and which licences let you ship the result. For the deep technical comparison of reference-image systems and long-form generation, read our AI video models with reference image support guide, which this one doesn't repeat.

Quick picks

• Best overall hosted: Kling 3.0 (Pro). 3 to 15 second clips at up to 1080p with native audio, a multi-shot storyboard, and the most complete character reference system. $0.168 a second with audio on fal.
• Best for character consistency across shots: Kling 3.0's element references, or Seedance 2.5 when one shot needs many references at once (up to 30 images per request).
• Best hosted quality per clip: Veo 3.1. 8 second clips at 720p, 1080p or 4K with dialogue and sound, $0.40 a second with audio, $0.15 on the Fast tier.
• Best open weights for commercial use: Wan 2.2 (Apache 2.0, no strings) for a clean licence, LTX-2.5 (LTX-2.x Community License, free under $10M revenue) for audio and 4K.
• Cheapest for volume: MiniMax H3 at $0.06 a second for 768p on fal, or Wan 3.0 at $0.05 a second for 480p drafts.
• Best for 2D and anime styles: Vidu Q3, the only major API with an explicit style: anime switch. For pixel art, animate real sprites instead, see the pixel art generators guide.
• Best for cutscenes from your own 3D scene: render a rough pass from your engine and restyle it with Kling's video-to-video or Runway Aleph 2.0.

Quick reference

Prices are what we read on the vendor's page or on fal.ai and Runway's API price list on September 6, 2026, at the usual trailer setting (720p or 1080p, audio on where the model has it). Everything reprices often, so read the column as a ranking.

What a game trailer actually needs

Read what the store expects before you generate anything. Steam's trailer documentation asks for the highest resolution you have up to 1920 by 1080, 30 or 60 fps, a bitrate of 5,000 Kbps or more, and an .mp4, .mov or .wmv file. Master at 1080p and keep the 4K and 9:16 versions for YouTube and TikTok.

The same page is blunt about content: "most Steam users are looking for gameplay," and Valve recommends the first trailer on your page is primarily gameplay from the player's perspective. Each trailer gets a category. "Gameplay" means mostly footage of the game being played, while "General / Cinematic" covers a mix of pre-rendered video, logos, title screens and limited gameplay. That's where AI footage belongs, and it should be labelled that way.

There's also a promise you make when you sign up. Steam's content survey reminds you that under the Steam Distribution Agreement your game "will be consistent with your marketing materials." A cinematic that looks nothing like the game isn't against the rules, but a trailer that implies gameplay you don't have is what players punish in reviews, and AI clips are very good at looking like gameplay from a game that doesn't exist. Keep cinematic footage clearly cinematic, then cut hard to real capture.

If you've never cut a trailer before, spend forty minutes on the talk below before you open a prompt box. The AI shots only fill slots in a structure you still have to build.

The disclosure rule is narrower than people think. Steam's AI policy covers "pre-generated" content, anything that ships with your game and is consumed by players, and "live-generated" content produced while the game runs. AI cutscenes inside the build are pre-generated content and go in the survey. A trailer that only lives on your store page isn't in the game, so the survey doesn't ask, but an undeclared AI trailer next to an AI label is a bad look. Say so in the trailer description.

So where does AI video fit? The mood intro, the first five to ten seconds before the gameplay hits. Cutscenes and story beats, especially for a team with no animator. Key art in motion, a slow move on the still you already commissioned. And vertical social clips, which need volume more than fidelity. Everything else should be captured from the game. If you built it in the game creator it runs in the browser, so a screen recorder at 1080p60 is the whole capture rig.

The tools, one at a time

Google Veo 3.1

Veo 3.1 is the model for a single shot that has to look finished. It generates up to 8 seconds per call at 720p, 1080p or 4K with dialogue and sound in the same pass, takes reference images plus first and last frames, and an extension endpoint chains 7 second continuations to around two and a half minutes. On fal the Veo 3.1 endpoint is $0.20 a second silent or $0.40 with audio at 720p and 1080p, and $0.60 with audio at 4K. Veo 3.1 Fast is $0.10 silent and $0.15 with audio, and Runway's API relays the same rates. The 8 second cap suits a trailer, where shots run two to four seconds, but it makes every cutscene a stitching job.

Kling 3.0 Omni

Kling is the trailer workhorse because of its reference system. You upload a frontal photo of a character as an element, add more angles if you have them, then write @Element1 walks through the burning gate and the model puts that character in the scene rather than animating the photo. Per Kling's 3.0 Omni guide, a request takes up to 7 images and elements combined, clips run up to 15 seconds at 720p or 1080p, and a multi-shot storyboard writes several shots with their own duration and camera in one generation. On fal, Kling v3 Pro is $0.112 a second silent and $0.168 with audio, and v3 Standard is $0.084 and $0.126. Our own Video Generator runs Kling 3.0 Pro with the storyboard and up to four reference images if you'd rather skip the API setup.

Seedance 2.5

ByteDance's Seedance 2.5 is for the 30 second take in a single pass. Per the Seed team's announcement it generates up to 30 seconds per generation with multi-round extension, and takes up to 30 images, 10 video clips and 10 audio clips as references at once, so a whole cast plus a location board fits one request. Runway's API added it on August 7, 2026 at 20, 30 and 68 credits a second ($0.20, $0.30 and $0.68) for 480p, 720p and 1080p, with an 80 credit minimum. It's also on fal and on BytePlus ModelArk, where billing is per token. For a cutscene where three characters have to hold across a minute, the 30 second window halves the stitching.

Runway Gen-4.5 and Aleph

Gen-4.5 generates 2 to 10 second clips from text or an image at $0.12 a second on the API, with true HDR delivery added in August 2026. Runway's launch post claims "stylistic control spanning photorealistic to animated styles," and it does hold a stylised look better than most. Aleph 2.0 is the editing half: 2 to 30 seconds of existing video plus up to 5 keyframe images and a prompt, at 28 credits a second, the tool for turning a grey-box capture of your level into something dressed and graded. Runway's terms don't restrict commercial use of outputs or claim ownership, but do let Runway train on them. Subscriptions are $15, $35 and $95 a month for 625, 2,250 and 9,500 credits.

Luma Ray3.2

Ray3.2 is the cheap 720p option with the most keyframe control: up to 16 keyframes per clip, a Character Reference feature, a Reframe tool that re-composes 16:9 into 9:16 or 1:1, and 16-bit HDR with EXR export. API pricing is per 5 second block: $0.30 at 720p ($0.06 a second), $1.20 at 1080p, HDR doubles it. Text and image to video run 5 or 10 seconds, and the Modify video-to-video mode goes to 20. Read the terms before shipping: Luma assigns you the output, but commercial use only applies to clips "produced during an active Subscription Term under Customer's paid subscription," so free-tier clips can't go in a trailer.

MiniMax H3

MiniMax H3 replaced the Hailuo 2.x line on July 31, 2026 and sits near the top of the Artificial Analysis arena while being one of the cheapest hosted models. It generates 4 to 15 seconds at 768p or 2K with native stereo audio, and its Ref2VA mode takes up to 9 reference images. On fal, H3 is $0.05 a second at 480p, $0.06 at 768p and $0.13 at 2K. The catch is the licence on the open weights: the MiniMax H3 Community License defines its territory as worldwide "excluding the Excluded Territories," which are the EU, the UK, South Korea and the United States, and requires a "MiniMax H3" credit in any commercial product. The hosted API is a different contract, so for a Western studio H3 is a hosted model.

Wan 2.2 (open) and Wan 3.0 (API)

Wan 2.2 is the cleanest open-weights answer. The GitHub repo is Apache 2.0 and says outright that Alibaba claims no rights over generated content. The TI2V-5B model generates 5 seconds of 720p at 24 fps on a 24 GB card like an RTX 4090 in under 9 minutes, and the 14B models want 80 GB. Five seconds is a trailer shot, not a cutscene, so Wan 2.2 is for batching B-roll overnight on hardware you own. Wan 3.0, released August 2026, is a different product: hosted only, 30 second takes at up to 1080p with native audio, and a reference endpoint that takes up to 10 images, 5 videos and 5 audio tracks. On fal it's $0.05, $0.10 and $0.20 a second at 480p, 720p and 1080p, and it shares the top of the text-to-video arena. There are no Wan 3.0 weights, whatever the SEO pages say.

LTX-2.5

Lightricks' LTX-2.5 is the open-weights model with sound and 4K. The model card describes a 22B model with native audio, output up to 3840 by 2176, and native multi-shot generation that keeps one character across connected shots in a single pass. Hosted, the fal LTX-2.5 Fast endpoint is $0.09 a second at 720p, $0.13 at 1080p and $0.30 at 4K, audio included. Self-hosted, Section 2.1 of the LTX-2.x Community License grants a royalty-free licence for any purpose, "provided however, that Entities with annual revenues of at least $10,000,000" must obtain a paid commercial licence, and Section 5 says Lightricks "claims no rights in the Output you generate." For an indie studio that's free and commercial.

Vidu Q3

Vidu Q3 is here for two reasons. Its text-to-video API has a style parameter with the values general and anime, which no other model on this list exposes, and anime mode is the closest thing to a purpose-built generator for a 2D-styled game. Its reference-to-video mode takes up to 7 subject images tagged @1, @2 in the prompt, runs 3 to 16 seconds at up to 1080p, and generates speech and music from the prompt. Pricing is credits at half a cent each: Q3 Pro is $0.10 a second at 720p and $0.12 at 1080p, Q3 Turbo is $0.055 and $0.065, and off-peak rates halve that.

Sora

Don't build on it. OpenAI's deprecations page lists the Videos API and every sora-2 and sora-2-pro snapshot as discontinued on September 24, 2026, with no replacement named. Existing clips are yours to keep, but a new pipeline starts with one of the models above.

Where the leaderboard stood

We read the Artificial Analysis text-to-video arena (with audio) on September 6, 2026. Wan 3.0 and Gemini Omni Flash were tied at 1238 Elo, then fal's MiniMax H3 Max at 1235, MiniMax H3 at 1227 and Seedance 2.0 at 1222. Kling 3.0 Pro sat 10th at 1108, Veo 3.1 14th at 1091, Vidu Q3 Pro 20th and LTX-2.5 Fast 23rd. Arena rank measures blind preference on generic prompts, not how well a model holds your character across eight shots, which is why Kling ranks mid-table there and first here.

Workflow: from your game to a finished trailer

Here's the shape we're building toward, with the eight AI shots from the cost example below slotted into a 60-second cut.

Start from your own frames. The best input for image-to-video is a still that already looks like your game. Screenshot at the highest quality your engine offers, or render a hero frame with the lighting pushed further than you'd ship. If the scene doesn't exist yet, generate concept art at the aspect ratio you'll cut in, and mind the input limits (Kling rejects images under 300 pixels on a side). For an environment shot, a 360° panorama from the Skybox Generator is a clean backdrop for a slow pan.

Lock the character before you animate. Every reference system wants a clean, front-facing, evenly lit image, and most accept extra angles. Make that turnaround first and reuse the exact same files for every shot. If your character is a 3D model, render the turnaround from the asset, since a real render beats any generated still, and a mesh from the 3D generator gives you an orbitable source in minutes.

Generate short and generate several. Trailer shots are two to four seconds on screen. Ask for 5 seconds, keep the best two, and expect three or four takes per shot. Write camera moves into the prompt ("slow dolly in", "handheld tracking shot from the left") so the editor has motion to cut on. Generate silent unless the sound is the point, since you'll replace it with your score and silent is 30 to 50 percent cheaper on Veo and Kling.

Restyle your own captures instead of inventing shots. For a cutscene, block the scene in your engine with correct camera work and timing, record it, and push the recording through a video-to-video mode. Kling's edit mode takes 3 to 10 second source clips with element references, Aleph 2.0 takes up to 30 seconds with keyframes, Luma Modify takes 20. The engine gives you the staging AI can't be trusted with, and the model gives you the lighting you couldn't afford. The deep dive covers this render-low, transform-high approach at length.

Upscale and re-time. Most hosted output is 720p or 1080p at 24 or 25 fps. Steam wants 1080p at 30 or 60, and YouTube rewards 4K. Topaz Video upscales to 4K and 8K and interpolates to 60 or 120 fps at $299 a year on its current price list, and DaVinci Resolve's free tier does competent upscaling and retiming. Never interpolate real gameplay to 60 unless you captured it at 60.

Cut to music, then caption, then go vertical. Pick the track first and cut on its hits, because AI shots have no rhythm of their own. The AI music generators guide covers scoring with commercial licences. Burn in captions for any dialogue, since most social video plays muted. Then make the 9:16 version: regenerate key shots vertical (Veo and Vidu both take 9:16) or use Luma Reframe to re-compose the horizontal cut. Don't just crop.

Licensing: what you can ship

The open-weights picture is simple if you read the licences instead of the headlines. Wan 2.2 is Apache 2.0 with an explicit statement that Alibaba claims no rights over generated content. LTX-2.5 is free for any purpose below $10M annual revenue and disclaims rights in outputs, with a paid licence above that line. MiniMax H3's weights are not licensed for use in the US, EU, UK or South Korea and require a "MiniMax H3" credit elsewhere, so treat it as hosted unless you're in a covered territory. Older Hunyuan and CogVideoX releases carry their own community licences with use caps, which is why they're not in the table.

Hosted tools mostly let you use what you paid for. Kling's paid service terms say members' commercial use of outputs "is not restricted," while free users must keep the Kling watermark or state that the result was generated by Kling AI. Runway doesn't claim outputs and doesn't restrict commercial use on any plan, but reserves the right to train on them. Luma assigns you the rights only for clips made during a paid subscription. Veo, Seedance, Wan 3.0 and Vidu are governed by their API terms, so read them before launch. In every case, keep the generation records: prompt, model, date and account. If a rights question comes up after launch, that log is the answer.

One more thing that isn't a licence but behaves like one: AI video with no human authorship has weak or no copyright protection in the US and several other jurisdictions. A competitor can lift your AI cutscene with little recourse. Your gameplay footage, your music and your edit are protected. Lean on those.

What a 60-second trailer costs

Take a typical structure: eight AI shots making up the mood intro and a couple of story beats, with the rest captured gameplay. Eight shots at 7.5 seconds is 60 seconds of generated footage, and you should budget three takes per shot, so 180 seconds generated. Here's the bill at the prices verified above, at 1080p where the model offers it and audio off where it's a toggle.

The generated portion of a trailer costs less than an hour of a freelance motion designer on every model here, and the spread between models is small enough that you should pick on consistency and look, not price. The exception is finishing, where a Topaz licence costs more than all the generation combined, so upscale in Resolve unless you're shipping 4K to a platform that rewards it.

Common Questions

What is the best AI video generator for a game trailer?

Kling 3.0 for most indie trailers, because its element references keep a character consistent across shots and its storyboard mode writes several shots in one call. Veo 3.1 gives the most finished single shots with sound at about twice the price. Use either for the cinematic intro and story beats, and capture the gameplay from the real game.

Can I make a whole game trailer with AI?

You can generate every frame, but you shouldn't. Steam's trailer guidance says most users are looking for gameplay and recommends the first trailer be primarily gameplay, and your distribution agreement requires the game to be consistent with its marketing. Use AI for the mood intro, cutscenes and social cuts, then cut to real capture at 1080p, 30 or 60 fps, for the rest.

Is there an AI cutscene generator?

Not as a single product, but Seedance 2.5 (30 second takes, up to 30 reference images), Kling 3.0 (15 second multi-shot storyboards) and Wan 3.0 (30 second takes) are the closest. The reliable route to a long cutscene is to block it in your engine, record it, and run the recording through a video-to-video mode like Kling's edit mode or Runway Aleph 2.0, so the staging is yours and only the look is generated.

Which open source video model can I use commercially?

Wan 2.2 is Apache 2.0 with no revenue caps and an explicit statement that Alibaba claims no rights over outputs. LTX-2.5 is free for commercial use under $10M annual revenue and disclaims rights in outputs. MiniMax H3's weights exclude the US, EU, UK and South Korea, so use it through a hosted API there. Wan 3.0 and Veo have no downloadable weights.

How do I keep a game character consistent across AI video shots?

Use a model with true reference support and feed it the same frontal image and angle shots in every request. Kling's @Element references, Vidu's @1 tags, Seedance 2.5's 30-image reference list and MiniMax H3's Ref2VA all do this. Render the turnaround from your actual 3D character if you have one, since a real render beats any generated still.

Do I have to disclose an AI trailer on Steam?

Steam's AI disclosure covers content that ships with the game and is consumed by players (pre-generated) and content generated at runtime (live-generated). An AI cutscene inside the build is pre-generated content and goes in the content survey. A store-page trailer isn't in the build, so the survey doesn't ask, but if the game carries an AI label it's wise to say so in the trailer description too.

Related

• Best AI Video Models with Reference Image Support: the deep technical comparison this guide points to
• How to Promote an Indie Game With No Budget: where the trailer goes once you've cut it
• Steam Next Fest Strategy: the data on demos, wishlists and trailer timing
• Best AI Music Generators for Games: the track you cut the trailer to
• Best AI Pixel Art and Sprite Generators: animate real sprites for a 2D trailer
• Video Generator: Kling 3.0 Pro with storyboard and reference images, in the browser

Last updated: September 2026.

If you want the most complete character rigging add-on for Blender, buy Auto-Rig Pro: for $50 it rigs bipeds and creatures, retargets mocap, builds a face rig and exports to Unity, Unreal and Godot, which is why it has passed 68,700 sales on Superhive. If you want a free rig and don't mind placing bones yourself, Rigify is already inside Blender. If you want a humanoid game character rigged, animated with 260 CC0 clips and exported with engine presets for one $29 payment, the Cinevva Rig add-on does that on your own machine, offline.

Quick picks

• Most complete, worth the money: Auto-Rig Pro Full, $50 once on Superhive, free updates. Facial rig, multi-limb creatures, Remap retargeting, Unity, Unreal and Godot export.
• Free and already installed: Rigify, bundled with every Blender. You place the metarig bones by hand, Blender computes the weights, and you fix the deform hierarchy before exporting to a game engine.
• You already have a skeleton: ARP: Quick Rig, $12.50, turns a Mixamo, Character Creator, DAZ or VRoid skeleton into an Auto-Rig Pro control rig. It needs Auto-Rig Pro installed.
• Humanoid for a game, cheapest all-in: the Cinevva Rig add-on, $29 launch price, one purchase. Rigging runs locally and offline, 260 CC0 animations retarget inside Blender, export presets for Unity, Unreal, Godot and the web. Blender 4.2 and newer on Windows, macOS and Linux.
• Weights are your only problem: Voxel Heat Diffuse Skinning, $30, fixes "bone heat weighting: failed to find solution for one or more bones" and skins multi-part characters.
• "Auto-Rig Pro free download": there isn't one. It's a paid add-on. The legitimate free paths are Rigify and the first character on Cinevva's web Auto Rigger.

Quick reference

What Auto-Rig Pro actually is, and why it leads

Auto-Rig Pro is Artell's add-on for rigging characters, retargeting animations and exporting to game engines, first released in 2016 and updated ever since. The Superhive listing shows two editions. Full costs $50 and bundles "Auto-Rig Pro core, Smart tool (biped body recognition), Fbx/Gltf export to Unreal/Unity, Remap tool to retarget animations, updates and support messages". Lite costs $25 and is "Auto-Rig Pro core only". Studio seats are $162 for ten and $227 for twenty. The listing declares compatibility from Blender 2.93 through 5.1 and marks the add-on as Blender Extension compatible.

Its sales count is the plainest evidence of category leadership: 68,700 and climbing, with more than 430 ratings. The next biggest rigging-related sellers on Superhive, Voxel Heat Diffuse Skinning and Quick Rig, sit at 12,500 and 9,500.

Here's what that $50 buys, in the add-on's own terms.

Smart placement. You add green markers to a biped in T-pose or A-pose and the Smart tool places the reference bones, which stay editable. The Smart documentation adds an optional Guess Markers step: "An AI model has been implemented in option, to setup automatically the markers", using separately installed AI files. Without them, finger detection relies on "traditional algorithms (Voxel centroids for fingers detection, depth estimation based on standard human proportions...)", per the FAQ. That FAQ answers "So, it's a magic one click rigging solution?" with "It's not!" and says "the rigging artist's hand is still required to adjust the bones positions, vertex weights". Remember that when anything else promises one click.

A modular rig definition. Spine, arms with fingers, legs with toes, head and neck, ears, tail, wings, kilt, spline IK and bendy-bone chains, with Human, Dog, Horse and Bird presets. Duplicate or remove limbs and you can rig a centaur or a spider. Only Rigify comes close here, and no automatic rigger, ours included, competes.

A facial rig. Eyebrows, eyelids, lips, cheeks, jaw and eye targets, placed by the Smart tool's facial pass and editable afterwards.

Skinning. Auto-Rig Pro binds with Blender's own automatic weight solver plus two switches. The FAQ's fix for "Binding doesn't give satisfying results" is Voxelize, which evaluates "voxelized instances of meshes (water-tight, closed volumes)", and Split Parts for "meshes made of multiple disconnected pieces (clothes, teeth, eyes...)". The listing also calls it "Compliant with the Voxel Heat Diffuse Skinning addon".

Remap. The Remap tool retargets "an armature animation to another one", onto "any type of armature (Auto-Rig Pro, Rigify, custom rig...)". Import a BVH or FBX, assign source and target, click Build Bones List, correct the mapping or load a Mixamo, Rokoko or XSens preset, mark the root and IK bones, retarget. Remap moves animations you already own. Auto-Rig Pro ships none.

Game engine export. File > Export > Auto-Rig Pro FBX/GLTF. The export docs offer "Humanoid for human characters, Universal for any skeletons", with "Full support in Unity, Unreal Engine, Godot". Root motion is handled per engine (Unity Humanoid computes it on import, Unity Generic and Unreal get the c_traj motion baked onto the armature object, Godot gets Export Root Bone with Godot Root Axes), the Unreal Mannequin hierarchy and axes are converted, twist bones are baked for engines without dual quaternion skinning, and shape keys export. One warning from the docs: "UE 5.5/5.6 don't import GLTF morph targets and animations properly. Works in 5.7."

That list is why it leads. One purchase covers marker to Mannequin, with a decade of backward compatibility behind it.

What Quick Rig adds

ARP: Quick Rig is a $12.50 extension with a warning in its first line: "Auto-Rig Pro must be purchased and installed first." It solves a different problem from rigging a bare mesh. You already have a skinned skeleton from Mixamo, Reallusion Character Creator, DAZ, Human Generator, the Unreal Mannequin or VRoid, and you want Auto-Rig Pro's controllers on it without re-rigging.

The Quick Rig documentation has you add limbs one by one (select the pelvis bone, click plus for a spine limb, select a shoulder, click plus for an arm), check the guessed bone names, then choose a mode. Preserve "keeps the existing armature untouched while binding it to the rig controllers only", Convert "will generate a full Auto-Rig Pro armature compliant with all Auto-Rig Pro editing and exporting tools". Weights are preserved, existing animation can be baked onto the control rig, and orphan bones such as facial, cloth and prop bones are inserted into the hierarchy so nothing is dropped. The listing states one limitation: "Multiple heads or multiple spines not yet supported." It shows 9,500+ sales and the same 2.93 to 5.1 range as the parent add-on.

If your characters come from Mixamo or Character Creator, Quick Rig plus Auto-Rig Pro is the combination that turns them into something you'd want to keyframe in Blender.

When Rigify is enough

Rigify ships inside Blender. The manual lists it under Rigging as "Automatic rigging from building-block components", GPL, and notes "This add-on is bundled with Blender." You enable it in Edit > Preferences > Add-ons, and there's nothing to buy or download.

The basic workflow is three steps. Add a metarig from Add > Armature (Shift-A), where the predefined types are Basic Human, Basic Quadruped, Human, Cat, Wolf, Horse and Shark. Edit the bone positions to match your character, in Pose Mode with Apply Pose As Rest Pose or in Edit Mode. Then in the Armature properties click Generate Rig, which "will take from few seconds to one minute". Skinning is Blender's own: select mesh then armature, Ctrl-P, With Automatic Weights, which the skinning manual describes as calculating influence "based on the distance from those vertices to a particular bone ('bone heat' algorithm)". The Rigify manual adds that this does "a really good job out of the box if you correctly place your bones (and there is enough topology to work with!)".

It's enough when you animate and render inside Blender and have twenty minutes to place bones. The generated rig has IK and FK limbs, a torso control, fingers and a modular face, though the manual warns face bones "can be tricky if you are not an expert in bone editing and they are almost useless if you plan to make facial animation through shape keys", and suggests deleting them if you don't need them.

Here's where it isn't enough.

Placement is manual. No marker detection, no guessing. The manual's alignment tips ask for straight legs in front view, a slight bend at knees and elbows because Rigify "needs to know where your knee/elbow is pointing", and a human about two units tall, since "Rigify assumes that 1 unit corresponds to 1 meter". Placing a full Human metarig well is a skill, and a first attempt usually produces a knee that bends sideways.

Game export needs a fix. Deforming bones live in the DEF collection, organised for Blender rather than an engine. Blender's tracker recorded it in issue #57536, "rigify: rigs don't export well to game engines": "rigify splits the deformation bones (layer 29) into separate chains for each module. Once non deformation bones have been deleted, baked animations are likely break, and limbs won't follow the body." It was closed with the maintainer's note that "there are no plans, and few reasons, to change rigify architecture only to accomodate games", pointing to his Expy-Kit add-on. The workaround: reparent the DEF bones into one hierarchy (Expy-Kit or CGDive's Game Rig Tools), then export FBX with Only Deform Bones ticked and Add Leaf Bones unticked in the Armature section of the FBX exporter. It works, but it's an extra tool and a checklist on every export.

No animations. Clips come from you, from Mixamo, or from a retargeter such as Auto-Rig Pro's Remap, which lists Rigify as a supported target.

Other paid options you can verify

Voxel Heat Diffuse Skinning by Mesh Online, $30 for one seat, 12,500+ sales, Blender 3.6 to 5.1 per its Superhive page. It isn't a rigger. It replaces bone heat weighting with a voxel solver, and its pitch names the three problems it fixes: the error "bone heat weighting: failed to find solution for one or more bones", parts and accessories that automatic weights ignore, and weights you've spent hours on and still hate. Twelve thousand people paying $30 to skip weight painting tells you where rigging's pain sits. Auto-Rig Pro and Rigify both benefit from it. Cinevva's add-on computes its own weights, so you'd reach for it only when the automatic result is wrong.

Better FBX Importer & Exporter, also Mesh Online, $25 for one seat, 12,600+ sales, Blender 3.6 to 5.1 per Superhive. It sells because FBX imports stop breaking: Automatic Bone Orientation untwists Maya and 3ds Max skeletons, and it exports "game engine friendly armature and 3d models" with LODs for Unreal and Unity. If you rig with Rigify and export by hand, this fixes the import half of the problem.

The Mixamo add-on for Blender needs a status check because people still search for it. Adobe's Substance 3D plugins page still describes a "one-click solution to create an IK control rig" for Mixamo-rigged characters. The maintained version is the community Mixamo Rig extension on extensions.blender.org, which calls itself a "3rd party upgrade to official addon because it is no longer supported", points to Adobe's "official version for Blender 3.6", and lists Blender 4.2 LTS compatibility, version 1.2.2 from April 2026 and about 69,700 downloads. The route is alive but community-maintained, and Mixamo's rigger itself is online only. Our free character animations guide covers Mixamo's terms.

We wanted to include BoneBrush, a creature rigger on Superhive, but its product page wouldn't load for us this session, so we can't state its price or scope.

The Cinevva Rig add-on: the one-time option for humanoids

The Cinevva Rig add-on is what we built for the reader who has a humanoid mesh and a game to ship. It runs on your own machine, offline, for one $29 purchase at launch price, on Blender 4.2 and newer for Windows, macOS and Linux. It installs as a standard extension and the download itself is free, with a 14-day refund if it isn't for you.

It has three parts, and only one is paid.

Rigging is what the $29 key turns on. Select a mesh, pick the front of the character from four rendered views, press Rig. The add-on downloads its rigging engine once, about 2.4 GB, and from then on rigs locally with no per-rig charge and no count. The result is a skinned, Mixamo-named humanoid armature, and the panel reports what it built: how many bones, how many fingers it found, anything it corrected. A key activates up to three machines. If you'd rather not download the engine, or you have a quadruped, online rigging is available from inside Blender with a Cinevva account and costs credits.

260 CC0 animation clips come with the add-on regardless of the key: walks, runs, idles, combat, climbing, crawling, emotes. A browser docked in the viewport previews each clip, and a click retargets it onto your rigged character inside Blender. CC0 means no licence line in a shipped game. Mixamo's terms are Adobe's to set, and Auto-Rig Pro ships no clip library at all.

Game-ready export is free, no key, no account, no network. Before you export, a size analysis splits the estimated file into geometry, textures, animation and shape keys. Then a preset sets the engine's conventions. Web writes GLB, Y-up, textures capped at 1024 px as WebP at quality 85, Draco level 6, for three.js, Babylon.js and model-viewer. Unity writes FBX, forward -Z, up Y, FBX_SCALE_ALL, no leaf bones, textures embedded and capped at 2048 px. Unreal writes FBX, forward -Y, up Z, FBX_SCALE_NONE, primary bone axis Y and secondary X. Godot writes GLB, Y-up, no Draco because Godot 4 imports plain glTF cleanly, textures capped at 2048 px. Measured against a plain Blender GLB export, the presets produced files 68%, 89%, 92% and 98% smaller on four real models.

Now the limits. It's humanoid-first: bipeds rig locally, anything else goes through the online Pro engine on credits. It builds no facial rig. And it hands you a deform skeleton, not an animator's control rig, so if you keyframe by hand in Blender you'll want Rigify or Auto-Rig Pro on top. What it replaces is the hour of marker placement, weight cleanup, clip hunting and export fiddling between a finished mesh and a character walking in your engine.

"Auto-Rig Pro free download": what you actually get

More than a thousand people a month search for a free download of Auto-Rig Pro. Here's the straight answer. It's a paid add-on, $25 for Lite and $50 for Full, with no free edition. The licence page says "Auto-Rig Pro cannot be freely distributed as is. Some components are GPL, some are not." The Blender Python parts are GPL-3, but the Smart tool's AI binaries are under a "restrictive copyrighted license" that forbids redistribution. A "free download" from a warez site is a pirated copy: no updates, no support, no AI files that legally work, and whatever else the uploader packed into the zip.

The legitimate free paths are real and good. Rigify is already in your Blender. Cinevva's web Auto Rigger rigs your first humanoid free, from a GLB, FBX or OBJ up to 50 MB, and returns a rigged GLB you can open in Blender. Mixamo still rigs humanoids online for free with an Adobe ID. To try Auto-Rig Pro's rig before paying, download Mike, the free character Artell links from the Superhive listing. The cheapest legitimate way into Auto-Rig Pro itself is Lite at $25, which drops Smart, Remap and the game exporter.

Pick by situation

You animate and render in Blender. Rigify if you're comfortable placing bones, Auto-Rig Pro if you want Smart placement and a face. Both give you the IK and FK controls hand animation depends on.

You're an indie shipping a humanoid to Unity, Unreal, Godot or the web. The Cinevva Rig add-on. One $29 payment, rigging on your machine, 260 CC0 clips retargeted, and a preset that matches your engine's axes and scale so the character stands up straight on first import. For hand-keyed cinematics later, add Rigify on top for free.

You have a library of Mixamo or Character Creator characters. Auto-Rig Pro Full plus Quick Rig, $62.50 together. Quick Rig converts each skeleton into a control rig with weights intact, Remap moves clips between them, and the exporter puts them back into the engine.

You rig creatures, robots or unusual body plans. Auto-Rig Pro. Its limb system and Dog, Horse and Bird presets are why CGDive can teach a T-rex, a fox and a bird with it. Rigify's Cat, Wolf, Horse and Shark metarigs are the free fallback if you'll place every bone.

The rig is fine, the weights aren't. Voxel Heat Diffuse Skinning, $30, under whichever rigger you use.

Your imports keep breaking. Better FBX Importer & Exporter, $25, before you blame the rigger.

Common Questions

Is Auto-Rig Pro free, or is there a free download?

No. Auto-Rig Pro is a paid add-on, $25 for Lite and $50 for Full on Superhive, with free updates after purchase. Its licence page states it "cannot be freely distributed as is", and the Smart tool's AI binaries forbid redistribution, so sites offering a free download are handing out pirated copies with no updates and no working AI files. Artell's free character Mike lets you try the generated rig, and the legal free routes to a rig are Rigify, Cinevva's web Auto Rigger for your first character, and Mixamo with an Adobe ID.

Is there a free alternative to Auto-Rig Pro?

Rigify, which is bundled with every copy of Blender and enabled in Preferences. It generates a full control rig from a metarig you position by hand and skins with Blender's Automatic Weights. For a humanoid game character you can also rig your first one free on Cinevva's web Auto Rigger, which places bones and weights automatically and returns a rigged GLB.

Rigify vs Auto-Rig Pro, which should I use?

Use Rigify if your budget is zero, you animate inside Blender, and you can spend twenty minutes placing bones. Use Auto-Rig Pro if you want Smart marker placement, a facial rig, creature limbs, mocap retargeting with Remap, or a game exporter that handles Unity, Unreal Mannequin and Godot conventions for you. Rigify rigs need a deform-bone fix before a clean engine export, Auto-Rig Pro's exporter does that work itself.

What is ARP Quick Rig?

Quick Rig is a $12.50 extension for Auto-Rig Pro that converts an existing skinned skeleton into an Auto-Rig Pro control rig, keeping the weights and optionally baking the existing animation onto the new controls. It ships mapping presets for Mixamo, Reallusion Character Creator, DAZ, Human Generator, the Unreal Mannequin and VRoid. It does nothing on its own, since Auto-Rig Pro must be installed first.

What is the best rigging addon for Blender?

For breadth, Auto-Rig Pro, and its 68,700+ sales on Superhive say most Blender users agree. For price, Rigify, because it's free and already installed. For a humanoid game character with animations and engine export included, the Cinevva Rig add-on at a one-time $29 covers more of that specific pipeline than either. Best depends on whether you're an animator, a game artist, or both.

Does the Cinevva Rig add-on replace Auto-Rig Pro?

Not for animators. Auto-Rig Pro builds a facial rig, rigs creatures and multi-limb characters, retargets mocap and gives you an animator's control rig, and the Cinevva add-on does none of that. It replaces the humanoid game pipeline: automatic bone placement and weights on your machine, 260 CC0 clips retargeted in Blender, and export presets for Unity, Unreal, Godot and the web, for one $29 purchase on Blender 4.2 and newer.

Related

• How Automatic Rigging Works (and How to Prepare a Model for It): what a rig is, how auto riggers place joints, and the ten-minute mesh prep that makes any of them work
• Free Character Animations and Auto-Rigging: Mixamo and Its Alternatives: Mixamo's status and licence in 2026, plus the CC0 clip libraries
• Best Free Rigged 3D Character Models for Games: skip rigging entirely with characters that already have a skeleton
• Cinevva Rig for Blender: the add-on, the $29 launch price, and how the key works
• Auto Rigger: rig your first humanoid free in the browser, GLB, FBX or OBJ up to 50 MB
• Character Animation Library: preview the same 260 CC0 clips on your own rigged model
• How to Rig a Character in Blender (2026): Rigify, manual armatures and the one-click route, step by step
• Blender Weight Painting: The 7 Problems Everyone Hits: fixing weights by hand, and skipping the step

Last updated: September 2026.

Automatic rigging fits a skeleton inside a static 3D character and works out how much each bone pulls on each vertex, so the mesh bends when the bones move. Every auto rigger, whether it fits a template skeleton to markers (Mixamo, Auto-Rig Pro) or predicts joints with a trained model (RigNet, UniRig, Cinevva's Auto Rigger), wants the same input: one connected mesh in a T-pose or A-pose, at human scale, facing forward, with nothing else in the file. Give it that and a humanoid rigs in under a minute. Give it a posed, multi-shell model with props and you get folded elbows and a floating hat.

Quick answer

• What a rig is: a hierarchy of joints plus, for every vertex, up to four joint indices and weights that sum to one. In glTF that's the skins array and the JOINTS_0 and WEIGHTS_0 vertex attributes.
• How auto riggers place joints: by fitting a template skeleton to landmarks on your mesh, or by predicting joint positions from the geometry with a trained model.
• What to give it: one watertight mesh, T-pose or A-pose, origin at the feet, about 1.8 metres tall, transforms applied, normals outward, no armature, no props.
• How to check it: bend an elbow and a knee, look at the armpits and hips, twist a wrist and watch for the candy-wrapper pinch.
• Fastest route in 2026: upload a GLB, FBX, or OBJ to the Auto Rigger and get a rigged GLB back with animations baked in.

Quick reference

What a rig actually is

A skeleton. A tree of joints, each a transform relative to its parent. Move the shoulder and the elbow, wrist, and fingers come along. In glTF the skeleton isn't a separate structure: the glTF 2.0 specification's Skins section says "the joint hierarchy used for controlling skinned mesh pose is simply the node hierarchy", with a skin.joints array naming which nodes are joints. That's why the GLB viewer shows bones as ordinary nodes in the scene graph.

A bind pose. The pose the character held when the skin was attached. glTF stores it as inverseBindMatrices, one MAT4 per joint, "used to bring coordinates being skinned into the same space as each joint". When a downloaded animation folds a character's arms through its chest, this is usually the piece that disagrees.

Skin weights. For each vertex, which joints move it and by how much. glTF puts these in the JOINTS_n and WEIGHTS_n attributes, both VEC4, so each set carries up to four influences per vertex. Weights "MUST NOT be negative" and their sum "SHOULD be as close as reasonably possible to 1.0". A vertex mid-forearm is 100% forearm. A vertex at the elbow crease might be 55% upper arm and 45% forearm, and that blend is what makes the crease bend instead of tear. This is linear blend skinning, the maths every engine runs in its vertex shader, and it has one famous weakness we'll meet at the wrist.

Here is where each piece lives on the character.

Rigging means placing the joints and computing the weights. By hand it's an afternoon per character. Automatically it's seconds to minutes.

How an auto rigger places joints

Template fitting. The tool has one humanoid skeleton and needs to know where your landmarks are. Mixamo asks you: Adobe's rigging help page has you upload an FBX, OBJ, or ZIP, "place the markers on key points (wrists, elbows, knees, and groin)", and confirm, after which rigging "usually takes a few minutes". (Mixamo is still online and free with an Adobe ID as of September 2026, but its help pages date from September 2021 and it had a multi-day outage in June 2025, so keep the rigged file.) Auto-Rig Pro's Smart mode does the same inside Blender, and "an AI model has been implemented in option, to setup automatically the markers". Rigify is the fully manual end: per the Rigify basics page, "meta-rig bones must be moved to correct positions" before you press Generate Rig. Template fitting is predictable and gives you a standard bone set, which is what retargeting wants. It fails when the character doesn't match the template: extra limbs, no neck, a tail.

Learned joint prediction. The tool has seen thousands of rigged characters and predicts where joints belong on yours. RigNet (SIGGRAPH 2020) was the milestone: a network clusters vertices into joint candidates, then separate networks pick the root, decide connectivity, and predict weights. It trained on 2,703 rigged models and needs input remeshed to between 1,000 and 5,000 vertices, a hint at how sensitive these models are to mesh density. UniRig (SIGGRAPH 2025, Tsinghua University and Tripo) collapsed that into one autoregressive transformer that writes the skeleton out as a token sequence, so the tree is valid by construction, then predicts weights with bone-to-point cross attention. Its Rig-XL training set has over 14,000 rigged models across humans, animals, and objects, which is why it handles a dragon where template tools can't. The code is MIT-licensed, with the full Rig-XL checkpoints listed as coming soon. Learned prediction needs no markers and copes with more body plans, but joints land where the training data says joints usually are, so unusual proportions get averaged toward normal.

Cinevva's Auto Rigger is in the second family. It detects whether the upload is a biped or a quadruped, fits a skeleton, and binds the vertices with no markers to place. The Fast engine handles humanoids and is behind the free first download. Quadrupeds and awkward humanoids go to the Pro engine on the Standard and Pro plans. The Blender add-on runs the same Fast engine locally and reports how many bones and fingers it found.

Why the pose and a single mesh matter

Adobe's Mixamo FAQ states the assumptions every rigger shares: the character should have "distinguishable head, body, arm, and leg areas", be "in a default or neutral pose", have "no other content in the file", have "no spaces between any of the parts", and be "centered in the scene". Here's why.

T-pose or A-pose. Marker placement and learned prediction both find limbs by looking for tubes of geometry sticking out of a trunk. Arms at the sides merge into the body and the weights bleed across, so raising the arm drags the ribcage with it. An A-pose (arms down about 45 degrees) often skins the shoulders a little better than a strict T because the armpit is less stretched. Crossed arms or a hero pose don't work, and the rig gets built as if that pose were neutral.

One connected mesh. Weights are computed from distance through the mesh volume, not through the air. Blender's manual describes its Automatic Weights as working "based on the distance from those vertices to a particular bone ('bone heat' algorithm)", and learned riggers use similar geodesic features. A head floating a millimetre above the neck or a glove that is a separate shell is a separate island, and the solver guesses how it connects. Often the glove stays behind when the arm moves.

Side by side, the difference is easy to spot before you upload.

Scale and origin. Rigify says it outright: "Rigify assumes that 1 unit corresponds to 1 meter. So a human is about 2 units tall." Learned riggers trained on characters at roughly human scale too. A character exported from a centimetre-based tool at 180 units tall is outside what any rigger expects, and so is one whose origin sits at the hips.

What breaks, and why

Clothing shells are the most common real-world failure because generated and marketplace characters are usually built that way. Auto-Rig Pro offers a Voxelized skinning mode for "multiple layers of clothes, props, complex topology" for exactly this reason. If your tool has one mode, merge the clothes into the body first. Quadrupeds are a body-plan question: Mixamo is for "bipedal humanoids only", while Tripo's rigging API has a v2.5-20260210 model for "quadruped, hexapod, octopod, serpentine, aquatic, avian" rigs and Cinevva's rigger sends quadrupeds to its Pro engine.

Prepare your model in 10 minutes

All in Blender, on a copy.

Delete everything that isn't the character. Cameras, lights, the floor, the old armature, any animation. Mixamo's FAQ: "extra helper objects, cameras, or scene objects cause the auto-rigger to not work."

Join and merge. Select every mesh that should deform with the body and join them (Ctrl-J). In Edit Mode select all and run Mesh, Merge, By Distance, which merges "each cluster of vertices that are closer to each other than a certain distance". Start the Merge Distance at 0.0001 m and raise it only if a seam still gapes. Leave a sword out: rig the body, then parent the prop to the hand bone, which the glTF spec allows since "a joint node MAY have other nodes attached to it".

Recalculate normals. Mesh, Normals, Recalculate Outside (Shift-N), which "flips the orientation of the selected faces where necessary, making them all point outward". Turn on the Face Orientation overlay first: red is inside out.

Pose it neutral. If the character came posed, move the arms to a T or A and straighten the legs with a temporary armature or proportional editing. Arms 20 to 30 degrees from the body still rig far better than arms at the sides.

Set origin and scale. Origin at the bottom of the feet, character at world zero. Check Dimensions in the N panel: a human should read 1.7 to 1.9 metres. If it reads 180 or 1800, scale it down.

Apply transforms. Object, Apply, All Transforms (Ctrl-A). The manual's own warning: "It is recommended to apply transforms before rigging and animation." This bakes rotation and scale into the vertices, so the rigger doesn't see a 0.01-scaled object rotated 90 degrees on X, which is how most FBX imports arrive.

Export a GLB. File, Export, glTF 2.0, format glTF Binary (.glb), which the exporter documentation describes as "a single .glb file with all mesh data, image textures, and related information packed into a single binary file". Tick Include, Selected Objects. Leave Transform, +Y Up on. Under Data, Mesh tick Apply Modifiers, UVs, and Normals. Leave Animation off. Open the result in the GLB viewer to confirm one mesh, no skeleton yet, and a size under the Auto Rigger's 50 MB limit. The rigger also takes FBX and OBJ directly, including a zipped OBJ bundle with textures.

Judge a rig in 30 seconds

A rest pose hides everything. Pose it or play a clip instead (the GLB viewer has a Bones overlay and plays baked clips).

Bend an elbow and a knee to 90 degrees. The inside should crease, not fold flat, and the outside should keep its volume. A knee that pinches flat means the weights transition over one vertex loop instead of three or four, a mesh density problem more than a rigger problem.

Raise the arms overhead and look at the armpits, then squat and look at the hips. Three joints meet at each. Bleeding shows as the chest lifting with the arm, and clothing shells show up as a trouser leg the thigh pushes through.

Twist a wrist 90 degrees and watch the forearm. If it narrows to a pinched waist halfway along, that's the candy-wrapper artefact of linear blend skinning: a vertex weighted half to each of two joints gets a blend of a rotated and an unrotated matrix, and the blend shrinks toward the axis. Every auto rigger produces some of it. Forearm twist bones or dual quaternion skinning in the engine hide it.

Play a walk. Feet should plant at contact. Sliding feet usually mean the clip is authored in place and your game is meant to move the character. Sinking or floating feet mean the rig's scale disagrees with the clip's.

If the first four pass, the rig is good enough for a game. If two fail, fix the mesh and rig again rather than painting weights: the second attempt takes a minute, painting takes an hour.

How animations get onto a rig

Animations almost always come from somewhere else: a library, mocap, or a text-to-motion model. Retargeting copies a clip made for one skeleton onto another with different bone names, proportions, and bind pose.

Bone naming is the first hurdle, which is why humanoid conventions matter. Mixamo names its bones mixamorig:Hips, mixamorig:LeftArm and so on, and because so many clips were built for it, "Mixamo-compatible" became a de facto standard: Tripo's API offers a mixamo spec for "Mixamo-compatible bone naming", and Cinevva's Blender add-on outputs a Mixamo-named skeleton. The VRM humanoid specification defines roles instead of names: 15 required bones (hips, spine, head, and the upper leg, lower leg, foot, upper arm, lower arm, and hand per side) plus optional chest, neck, eyes, jaw, toes, and fingers. Unity's Humanoid avatar needs the same "at least 15 bones" and a T-pose. If your rig has those 15, it retargets to almost anything.

Proportions and bind pose are the second hurdle. Copying local rotations between two skeletons whose bones point along different local axes puts the arms out by 90 degrees. Cinevva's Animation Library sidesteps this by solving in world space: for each frame it "works out where the source joint actually is relative to its own bind pose, then puts your joint in the matching place relative to yours". It matches names flexibly (mixamorig:LeftArm, LeftArm, and left_arm all resolve), treats fingers as optional, and retargets 260 CC0 clips onto any humanoid you upload. Prompt Animations does the same for generated motion, mapping a 77-bone source skeleton's 22 body bones onto your character and auto-detecting Mixamo, Tripo, Reallusion CC4, UE5, and generic naming.

Quadrupeds don't get this. There's no sensible mapping from a biped's spine to a dog's, so a four-legged rig comes back from Cinevva's rigger with a walk cycle baked in and no library to browse.

Where auto rigging still fails

Fingers. Twenty small bones in a few centimetres, often modelled as a mitten or with fingers touching. Learned riggers find three fingers on one hand and five on the other, or fuse a thumb to the palm, which is why Cinevva's add-on reports the finger count and the Animation Library treats fingers as optional. Auto-Rig Pro's guidance for finger detection is "fingers spread apart" with "the palm must face the floor".

Faces. No body rigger does facial animation. Expressions come from blend shapes (glTF morph targets) or a separate facial rig, and generated characters usually have neither.

Skirts, capes, coats, long hair. These need physics or their own bone chains. A body rigger weights them to the nearest leg or spine bone, so a skirt bends with the thigh and a cape hangs rigid. Rig the body, then add cloth simulation or chained bones in your engine.

Wings and tails. Humanoid templates have no slot for them. Learned riggers trained on animals (UniRig, Tripo's v2.5 model, Cinevva's Pro engine) do place joints in tails, but wing membranes stay hard because they're thin sheets with joints at the edge. For a mech or anything else that isn't roughly a body, parenting rigid parts to bones by hand still beats asking a solver to skin pistons.

If you work in Blender

The same rigging runs inside Blender through the Cinevva Rig add-on: select the mesh, pick the front view, press Rig, and the skinned, Mixamo-named armature appears on your own model with your materials and modifiers intact. It rigs on your machine, offline, for one $29 purchase (launch price), plays the 260 CC0 clips on the result, and exports with presets for Unity, Unreal, Godot and the web. Blender 4.2 and newer on Windows, macOS and Linux. The Blender rigging how-to covers Rigify and manual armatures alongside it.

Common Questions

What is rigging in 3D?

Rigging is adding a skeleton to a 3D model and binding the mesh to it so the model can be posed and animated. The skeleton is a hierarchy of joints, and the binding is a set of skin weights saying how much each joint moves each vertex. In glTF that's a skins entry plus JOINTS_0 and WEIGHTS_0 attributes on the mesh.

How does automatic rigging work?

An auto rigger locates a character's joints from its geometry, either by fitting a template skeleton to landmarks or by predicting joint positions with a model trained on thousands of rigged characters, then computes skin weights from how each vertex sits relative to the bones. Cinevva's Auto Rigger does this in the browser for humanoids and quadrupeds, with no bone placement or weight painting.

How do I prepare a model for auto rigging?

One connected mesh, T-pose or A-pose, about 1.8 metres tall, origin at the feet on the world origin, facing forward, transforms applied, normals outward, and nothing else in the file. In Blender: join, Merge by Distance, Recalculate Outside, Apply All Transforms, then export a GLB with Selected Objects and Apply Modifiers on.

Can I rig a 3D model online?

Yes. Cinevva's Auto Rigger rigs a GLB, FBX, or OBJ up to 50 MB in the browser and returns a rigged GLB, with your first character free to download including up to six baked animations. Mixamo rigs humanoids online for free with an Adobe ID and exports FBX or DAE. Tripo's hosted rigger runs on API credits.

What are skin weights?

Skin weights are the per-vertex numbers that say how strongly each joint moves that vertex. glTF allows up to four joints per vertex per attribute set, weights can't be negative, and they should sum to 1.0. A mid-forearm vertex is weighted entirely to the forearm joint. An elbow vertex is split between upper arm and forearm, which is what makes the elbow crease smoothly instead of tearing.

Does auto rigging work on animals and quadrupeds?

Only if the rigger has a quadruped body plan. Mixamo is "bipedal humanoids only" per Adobe's FAQ. Cinevva's Auto Rigger detects a quadruped and rigs it on the Pro engine with a walk cycle baked in, Tripo's v2.5 model covers six creature plans, and Rigify ships Cat, Wolf, Horse, and Shark metarigs you fit by hand. Expect to animate the result yourself, since the big free clip libraries are humanoid.

Related

• Free Character Animations and Auto-Rigging: Mixamo and Its Alternatives: the roundup of free riggers and CC0 animation libraries, licences checked
• Best Free Rigged 3D Character Models: skip rigging with characters that already have a skeleton
• Best AI 3D Model Generators: which text-to-3D and image-to-3D tools produce meshes that rig cleanly
• Best AI Animation Generators for 3D Characters: text-to-motion tools to put clips on your new rig
• Best Free 3D Model Sites for Games: where to find characters worth rigging
• Game Asset Licenses Explained: what you can ship from each rigger and library

Last updated: September 2026.

The Blender add-ons that pay for themselves in game work are the ones that sit on a step you repeat for every asset: rigging, weight painting, UV packing, baking, and the export dialog. For most indie teams the shortlist as of September 2026 is Rigify (built in) or Auto-Rig Pro ($50) for rigs, Voxel Heat Diffuse Skinning ($30) when weights fail, Animation Layers ($30) for editing motion, Better FBX Importer & Exporter ($25) when FBX files break, UVPackmaster 4 ($55) and TexTools (free) for UVs, SimpleBake ($20) for textures, and Blender's own glTF exporter for anything that ships to the web or Godot. Everything below was checked against its Superhive or extensions.blender.org listing, its GitHub repository, or the vendor's own page this month.

Quick picks

• Rigging, free: Rigify, bundled with Blender, enabled from Edit > Preferences > Add-ons. Meta-rigs for humans, quadrupeds, cats, wolves, horses and sharks.
• Rigging, full control rig: Auto-Rig Pro, $50 for the full version, more than 65,000 sales on Superhive, Blender 2.93 to 5.1.
• Rigging, one purchase with animations and export included: the Cinevva Rig add-on, $29 launch price, rigs on your own machine offline, Blender 4.2 and newer on Windows, macOS and Linux.
• Skinning: Voxel Heat Diffuse Skinning, $30, fixes the "bone heat weighting: failed to find solution" error on non-watertight meshes.
• Animation editing: Animation Layers, $30, layers on top of Blender's NLA.
• Export that stops breaking: Better FBX Importer & Exporter, $25, built on the official FBX SDK.
• UVs: UVPackmaster 4 PRO, $55, GPU packing. TexTools, free, for texel density and layout.
• Baking: SimpleBake, $20 single user. Bake Wrangler, $25 indie, if you want a node graph.
• LODs: the Decimate modifier plus LODGen (free, Blender 4.5+) or LODify (free, Blender 4.2+).

Quick reference

Prices are the single-seat prices the listings showed when we read them, before sales and tax. Blender versions are the ranges the listings state. Where a listing is older than this month we say so.

How add-ons work in Blender 4.2 and newer

Blender 4.2 LTS introduced the Extensions Platform, and it changed where add-ons come from and how they update. The 4.2 release notes describe an extension as a zip archive holding the files plus a manifest with "license, copyright, permissions, useful links". The official directory is extensions.blender.org, which "only offers GNU GPL compliant software". That one rule explains the split you'll see below: free tools live on extensions.blender.org and install with a drag, while paid tools with a binary engine (Auto-Rig Pro's AI files, UVPackmaster's packer, Better FBX's SDK bridge) sell on Superhive or Gumroad and install from a zip.

The online-access permission. The first time you open Edit > Preferences > Get Extensions, Blender asks you to "Allow Online Access". The System preferences page explains the switch: "Add-ons that follow this setting will only connect to the internet if enabled. However, Blender cannot prevent third-party add-ons from violating this rule." So the toggle is a convention, not a firewall. An extension's manifest declares what it wants (Blendkit's asks for network and files), and the listing shows that under Permissions. Add-ons that run on your own machine don't need the network permission at all.

Installing and updating. The Extensions preferences list three routes: drag the Get button from the website into Blender, search inside Blender and click Install, or use the drop-down at the top right and pick Install from Disk for a zip. Extensions from a zip go into a Local Repository "and no updates will be available", so paid add-ons update through the vendor's own updater or a re-download. Even platform extensions "don't update automatically", per the About page: you check from the same drop-down, or turn on Check for Updates on Startup for the remote repository.

Legacy add-ons still work. The release notes are explicit: "Add-ons that haven't been converted to extensions yet, are still supported as legacy add-ons and can be installed from disk as usual." The Add-ons preferences page covers this under Installing Legacy Add-ons: click Install from Disk, pick the .py or .zip, then tick the checkbox to enable it. Most add-ons in this guide now ship as extensions, and Superhive marks them with a "Blender Extension Compatible: Yes" line.

Rigging

Rigify (free, bundled). The Rigify manual describes it as "Automatic rigging from building-block components", licensed GPL and bundled with Blender. You add a meta-rig from Add > Armature (Basic Human, Basic Quadruped, Human, Cat, Wolf, Horse, Shark), move its bones onto your mesh in Edit Mode, then press Generate Rig in the armature properties. Rigify assumes one unit is one metre, so a human should be about two units tall before you start. You get a full animator's control rig for free, and the cost is your time placing bones and painting weights. For a game export you'll want a deform-only skeleton, which is where Better FBX (below) and Auto-Rig Pro's export step earn their keep.

Auto-Rig Pro ($50 full, $25 Lite, $162 for 10 seats). This is the category leader, with more than 65,000 sales on Superhive and a listed range of Blender 2.93 to 5.1. The Smart tool places bones on humanoids from a few markers, and since version 3.74 an optional 400 MB AI file pack (installed separately) places the markers for you. The Remap tool retargets any armature's animation to any other, and the Game Engine Export module writes FBX or glTF with "dedicated settings for Unity, Unreal Engine, Godot". The FAQ is honest about what it isn't: "It's not a magic one click rigging solution", the artist still adjusts bone positions and weights. If you animate in Blender and want one tool that rigs, retargets, and exports, this is the one to buy.

Cinevva Rig ($29 launch price, export half free). The Cinevva Rig add-on takes the other approach: select a mesh, press Rig, get a skinned, Mixamo-named humanoid skeleton. Rigging runs on your own machine, offline, after a one-time engine download of about 2.4 GB, with no per-rig charge and no count. It supports Blender 4.2 and newer on Windows, macOS, and Linux, installs as a standard extension, and the Python is GPL-3.0 (the purchase covers engine access, activation on up to three machines, the animation catalogue, and updates). What earns it a place here is what comes with the rig: 260 CC0 animation clips (walks, runs, idles, combat, climbing, crawling, emotes) retargeted onto your character inside Blender and previewed in a browser docked in the viewport, plus game-ready export presets covered below. CC0 means no licence line in your shipped game. You don't get an animator's control rig, so if you keyframe by hand you'll still want Rigify or Auto-Rig Pro on top. There's a 14-day refund.

The Mixamo add-on. Adobe still hosts a Mixamo Blender add-on page: a GPL-3.0 "auto control-rig add-on" that builds an IK control rig on a Mixamo skeleton and bakes animation in and out of it. Adobe's page doesn't state a supported Blender version. A community fork on extensions.blender.org, Mixamo Rig (version 1.2.2, GPL-3.0, Blender 4.2 and newer, about 69,700 downloads), describes itself as a "3rd party upgrade to official addon because it is no longer supported" and says the official build targets Blender 3.6. If you use Mixamo clips in 2026, install the community extension. Mixamo itself stays free with an Adobe ID, and its FAQ says you can use characters and animations royalty free in commercial projects including video games, with the caveat that "the auto-rigger and animation libraries are for bipedal humanoids only".

Skinning

Voxel Heat Diffuse Skinning ($30 indie, $180 for 10 seats). Blender's Automatic Weights work well on a single watertight mesh and fall over on the way artists actually build characters: hair, eyes, armour and clothes as separate shells. The Superhive listing names the three problems it fixes, starting with the exact error message "bone heat weighting: failed to find solution for one or more bones". It voxelises the character so weights diffuse through volume rather than across a broken surface, and it bundles a Surface Heat Diffuse Skinning mode, a Corrective Smooth Baker, and a Joint Alignment Tool. More than 12,500 people have paid for it, the clearest evidence in this list that skipping weight painting is worth $30. Listed for Blender 3.6 to 5.1, GPL Python with a separate compiled solver.

If you don't want to spend, the built-in Corrective Smooth modifier softens the worst bends after Automatic Weights, and the auto-riggers above produce their own weights so you rarely touch the brush at all.

Animation

Animation Layers ($30 single, $200 for 10 seats). Tal Hershko's add-on wraps Blender's NLA editor in a layers panel that behaves like the one in Maya or a DAW: add a layer, key on top of your mocap or base cycle, adjust influence, mute or solo, then merge or bake. The listing states support for Blender 3.2 to 5.1 (with a note that it was updated for the 4.4 action Slots), 9,600 sales, GPL. Use it to clean mocap or add a head turn to a walk cycle without touching the original curves.

Rokoko Studio Live (free, LGPL-3.0). Rokoko's GitHub repository streams motion capture from Rokoko Studio into Blender in real time, retargets between armatures, and handles 52 facial blendshapes. The latest tagged release is 1.4.3 from September 2025, the repository was still active in May 2026, and the README asks for Blender 2.80 or higher. You don't need Rokoko hardware to use the retargeting panel.

MotionGen ($29 Pro, $57 Gold, $1 Lite limited to three-second clips). Despite the name, this is video-to-animation, not text-to-motion. The Superhive listing says it extracts motion from MP4 or AVI footage entirely on your machine (one online licence check) and retargets with one click onto Rigify, Unreal Mannequin or MetaHuman, and Mixamo rigs. Listed for Blender 3.6 to 5.2 with an MIT licence, around 100 sales, and one hard requirement: "Currently, only Windows and NVIDIA GPU supported".

Mixamo clips stay the free default for a humanoid, and the community Mixamo Rig extension above turns them into something you can edit.

Export and pipeline

glTF 2.0 exporter (free, bundled). Reach it from File > Export > glTF 2.0 (.glb/.gltf). The manual covers what game developers need: a single .glb "with all mesh data, image textures, and related information packed into a single binary file", Draco mesh compression under Data > Compression with a compression level and quantization bits, WebP image output with a quality slider ("If WebP is chosen, all textures will be saved as WebP, without any png/jpg fallback"), and Optimize Animation Size, which removes duplicate keyframes. This is the exporter three.js, Babylon.js and Godot want.

FBX exporter (free, bundled). File > Export > FBX (.fbx). The FBX manual page is candid about the limits: "Animation support is minimal currently", bones need an orientation correction because FBX bones are -X aligned while Blender's are Y aligned, and imported actions aren't linked to objects. It works for the common Unity and Unreal cases when you set forward and up axes correctly, apply scale, and untick Add Leaf Bones. When it doesn't, the next entry exists.

Better FBX Importer & Exporter ($25 indie, $150 for 10 seats). Mesh Online rewrote FBX import and export on top of the official FBX SDK, and 12,600 people have bought it because "when we import some earlier and newer FBX files, it often fails" is a daily experience. The listing claims compatibility with every FBX version from 5.3 to 2020, imports FBX, DAE, OBJ, DXF and 3DS, exports mesh LODs for Unreal and Unity (version 6.2.0), supports Blender 4.2's drag and drop and Collection Exporters (version 6.1.0), and exports "game-friendly armature from Rigify". It does not support IK bones. Listed for Blender 3.6 to 5.1, GPL Python with a compiled SDK bridge. If you receive FBX files from Maya or 3ds Max artists, buy this first.

Send to Unreal (free, MIT). Epic's own BlenderTools repository describes it as "A one-click solution for sending assets from Blender to Unreal Engine", with a sibling add-on, UE to Rigify, that retargets Marketplace animation onto Rigify rigs. The last tagged release is Send to Unreal 2.4.3 (November 2023) and its bl_info asks for Blender 3.3 or newer, but the repository was pushed to in September 2026, so it isn't abandoned.

Godot needs no add-on. The Godot import docs say the editor "can directly import .blend files by calling Blender's glTF export functionality in a transparent manner", which needs Blender 3.0 or later installed (3.5 or later recommended) and, if Godot can't find it, a path set under Editor Settings > Filesystem > Import > Blender > Blender Path. The old Godot Blender Exporter that wrote .escn files "is not maintained or supported in Godot 4.x". FBX imports through ufbx since Godot 4.3.

Unity and .blend files. Unity's model formats page says .blend files "fail to import unless you have the corresponding 3D modeling software installed", so every teammate needs Blender. Export FBX instead.

Cinevva Rig export presets (free, no key, no account, no network). The export half of the Cinevva Rig add-on works without a purchase. It first shows a size analysis that splits the estimated file into geometry, textures, animation and shape keys, then applies a preset per engine: Web (GLB, Y-up, textures capped at 1024 px and re-encoded as WebP at quality 85, Draco level 6), Unity (FBX, forward -Z, up Y, FBX_SCALE_ALL, no leaf bones, textures embedded at 2048 px), Unreal (FBX, forward -Y, up Z, FBX_SCALE_NONE, primary bone axis Y and secondary X), and Godot (GLB, Y-up, no Draco because Godot 4 imports plain glTF cleanly). Against a plain Blender GLB export the presets produced files 68%, 89%, 92% and 98% smaller on four real models. If you only want the size breakdown and the axis settings done right, install it and never buy the key.

Modelling and UVs for game assets

Hard Ops and Boxcutter ($38 for the bundle on Superhive, $19 each on Gumroad). TeamC's pair is the standard hard-surface kit: Boxcutter draws boolean cuts directly in the viewport, Hard Ops manages the resulting modifier stack, bevels, mirroring and sharpening from a single Q menu. The bundle listing shows 47,800 sales and Blender 3.5 to 5.2, GPL. For props, weapons and vehicles it's the fastest route from block-out to bake-ready high poly, and boolean output stays triangle soup until you retopologise or decimate for the game mesh.

UVPackmaster 4 PRO ($55 single user on Superhive, $44 on Gumroad, $199 for a 2 to 5 seat studio). A GPU-accelerated packer using CUDA and Vulkan that also runs on the CPU and every GPU at once, with grouping, stacking, alignment and a Python-scriptable engine. The listing states Blender 2.93 to 5.1 and 18,600 sales. Packing efficiency translates directly into texture memory, so this is the paid UV tool that pays back fastest on a project with many props.

TexTools (free, GitHub). The README calls it "Fully compatible with Blender 3.2 and later" and lists UV align, rectify, sort and randomise, texel density get and set, colour ID tools, and several bake modes. The source declares version 1.6.2, the last tagged release is 1.6.1 from March 2024, and the last commit we saw was December 2024, so it's maintained slowly. It's the free way to check that every asset in a scene shares one texel density.

MACHIN3tools ($8 Prime, $20 DeusEx, plus $2 or $4 a year for continued updates). A collection of pie menus and small tools (smart vertex, edge and face operators, align, mirror, focus, clean up) that speeds everything up without imposing a workflow. The developer's Gumroad page explains that the base version "used to be called Standard and was free/pay what you want, but this has proven to be unsustainable after 6 years and less than 1% of users paying voluntarily", and states that version 1.13.12 "works in Blender 4.2 LTS to 5.2 LTS". The Superhive listing shows 34,700 sales and GPL. If you see an older article calling it free, that changed.

Quad Remesher ($109.90 Pro perpetual, $59.90 Indie perpetual for non-commercial use, $15.99 per three-month subscription). Exoside's auto-retopology engine turns a sculpt or a boolean mess into clean quads that deform properly under a rig. The buy page lists those prices per host application, and a 30-day non-commercial trial is available. The pages we could read don't state a supported Blender range, so check the download area before buying.

Baking and texturing

SimpleBake ($20 single user, $60 for 2 to 5 users, $80 unlimited). The most-bought baking add-on on Superhive at 16,100 sales. It bakes PBR channels from any Principled BSDF and Emission setup, mixes included, handles high-to-low baking with automatic matching by name or position, packs channels, bakes decals and AOVs, and can push the result straight to Sketchfab. One caveat on currency: the listing we could read dates from November 2025 and stated Blender 4.2 to 4.5, so check the current range before you buy for Blender 5.

Bake Wrangler ($40 commercial, $25 indie). A node-based baker: you wire objects, bake passes and outputs into a tree that lives in the file and can be reused across projects. The listing shows Blender 4.2 to 5.0, GPL, and around 800 sales, so it's a smaller community than SimpleBake but the right shape for a studio that bakes the same way every time.

Substance 3D add-on for Blender (free add-on, needs Substance materials). Adobe's add-on page says it lets you "Load your own Substance materials or from the Adobe Substance 3D Assets platform and attach them to objects directly in Blender", generating the texture set and feeding it into the BSDF, on Windows, macOS and Linux. The add-on is a free download. The materials are the paid part, through a Substance 3D plan or purchased .sbsar files, and Adobe's page doesn't quote a price, so we won't either.

LODs and optimisation

Decimate modifier (free, bundled). The manual gives it three modes: Collapse merges vertices progressively with a Ratio slider (0.5 keeps about half the faces, counted in triangles), Un-Subdivide reverses grid subdivision, and Planar removes detail on flat surfaces. Tick Symmetry to keep a character mirrored and Triangulate to see the real game-engine count. The modifier panel shows the remaining face count, which is the number you're budgeting.

LODGen (free, GPL-3.0, Blender 4.5 and newer). A 15 KB extension on extensions.blender.org that takes selected meshes, applies progressive Decimate steps (default 0.5 scale, six iterations), hides the originals, and drops the results into per-object LOD collections. Version 0.0.5 (August 2025) needs 4.5 because it dropped deprecated API calls, and the page tells 4.4 users to stay on 0.0.4. Better FBX or the standard FBX exporter can then carry the chain into Unreal or Unity.

LODify (free, GPL-3.0, Blender 4.2 and newer). Broader than LODGen: the listing covers texture downsizing based on screen coverage from the active camera, a geometry LOD system with Decimate or Geometry Nodes, and viewport display culling by distance. The texture scanner alone is worth running before you ship a level.

For web builds, run the exported GLB through the GLB optimizer or follow the optimize GLB for web guide, where texture size and Draco settings matter more than triangle count.

Asset management

Asset Browser (free, bundled). Introduced in Blender 3.0 per the manual, the Asset Browser shows any data-block you've marked as an asset (Object > Asset > Mark as Asset), organised into catalogs you can nest by dragging, with the special "Current File" library always available. Point a library at your project's assets/ folder and every modular wall, prop and material is a drag away, which makes it the most under-used built-in feature for game teams.

Blendkit, formerly BlenderKit (free plan, $9.90 a month Full, $29 a month Business). The pricing page lists 23,190 models, 38,804 materials, 4,995 HDRIs and 1,271 brushes on the free tier, drag-and-dropped from a panel in the viewport. The add-on itself is GPL-2.0-or-later on GitHub, requires Blender 3.0 or newer, and declares network and files permissions in its manifest. Check each asset's licence before it goes into a commercial game (our game asset licences guide explains what to look for) and read the free 3D model sites round-up for CC0 alternatives.

A starter kit for $0

You can run a complete Blender game pipeline without spending anything, and it's worth knowing exactly which pieces are free before you pay for shortcuts.

Start with Rigify and Automatic Weights. When a rig fails on a character with separate shells, Voxel Heat Diffuse Skinning earns its $30. When a contractor's FBX imports with missing materials or a folded skeleton, buy Better FBX. When you're packing UVs for the fortieth prop, buy UVPackmaster. Buy the tool the day the free path costs you an afternoon, not before.

Common Questions

What are the best Blender add-ons for game development?

The ones on the steps you repeat: Auto-Rig Pro or Rigify for rigging, Voxel Heat Diffuse Skinning for weights, Animation Layers for editing motion, Better FBX Importer & Exporter for files that won't import, UVPackmaster 4 for packing, SimpleBake for textures, and the built-in glTF exporter for the web and Godot. The quick reference table above lists prices and Blender versions for each as of September 2026.

Are Blender add-ons free?

Many are. Everything on extensions.blender.org is free and GPL-compliant by the platform's rules, and Blender bundles Rigify, the glTF and FBX exporters, the Decimate modifier and the Asset Browser. Paid add-ons on Superhive and Gumroad in this guide run from $8 (MACHIN3tools Prime) to $109.90 (Quad Remesher Pro), almost all as one-time purchases rather than subscriptions.

What is the best Blender animation add-on?

For editing motion, Animation Layers ($30) is the standard choice, since it turns the NLA into a layers workflow. For getting motion in, Rokoko Studio Live is free and open source and Mixamo clips are free through the community Mixamo Rig extension. MotionGen ($29) converts video to animation but only on Windows with an NVIDIA GPU.

What is the best Blender rigging add-on?

Auto-Rig Pro ($50) if you want a full animator's control rig with retargeting and engine export, and it has more than 65,000 sales to back that up. Rigify is free and bundled if you can spend the time placing bones, and the one-purchase auto-rigger in the rigging section above is the cheap route when you need a skinned skeleton and animations rather than a hand-animation control rig.

Do old add-ons still work in Blender 4.2 and later?

Yes. Blender's 4.2 release notes say legacy add-ons "are still supported as legacy add-ons and can be installed from disk as usual". Use Install from Disk in the Get Extensions or Add-ons preferences and pick the .py or .zip. What changed is distribution: extensions.blender.org only lists GPL-compliant extensions with a manifest, and updates for anything installed from disk are manual.

What is the best Blender export add-on for Unity or Unreal?

Better FBX Importer & Exporter ($25) for FBX correctness, because it uses the official FBX SDK and handles versions the built-in exporter refuses. Send to Unreal (free, MIT) if you want one click from Blender into an open Unreal editor. For Godot you don't need an add-on at all: it imports .blend files directly when Blender 3.0 or newer is installed, and glTF is its recommended format.

Does the Mixamo add-on for Blender still work?

Adobe still hosts the GPL-3.0 add-on but doesn't state a current Blender version, and the community Mixamo Rig extension on extensions.blender.org says the official build is no longer supported and targets Blender 3.6. Install Mixamo Rig (version 1.2.2, Blender 4.2 and newer) instead. Mixamo's own service and its royalty-free licence for games are unchanged.

Related

• Auto-Rig Pro alternatives: the rigging comparison in more depth, free and paid.
• Blender to Unity export checklist: axes, scale, leaf bones and materials, step by step.
• Optimize GLB for the web: Draco, texture caps and animation trimming for browser games.
• Free 3D model sites: where to get CC0 props and characters to rig.
• Game asset licences: what CC0, CC-BY and store licences let you ship.
• Cinevva Rig for Blender: the add-on, its free export half, and the launch price.

Last updated: September 2026.

If you make characters and props for a game engine, install Blender 5.2 LTS. It shipped on July 14, 2026, gets bug fixes until July 2028, and it's the first long-term release that contains every Blender 5 change at once: slotted actions with the old Action API gone, the C++ FBX importer as the default, meshopt compression in the glTF exporter, and a Python 3.13 runtime that add-ons had to be rebuilt for. Blender 4.2 LTS stopped receiving fixes in July 2026, so if you're still on it, 5.2 LTS is the move, with 4.5 LTS as the fallback for Intel Macs and older GPUs.

We refresh this page at every Blender release. This revision is dated September 6, 2026 and covers 5.0, 5.1, 5.2 LTS and the 5.3 alpha.

Quick answer

• Production version today: Blender 5.2 LTS (5.2.1, August 25, 2026). Supported to July 2028. Source: the LTS page.
• Still on 4.2 LTS? Its two years ended in July 2026 (last update 4.2.23). Move to 5.2 LTS, or to 4.5 LTS if your Mac is Intel or your GPU is older than a GeForce 900, Radeon RX 400 or Intel Kaby Lake.
• Biggest animation change: Actions have slots (since 4.4) and the legacy action.fcurves and action.groups API was removed in 5.0. Any exporter or retargeting script written before 4.4 breaks. Layered animation is still not in the UI as of 5.2 LTS.
• Biggest export change: the C++ FBX importer is the default in 5.0, Collada is gone, and the glTF exporter gained EXT_meshopt_compression and KHR_meshopt_compression in 5.2.
• Biggest add-on change: 5.1 moved to Python 3.13, so any extension that bundles compiled wheels needs a cp313 build. 5.0 removed dict-style access to bpy.props data and the BGL drawing API.
• Blender 5.3 is in alpha until September 30, 2026 and is scheduled for November 10, 2026. It makes Vulkan the default backend on Windows and Linux.

Quick reference

Dates come from the Blender release notes index, the LTS page and the 5.3 milestone.

Which version to use for production, and why

Blender's release cycle targets a new version every four months, and the release notes index states the support rule plainly: every release is supported until its successor, and once a year an LTS version is maintained for two years. The LTS page adds the part that matters for a pipeline: an LTS version "will not have any new features, API changes or improvements", only critical fixes ported from the current release.

That's the whole argument for 5.2 LTS. A game project runs longer than four months. Build on 5.1 and your only path to a fix after July 2026 is 5.2, with whatever changes it brings. Build on 5.2 LTS and you keep the same Python API, exporters and file format until July 2028, with 4.5 LTS overlapping until July 2027 if a studio you work with hasn't moved yet.

Two groups should pick 4.5 LTS instead. Intel Mac owners, because the requirements page says 4.5 LTS is the last release to support Intel, and 5.0 and later require Apple Silicon on macOS 13 or newer. And anyone on an older GPU, because the compatibility page raised the 5.0 minimum to NVIDIA GeForce 900, AMD Radeon RX 400 and Intel Kaby Lake. Older cards may still run it, but bugs on them won't be fixed.

Don't mix versions casually. The compatibility page says blend files created with 5.0 and later "can only be opened by Blender 4.5 or later", and older versions "will report them as invalid". A teammate on 4.2 can't open your 5.2 files at all.

What changed for animation

Slotted actions are the foundation, and the old API is gone. The 4.4 release notes introduced slots: "slots make it possible to store the animation of multiple 'things' in the same Action". A walk cycle can carry the bone curves in one slot and the shape key curves in another. Every action in every file is slotted now, and old actions were upgraded with a single "Legacy Slot". The 5.2 manual puts it simply: a data-block "specifies both an action and a slot within that action".

For scripts, the 5.0 Python notes are the breaking point: "The legacy Action API has been removed. This covered the properties action.fcurves, action.groups, and action.id_root." We confirmed it on a local 5.0.1 build: bpy.data.actions.new('t').fcurves no longer exists, while .slots and .layers do. A batch exporter or bake script from the 4.2 days fails on its first action.fcurves call. The fix is in the same notes: get a channelbag with bpy_extras.anim_utils.action_ensure_channelbag_for_slot(action, action_slot) and call channelbag.fcurves.find(), .new() or the new .ensure(). The 4.4 upgrade guide has side-by-side examples.

One behaviour change trips people who never touch Python. Since 4.4, assigning an Action also has to pick a slot, and the auto-assignment rules deliberately don't pick "the only slot" for a plain assignment, so that assigning Cube's action to Suzanne and keying her creates a new slot instead of overwriting her with Cube's motion. If you assign an action and nothing moves, look at the slot selector next to the action name.

Layered animation is still not in the UI. Project Baklava, described in Animation 2025: Progress and Planning, has two pillars: multi-ID animation (that became slots) and layers. The Layered Animation Workshop 2024 post settled a minimal feature set: named, lockable, mutable layers with replace and combine blend modes, animatable influence and a bake-down. As of 5.2 LTS none of it has shipped. The manual says the layers and strips under every action are "not currently exposed in the UI", the 5.0 to 5.2 notes contain no layer editor, and the Winter of Quality 2026 report lists only documentation work on it. Additive layers for game animation still happen in the NLA or in the engine.

The NLA didn't change structurally. Tracks and strips work as before per the NLA manual. What changed is how exporters read it: the glTF manual notes that "with Blender 4.4, and the introduction of slotted actions, this default behavior has been changed. Now, tracks are merged by the action they are using", not by name. More in the export section.

Performance: 5.1 roughly doubled action evaluation. The 5.1 animation notes benchmarked a 2,600-bone armature keyed for about 1,000 frames at 32.8 fps in 5.0 against 74.1 fps in 5.1 on 4 threads, and a million-vertex shape key mesh went from 39.2 to 158.7 fps on 24 threads. A production character file improved 4 to 14 percent, so the win is for heavy rigs and dense blend shapes.

Pose library. The asset-based pose library is unchanged in shape, and since a pose asset is a one-frame action it can carry slots, which the manual recommends against for generic poses ("use single-slot actions"). 5.0 removed the converter for 2.93-era pose libraries, so convert those in 4.5 first. 5.2 corrects rotation mode when a pose asset and the bone differ.

Smaller items. 5.1 added a Replace Action operator (Object > Animation or Pose > Animation) that swaps an action on every object using it. 5.2 added Select > Select by Type in the Dope Sheet, playback loop modes, and turned on the "Only Insert Available" preference by default, so pressing I now keys only channels that already exist unless you change it back. 5.3 alpha adds anim.rotation_mode_convert on Ctrl+R and deprecates Rigify's own pos.convert_rotation.

What changed for rigging

Bones on instanced armatures. The 5.0 animation and rigging notes moved bone visibility and selection in Object and Pose mode onto the pose bone, so two instances of the same armature can hide and select bones independently. The cost is an API break: bpy.data.armatures[...].bones[0].select was removed, bones[0].hide now affects edit-bone visibility only, and Pose mode uses object.pose.bones[0].hide and .select. Rig UI scripts that toggle bone visibility need the new path, and anim.version_bone_hide_property moves animated hide curves for you.

New constraint and custom-shape options. 5.0 added the Geometry Attribute constraint, which reads a vector, quaternion or matrix attribute from geometry and applies it to a bone's transform, plus two Custom Shape options, Affect Gizmo and Use As Pivot.

Weight tools. The 4.5 notes made the vertex group Assign button respect auto-normalize, and the 5.1 notes added loop selection in Weight Paint mode when vertex selection is on. There is no new skinning algorithm in 5.x: Automatic Weights is still bone heat. That's why Voxel Heat Diffuse Skinning keeps selling on Superhive at around $30, and why one-click riggers exist. If you'd rather not paint weights at all on a humanoid, the Cinevva Rig add-on rigs a mesh into a skinned, Mixamo-named skeleton on your own machine, offline, for a one-time $29 launch price, and it declares Blender 4.2.0 as its minimum so it runs on 4.2, 4.5 and every 5.x release on Windows, macOS and Linux.

Armature editing quality of life in 5.2. The 5.2 notes added Duplicate and Rename in the Armature menu, which duplicates selected bones and runs a search and replace on the name so you stop getting .001 suffixes when mirroring a chain by hand. Bone parenting gained a Head/Tail slider, adding a bone exposes Space, Align, Length and Deform in the redo panel, and Copy Constraints joined the Ctrl+L Link/Transfer Data menu. In-between tools (breakdowner and friends) now work in Object mode under Object > Animation > In-Betweens.

Rigify. Rigify is still the bundled, free generator and the manual still describes the same deal: it "only automates the creation of the rig controls and bones. It does not attach the rig to a mesh, so you still have to do skinning etc. yourself". The 5.x release notes carry almost nothing Rigify-specific beyond a 5.1.x UI fix and the 5.3 deprecation above. Auto-Rig Pro, the paid category leader, is a third-party extension and its 5.x compatibility is the author's to declare, which brings us to add-ons in a moment.

Shape keys. 5.0 rebuilt the shape key list with multi-select and drag and drop, and added Make Basis. 5.1 added Apply to Basis, which bakes selected shape keys into the base mesh and deletes them, a handy step before export when a generator left you with corrective shapes you don't want in the GLB.

What changed for import and export

FBX. The 5.0 pipeline notes made the C++ FBX importer (experimental in 4.5) the default and marked the Python importer legacy: add-ons using bpy.ops.import_scene.fbx "are advised to switch to bpy.ops.wm.fbx_import". The FBX manual describes what the new importer does with animation: "Each FBX 'take' is imported as a separate Action, with each animated object assigned to its own Action Slot." Export is unchanged in mechanism: File > Export > FBX (.fbx) still runs the Python add-on with the same Forward, Up, Apply Scalings, Add Leaf Bones and Bake Animation options. One real export fix landed in 5.1: the exporter "now also exports shapekey normals, when exporting normals for the base mesh is enabled", which the notes say solves "some import issues with some game engines". Better FBX Importer and Exporter still sells for a reason: the built-in exporter's own Missing list in the manual includes vertex shape keys and material textures.

glTF. The exporter got the most game-relevant additions. The 5.2 notes list EXT_meshopt_compression and KHR_meshopt_compression export and import behind a new Data > Meshopt Compression panel, official KHR primitive attributes, point clouds, iridescence and dispersion materials, and hooks that can stop the export. Draco is still there. The 5.3 alpha adds Animation Pointer for custom properties. The glTF manual documents the slot-era import behaviour: "Each animation will be imported as a single action, with multiple slots if the animation affects multiple objects." On export, the default Actions mode exports an action only if it is active or stashed to an NLA track ("If you have multiple actions you want to export, make sure they are stashed!"), and Merge Animation is now "by Action (using slot), by NLA Track Name, or no merge". If your clips merged unexpectedly after upgrading past 4.4, that setting is the reason.

USD. The USD manual imports USD skeletons as armatures and blend shapes as shape keys, and exports armatures and Armature-modifier meshes as USD skeletons and skinned meshes, with two stated limits: "Modifiers in addition to Armature modifiers will not be applied" and "Bendy bones are not supported". 5.1 made mesh export write indexed UVs so other apps can rebuild UV islands, and 5.2 added colour space tagging on export and conversion on import.

Collada is gone. Removed in 5.0. If an old pipeline still emits .dae, 4.5 LTS is the last version that reads it. And 5.0 changed the blend file header and switched compression on by default, so only 4.5 and newer open 5.x files.

Add-ons: the Extensions platform and what broke

Extensions replaced legacy add-ons in 4.2. Add-ons now ship as extensions with a blender_manifest.toml, install from Preferences > Get Extensions, and live on extensions.blender.org, which "only offers GNU GPL compliant software". The manual requires blender_version_min (at least 4.2.0) and allows an optional blender_version_max, "Blender version that the extension does not support". Legacy add-ons still install through Install from Disk in 5.2, but the old way is deprecated, and the extensions site warns that "Extensions don't update automatically".

How to check whether an add-on works on 5.2. Read the Blender version range on the extension's page, or search it in Preferences > Get Extensions, where the listing shows whether a build exists for your version. Install it, open Window > Toggle System Console on Windows or launch Blender from a terminal on macOS and Linux, and enable it: the manual's tip is that if an add-on doesn't activate, "check the Console window for any errors". Three errors account for most post-upgrade failures.

An AttributeError on fcurves, groups or id_root means the add-on uses the legacy Action API removed in 5.0. A wheel that refuses to load means the extension bundles a compiled module built for Python 3.11, which 5.0 still used (our local 5.0.1 reports 3.11.13), while the 5.1 Python notes moved Blender to Python 3.13, so anything bundling numpy or an inference runtime needs cp313 wheels from 5.1 on. And if a tool that relied on pip install --user packages can't find them, that's the 5.1 core change: "The Python user-site-directory is no longer loaded by default", restorable with --python-use-user-env.

The other 5.0 breaks that hit game tooling. The 5.0 Python notes removed dict-style access to bpy.props storage ("bpy.context.scene['cycles'] will not give access to Cycles' scene settings"). The BGL module and Image.bindcode were removed, so anything drawing in the viewport with raw OpenGL calls (older bone pickers, weight visualisers) needs the gpu module. scene.node_tree became scene.compositing_node_group, and the EEVEE engine identifier changed from BLENDER_EEVEE_NEXT to BLENDER_EEVEE, which trips render scripts that pick an engine by name. In 5.2, the Geometry Nodes modifier API changed from modifier["identifier"] = 5.0 to modifier.properties.inputs.identifier.value = 5.0, so batch tools that drive a GN decimation or LOD setup by name need updating for the LTS.

Where the Cinevva Rig add-on stands. It's a standard extension with a 4.2.0 minimum, version 0.4.0 from September 5, 2026, and it runs on 5.0, 5.1 and 5.2 LTS. Rigging is the paid half, unlocked by the $29 key and run locally after a one-time engine download of about 2.4 GB. The 260 CC0 animation clips and the export presets for Unity, Unreal, Godot and the web work without a key or an account. Against a plain Blender GLB export, the presets produced files 68 to 98 percent smaller on the four models we measured, mostly by capping and re-encoding textures.

Viewport and performance for asset work

GPU backend. The System preferences offer OpenGL and Vulkan, with a restart to switch and Metal fixed on macOS. The Q2 2025 projects update declared Vulkan "officially supported in the upcoming Blender 4.5 LTS, offering feature parity and comparable performance to OpenGL". 5.1's EEVEE notes measured Vulkan cold-start material compilation on the Barbershop scene dropping from 24.87 to 11.67 seconds and texture pool memory from 406 to 245 MB, and the 5.3 alpha notes finally flip it: "Vulkan backend is now default on Windows (not ARM) and Linux. Existing user preferences will not be migrated." On 5.2 LTS it's opt-in. Try it, and switch back to OpenGL if a viewport-drawing add-on misbehaves. The 5.1.x corrective releases fixed Vulkan issues on Intel Iris Xe and NVIDIA 595 drivers, so keep drivers current.

EEVEE and material compile times. The 5.0 EEVEE notes say simple materials compile about four times faster on NVIDIA OpenGL, and 5.1 added parallel pipeline compilation on every backend. For look-dev on a character with a dozen materials, that's a grey viewport for seconds instead of a minute. 5.2's screen-space raytracing overhaul changes how existing scenes look ("some scenes might render darker than in 5.1"), and EEVEE inherited the Workbench instancing optimisation, up to twice as fast on scenes with many instances, which describes a modular environment kit exactly.

Curves and hair got heavier. A 5.0 gotcha for characters with particle hair: curve drawing now honours the resolution attribute, and the notes warn that a default hair system "will now render 15 times more geometry in 5.0". If a file that opened fine in 4.5 crawls in 5.x, lower the curve resolution.

Platform minimums decide whether you can install 5.x at all: Apple Silicon on macOS 13 or newer, and on Windows and Linux a GPU with OpenGL 4.3 and 2 GB of VRAM from the GeForce 900, Radeon RX 400 or Kaby Lake generation onward, per the requirements page.

Upgrade checklist for a game-asset pipeline

Do this once per project, in this order, on a copy of your files.

1. Pick the version and pin it. Install 5.2 LTS from the LTS page. If any teammate is on an Intel Mac or a pre-2016 GPU, the team pins 4.5 LTS instead, because 4.2 can't open 5.x files and 4.5 truncates long names.
2. Open your oldest rig in 4.5 first if it dates from 2.79 or earlier. 5.0 dropped loading of pre-2.50 animation data and the 2.93-era pose library converter. The notes recommend opening and saving such files in 4.5 before moving on.
3. Inventory add-ons against the version range. For each one, read blender_version_min and blender_version_max on its extension page. Reinstall from Preferences > Get Extensions rather than copying an old add-ons folder, and check the console on first enable.
4. Grep your scripts. Search for action.fcurves, action.groups, id_root, bones[...].select, import_scene.fbx, scene.node_tree, BLENDER_EEVEE_NEXT, bgl and bracket access like modifier["Socket_. Each is a documented 5.x break with a documented replacement.
5. Re-import one FBX character pack and inspect actions. With the C++ importer, every take becomes an action with one slot per animated object. Confirm clip names and that the armature slot is assigned before you batch anything.
6. Re-export one animated GLB and check the animation list. Set Animation > Mode to Actions, stash every clip you want to an NLA track, and set Merge Animation to the mode you intend. Open the result in a viewer and count the clips. Then try Meshopt Compression against Draco on a real asset and keep whichever your engine or loader decodes.
7. Re-export one FBX for your engine with normals on. 5.1's shape key normals fix changes what Unity and Unreal receive for blend-shape characters. Import it and check facial shapes for shading seams.
8. Decide on the GPU backend deliberately. Stay on OpenGL for 5.2 LTS unless you've tested Vulkan with your add-ons. When 5.3 arrives it defaults to Vulkan on Windows and Linux without migrating your preference, so note the choice now.
9. Re-save assets that use Node Tools or Geometry Nodes assets. 5.1 and 5.2 both require opening and re-saving asset files for node tools to work, per the compatibility notes.
10. Turn compression back off if a tool reads .blend files directly. 5.0 enables blend file compression on saving by default and changed the block header format, so external parsers need updating or uncompressed files.

Common Questions

When was Blender 5.0 released and is it still supported?

Blender 5.0 was released on November 18, 2025, with the 5.0.1 corrective release on December 16, 2025. It is no longer supported: Blender supports a regular release only until its successor, and 5.1 replaced it on March 17, 2026. If you're on 5.0, move to 5.2 LTS, which keeps the same slotted-action model and adds fixes through July 2028.

What are the new features in Blender 5.0 for animators and riggers?

The headline 5.0 features were colour management (ACES, HDR, working colour space) and the sequencer overhaul. For animation and rigging the notes list the Geometry Attribute constraint, per-instance bone visibility and selection, a shape key UI rebuild with multi-select and Make Basis, Copy Global Transform moving into core, Jump Time by Delta, and slot selectors that show the slot type. The removals matter as much: the legacy Action API, pre-2.50 animation loading and the old pose library converter.

What is Blender 5.1 and what did it change for game artists?

Blender 5.1 shipped on March 17, 2026. For game work the changes are performance and plumbing: action evaluation roughly doubled on heavy rigs, shape key evaluation up to four times faster, Python moved to 3.13, the user site-packages directory stopped loading, the FBX exporter began writing shape key normals, and EEVEE materials compile faster on every backend. It was superseded by 5.2 LTS on July 14, 2026.

Is Blender 5.2 an LTS release and until when?

Yes. Blender 5.2 LTS was released on July 14, 2026 and will be maintained until July 2028, with 5.2.1 released on August 25, 2026. It overlaps with 4.5 LTS, supported until July 2027. 4.2 LTS ended in July 2026.

What are slotted actions in Blender?

A slot is a named, typed sub-container inside an Action, so one Action can animate several data-blocks at once, for example an armature's bones and its mesh's shape keys. Slots arrived in 4.4 and every action is slotted now. For users, the visible change is a slot selector next to the action name and a Merge Animation choice in the glTF exporter. For scripts, action.fcurves was removed in 5.0 in favour of the per-slot channelbag.

Does Blender 5 have layered animation?

Not in the interface, as of 5.2 LTS. The data model has layers and strips underneath every action, and the manual says this is "purely in preparation for future animation features that are not yet in Blender". The layer editor, blend modes and bake-down described in the Layered Animation Workshop 2024 post have not shipped in 5.0, 5.1, 5.2 or the 5.3 alpha notes.

Do my Blender 4.2 add-ons work in Blender 5?

Some do. An extension declares blender_version_min and optionally blender_version_max, and legacy add-ons still install from disk. What breaks is code, not packaging: the legacy Action API, bones[].select, BGL drawing, dict access to bpy.props data, and compiled wheels built for Python 3.11 rather than 3.13 (from 5.1). Check the console when you enable an add-on, and check the extension page for a 5.2 build before you upgrade.

Related

• How Automatic Rigging Works (and How to Prepare a Model for It): what a rig is, how riggers place joints, and how to prep a mesh so the 5.x weight tools have less to fix
• Cinevva Rig for Blender: one-click humanoid rigging on your own machine, 260 CC0 clips, and export presets for Unity, Unreal, Godot and the web, on Blender 4.2 and newer
• How to Rig a Character in Blender (2026): Rigify, manual armatures and the one-click route, step by step on 5.2 LTS
• Blender to Unity Export Checklist: the FBX settings, scale and axis choices that survive the 5.x importer changes
• How to Optimize a GLB for the Web: what Draco, meshopt and texture caps do to a file after it leaves the glTF exporter
• GLB Viewer: count the animation clips in an exported GLB and check the skeleton before it goes into an engine

Last updated: September 2026.

Export a GLB from Blender with +Y Up on, transforms applied, Apply Modifiers ticked, Materials set to Export and Compression off, drop it into your Godot project folder, and Godot 4 builds the scene, the materials, a Skeleton3D and an AnimationPlayer for you. The direct .blend import does the same job by calling Blender behind the scenes, which is handy on one machine and a problem for a team. Nearly every "it looks wrong in Godot" report comes down to one of five things: unapplied transforms, a character modelled facing the wrong way, an action that was never stashed to the NLA, a Draco-compressed file, or textures that never left Blender.

Quick answer

• Format: glTF 2.0, as a single .glb. Godot's docs mark it "(recommended)", and the binary form "include[s] the mesh and textures set up in Blender".
• Axes and scale: leave the exporter's +Y Up on, model characters facing -Y in Blender, keep 1 Blender unit as 1 metre, and run Object > Apply > All Transforms (Ctrl-A) before you export.
• Compression: leave Data > Compression off. Godot cannot open Draco-compressed glTF.
• Animations: every action you want must be the active action or stashed to an NLA track. Name looping clips with loop or cycle in the action name, no hyphen, and Godot sets the loop flag.
• Collision and physics: append -col, -convcol, -colonly or -rigid to the Blender object name and Godot creates the body on import.
• Textures missing: export GLB, not glTF Separate, set Materials to Export, and use image textures on a Principled BSDF, not procedural nodes.
• No export dialog at all: the Cinevva Rig add-on has a Godot preset that applies these settings in one click. Its export half is free, runs on your machine offline, and works in Blender 4.2 and newer on Windows, macOS and Linux. Rigging is the paid half, $29 once at the launch price.

Quick reference

The Blender glTF exporter settings that matter for Godot 4, from the Blender manual and the Godot import docs. Everything else can stay at its default.

Two roads into Godot: direct .blend or a GLB

Godot 4 supports "glTF 2.0 (recommended)", .blend, Collada, OBJ and FBX. The .blend path "works by calling Blender to export to glTF in a transparent manner (requires Blender to be installed)", so both roads end in the same importer.

The direct .blend import

The available formats page spells out the requirements. It "requires Blender 3.0 or later", with 3.5 or later recommended "as it includes many fixes to the glTF exporter", and "an official Blender release downloaded from blender.org, as opposed to a Linux distribution package or Flatpak". You "must install Blender before opening the Godot editor". If Blender lives in its default location Godot finds it. If not, set Editor Settings > Filesystem > Import > Blender > Blender Path. The payoff is iteration speed: "you can save the scene in Blender, alt-tab back to Godot then see your changes immediately", and you don't commit an exported copy.

The Import dock then shows a Blender-only section: Nodes > Visible (All, Visible Only or Renderable), Modifiers, Meshes > Skins (4 Influences (Compatible) or All Influences, "up to 8 in Godot"), Materials > Unpack Enabled, which writes the original images into the Godot filesystem and "should be left checked", and Animation > Group Tracks, which keeps stashed actions separate. Untick that last one and "all the currently assigned actions become one glTF animation".

When to avoid it: the docs are blunt that "using .blend files in your project will require all team members to have Blender installed", and the import "is also not available on the Android and web editors, as these platforms can't call external programs". A fresh clone imports nothing until Blender is present, so a build machine needs Blender too, and you only get the exporter options Godot exposes in the dock. If you don't want Godot touching .blend files that live in the project, turn off Filesystem > Import > Blender > Enabled in the advanced Project Settings.

The GLB export

Blender's exporter offers three forms. glTF Binary (.glb) is "a single .glb file with all mesh data, image textures, and related information packed into a single binary file". glTF Separate writes a .gltf, a .bin and loose image files, and the manual warns that "sharing this format requires sharing all of these separate files together as a group". glTF Embedded base64-encodes everything into JSON and the manual calls it "the least efficient of the available forms". Godot's docs give two reasons to pick Separate: a text-based scene for version control diffs, or needing the texture files apart from the material. "If you don't need either of those, glTF binary files are fine." Pick GLB.

Why not FBX, Collada or the old ESCN exporter

FBX in Godot 4 comes in two eras. Before 4.3 the importer was FBX2glTF, and the docs note that this "requires installing an external program that links against the proprietary FBX SDK", which is why Godot can't ship it and why you had to set Filesystem > Import > FBX > FBX2glTFPath yourself. Since Godot 4.3 (August 2024) the built-in ufbx library reads FBX directly and "it will no longer be necessary to download the external FBX2glTF converter". FBX now works, then, but it adds a conversion step glTF doesn't need, and the same article warns that Blender's FBX exporter writes objects at 100x scale by default unless you set Apply Scalings to FBX Units Scale. If you must live in FBX, the third-party Better FBX Importer & Exporter (12,600+ sales on Superhive, $25 for one seat, Blender 3.6 to 5.1) exists because, in its author's words, Blender's native FBX "often fails" on files from other packages. For Godot you don't need any of that.

Collada is a step down: Blender's built-in exporter "does not work properly for the needs of game engines and shouldn't be used as-is", though simple static scenes may survive. OBJ "doesn't support skinning, animation, UV2 or PBR materials". And the Godot Blender Exporter that wrote .escn files for Godot 3 "is not maintained or supported in Godot 4.x" per its own docs page. If a tutorial tells you to install it, the tutorial is for Godot 3.

Axes, metres and applied transforms

Three conventions have to agree, and two of them are already the same. The glTF 2.0 specification says "glTF defines +Y as up, +Z as forward, and -X as right", that "the front of a glTF asset faces +Z", and that "the units for all linear distances are meters". Godot's model export considerations page says Godot "uses a right-handed, Y-is-up coordinate system, with the -Z axis as the camera's forward direction", so an oriented asset faces +Z, and "Godot uses the metric system for everything in 3D, with 1 unit being equal to 1 meter". Blender is the odd one out with Z up, and the exporter's Transform > +Y Up option ("Export using glTF convention, +Y up") does the conversion. Leave it on. Turning it off is the fastest way to a model lying on its side.

Forward is the one you have to model for. Godot's docs translate it: "In Blender, this means that +Y is rear and -Y is front for an asset." Build your character looking down Blender's -Y axis (the default front view, Numpad 1, looks at the character's face) and it will face +Z in Godot, which is what look_at with use_model_front and the Vector3.MODEL_* constants expect. A character modelled facing +Y walks backwards the first time you attach movement code.

Scale is simpler than it looks. The exporter has no unit option: one Blender unit becomes one glTF metre. Blender's Unit Scale in Properties > Scene > Units "only influences the values displayed in the user interface and not how things behave internally", so a centimetre-scale scene with Unit Scale at 0.01 still exports its raw values. Keep the default metric setup, make a human about 1.8 units tall, and Godot agrees with you. If a downloaded model arrives 100x too big, scale it in Object Mode and apply, or use the Import dock's Apply Root Scale, which "will be applied on the meshes and animations directly, while keeping the root node's scale to the default (1, 1, 1)".

Apply transforms every time. Object > Apply > All Transforms (Ctrl-A) bakes rotation and scale into the vertices, and the Blender manual says "It is recommended to apply transforms before rigging and animation." Godot asks for the same thing "to avoid issues with 3D selection in the editor", and its retargeting docs name the failure: "a glTF exported from Blender with no 'Apply Transform' executed" gives the skeleton a node transform that the Apply Node Transform import option has to undo. Also make sure "the skeleton is reset to its T-pose or default rest pose before exporting". A mesh exported mid-pose bakes that pose into the skin.

Export settings, in the order the dialog shows them

File > Export > glTF 2.0 (.glb/.gltf), Format glTF Binary, Include > Selected Objects on. Cameras and Punctual Lights stay off, since Godot's advice is to "design the scene's lighting in the Godot editor after importing the scene". The table above has the full list. Four settings deserve the reasoning.

Data > Mesh > Apply Modifiers. Godot "can triangulate meshes on import, but results may be unpredictable or incorrect, especially with N-gons", and its fix is "adding a Triangulate modifier to your objects and making sure Apply Modifiers is checked in the export dialog". Turn on Tangents if any material uses a normal map, otherwise Godot's Ensure Tangents import option generates them with Mikktspace at import time.

Data > Armature > Export Deformation Bones only. Godot's docs carry a warning box: if the model has blend shapes (shape keys), this "needs to be configured to Enabled", because "exporting non-deforming bones anyway will lead to incorrect shading". It also strips the helper bones a control rig carries. Keep Use Rest Position Armature on so the rest pose, not the current frame, becomes the joint rest.

Data > Compression off. The Draco option writes the KHR_draco_mesh_compression extension, and Godot's importer refuses it with GLTF: Can't import file, required extension 'KHR_draco_mesh_compression' is not supported (issue #73738). Godot compresses meshes its own way at import, so you lose nothing.

Animation > Reset pose bones between actions on. The manual says it "is needed when some bones are not keyed on some animations", otherwise a bone left unkeyed in your idle inherits its last pose from the walk. Set all glTF Animation starting at 0 "can be useful for looping animation" when your actions start at frame 1.

On the Godot side, the Import dock's defaults are mostly right. Root Type should inherit from Node3D or you "lose the ability to position the node directly in the 3D editor". Animation > FPS bakes curves to points, and "there is usually not much benefit in going above 30 FPS". glTF > Embedded Texture Handling decides what happens to the images inside your GLB: Extract Textures pulls them out as image files, which the docs say gives "smaller file sizes and more control over import options", while the two Embed options keep them inside the scene.

Import hints: suffixes Godot reads from object names

This is Godot's oldest and best trick. The glTF node name is the Blender object name, and the name suffix page lists suffixes the importer acts on. Name a wall Wall-col and the import produces the mesh plus a static collision child. No Godot-side clicking, and it survives every re-import.

Two of these do more than the card can say. -colonly "will remove the mesh upon importing and will create a StaticBody3D collision instead", which is how you ship a hand-made low-poly collision mesh next to the visible one: model it, name it Room_collision-colonly, and only the physics survives. And -noimp removes "nodes and animations" of any type, so reference geometry and scratch actions can stay in the .blend without reaching the game.

The animation hint is the odd one. "Animation clips in the source 3D file that start or end with the token loop or cycle will be imported as a Godot Animation with the loop flag set. Unlike the other suffixes described above, this does not require a hyphen." Walk_loop, loop_walk and WalkCycle all count.

If you'd rather not touch names, the Advanced Import Settings dialog (double-click the file, or Advanced… in the Import dock) does the same per node: Skip Import, Generate > Physics with Body Type (Static, Dynamic, Area) and Shape Type (Trimesh for static level geometry, primitives or Decompose Convex for dynamic bodies), Generate > NavMesh and Generate > Occluder. Names win when the same model is reimported often or shared between projects, because the settings travel with the file.

Animations: actions, NLA tracks and loops

The Blender exporter's default Actions mode has one rule that causes most missing-animation reports. From the manual: "An action will be exported if it is the active action on an object, or it is stashed to an NLA track (e.g. with the Stash or Push Down buttons in the Action Editor). Actions which are not associated with an object in one of these ways are not exported. If you have multiple actions you want to export, make sure they are stashed!" Open the Action Editor in the Dope Sheet, and for each action you want, select it and press Stash (or Push Down). Each ends up on its own NLA track, and each becomes one Godot animation named after the action. You can rename the NLA track to override the name. One version note: "Before Blender 4.4, tracks were merged regarding their name. With Blender 4.4, and the introduction of slotted actions, this default behavior has been changed. Now, tracks are merged by the action they are using, and not by their name."

Only three kinds of animation survive the trip: "Object transform (location, rotation, scale)", "Pose bones" and "Shape key values". Animated materials, lights, modifiers and physics don't export, so bake them or rebuild them in Godot.

Looping is Godot's decision, not the file's. The glTF spec "defines only storage of animation keyframes, so this specification doesn't define any runtime behavior, such as: order of playing, auto-start, loops". So Godot reads the name: "In Blender, this requires using the NLA Editor and naming the Action with the loop or cycle prefix or suffix." If you forgot, select the animation in the AnimationPlayer panel and set its Loop Mode. The Animation class offers None ("the animation will stop playing"), Linear ("repeated without changing the playback direction") and Ping-Pong ("repeats playback and reverse playback at both ends").

Godot puts everything into one AnimationPlayer under the imported root with an AnimationLibrary holding each clip. To share one set of animations across several characters, select the GLB in the FileSystem dock and change its import mode to Animation Library, which "allows you to use one set of animations for several characters, without having to duplicate animation data". Pair that with the retargeting options below so the clips fit skeletons that aren't identical.

Materials and textures

Blender's exporter only understands one shader. The manual: "The exporter supports Metal/Rough PBR (core glTF) and Shadeless (KHR_materials_unlit) materials. It will construct a glTF material based on the nodes it recognizes in the Blender material." Base colour comes from the Base Color input of a Principled BSDF, either the colour swatch or an Image Texture connected to it. Metallic and roughness come from the sliders or from one image with "metallic values to be encoded in the blue (B) channel, and roughness to be encoded in the green (G) channel", split with a Separate RGB node and with the Image Texture's Color Space set to Non-Color. A normal map goes through a Normal Map node in Tangent Space, also Non-Color. Emission goes into the Emission input. Anything else, a noise texture, a colour ramp, a mix of two shaders, doesn't exist in glTF, and Godot's docs add that "procedural Blender materials may not work correctly". Bake procedural work to an image first.

On the Godot side that lands in a StandardMaterial3D, whose docs describe the same packing: "Instead of separate settings and textures for occlusion, roughness, and metallic, there is a single ORM texture." Normal maps must be "OpenGL style" (+Y up), which is what glTF and Blender's Normal Map node produce, so nothing to flip. Colour space follows the rule you set in Blender: base colour images stay sRGB, data maps are Non-Color. Get that backwards and the roughness map is gamma-shifted before Godot ever sees it.

"Textures missing" has a short list of causes. You exported glTF Separate and moved only the .gltf, leaving the .bin and images behind. You used the .blend import with Materials > Export Materials set to Named Placeholder or Placeholder, where the docs say "textures will have to be reassigned manually". Data > Material > Materials was left on Placeholder in the exporter. The Image Texture node points at a file Blender itself can't find (magenta in the viewport), so there's nothing to pack. Or the material was procedural. GLB plus Export plus image textures fixes all five.

Two more surprises. Backface culling: "By default, Blender has backface culling disabled on materials and will export materials to match how they render in Blender. This means that materials in Godot will have their cull mode set to Disabled", so every backface renders. Tick Backface Culling in the Blender material's Settings panel for anything that's a closed surface. And transparency: the exporter picks Opaque, Mask or Blend from what's wired into the Alpha socket, and Godot maps that onto its Transparency modes. For leaves and grilles, round the alpha with a Math node so it exports as Mask, which Godot renders far cheaper than blended alpha.

If you want to edit materials in Godot without losing them on the next re-import, use Actions… > Extract Materials in the Advanced Import Settings dialog. Godot "will not overwrite changes made to extracted materials when the source 3D scene is reimported", though renaming the material in Blender breaks the link.

Skeletons: Skeleton3D, bone names and retargeting

An armature imports as a Skeleton3D, which "provides an interface for managing a hierarchy of bones, including pose, rest and animation", with the skinned meshes as MeshInstance3D children pointing at it. Godot's retargeting docs explain the catch with Blender rigs: "the bones of a glTF model output from Blender have 'Edit Bone Orientation' as the Bone Rest rotation", so two Blender characters with the same bone names can still have different rests, and an animation authored on one twists the other.

The fix is built into the importer. In Advanced Import Settings, select the Skeleton3D node and the right-hand panel shows a Retarget section with a single bone_map property. Create a BoneMap, give it the SkeletonProfileHumanoid profile, and "auto-mapping will be performed when the SkeletonProfile is set". The profile is Godot's standard humanoid, 56 bones in four groups (Body, Face, LeftHand, RightHand), read-only, with names like Hips, Spine, Chest, UpperChest, Neck, Head, LeftUpperArm, LeftLowerArm, LeftHand, LeftUpperLeg, LeftLowerLeg, LeftFoot. Its reference pose is a T-pose facing +Z. Auto-mapping "uses pattern matching for the bone names. So we recommend to use common English names for bones." Name bones upper_arm.L or LeftUpperArm rather than Bone.014, and check for magenta buttons in the map, which flag "any missing, duplicate or incorrect parent-child relationship mappings".

Then the Rest Fixer options. Overwrite Axis rewrites every bone rest to match the profile and the docs call it "the most important option for sharing animations in Godot 4", with the warning that it "can produce horrible results if the original Bone Rest set externally is important". Fix Silhouette bends the model into the profile's T-pose, which "does not need to be enabled for T-pose models, but should be enabled for A-pose models". Apply Node Transform fixes the unapplied-transform case from the axes section. Normalize Position Tracks scales root motion by hip height so a tall and a short character share a walk without foot sliding. Under Remove Tracks, the docs recommend enabling Except Bone Transform, Unimportant Positions and Unmapped Bones for a shared AnimationLibrary, and leaving them off for a scene whose accessories are animated.

A rigging note for Blender users. Whether your skeleton comes from Rigify, Auto-Rig Pro or an auto rigger, export with Export Deformation Bones only so control bones stay in Blender, export in rest pose, and keep the English bone names (Hips, Spine, LeftArm) that Mixamo-style rigs use, because that's what the auto-mapper pattern-matches against.

Symptom, cause, fix

The longer list, including the ones that don't fit on a card.

The checklist

Run it top to bottom before every export. Most steps are one keypress.

1. In Blender, select everything that should ship and nothing else. Delete or hide reference meshes, or name them -noimp.
2. Face characters and props down -Y. Numpad 1 should show the character's face.
3. Check Properties > Scene > Units is metric with Unit Scale 1.0, and the character is about 1.8 units tall.
4. Object > Apply > All Transforms (Ctrl-A) on every mesh and the armature.
5. Put the armature in rest pose. Godot: "make sure that the skeleton is reset to its T-pose or default rest pose before exporting".
6. Add a Triangulate modifier if you have n-gons. Confirm every material is a Principled BSDF with image textures, Non-Color on data maps, and Backface Culling ticked on closed surfaces.
7. Open the Action Editor and Stash every action you want in Godot. Name looping ones with loop or cycle.
8. Rename objects with import hints: -col for level geometry, -convcol for props, -rigid for things that fall.
9. File > Export > glTF 2.0. Format: glTF Binary. Include > Selected Objects on. +Y Up on. Apply Modifiers on. Materials: Export. Export Deformation Bones only on. Compression off. Animation mode: Actions, Reset pose bones between actions on.
10. Drop the .glb into the Godot project folder and click back into the editor. Godot imports when the window gets focus.
11. In the Import dock, set Root Type to a Node3D type, Animation > FPS to your Blender frame rate, and glTF > Embedded Texture Handling to Extract Textures if you want per-image compression settings.
12. Open Advanced Import Settings. Check the animation list, set any missing loop modes, add a BoneMap on the Skeleton3D if you'll share animations, and Extract Materials if you'll edit them in Godot.
13. Instance the scene, press play, and bend an elbow. If it looks right here, it will look right in the build.

The one-click route: the Godot preset in Cinevva Rig

Steps 9 to 11 are the part people get wrong on the third export of the day, when one checkbox drifts. The Cinevva Rig add-on folds them into a preset. Before it writes anything it runs a size analysis that splits the estimated file into geometry, textures, animation and shape keys, so you can see whether an 80 MB export is a 4K texture problem or an unsampled-animation problem before Godot ever loads it. The Godot preset then exports GLB, +Y Up, no Draco because Godot 4 imports plain glTF cleanly, textures capped at 2048 px, and animation size optimisation on. Against a plain Blender GLB export, its presets produced files 68%, 89%, 92% and 98% smaller on four real models, most of that from texture caps rather than mesh tricks.

The facts that matter for a Blender user: the export half and the 260 CC0 animation clips work without a key, an account or a network connection, on your own machine. Rigging is what the $29 launch-price key turns on, also local and offline after a one-time engine download of about 2.4 GB, with no per-rig count. It supports Blender 4.2 and newer on Windows, macOS and Linux, installs as a standard extension, and the current version is 0.4.0 from September 5, 2026. If you'd rather keep your own workflow, the checklist above is exactly what the preset does, and the GLB viewer will show you the scene graph, skeleton and animation list of the result before you hand it to Godot.

Common Questions

How do I import a Blender file into Godot 4?

Two ways. Save the .blend inside your Godot project folder and Godot imports it by calling Blender's glTF exporter, which needs Blender 3.0 or later installed (3.5+ recommended) and found at Editor Settings > Filesystem > Import > Blender > Blender Path. Or export a .glb from File > Export > glTF 2.0 and drop that in the project instead. The GLB works for teammates without Blender and on every editor platform.

Should I use glTF or FBX for Blender to Godot?

glTF, as a single .glb. Godot's docs list glTF 2.0 as the recommended format, and the .blend import is glTF underneath. FBX works since Godot 4.3 through the built-in ufbx importer, and needed the external FBX2glTF program before that, but it adds a conversion step and Blender's FBX exporter applies a 100x scale by default. Use FBX only when a downstream tool demands it.

Why is my Blender model the wrong size in Godot?

Godot treats 1 unit as 1 metre and so does glTF, and Blender's exporter writes one Blender unit as one metre regardless of the scene's Unit Scale, which only changes what the interface displays. A model built at centimetre numbers arrives 100x too big. Scale it to about 1.8 units for a human, apply the scale with Ctrl-A, and re-export, or use Apply Root Scale in Godot's Import dock.

How do I import Blender animations into Godot 4 and make them loop?

Stash every action to an NLA track in the Action Editor, because the exporter only writes actions that are active or stashed. Export with Animation mode set to Actions and each action becomes one animation in the imported AnimationPlayer. To loop, put loop or cycle at the start or end of the action name (Walk_loop) and Godot sets the loop flag on import, or set Loop Mode to Linear on the animation afterwards.

What do -col and -rigid mean in Godot import?

They're import hints Godot reads from node names. -col adds a child StaticBody3D with a triangle-mesh collision shape matching the mesh, -convcol uses a convex shape instead, -colonly drops the mesh and keeps only the collision, and -rigid imports the mesh as a RigidBody3D. Type them onto the object name in Blender, and the physics setup survives every re-import.

Why are my textures missing when I import from Blender to Godot?

Usually one of five things: you exported glTF Separate and copied only the .gltf, the exporter's Materials option was Placeholder, the .blend import's Export Materials was set to Named Placeholder, the material used procedural nodes glTF can't store, or the Image Texture node pointed at a file Blender couldn't find. Export a GLB with Materials: Export and image textures wired into a Principled BSDF.

Does Godot 4 use Skeleton3D for Blender armatures?

Yes. A Blender armature imports as a Skeleton3D node with the skinned meshes as MeshInstance3D children, and the actions become animations on an AnimationPlayer. To share animations between characters, give the Skeleton3D a BoneMap with the SkeletonProfileHumanoid profile in Advanced Import Settings and enable Overwrite Axis, because Blender bone rests differ per rig even when the names match.

Related

• Blender to Unity Export Checklist: the FBX side of the same problem, with the 100x scale and Humanoid Avatar mapping
• Blender to Unreal Export Checklist: centimetres, Z-up, bone axes and retargeting onto the UE5 Mannequin
• Godot vs Unity for Web Games (2026): if you're still choosing the engine
• How to Optimize GLB Files for the Web: texture caps, quantization and when Draco or Meshopt is worth it
• GLB Viewer and glTF Inspector: inspect the scene graph, materials, skeleton and animations of your export before Godot sees it
• Cinevva Rig for Blender: rig, animate and export for Godot from one panel in Blender

Last updated: September 2026.

To get a Blender model into Unity at the right size, facing the right way, with a rig Unity can read, export FBX from File > Export > FBX (.fbx) with Apply Scalings set to FBX Units Scale (or FBX All), Forward -Z and Up Y, Apply Unit on, Add Leaf Bones off, Smoothing set to Face, and Path Mode Copy with Embed Textures on. Don't drop the .blend file into Assets, and keep glTF for static props until Unity's glTFast importer plays animation without extra work. Everything below explains why each setting matters, what it looks like when it's wrong, and how to fix it on either side.

Quick answer

• Format: FBX for anything rigged or animated. glTF (.glb) only for static props, and only after installing the com.unity.cloud.gltfast package. Never the raw .blend.
• Scale: Blender Scene Properties, Unit System Metric, Unit Scale 1.0. In the exporter, Scale 1.00, Apply Scalings FBX Units Scale, Apply Unit ticked. In Unity, Scale Factor 1 and Convert Units ticked. A 1.8 m character should read 1.8 units tall with a scale of 1 on every transform.
• Axes: Forward -Z, Up Y in the exporter (the defaults). In Unity's Model tab, tick Bake Axis Conversion so the -90 on X disappears from the root transform.
• Bones: untick Add Leaf Bones. Tick Only Deform Bones if you export a Rigify or Auto-Rig Pro control rig. Model in a T-pose and name bones after body parts so the Humanoid Avatar maps itself.
• Animation: one Action per clip, or one NLA strip per clip. Leave NLA Strips and All Actions on, Key All Bones on, Sampling Rate 1. In Unity the clips appear in the Animation tab, one per FBX AnimStack.
• Textures: Path Mode Copy, Embed Textures on. In Unity's Materials tab press Extract Textures, then Extract Materials. Pink means the shader doesn't match your render pipeline, not that the texture is missing.

Quick reference

The Blender FBX exporter settings that matter for Unity, with the value to use and the reason. Option names and descriptions come from the Blender manual and the exporter's source.

Don't drop the .blend into Assets

Unity will accept a .blend file, and that's the trap. Unity's proprietary format page explains what happens: "You need to have the 3D modeling software installed to import proprietary files directly into Unity", and "the first time you import a proprietary file into Unity, the 3D modeling software has to launch in a command-line process." Unity is running Blender's FBX exporter in the background with settings you don't control, so you get the exporter's defaults, including the leaf bones and the scale layout that produce most of the problems on this page.

The same page lists what the .blend route can't do: "Textures and diffuse color are not assigned automatically", and "Blender does not export the visibility value inside animations in the FBX file." Unity's 3D formats page adds the team problem: assets saved as .blend "fail to import unless you have the corresponding 3D modeling software installed on your computer", so "everybody working on your Unity project must have the correct software installed", including your build machine. Unity's own verdict: "It's best practice to use the .fbx file format whenever possible, and not use proprietary model file formats in production."

Keep the .blend in a source folder outside Assets (or in a folder ending in ~, which Unity ignores) and export FBX into Assets.

FBX or glTF for Unity in 2026

FBX. Unity's importer reads .fbx, .dae, .dxf and .obj natively, and its 3D formats page doesn't mention glTF at all. glTF support comes from Unity glTFast, a package you add through Window > Package Manager > Add package by name with com.unity.cloud.gltfast. It's an official Unity package since December 2023, at version 6.17.0 as of March 2026, and its installation page says the Editor installs the latest version plus dependencies. Once it's in, dropping a .glb into Assets works through a ScriptedImporter, and it supports Built-in, URP and HDRP.

Three things stop it being the default for characters. Its features page lists animation as fully supported only "via legacy Animation System", and for Mecanim says "Animation clips can be imported Mecanim compatible, but they won't be assigned and cannot be played back without further work." Draco, KTX2 and Meshopt each need another package (com.unity.cloud.draco, com.unity.cloud.ktx, com.unity.meshopt.decompress). And Unity's texture importer reads BMP, EXR, GIF, HDR, IFF, JPG, PICT, PNG, PSD, TGA and TIFF, not WebP, which is why glTFast 6.17 added an explicit error for WebP images. A GLB tuned for the web (WebP textures, Draco) is the wrong file for Unity.

glTF earns its place for static props and for anything loaded at runtime from a server, where glTFast is excellent. For a rigged, animated character going into an Animator Controller, export FBX. If you already have a GLB, the GLB viewer shows you what's in it, and Blender imports it cleanly for a re-export.

Scale: why the model arrives 100x too big, or with 0.01 on everything

FBX measures in centimetres, Blender in metres. The exporter's unit code is one line: the Blender-to-FBX factor is 100.0 * scene.unit_settings.scale_length, with a comment that FBX stores "the 'reference' unit of a file in its UnitScaleFactor property (1.0 meaning centimeter)". So every metre export carries a factor of 100 somewhere, and the Apply Scalings dropdown decides where.

The default, All Local, is described as "Apply custom scaling and units scaling to each object transformation, FBX scale remains at 1.0". Every object in the file gets a scale of 100 on its transform. Unity's Model tab then applies Convert Units, which "converts the model scaling defined in the model file to Unity's scale", and the prefab looks the right size, with a scale of 100 on the mesh and a file scale of 0.01 to cancel it. That's the famous 0.01. It works until you parent something to a bone, drive a transform from code, or retarget, and the hidden 100 shows up.

FBX Units Scale is "Apply custom scaling to each object transformation, and units scaling to FBX scale": the 100 moves into the file's unit header and every object keeps a scale of 1. FBX All puts both the unit factor and your custom Scale value in the header, which is the same result as long as Scale stays at 1.00. Either is right for Unity. The Unity side wants the defaults: Unity's Model tab says Scale Factor exists because "Unity's physics system expects 1 m in the game world to be 1 unit in the imported file", so leave it at 1 and leave Convert Units ticked.

Two other scale mistakes are common. If you changed Unit Scale in Scene Properties to work in centimetres, the exporter multiplies by 100 times that Unit Scale, and the Blender manual notes the setting "only influences the values displayed in the user interface and not how things behave internally", so a 0.01 Unit Scale with Apply Unit on can shrink a 180 cm character to 1.8 cm. And an object scale that isn't 1.0 gets baked into the FBX. Select everything and run Object > Apply > All Transforms (Ctrl-A). The Blender manual agrees: "It is recommended to apply transforms before rigging and animation." Don't apply scale to an armature that already carries animation, because that rescales the keyframes.

Axes: where the -90 on X comes from

Blender is Z up. The FBX manual states it plainly: "Blender uses Y Forward, Z Up (since the front view looks along the +Y direction). For example, its common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed." Unity is Y up and Z forward. Blender's front view looks along +Y, so a character modelled to face the front camera faces -Y, and the exporter's defaults of -Z Forward and Y Up are what map that to Unity's forward. Leave them.

Even with the right axes, the root object of a Blender FBX shows a rotation of -90 (often -89.98) on X in Unity's Inspector, with a compensating rotation on the children. That's the axis conversion stored as a transform rather than baked into vertices. Three ways to remove it, in order of preference.

Bake Axis Conversion in Unity. The Model tab option "Bakes the results of axis conversion directly into your application's asset data (for example, vertex or animation data) when you import a model that uses a different axis system than Unity." Tick it and the root reads 0, 0, 0, and nothing changes in Blender.

Counter-rotate in Blender. With all transforms applied, rotate the object -90 on X, apply rotation, then rotate it +90 on X and export without applying. The exporter's Use Space Transform ("Apply global space transform to the object rotations") turns that +90 into a zero rotation on the Unity side. Community add-ons automate this: the blender-to-unity-fbx-exporter project gives every exported object "a rotation of +90 degrees around the X axis in their transform without actually modifying the visual pose", reverted after export.

Apply Transform in the exporter. Don't, for anything rigged. Its own description ends "(WARNING! experimental option, use at own risk, known to be broken with armatures/animations)", and the exporter draws an error icon next to it. It works on a static prop, and it's still fine to skip.

Bones: leaf bones, orientation, and the Humanoid Avatar

Leaf bones. Add Leaf Bones is on by default and described as "Append a final bone to the end of each chain to specify last bone length (use this when you intend to edit the armature from exported data)". The exporter names each one after its parent plus _end, so Unity's hierarchy fills with Head_end, LeftHand_end and LeftToeBase_end. They're harmless for Generic rigs and they confuse Humanoid automapping and retargeting tools. Untick it. If you're re-importing someone else's FBX, the importer's Ignore Leaf Bones option strips them.

Control rigs. A Rigify or Auto-Rig Pro rig has hundreds of non-deforming bones for controls, IK targets and mechanisms. Only Deform Bones writes "Only deforming bones (and non-deforming ones when they have deforming children)", which is the skeleton Unity wants. Bake the animation onto the deform bones first, since control-rig constraints don't export, only their result as keyframes.

Bone orientation. Blender bones point along their local Y. Unity reads the bind pose and the skin weights and plays what it's given, so the Primary and Secondary Bone Axis settings can stay at Y and X. They matter when the same FBX goes to a tool that assumes a convention, such as Unreal or a retargeting add-on.

The Humanoid Avatar. Unity's Rig tab gives you Generic ("if your rig is non-humanoid (quadruped or any entity to be animated)") or Humanoid ("if your rig is humanoid (it has two legs, two arms and a head)"). Humanoid unlocks retargeting between characters, and it has rules, from the Avatar configuration page. The skeleton needs "at least 15 bones organized in a way that loosely conforms to an actual human skeleton". "If Unity can't create the Avatar, a cross appears next to the Configure button, and no Avatar sub-asset appears." Inside Configure, a bone Unity accepts "appears in green in the Avatar Mapping tab" and a rejected one "appears in red". And the pose: "If the bone assignment is correct, but the character is not in the correct pose, you will see the message 'Character not in T-Pose'. You can try to fix that by choosing Enforce T-Pose from the Pose menu."

So rig in a T-pose with the rest pose in a T-pose too, and name bones after body parts (Unity's guidance for automatic mapping is to name bones "in a way that reflects the body parts they represent"). Mixamo names (mixamorig:Hips, mixamorig:LeftArm) automap reliably, which is one reason so many riggers output them. If a few bones fail, drag them from the Hierarchy onto the slots, then Pose > Enforce T-Pose, then Apply, and save the result as a Human Template (.ht) for the next export of the same rig.

If you don't have a rig yet, the automatic rigging guide covers what auto riggers need from a mesh, and the Cinevva Rig add-on produces a Mixamo-named humanoid armature inside Blender, on your own machine, offline, for a one-time $29 launch price, on Blender 4.2 and newer for Windows, macOS and Linux.

Root motion

Root motion is the movement of the character's root through the world, as opposed to the limbs moving in place. Unity's root motion page works from a Root Transform that "is a projection on the Y plane of the Body Transform and is computed at runtime", and per clip you choose whether to bake rotation, Y and XZ into the pose or keep them as motion that moves the GameObject. Bake Into Pose on XZ is the normal setting for idles "to force the delta Position (XZ) to be 0" so the character doesn't drift. For Generic rigs the page says "instead of using the Body Transform to compute/project a Root Transform, the transform set in Root Node is used", and that Root Node defaults to None in the Rig tab, so pick your hips or root bone there or root motion silently does nothing.

On the Blender side the rule is: animate travel on a bone, not on the armature object. The exporter writes the armature object as a Null node (Armature FBXNode Type, "similar to Blender's Empty"), and Unity's root motion settings look at bones under the Avatar, not at that empty. A dedicated root bone at the floor, parent of Hips, keyed with the travel, is the layout Unity's Root Node option is designed for. Clips authored in place with the travel handled by code need no root bone at all, and that's what most animation libraries ship.

Animations: actions, NLA strips, and baking

Unity reads FBX AnimStacks and shows each one as a clip in the Animation tab, where you can split, rename, loop and trim them. Blender's Bake Animation panel decides how many AnimStacks you get.

One Action per clip. With All Actions on, the exporter will "export each action as a separated FBX's AnimStack, instead of global scene animation (note that animated objects will get all actions compatible with them, others will get no animation at all)". Name your Actions Idle, Walk, Run, Jump, and Unity lists them under those names. The catch in that description: any Action whose channels match the armature counts as compatible, so a stray Action from another rig attaches itself. Delete Actions you don't want shipped.

One NLA strip per clip. With NLA Strips on, the exporter will "export each non-muted NLA strip as a separated FBX's AnimStack, if any, instead of global scene animation". Push each Action down to its own track, mute the ones you're not shipping, and you get exact control over frame ranges, plus a way to export a clip that blends two Actions.

Bake first when constraints are involved. The Blender FBX manual lists constraints under things that don't export: "The result of using constraints is exported as a keyframe animation however the constraints themselves are not saved in the FBX." IK, Copy Rotation and Child Of get sampled at the export Sampling Rate, which is why Key All Bones ("Force exporting at least one key of animation for all bones") and Force Start/End Keying should stay on. Unity's own Bake Animations option is "only available for Autodesk Maya, Autodesk 3ds Max and Cinema 4D files", so the baking has to happen in Blender. Object > Animation > Bake Action with Visual Keying and Clear Constraints, on a copy, gives you an FK-only Action nothing can misread.

Simplify. The exporter's Simplify ("How much to simplify baked values (0.0 to disable, the higher the more simplified)") defaults to 1.0 and is safe for game clips. If a clip wobbles in Unity but not in Blender, set it to 0 and let Unity's Anim. Compression do the keyframe reduction.

Two Unity habits round it off. Files named modelName@animationName.fbx are collected automatically: per the splitting animations page, "Unity automatically imports all four files and collects all animations to the file without the @ sign in", so hero.fbx plus hero@walk.fbx gives one character with a Walk clip, and you can re-export a single clip without touching the mesh. And set Loop Time on cycles in the Animation tab, since FBX has no notion of looping.

Textures and the pink material

Blender's FBX exporter references textures by path unless you tell it to carry them. Set Path Mode to Copy, and then the Embed Textures toggle becomes available, described as "Embed textures in FBX binary file (only for 'Copy' path mode!)". The .fbx now contains the images. In Unity, the Materials tab keeps materials as sub-assets by default ("Use Embedded Materials"), and two buttons pull them out: Extract Textures writes the embedded images into a folder, and Extract Materials turns the sub-assets into editable .mat files. Do Textures first, then Materials, so the extracted materials point at the extracted textures. Once extracted, "new imports or changes to the original asset do not affect extracted materials", which is what you want: you can re-export the mesh a hundred times without losing the Unity-side material tweaks.

What arrives is the base colour and a few slots. FBX has no PBR standard that Blender's Principled BSDF maps onto one-to-one, so expect to assign roughness, metallic and normal maps by hand in Unity. The Material Creation Mode "Import via MaterialDescription" reads the material description embedded in the FBX and gets closer than the Standard (Legacy) mode.

Then the pink. Unity's error shader page: "Unity renders an object with the default error shader when there's a problem with that object's material or shader", such as a shader that doesn't compile or isn't supported, and "the default error shader is magenta (bright pink)." The specific case for imports: "If your project uses the Universal Rendering Pipeline (URP), Unity might render an object using the default error shader if the object uses a shader from the Built-In Render Pipeline." Imported FBX materials default to Built-in shaders, so in a URP or HDRP project they come in pink. Missing textures do not turn a material pink, they turn it grey or white.

The fix is one menu. Select the pink materials and run Edit > Rendering > Materials > Convert Selected Materials to URP, or open Window > Rendering > Render Pipeline Converter, choose Built-in Render Pipeline to URP, tick Material Upgrade and run it, per the converter docs. The one limit: "This converter doesn't support materials with custom shaders", which imported FBX materials never are. HDRP has the equivalent under Edit > Rendering > Materials.

Smoothing and normals

Blender's Smoothing dropdown has four options and one of them breaks a Unity feature. Normals Only exports "only normals instead of writing edge or face smoothing data", and the manual notes that "if the importer supports custom split normals, using Normals Only is generally the most accurate". Face writes face smoothing, Edge writes edge smoothing, Smoothing Groups writes groups of faces shaded together. Unity imports the normals fine in every case (its Normals setting defaults to Import). But Unity's Model tab warns, under Import BlendShapes: "Importing blend shape normals requires smoothing groups in the FBX file." Export a face with shape keys using Normals Only and the morph targets arrive with flat or broken shading.

Face is the safe default for Unity, and Smoothing Groups if you're also sending the file to 3ds Max style tools. If your hard edges come from the Smooth by Angle modifier, tick Apply Modifiers or they vanish. If a mesh looks faceted in Unity and smooth in Blender, switch Unity's Normals to Calculate and Smoothness Source to From Angle as a quick check, then fix the export.

Symptom, cause, fix

The 10-step checklist

Run this in Blender on a copy of the file, then in Unity.

1. Clean the scene. Delete cameras, lights, reference images and anything not shipping. Join meshes that share a material where sensible, and make sure every mesh that should deform is parented to the armature with an Armature modifier.
2. Check units. Scene Properties, Units: Unit System Metric, Unit Scale 1.0, Length Meters. Read the Dimensions panel (N) on your character: 1.6 to 2.0 m for a human.
3. Apply transforms. Select meshes, Object > Apply > All Transforms. For an armature without animation, apply too. For an animated armature, leave it and make sure its scale already reads 1.0.
4. Fix the pose and names. Rest pose in a T-pose, facing -Y (the front view). Bone names that read as body parts, mirrored .L and .R or Left and Right. No _end bones of your own.
5. Prepare the clips. One Action per clip with a fake user, or one NLA strip per clip. Bake anything driven by IK or constraints with Object > Animation > Bake Action, Visual Keying on.
6. Export. File > Export > FBX (.fbx). Selected Objects on. Object Types Armature and Mesh. Scale 1.00, Apply Scalings FBX Units Scale, Forward -Z, Up Y, Apply Unit on, Use Space Transform on, Apply Transform off. Smoothing Face, Apply Modifiers on. Only Deform Bones on for control rigs, Add Leaf Bones off. Bake Animation on with Key All Bones, NLA Strips, All Actions and Force Start/End Keying on, Sampling Rate 1.0, Simplify 1.0. Path Mode Copy, Embed Textures on. Save these as an operator preset (the + at the top of the panel).
7. Import. Drop the .fbx into Assets. Model tab: Scale Factor 1, Convert Units on, Bake Axis Conversion on, Import BlendShapes on if you have shape keys. Apply.
8. Rig. Rig tab: Humanoid for a biped, Generic otherwise. Avatar Definition Create From This Model. Press Configure and check for green bones and no T-pose message. For Generic, set Root Node if the clip should move the character. Apply.
9. Animation. Animation tab: confirm one clip per Action. Set Loop Time on cycles. Set Root Transform Position (XZ) Bake Into Pose on idles. Apply.
10. Materials. Materials tab: Extract Textures to a Textures folder, then Extract Materials to a Materials folder. In a URP or HDRP project, select the extracted materials and Edit > Rendering > Materials > Convert Selected Materials to URP. Drag the prefab into a scene and check scale, facing and shading against Blender.

The one-click route

If you'd rather not remember step 6, the Cinevva Rig add-on has an export card with a Unity preset that applies exactly this recipe: FBX, Forward -Z, Up Y, unit scale applied with FBX All, no leaf bones, Face smoothing, textures embedded and capped at 2048 px. Before you press Export, its size analysis splits the estimated file into geometry, textures, animation and shape keys, so you can see that the 60 MB is three 4K textures and not the mesh. Measured against a plain Blender GLB export, the presets produced files 68%, 89%, 92% and 98% smaller on four real models, almost all of it from the texture cap and re-encoding. Export runs locally with no key, no account and no network. The paid half of the add-on is rigging: one $29 launch-price purchase, unlimited local rigging after a one-time engine download of about 2.4 GB, on Blender 4.2 and newer, plus 260 CC0 animation clips retargeted onto the rig inside Blender, which then export as the Actions described above.

The established paid fix for the FBX round trip is Better FBX Importer & Exporter by Mesh Online, 12,800+ sales on Superhive. It's a from-scratch FBX implementation on Autodesk's official FBX SDK, "compatible with all FBX versions, from ASCII to binary, from FBX 5.3 to FBX 2020", with exports "verified in Unity Engine 2021, Unreal Engine 4/5 and Godot Engine v4.1.1" per its product page. Its two standout features are automatic bone orientation on import (the bone axes Blender's importer leaves twisted) and an "Optimize For Game Engine" export that writes armatures with "unit scale and zero rotations". If you import a lot of FBX from other artists or round-trip through Maya or 3ds Max, it pays for itself the first week. If you only export your own Blender work to Unity, the settings on this page get the same result for free.

Common Questions

How do I export from Blender to Unity?

Export an FBX, not the .blend. File > Export > FBX (.fbx) with Selected Objects on, Scale 1.00, Apply Scalings FBX Units Scale, Forward -Z, Up Y, Add Leaf Bones off, Smoothing Face, Path Mode Copy with Embed Textures on. In Unity's Model tab tick Convert Units and Bake Axis Conversion, then extract textures and materials from the Materials tab.

Why is my Blender model scaled 0.01 or 100 in Unity?

FBX counts in centimetres, so Blender's exporter multiplies a metre scene by 100. With the default Apply Scalings of All Local that 100 lands on every object's transform and Unity's Convert Units cancels it with a 0.01 file scale. Choose FBX Units Scale or FBX All instead and the factor goes into the file header, leaving every transform at 1. If the model is 100 times too big, Convert Units is off or Scale Factor was changed in Unity.

Why does my Blender FBX have a -90 rotation on X in Unity?

Blender is Z up and Unity is Y up, and the exporter stores the 90 degree turn between them as a rotation on the root object, which Unity displays as -90 (often -89.98). Tick Bake Axis Conversion in Unity's Model tab and the rotation is baked into the vertices and the root reads zero. Don't use the exporter's Apply Transform on a rigged model, since its own description says it's broken with armatures and animation.

How do I export animations from Blender to Unity?

Make one Action per clip (or one NLA strip per clip), bake any IK or constraint-driven motion with Bake Action, and export with Bake Animation on, Key All Bones, NLA Strips, All Actions and Force Start/End Keying ticked. Each Action arrives as a clip in Unity's Animation tab under its Blender name. For a Generic rig set Root Node in the Rig tab if you want root motion, and set Loop Time on cycles.

Should I use FBX or glTF for Unity?

FBX for anything rigged or animated. Unity imports FBX natively, while glTF needs the com.unity.cloud.gltfast package, whose animation import is complete only for the legacy Animation system and needs "further work" for Mecanim, and Unity can't read WebP textures. glTF is a good choice for static props and for models loaded at runtime from a server.

Why are my materials pink in Unity after importing from Blender?

Pink is Unity's error shader, and for imports it almost always means the material uses a Built-in Render Pipeline shader in a URP or HDRP project. Select the materials and run Edit > Rendering > Materials > Convert Selected Materials to URP, or use Window > Rendering > Render Pipeline Converter. Missing textures make a material grey, not pink: for those, export with Path Mode Copy and Embed Textures, then press Extract Textures in Unity.

Why won't Unity make a Humanoid Avatar from my Blender rig?

Unity needs at least 15 required bones it can recognise and a T-pose. A cross next to Configure means the mapping failed, red bones in the Mapping tab are the ones it couldn't place, and "Character not in T-Pose" means the rest pose is off. Name bones after body parts (Mixamo names always map), untick Add Leaf Bones so _end bones don't confuse it, drag any red bones into place by hand, and use Pose > Enforce T-Pose.

Related

• Blender to Unreal Export Checklist: the same walk for Unreal, where the units and bone axes go the other way
• Blender to Godot Export Checklist: glTF is the native path in Godot 4, and the settings differ
• How Automatic Rigging Works: what a rigger needs from your mesh before any of this matters
• How to Optimize GLB Files for the Web: Draco, Meshopt and KTX2 for the browser, where glTF is the right format
• GLB Viewer: inspect a glTF's scene graph, bones and clips before you re-export it for Unity
• Cinevva Rig for Blender: rigging, 260 CC0 clips and the Unity export preset in one add-on

Last updated: September 2026.

Getting a Blender character into Unreal Engine cleanly comes down to six FBX exporter settings and one scene setting. In File > Export > FBX (.fbx): Selected Objects on, Apply Unit on with Apply Scalings set to FBX All (or leave it on All Local and set the scene's Unit Scale to 0.01), Smoothing set to Face, Add Leaf Bones off, Primary Bone Axis Y with Secondary X, and Bake Animation with NLA Strips or All Actions depending on how you store clips. Rename the armature object to root before you press Export, because Unreal turns that object into your root bone. Everything below explains why each setting matters, what the failure looks like when you skip it, and how to retarget the result onto the UE5 Mannequin or a MetaHuman.

Quick answer

• Scale: Unreal works in centimetres, Blender's internal unit is a metre. Either set Scene Properties > Units > Unit Scale to 0.01 and model at Unreal size, or keep 1.0 and export with Apply Scalings: FBX All so the file's header carries the conversion. Leaving both at defaults is what puts a scale of 100 on your root bone.
• Axes: leave Forward -Z and Up Y (Blender's default). Unreal's Convert Scene import option reads the FBX header and rotates into its Z-up, X-forward frame. Model the character facing -Y in Blender (looking at you in Numpad 1 front view) and it faces +X in Unreal.
• Bones: Primary Bone Axis Y, Secondary Bone Axis X. These are Blender's defaults and also what Epic's own Send to Unreal add-on ships. Changing them is the usual cause of "my bones import rotated 90 degrees".
• Root bone: the armature object becomes Unreal's root bone under the object's name. Rename it root, keep the hips as its first child, and don't skin anything to it.
• Leaf bones and smoothing: Add Leaf Bones off (otherwise every chain grows a _end bone), Smoothing set to Face (otherwise Unreal warns about missing smoothing groups).
• Animation: one Action per clip, Bake Animation on, Key All Bones on, Simplify 0. Import onto the existing Skeleton asset with Import Mesh off.
• One-click route: the Cinevva Rig add-on has an Unreal export preset that applies these conventions for you and shows a size analysis first. It runs on your own machine, offline, for one $29 purchase (launch price), on Blender 4.2 and newer for Windows, macOS and Linux.

Quick reference

The matrix. Find the symptom you're seeing in Unreal, read across.

Units and scale: where "scale 100" comes from

Unreal's FBX importer works in centimetres. Its Convert Scene Unit option is described in the FBX Import Options Reference as converting "from the FBX units of measurement to UE's unit of measure, centimeters." Blender's internal unit is a metre. The exporter's source says it plainly: "Default Blender unit is equivalent to meter, while FBX one is centimeter". So something has to multiply by 100, and the only question is where that 100 gets written.

Blender's exporter (io_scene_fbx, version 5.12.4 in Blender 4.2) gives you two settings for it. Apply Unit, on by default, means "take into account current Blender units settings". Apply Scalings decides where the factor lands. Its first option, All Local (FBX_SCALE_NONE), applies "custom scaling and units scaling to each object transformation, FBX scale remains at 1.0". Its last, FBX All (FBX_SCALE_ALL), applies "custom scaling and units scaling to FBX scale", meaning the file's header.

Read the code and the famous symptom falls out. With Unit Scale 1.0 and All Local, the exporter multiplies every top-level object transform by 100 and writes a UnitScaleFactor of 1.0. The mesh arrives the right size because its transform carries the 100. So does the armature object, and Unreal turns that object into the root bone, which is why the root reads Scale 100.0 in the skeleton tree. The Scale field's own tooltip warns "Some importers do not support scaled armatures!", and this is the case it means.

You have two clean ways out, and both are fine.

The 0.01 trick. In Properties > Scene > Units set Unit Scale to 0.01 and Length to Centimeters. The Blender manual describes Unit Scale as the "scale factor to use when converting between internal units and values displayed in the user interface", and notes it "only influences the values displayed in the user interface and not how things behave internally". A 180 cm character is now 180 Blender units tall, the exporter's factor becomes 100 times 0.01, which is 1, and the root bone imports at scale 1. Downsides: existing metre-scale assets need scaling up by 100, physics and cloth run at the wrong scale (the manual says exactly this), and viewport clip distances need raising. Unreal-first pipelines tend to settle here because everything made afterwards is already at Unreal size.

FBX All. Keep Unit Scale at 1.0 and set Apply Scalings to FBX All. The header now carries UnitScaleFactor 100, transforms stay at 1, and Unreal's Convert Scene Unit turns metres into centimetres on import. The tooltip cautions that "Blender uses FBX scale to detect units on import, but many other applications do not handle the same way". Unreal does, so this is the setting that lets you keep modelling in metres.

Whichever you pick, leave the exporter's Scale field at 1.0. It multiplies on top of the unit factor and is one more place for a stray 100 to hide.

Axes: Z-up in both, but not the same Z-up

Both applications are Z-up, which is why people expect this part to be free. It isn't, because the forward axis and the handedness differ. Blender's manual states that "Blender uses Y Forward, Z Up (since the front view looks along the +Y direction)". Numpad 1 puts the camera on the -Y side looking toward +Y, so a character modelled to face the front view faces -Y. Unreal is Z-up with X forward, and its importer's Force Front XAxis option is described as converting the scene "with the front X axis instead of -Y axis", which tells you the importer assumes an FBX file's front is -Y unless you say otherwise.

Here's the part most tutorials skip. The Forward and Up dropdowns don't rotate your model into Unreal's frame by themselves. The exporter builds a conversion matrix from them and, in the same pass, writes the matching UpAxis and FrontAxis values into the file's GlobalSettings. Unreal's Convert Scene, described as converting "the scene from the FBX coordinate system to use UE's coordinate system", reads those values, so any consistent pair works. Blender's default -Z Forward, Y Up writes a Y-up file. Epic's Send to Unreal ships Y Forward, Z Up, Blender's axes verbatim. Both import facing the same way.

What does change the result is the character's facing inside Blender. Model it facing -Y, apply rotation (Ctrl+A > Rotation), and it arrives in Unreal facing +X, the engine's forward direction. If a downloaded model faces +Y or +X, rotate it in Object Mode, apply, re-export. Don't fix facing with the Forward dropdown, or the header and the geometry disagree and later animation exports won't match.

Leave Use Space Transform on and Apply Transform off. Apply Transform (bake_space_transform) is labelled in the exporter's own tooltip as a "WARNING! experimental option, use at own risk, known to be broken with armatures/animations". It exists for static props where you want the axis conversion baked into vertex data. Never use it on a rigged character.

Bone axes: why bones import rotated

Blender bones have a fixed local frame. The manual's bone structure page says "The Y axis is always aligned along the bone, oriented from root to tip, this is the 'roll' axis of the bones." Many Maya-built rigs, and the tutorials written around them, run X along the bone instead. FBX doesn't care which axis points down a bone. It stores each bone's full transform. What matters is that the mesh's skin weights, the bind pose, and every animation key agree on the same frame.

Keep Primary Bone Axis at Y and Secondary Bone Axis at X. They're the exporter's defaults, and they're the defaults Epic ships in Send to Unreal's FBX settings. Unreal imports the bones in whatever frame the file declares, so a Blender rig with Y-along-bone works, animates and retargets correctly. Where the mismatch bites is mixing: exporting the mesh with one primary axis and an animation with another, or exporting Blender animations for a skeleton that was originally authored in Maya. If you're targeting a skeleton that already exists in Unreal, either export from the same Blender file every time, or import the Unreal skeleton into Blender first and animate on that.

The root bone question

Unreal's skeletal mesh pipeline page says the pivot of a skeletal mesh "is always located at the root bone/joint of the skeleton", and its importer wants exactly one. The FBX Import Errors page lists the message you get otherwise: "Found multiple roots. The importer only supports one root per mesh."

Blender's exporter writes your armature object as its own node above the bones. The Armature FBXNode Type option controls what kind: the default is Null, "similar to Blender's Empty", with Root and LimbNode as alternatives the tooltip advises against unless "you experience issues with the other app". Unreal reads that node as the top of the bone hierarchy and makes it the root bone, named after the armature object. Epic documents this behaviour in Send to Unreal's export settings: its "Export object name as root bone" option "uses the armature object's name in blender as the root bone name in Unreal, otherwise the first bone in the armature hierarchy is used as the root bone".

This is why a bone called "Armature" shows up above your hips. The fix is renaming the armature object, not the armature data block, to root in the Outliner. Keep it at the world origin with unit scale and zero rotation, parent your hips (or pelvis) to nothing so it becomes the first child of that node, and don't skin any vertices to it. You now have the same shape as Epic's skeletons: a root at the floor, a pelvis above it. That shape matters later, because Unreal's IK Retargeter asks you to designate a pelvis bone on both rigs to transfer root motion between characters.

If you'd rather the armature node disappear entirely, that's what Send to Unreal's "first bone in the armature hierarchy" mode does, and Better FBX Importer & Exporter does the equivalent. Blender's built-in exporter can't drop it, so rename it.

Leaf bones and deform bones

Add Leaf Bones is on by default, and the exporter's source even carries a comment marking it as meant to be off. Its tooltip: "Append a final bone to the end of each chain to specify last bone length (use this when you intend to edit the armature from exported data)". The code generates one hidden bone per chain end, named <bone>_end. Unreal shows every one of them in the skeleton tree, on each fingertip, the head, both toes. They're harmless but they pollute the hierarchy, break retarget chain auto-matching, and add bone tracks to every animation. Turn it off for engine exports.

Only Deform Bones is worth turning on if your armature has control bones: IK targets, pole targets, Rigify's control layers. The tooltip says it writes "only deforming bones (and non-deforming ones when they have deforming children)". Rigify users should export the generated rig with Only Deform Bones on so the deforming bones go across and the control machinery stays behind. Check that every bone the mesh is weighted to has its Deform flag ticked, or the vertices weighted to it will freeze in place in Unreal.

Smoothing groups, normals and triangulation

Unreal's importer expects smoothing groups. If it doesn't find them, the FBX Import Errors page lists the exact warning: "No smoothing group information was found in this FBX scene. Please make sure to enable the 'Export Smoothing Groups' option in the FBX Exporter plug-in before exporting the file." Blender's exporter defaults Smoothing to Normals Only, described as "Export only normals instead of writing edge or face smoothing data", with a note to "prefer 'Normals Only' option if your target importer understand split normals". Set Smoothing to Face and the warning stops. On import, Preserve Smoothing Groups is described as splitting "triangles with non-matching smoothing groups", which is how hard edges survive.

The skeletal mesh pipeline page states that meshes "must be triangulated as the graphics hardware only deals with triangles". Ticking Triangulate Faces in the exporter gives you control over which diagonal each quad splits on, which matters for normal maps baked in Blender. Tangent Space is optional and, per its tooltip, "will only work correctly with tris/quads only meshes". If your mesh has n-gons, turn Tangent Space off or triangulate first.

Textures and materials

Path Mode set to Copy with the Embed Textures toggle ticked packs your images into the FBX binary, and Unreal's Import Textures option pulls them out into texture assets. Expect a partial material. The static mesh pipeline page says "Only Color and Normal will automatically be connected" and the skeletal mesh page says the same in different words, "diffuse and normal map only". Roughness, metallic, emissive and ambient occlusion arrive as textures but not wired to anything. Blender's manual also lists "Material textures" as a known gap in the exporter.

The workable pattern is to embed nothing and treat the FBX as geometry plus skeleton. Export your textures from Blender's Image Editor or straight from Substance, import them into Unreal alongside the FBX, then build one master material with the Principled BSDF inputs you use and make Material Instances per character. Unreal's Material Import Method has a "Create New Instanced Materials" mode that lets you pick a base material for exactly this.

Skeletal mesh versus static mesh

Unreal decides what you've sent it by looking for a skin deformer. A mesh parented to an armature with an Armature modifier imports as a Skeletal Mesh, creates a Skeleton asset (the Skeleton option in the import dialog says "If no existing Skeleton is selected, a new one will be created"), and a Physics Asset. A mesh with no armature imports as a Static Mesh. The Import Content Type option lets you force geometry only or skinning only on a skeletal import.

For static props, two Blender-side conventions from the static mesh pipeline page save you work. Collision: Unreal reads meshes named UBX_, UCP_, USP_ and UCX_ followed by the render mesh's name as box, capsule, sphere and convex collision, in the form [PREFIX]_[RenderMeshName]_##, so a prop called Crate with a child mesh called UCX_Crate_01 arrives with its collision built. The page adds one caveat: "when importing multiple meshes with custom collision in a single file, only the first mesh's collision will be imported", so export props one per file. Vertex colors: "Vertex colors for Static Meshes can be transferred using the FBX pipeline. No special setup is necessary", which Blender writes from the active Color Attribute (the exporter's default is sRGB).

For skeletal meshes, the pipeline page confirms a character can be "a single, contiguous mesh or several separate meshes all skinned to the same skeleton", so you needn't join everything, but every piece must be parented to the same armature. Apply Modifiers is on by default and its tooltip warns it "prevents exporting shape keys". For facial shape keys, turn it off, apply the non-armature modifiers by hand, and tick Import Morph Targets in Unreal.

Animation: actions, NLA and the Skeleton asset

Blender's exporter always bakes: every animated bone is sampled at Sampling Rate (1.0 means every frame), and constraints, IK and drivers are written as plain keys. Three toggles decide how many clips come out.

All Actions writes "each action as a separated FBX's AnimStack", and the manual clarifies these are "all actions compatible with the selected armatures". NLA Strips writes "each non-muted NLA strip as a separated FBX's AnimStack". With both off, you get one clip covering the scene's frame range with the armature's current action. Unreal imports each AnimStack as its own Animation Sequence, and the animation import page confirms "Unreal allows content creators to import multiple animations in a single FBX file". So keep one Action per clip, named as you want the sequence named, and tick All Actions. If you assemble clips in the NLA editor instead, tick NLA Strips and leave All Actions off, or you'll get both.

Key All Bones forces "at least one key of animation for all bones (needed with some target applications, like UE4)". Leave it on. Force Start/End Keying adds a key at the first and last frame so Unreal's Animation Length set to Exported Time gets the range you meant. Simplify defaults to 1.0 and the tooltip says "0.0 to disable". Set it to 0 for game animation, because simplified curves can lose the exact contact frames.

On the Unreal side, do two imports. First the character with Import Animations off, which creates the Skeletal Mesh and Skeleton. Then the animation FBX (same armature, same bone axes, same scale settings, mesh not required) with Import Mesh off and the Skeleton dropdown pointed at the one you just made. Use Default Sample Rate is 30 frames per second per the reference, and Custom Sample Rate "when set to 0, the best sample rate is automatically determined". Match your Blender frame rate. If the import reports "Scene does not contain a Bind Pose", import with Use T0 As Ref Pose enabled, which uses frame 0 "to replace the Skeletal Mesh's reference pose".

Newer engine versions may show a different dialog. Epic's Interchange Framework is its "import and export framework. It is file format agnostic, asynchronous, customizable, and can be used at runtime", and the 5.5 release notes call it "production ready for asset imports and beta for level imports". Its import reference uses different names for familiar things: Offset Uniform Scale, Use 30Hz to Bake Bone Animation, Import Only Animations for the animation-onto-existing-skeleton case, and Skeleton where "Leaving this empty creates a new skeleton". The Blender-side checklist is identical either way.

Retargeting onto the UE5 Mannequin or a MetaHuman

Your Blender skeleton won't share bone names with Epic's, and it doesn't need to. Unreal 5's IK Retargeter is built to "transfer animation between skeletons with varying numbers of bones, bone names, and orientations". The process, from Epic's IK Rig retargeting page:

1. Create an IK Rig asset for your imported Skeletal Mesh (Animation > IK Rig in the Content Browser). Right-click your pelvis bone in the hierarchy and choose Set Pelvis. Press Auto Create Retarget Chains. Do the same for the target character if it doesn't already have an IK Rig.
2. Create an IK Retargeter, set the Source IK Rig to yours and the Target IK Rig to the Mannequin's (or the reverse if you're bringing Epic's animations onto your character).
3. Check the chain mapping. Epic uses fuzzy string matching, so a chain named ArmLeft matches left_arm when nothing better exists. Fix any chain it mapped wrong.
4. If your character was rigged in an A-pose and the target is a T-pose, open Edit Retarget Pose and align the arms, or use the Auto Align option.
5. Select the animations in the Asset Browser and click Export Selected Animations. You get new Animation Sequences on the target skeleton, with an optional prefix or suffix.

Two Blender-side details make this painless. Name bones by side and segment (upperarm_l, lowerarm_l, hand_l) so auto-mapping lands, and keep the root-then-pelvis hierarchy from the section above so Set Pelvis has an obvious bone and root motion transfers "proportionally between characters", as the page puts it. A Mixamo-named rig auto-maps well too, because the chain names come from bone names like LeftArm and LeftForeArm and the matcher reads words, which is one reason the Cinevva Rig add-on rigs to Mixamo names.

Send to Unreal: what Epic's add-on automates, and its state in 2026

Epic's BlenderTools repository holds Send to Unreal, "a one-click solution for sending data from Blender to Unreal Engine", and UE to Rigify. Send to Unreal wraps Blender's own FBX exporter ("All the standard FBX export settings that are in the blender FBX addon are available in this section to be customized") and adds the pipe: it writes the FBX, then uses Unreal's Python remote execution to import it into your open project. Setup on the Unreal side is the Python Editor Script Plugin, remote execution in Project Settings, and turning off "Use Less CPU when in Background" so the editor listens while Blender has focus. In Blender you move assets into a collection named Export and run Pipeline > Export > Send to Unreal.

Its defaults are what Epic chose, so they're a good sanity check: All Local scaling, Y Forward and Z Up, Face smoothing, Primary Bone Axis Y with Secondary X, leaf bones off, and the armature object's name as the root bone. It also does what the built-in exporter can't: drop the armature node, export LODs, and stash the active action into the NLA so each clip becomes its own sequence.

Maintenance is the caveat. The last release is Send to Unreal 2.4.3 from November 9, 2023, whose notes list tests passing on Blender 3.3 and 3.6 with Unreal 5.3, and the add-on's metadata sets Blender 3.3 as the minimum. The repository isn't archived, has around 3,300 stars, and took a documentation commit in September 2026, but the last code merge was July 2024 and close to a hundred issues sit open. It predates Blender's 4.2 extensions system, so test it on your version before building on it. If it works, it's the most complete free pipeline there is. If not, the checklist below gets you the same file.

On the import side, Better FBX Importer & Exporter deserves the credit it gets. It's a paid add-on from Mesh Online, around $25 for a single seat and one of Superhive's best sellers, and it exists because imports kept breaking. Its product page says it was built "with official FBX SDK from scratch", that the "exported armature and 3d models have unit scale and zero rotations", that it "supports automatic bone orientation" on import, and that its output was "verified in Unity Engine 2019, Unreal Engine 4/5 and Godot Engine v3.2". If you round-trip Epic's Mannequin or Marketplace animations into Blender and back, that automatic bone orientation is the feature you're paying for. For a one-way Blender-to-Unreal trip of your own character, the built-in exporter with the settings below is enough.

The checklist

Do these in order. Steps 1 to 5 are once per project, 6 to 13 once per export.

1. Properties > Scene > Units: Unit System Metric. Either Unit Scale 0.01 with Length Centimeters (then scale existing metre-scale assets by 100), or Unit Scale 1.0 and remember to pick FBX All in step 9.
2. Model the character facing -Y, feet on the floor at the origin. Numpad 1 should show its face.
3. In Object Mode select mesh and armature, Ctrl+A > All Transforms. Both should read location 0, rotation 0, scale 1.
4. Rename the armature object to root in the Outliner. Make sure the hips are the only top-level bone, or that every top-level bone has a real parent. Give root no weights.
5. Check every deforming bone has Deform ticked (Bone Properties). If you use Rigify or control bones, plan to export with Only Deform Bones on.
6. One Action per clip, named as you want the Animation Sequence named. Set the scene frame rate to what you'll use in Unreal (30 is Unreal's default sample rate).
7. Select the mesh objects and the armature. Nothing else. Cameras, lights and empties become extra nodes.
8. File > Export > FBX (.fbx). Include: Selected Objects on, Object Types limited to Armature and Mesh.
9. Transform: Scale 1.00, Apply Scalings FBX All (or All Local if your Unit Scale is 0.01), Forward -Z, Up Y, Apply Unit on, Use Space Transform on, Apply Transform off.
10. Geometry: Smoothing Face, Apply Modifiers on (off if you need shape keys), Triangulate Faces on, Tangent Space off unless the mesh is all tris and quads.
11. Armature: Primary Bone Axis Y, Secondary Bone Axis X, Armature FBXNode Type Null, Only Deform Bones as decided in step 5, Add Leaf Bones off.
12. Bake Animation: on for the character export only if you want clips in the same file, otherwise off here and on in a second animation-only export. Key All Bones on, NLA Strips off, All Actions on, Force Start/End Keying on, Sampling Rate 1.0, Simplify 0.
13. Path Mode Copy with Embed Textures only if you want Unreal to create placeholder materials, otherwise leave it and import textures separately.
14. In Unreal, drag the FBX into the Content Browser. Import as Skeletal Mesh with Skeleton empty, Import Animations off, Convert Scene on, Convert Scene Unit on, Import Uniform Scale 1.0. Open the result and confirm the root bone reads Scale 1.0, the character faces +X, and the bone count matches Blender's deform bone count.
15. Import the animation FBX with Import Mesh off and Skeleton set to the one from step 14. Play a clip and watch feet and hands.

If step 14 shows Scale 100 on the root, go back to step 1 or 9. If the character faces the wrong way, step 2. If there's a bone called Armature, step 4. If the tree has _end bones, step 11.

The one-click route

Every setting above is a convention, and conventions are what software is for. The Cinevva Rig add-on ships an Unreal export preset that writes FBX with forward -Y and up Z, unit scale applied with FBX_SCALE_NONE, primary bone axis Y and secondary X, no leaf bones, face smoothing, and textures embedded and capped at 2048 px, so a rigged character from the add-on goes to Unreal without touching the exporter dialog. Before it exports, a size analysis splits the estimated file into geometry, textures, animation and shape keys, which is how you find out that the 40 MB character is 36 MB of 4K textures on a 3,000-triangle mesh. Against a plain Blender GLB export, the presets produced files 68%, 89%, 92% and 98% smaller on four real models. Export needs no key, no account and no network. The rigging half rigs a mesh to a skinned, Mixamo-named humanoid armature on your own machine, offline, after a one-time engine download of about 2.4 GB, for one $29 purchase (launch price) with no per-rig charge, and it runs on Blender 4.2 and newer on Windows, macOS and Linux. The same 260 CC0 clips it retargets in Blender come along in the FBX as separate actions, ready for step 15.

Common Questions

How do I export from Blender to Unreal Engine 5?

Select the mesh and armature, File > Export > FBX (.fbx), tick Selected Objects, set Apply Scalings to FBX All (or use a 0.01 Unit Scale scene with All Local), Smoothing to Face, Add Leaf Bones off, Primary Bone Axis Y and Secondary X, and Bake Animation with All Actions on. Rename the armature object to root first. In Unreal, drag the file into the Content Browser and import with Convert Scene and Convert Scene Unit on.

What are the correct Blender FBX export settings for Unreal?

Scale 1.0, Apply Unit on, Apply Scalings FBX All, Forward -Z, Up Y, Use Space Transform on, Apply Transform off, Smoothing Face, Apply Modifiers on, Primary Bone Axis Y, Secondary Bone Axis X, Armature FBXNode Type Null, Add Leaf Bones off, Key All Bones on, All Actions on, Simplify 0. These match what Epic's Send to Unreal add-on ships apart from the scaling choice, where Send to Unreal uses All Local and expects you to work at Unreal scale.

Why is my Blender model scale 100 in Unreal?

Because Blender's metre and Unreal's centimetre differ by 100, and with the exporter's defaults (Unit Scale 1.0, Apply Scalings All Local) that 100 gets multiplied into the armature object's transform, which Unreal then reads as the root bone. Either set the scene's Unit Scale to 0.01 and model at Unreal size, or export with Apply Scalings set to FBX All so the factor goes into the file header and Unreal's Convert Scene Unit applies it.

Why do my bones import rotated in Unreal?

Blender bones always run along their local Y axis, and the exporter's Primary Bone Axis Y with Secondary X writes that frame as-is. If you changed Primary to X because a Maya tutorial said to, every bone frame in the file turns 90 degrees relative to the skin and animation data. Set the axes back to Y and X and re-export both mesh and animations from the same file.

How do I get rid of the Armature root bone in Unreal?

You can't remove it with Blender's built-in exporter, but you can name it. Unreal turns the armature object into the root bone under the object's name, so rename the armature object (not the armature data) to root, keep it at the origin, and make the hips its first child. Send to Unreal and Better FBX Importer & Exporter can both drop the node and promote the first bone instead.

Is the Send to Unreal Blender add-on still maintained in 2026?

Barely. The last release is 2.4.3 from November 2023, tested on Blender 3.3 and 3.6 with Unreal 5.3, and the last code merge was July 2024. The repository is still public, not archived, and picked up a documentation commit in September 2026, but there's been no release for Blender 4.x. Test it on your Blender version before building a pipeline on it, and keep the manual checklist as the fallback.

How do I retarget Blender animations to the UE5 Mannequin?

Import your character as a Skeletal Mesh, create an IK Rig for it, Set Pelvis on the hips bone and press Auto Create Retarget Chains. Create an IK Retargeter with your IK Rig as Source and the Mannequin's shipped IK Rig as Target, check the chain mapping, fix the retarget pose if your rig is an A-pose, then select your animations and click Export Selected Animations. The same steps work in reverse to put Epic's animations on your character.

Related

• How Automatic Rigging Works: what a skeleton, bind pose and skin weights are, and how to prepare a mesh for rigging
• Free Character Animations and Auto-Rigging: CC0 clip libraries and free riggers to fill the Actions you'll export
• Blender to Unity Export Checklist: the same walk for Unity, where the axis and scale answers differ
• Blender to Godot Export Checklist: glTF instead of FBX, and why Godot skips most of this
• GLB Viewer: inspect a skeleton hierarchy, bone count and animations in the browser before you import
• Cinevva Rig for Blender: the add-on with the Unreal export preset and size analysis described above

Last updated: September 2026.

Nearly every weight painting problem in Blender is one of seven: automatic weights refuse to run, weights bleed from one limb into another, a vertex has more than four bones pulling on it, weights don't add up to one, the two sides don't match, a wrist collapses when it twists, or a jacket stays behind when the body moves. Each has a specific tool in the Weights menu of Weight Paint Mode (Normalize All, Clean, Limit Total, Smooth, Mirror Vertex Group, Transfer Weights) or a modifier setting, and this guide gives the exact path for each. If you'd rather not paint at all, two add-ons skin a character for you, and we cover both at the end.

Quick answer

• Automatic weights fail with Bone Heat Weighting: failed to find solution for one or more bones: clean the mesh. Mesh > Clean Up > Merge by Distance, Degenerate Dissolve, Delete Loose, then Select > Select All by Trait > Non Manifold. Rig one connected body, attach clothes afterwards.
• Weights bleed into the wrong limb: select the affected faces, then Weights > Assign Automatic from Bones for only the bones that should own them, or paint them out and run Weights > Smooth and Weights > Clean.
• Too many bones per vertex: Weights > Limit Total with Limit 4, then Weights > Normalize All.
• Weights don't sum to one: Weights > Normalize All with Lock Active off, then Auto Normalize on in the tool options.
• One side is right, the other isn't: Weights > Mirror Vertex Group with Mirror Weights and Flip Group Names, or paint with Mirror Vertex Groups on in the Symmetry panel.
• Candy-wrapper wrist: Preserve Volume on the Armature modifier for renders, twist bones for a game engine.
• Clothing doesn't follow the body: a Data Transfer modifier on the clothing, Vertex Groups, Nearest Face Interpolated, source set to the body.
• Skip the step: Voxel Heat Diffuse Skinning (about $30) skins meshes Blender's solver rejects. The Cinevva Rig add-on ($29 launch price, runs offline on your own machine, Blender 4.2+ on Windows, macOS and Linux) places the skeleton and the weights together.

Quick reference

What skin weights are, in one paragraph

Every vertex on a character carries a small list: which bones move it and by how much. Blender stores that list as vertex groups named after bones, one weight per vertex per group, and the Armature modifier reads them: "a bone named 'forearm', will only affect the vertices in the 'forearm' vertex group. The influence of one bone on a given vertex is controlled by the weight of this vertex in the relevant group." Weight Paint Mode is a way to see and edit those numbers as colour. The manual's colour code: "areas of low value (with weights close to 0.0) are displayed as blue (cold) and areas of high value (with weights close to 1.0) are displayed as red (hot)", with green and yellow in between.

A good joint is a short gradient. A bad joint is either a hard step, which folds like paper, or a gradient that reaches somewhere it shouldn't.

See what you've got before you fix anything

Set up the view the way the manual's workflow describes: select the armature, Ctrl-Tab into Pose Mode, then select the mesh and switch to Weight Paint Mode. Edit > Lock Object Modes in the topbar must be unchecked or the second step fails. In the viewport header tick Bone Selection, then Alt-LMB a bone to show its vertex group on the mesh. Bones hide inside the body, so turn on In Front for the armature in its Viewport Display settings.

Then open Viewport Overlays and set Zero Weights to All. Per the overlay docs, vertices "are shown in black if they have no weight in any vertex group". Those are the vertices that stay behind when the character moves.

Problem 1: Automatic weights fail

You press Ctrl-P, choose Armature Deform > With Automatic Weights, and Blender answers:

Bone Heat Weighting: failed to find solution for one or more bones

That string lives in Blender's source, in source/blender/editors/armature/meshlaplacian.cc, and the function around it tells you what went wrong. Automatic weights treat each bone as a heat source and solve a diffusion problem over the mesh surface, which the manual describes as influence "based on the distance from those vertices to a particular bone ('bone heat' algorithm)". Two details from the code matter: the mesh is triangulated first ("bone heat needs triangulated faces"), and a bone only heats a vertex it can see, tested with a ray cast against the mesh. The error fires when the linear solve for a bone fails, and it fails when the mesh hands it a degenerate system. In practice that means one of these:

1. Doubled vertices and zero-area faces. Common after FBX or OBJ import, or a Boolean. In Edit Mode select all, then Mesh > Clean Up > Merge by Distance (the manual: "Merges the selected vertices that are closer to each other than a certain distance"), then Mesh > Clean Up > Degenerate Dissolve, which "Collapses any selected edges that are shorter than a certain length. This also results in the removal of small faces."
2. Loose geometry. Mesh > Clean Up > Delete Loose.
3. Non-manifold edges and interior faces. Select > Select All by Trait > Non Manifold selects "edges that do not belong to any face", "edges at boundaries and holes", and "edges that belong to three or more faces". Select > Select All by Trait > Interior Faces finds "faces that may have been accidentally created inside the mesh instead of on the mesh's surface". Fix what lights up. A hole with a bone poking through it is a problem, and Mesh > Clean Up > Fill Holes closes it.
4. Many separate shells. A character assembled from body, hair, eyes, teeth, boots and belt as separate islands is the classic trigger, and the reason the Voxel Heat Diffuse Skinning add-on exists. Rig the body alone first and attach the rest with the Data Transfer method in Problem 7, or join the pieces with Ctrl-J and Merge by Distance.
5. Scale. Rigify's documentation states the assumption plainly: "Rigify assumes that 1 unit corresponds to 1 meter. So a human is about 2 units tall." A 180-unit character is far outside that. Scale mesh and armature, Object > Apply > All Transforms, then parent again.

If the error persists, split the problem: select part of the mesh with face selection masking and run Weights > Assign Automatic from Bones for a few bones at a time. Every tool on the Weight Paint tools page works "with Vertex Selection Masking and Face Selection Masking", so you can find the one region that breaks the solve.

Problem 2: Weights bleed across limbs

The arm goes up and the ribcage comes with it. The thigh bends and the crotch of the trousers folds inward. The hand bone grabs a patch of hip because the hand rested near the hip in the bind pose. The manual is blunt about the cause: automatic weights "can often lead to armatures which do not deform child objects in ways you would want. Overlaps can occur when it comes to determining which bones should influence certain vertices".

The cleanest fix reruns the solver on a subset. In Weight Paint Mode turn on face selection masking, select the faces that should belong to the arm (and only those), select the arm bones in Pose Mode, then Weights > Assign Automatic from Bones. Per the manual this applies "from the selected bone(s) to the vertex group the same 'auto-weighting' methods as available in the Parent armature menu", but now the chest faces aren't in the selection, so nothing can bleed onto them. Repeat per limb.

For smaller bleeds, paint. Set the brush's Blend to Subtract with a low Strength, or hold Ctrl with the Draw brush to subtract, and brush the stray weight off the chest while the arm bone is active. Then Weights > Smooth, which "blends the weights of selected vertices based on the average of adjacent vertices". Factor 0.5 and two or three Iterations is a good start. Then Weights > Clean to drop the near-zero residue that Smooth leaves behind (details in the export checklist below).

The two checks that stop bleeding before it starts: pose the character so limbs are apart (a T-pose or A-pose, with a gap between hand and hip), and don't rig a mesh whose arms touch its sides. Our automatic rigging guide covers the pose and single-mesh preparation in detail.

Problem 3: More than four bones per vertex

Blender doesn't care how many groups a vertex belongs to. Game engines do. The glTF 2.0 specification stores skinning in JOINTS_0 and WEIGHTS_0 attributes and says "The number of joints that influence one vertex is limited to 4 per set". More than four means a second set (JOINTS_1, WEIGHTS_1), which many runtimes ignore. Unity's Skinned Mesh Renderer offers Skin Weights of 1 Bone, 2 Bones, 4 Bones or Auto, and warns that "If you import a custom number of skin weights and you want to allow more than four bones of influence, you must choose this option and make sure you set Skin Weights to Unlimited". Blender's own glTF exporter has a Bone Influences setting with the note "Models may appear incorrectly in many viewers with value different to 4 or 8".

So a vertex with six influences in Blender is silently truncated on export or on import, and the character deforms differently in the engine than in your viewport. Automatic weights produce six or seven influences routinely around the shoulders, hips and fingers.

The fix is two clicks. Weights > Limit Total, Limit 4. The manual: "Reduce the number of weight groups per vertex to the specified Limit. The tool removes lowest weights first until the limit is reached." Then Weights > Normalize All, because removing the smallest weights leaves the remaining ones summing to less than one.

Problem 4: Weights don't add up to one

This one hides. The manual's normalized weight workflow explains why: "The Armature modifier in Blender does this automatically, so it is technically not necessary to ensure that weights are normalized at the painting stage." A vertex whose weights sum to 0.6 or 1.7 deforms correctly in Blender. The glTF spec says weights' "linear sum SHOULD be as close as reasonably possible to 1.0 for a given vertex" and explains the stakes: "an error of 1/255 in the weight sum would result in an unacceptably large difference in the joint position." Don't count on an exporter to fix this quietly.

Weights > Normalize All. The manual: "For each vertex, this tool makes sure that the sum of the weights across all vertex groups is equal to 1. This tool normalizes all of the vertex groups, except for locked groups". Untick Lock Active unless you want the active group kept and everything else rebalanced around it. Then, in the tool settings, turn on Auto Normalize, which "Ensures that all deforming vertex groups add up to one while painting." From then on every stroke redistributes weight among the unlocked groups instead of adding on top.

Don't confuse Normalize All with Weights > Normalize, which "only works on the active vertex group" and scales it so "the highest weight value is 1.0".

Locking is the companion skill. Lock a group with the padlock in the Vertex Groups panel or the K pie menu, and Auto Normalize will "redistribute only between the unlocked groups". That's how you fix a shoulder without disturbing a chest you've already got right.

Problem 5: The two sides don't match

You painted the left arm for an hour and the right arm is still the raw automatic result. Weights > Mirror Vertex Group copies one side to the other, with two conditions from the manual. First, "Mirroring only works when the object's rest pose is perfectly symmetrical across the X axis." If your mesh is only nearly symmetric, tick Topology Mirror, which is "for meshes which are not fully symmetric (approximate mirror)". Second, "the weights are not transferred to the corresponding opposite bone weight group" unless you tell it to, which is what Flip Group Names does: it swaps assignments between groups with symmetrical names "(with components like 'L', 'R', 'right', 'left')". Tick Mirror Weights, Flip Group Names and All Groups to do the whole character at once.

That depends on your bones being named for it. The naming conventions page accepts hand_L and hand_R, hand.l and hand.r, handLeft and handRight, and the same with the side prefixed, but not handL with no separator. Mixamo-style LeftHand and RightHand work. An armature with Bone_012 names has to be renamed first, since mirroring can't know which bone pairs with which.

To avoid the problem, paint symmetrically from the start. In the Tool settings, Symmetry panel, tick Mirror Vertex Groups, which the manual describes as "mirrored painting on groups that have symmetrical names". Every stroke on the left arm now lands on the right arm's group too.

Problem 6: The candy-wrapper wrist

Twist a wrist 90 degrees and the forearm narrows to a pinched waist halfway along. This isn't a painting mistake. It's the mathematics of linear blend skinning: a vertex weighted half to the forearm and half to the hand gets the average of a rotated and an unrotated transform, and that average collapses toward the axis. The Armature modifier's Preserve Volume option swaps in quaternion blending, and the manual describes the trade exactly: "Without it, rotations at joints tend to scale down the neighboring geometry, up to nearly zero at 180 degrees from rest position. With it, the geometry is no longer scaled down, but there is a 'gap', a discontinuity when reaching 180 degrees from rest position."

Tick Preserve Volume for renders inside Blender. For a game, know that it's a modifier setting, not mesh data, and glTF and FBX don't carry it. Engines skin linearly unless you switch them to something else, so the pinch comes back on import. The fixes that survive export are the old ones: a forearm twist bone (or two) that splits the rotation into smaller steps, each with its own gradient, or spreading the wrist weights over more edge loops so no vertex sits at the 50/50 point.

The Smooth Corrective modifier is the other in-Blender tool, "typically useful after an Armature modifier, where distortion around joints may be hard to avoid, even with careful weight painting." Same caveat: it deforms in Blender and doesn't export as weights.

Problem 7: Clothing shells don't follow the body

You rigged the body and it moves well. The jacket, a separate mesh, either got its own bad automatic weights (the thigh pushes through the trouser leg because body and cloth blended slightly differently) or never got weights at all and hangs in the air. The right answer is to give the clothing the body's weights, not its own.

Add a Data Transfer modifier to the clothing object. Set Source to the body, tick Vertex Data, choose Vertex Groups, set the mapping to Nearest Face Interpolated, and click Generate Data Layers. The manual warns this button matters: "The modifier doesn't do this automatically, so make sure to click this button (or add the missing layers yourself) as the transfer may not work otherwise." Nearest Face Interpolated finds "the nearest point on the nearest source face, then use that point to interpolate between the values" of that face's vertices, which is what you want for a shell that sits a few millimetres off the skin. Set Layer Mapping to By Name so LeftArm on the body feeds LeftArm on the jacket. Then add an Armature modifier below it pointing at the same armature. Apply the Data Transfer modifier before export so the weights become real vertex groups.

The same thing exists as an operator: in Weight Paint Mode, select the body, then the clothing (active), Weights > Transfer Weights, and in the Adjust Last Operation panel set Source Layers Selection to By Name. The manual notes the objects "must be at the same location. If they are placed side-by-side, then the weight transfer will not work."

Where the shell is thick (a heavy coat, armour) rather than skin-tight, transferred weights still beat automatic ones, because they can't disagree with the body underneath.

Clean weights for game export, in order

Do these in Weight Paint Mode with no face or vertex masking active, so each tool touches the whole mesh.

1. Delete groups that aren't bones. In the Vertex Groups panel, remove any group that doesn't match a deforming bone. The Armature modifier docs note "Removing empty vertex groups helps to reduce dependencies".
2. Fix bleeding and asymmetry first (Problems 2 and 5). The tools below don't know a stray weight from a correct one.
3. Weights > Limit Total, Limit 4. For glTF, three.js, Babylon.js, Unity at default settings and most mobile targets. If your engine and export are both set for eight, use 8.
4. Weights > Normalize All, Lock Active off. Sums are back to 1.0 after Limit Total removed the tail.
5. Weights > Clean, Limit 0.001, Keep Single on. Clean "unassigns vertices from Vertex Groups whose weights are below the Limit". A weight of 0.0004 does nothing visible but still occupies one of the four slots. Keep Single guarantees "each vertex will keep at least one weight". glTF commonly stores weights as normalized bytes, where the smallest step is 1/255, so anything under 0.004 rounds to nothing anyway.
6. Weights > Normalize All again. Clean can leave a vertex at 0.999.
7. Check Zero Weights. Overlay set to All, look for black.
8. Export. In the glTF exporter, Data, Skinning, leave Bone Influences at 4 and Include All Bone Influences off. Data, Armature, tick Use Rest Position Armature so the bind pose is the rest pose, not the current frame.

Skip the step

People pay to not do this. Two products prove it in different ways.

Voxel Heat Diffuse Skinning by Mesh Online is the add-on Blender users buy when automatic weights refuse. Its Superhive listing shows an Indie licence at $30, more than 12,500 sales, and support for Blender 3.6 through 5.1 as an extension. The listing leads with the exact problem: "Blender throws a message: 'bone heat weighting: failed to find solution for one or more bones'." Its method is what the name says. Blender's built-in solver diffuses heat across the surface, which is why it needs a clean surface. This add-on voxelizes the character into a solid and lets "heat diffuse in the solid statue", so a character built from twenty overlapping shells skins as one body. The author is honest about the trade-off: the built-in surface method "can get much better result in detailed areas such as fingers and toes", so the add-on combines both. It wants at least 8 GB of memory. If your mesh is a mess and you want Blender's own skeleton, this is the one to buy.

The Cinevva Rig add-on takes the other route: don't fix the weights, don't place the bones either. Select a mesh, press Rig, and it places a Mixamo-named humanoid skeleton and skins it in one pass, with the weights already limited, normalized and cleaned for engines. It runs on your own machine, offline, after a one-time engine download of about 2.4 GB, for a single $29 launch-price purchase with no per-rig charge, on Blender 4.2 and newer for Windows, macOS and Linux. It also carries 260 CC0 animation clips that retarget onto the result inside Blender, and free Web, Unity, Unreal and Godot export presets that set Bone Influences, rest pose, axes and scale for you. It doesn't replace weight painting for a custom skeleton, a tail, or a face rig. It replaces it for the humanoid you need in a game by Friday. The Blender add-on page has the details.

For one character without opening Blender, the web Auto Rigger takes a GLB, FBX or OBJ up to 50 MB and returns a rigged GLB, first character free, already in the four-influence, sum-to-one shape this guide spends its middle third reaching.

Rigify is the free option, bundled with Blender, and its documentation sets expectations fairly: "Usually armature deform with automatic weights do a really good job out of the box if you correctly place your bones (and there is enough topology to work with!)." The parenthesis is the whole story of this article.

Common Questions

Why is Blender weight paint not working?

Usually one of three things. You're painting on the wrong vertex group, so Alt-LMB the bone with Bone Selection on and check the active group in the header. The armature isn't in Pose Mode, or Edit > Lock Object Modes is ticked. Or face selection masking is on and you're painting outside the selection. The Zero Weights overlay shows which vertices have any weight at all.

How do I fix "Bone Heat Weighting: failed to find solution for one or more bones"?

Clean the mesh in Edit Mode: Mesh > Clean Up > Merge by Distance, Degenerate Dissolve, Delete Loose, then Select > Select All by Trait > Non Manifold and fix what lights up. Make the character about 2 metres tall with transforms applied, and rig a single connected body before attaching clothes. If it still fails, the Voxel Heat Diffuse Skinning add-on skins non-watertight meshes without the bone heat solver.

How do I mirror weight paint in Blender?

Weights > Mirror Vertex Group with Mirror Weights, Flip Group Names and All Groups ticked, plus Topology Mirror if the mesh isn't perfectly symmetric. It needs a symmetrical rest pose across X and bones named in pairs like hand.L and hand.R. To paint both sides at once, tick Mirror Vertex Groups in the Symmetry panel of the tool settings.

How do I normalize weights in Blender?

Weights > Normalize All makes every vertex's weights sum to 1 across all unlocked groups. Turn Lock Active off unless you want the active group preserved. Then enable Auto Normalize in the tool Options so new strokes keep the sum at 1. Plain Weights > Normalize is different: it scales only the active group so its maximum is 1.0.

How do I smooth weight paint in Blender?

Enable vertex selection masking, select the vertices around the joint, and run Weights > Smooth. Factor controls how far each weight moves toward the average of its neighbours (0.5 is a good start), Iterations repeats the pass, and Expand/Contract grows or shrinks the affected area. Follow it with Weights > Clean at a small Limit, then Normalize All.

Why does my mesh deform wrong in Blender when I move a bone?

Either the wrong vertices belong to that bone's group (bleeding, fixed with Weights > Assign Automatic from Bones on a face selection or by painting them out), or the transition across the joint is too abrupt (Weights > Smooth), or the bone sits in the wrong place inside the mesh so the automatic weights were wrong from the start. Check Zero Weights too: vertices in no group stay put while everything around them moves.

What is the difference between heat weighting and voxel heat diffuse skinning?

Blender's bone heat weighting diffuses each bone's influence across the mesh surface, so it needs a clean, connected surface. Voxel heat diffuse skinning fills the character's volume with voxels and diffuses through the solid, so it doesn't care whether the mesh is watertight or built from separate shells. The Voxel Heat Diffuse Skinning add-on (about $30 on Superhive) brings that method to Blender and combines both for fine details like fingers.

Related

• How Automatic Rigging Works (and How to Prepare a Model for It): the mesh preparation that prevents most weight problems before they start
• How to Rig a Character in Blender: the full rigging walkthrough this guide plugs into
• Free Character Animations and Auto-Rigging: where to get CC0 clips for the rig once it deforms properly
• Cinevva Rig for Blender: bones and weights in one pass, local and offline, with game export presets
• Auto Rigger: rig one character in the browser, first one free
• GLB Viewer: check the exported skin and play the clips outside Blender

Last updated: September 2026.

To rig a character in Blender you fit a skeleton (an armature) inside the mesh, bind the mesh to it, and check that elbows, knees, hips and wrists bend without tearing. For most humanoids the fastest free route is Rigify: add the Human metarig from Add > Armature, move its bones onto your character, press Generate Rig, then parent the mesh with Ctrl-P > With Automatic Weights. If you'd rather not place bones at all, an auto rigger inside Blender does the whole job in one click, and a hand-built armature with IK constraints is the route when you want a small custom skeleton with exactly the bones your game needs.

Quick picks

• Most people, free: Rigify, bundled with Blender. Fit the metarig, Generate Rig, automatic weights. Budget an evening the first time.
• Smallest game skeleton or a non-human shape: a manual armature with IK. Around 17 bones for a biped, an hour or three, and you name every bone yourself.
• Fastest: the Cinevva Rig add-on. Select the mesh, press Rig, get a skinned Mixamo-named armature in about fifteen seconds. Runs on your own machine, offline, for one $29 purchase (launch price), Blender 4.2 and newer on Windows, macOS and Linux.
• The established paid option: Auto-Rig Pro, $50 for the Full edition or $25 for Lite on Superhive, with Smart bone placement for humanoids and its own FBX and glTF export module.
• Nothing to install: upload a GLB, FBX or OBJ to the web Auto Rigger. Your first rigged character is free.
• Before any of them: one mesh, A-pose or T-pose, origin at the feet, Ctrl-A > All Transforms. Skipping this step causes most rigging failures.

Quick reference

Prepare the mesh first

Every route below wants the same input, and the ten minutes you spend here save an hour of weight painting later. Our automatic rigging explainer goes deeper on why.

1. Join into one shell. Select all the body parts and press Ctrl-J. Separate shells for shirt, trousers and skin can stay as one object. What hurts is a floating hat, sword or backpack: parent those to a bone afterwards instead of skinning them.
2. Delete any existing armature and remove the old Armature modifier and vertex groups from the mesh (Object Data Properties, Vertex Groups, the small down-arrow menu, Delete All Groups). Old groups with bone names will otherwise be overwritten or, worse, half-kept.
3. Pose the arms out. A-pose (arms 30 to 45 degrees down from horizontal) or T-pose. Arms hanging at the sides put the hands next to the thighs, and every weighting method will bleed leg weights into the fingers.
4. Set the scale. Rigify's own documentation says it "assumes that 1 unit corresponds to 1 meter. So a human is about 2 units tall". Check Dimensions in the N panel. A character that reads 180 metres came in from FBX at centimetre scale, so scale it down in Object Mode.
5. Put the origin at the feet and the feet on the floor at the world origin: Object > Set Origin > Origin to 3D Cursor with the cursor at world zero, then move the mesh up until the soles sit on Z=0.
6. Face the character toward -Y. Blender's front view (Numpad 1) looks along +Y, so a correctly oriented character looks at you in front view.
7. Apply transforms: Ctrl-A > All Transforms. The Apply page of the manual says it plainly: "It is recommended to apply transforms before rigging and animation." Unapplied scale and rotation are the reason rigs come out 100 times too big or lying on their back in a game engine.

Route A: Rigify

Rigify ships inside Blender. In Blender's own words it "helps automate the creation of character rigs" from "smaller rig parts (e.g. arms, legs, spines, fingers...)", and once generated "that rig should no longer need Rigify", so you can hand the file to anyone (Rigify introduction). One line from the same page sets expectations: "Rigify only automates the creation of the rig controls and bones. It does not attach the rig to a mesh, so you still have to do skinning etc. yourself."

Step 1: enable it

Edit > Preferences > Add-ons, search "Rigify", tick the checkbox. It ships inside Blender's core add-ons, so there's nothing to download.

Step 2: add a metarig

In Object Mode, Shift-A > Armature. With Rigify enabled the menu grows to include the metarigs the Basics page lists: "Basic Human (doesn't include face and fingers), Basic Quadruped, Human, Cat, Wolf, Horse, Shark". For a game character pick Basic Human unless you need finger bones, in which case pick Human and delete the face later. Rigify stores everything it needs to build the final rig inside this simpler armature, which is why the metarig is what you edit and keep.

Step 3: align the bones to the mesh

This is the step that takes the time, and the one that decides how the rig deforms. Before you start, select the metarig, go to Object Properties, Viewport Display, and set Display As to Wire with In Front ticked so bones stay visible inside the mesh. In the armature's Edit Mode, turn on X-Axis Mirror (the Options dropdown in the viewport header, also under the N panel's Tool tab) so moving a .L joint moves its .R twin.

Then work through the joints. The manual's Bone Positioning Guide and the alignment tips on the Basics page are the source for every hint here.

Hips and spine. The hips bone sits in the centre of the pelvis. Keep the spine "as centered as possible inside the mesh bounding volume, just apply a slight offset toward the back". Keep it "as straight as possible in the front view". The chain runs spine, chest, neck, head: the Basics page notes "the last bone of the spine is the head. By default the next two bones (top to bottom) are considered the neck bones".

Shoulders. The shoulder bones are "general deformers", so don't push them forward onto the collar bone, which "could cause undesired deformations".

Arms. First make "a straight line that goes from the shoulder to the hand in both front and top view", then add a slight bend at the elbow. The bend matters more than it looks: "Give the knee and the elbow a slight bend angle (Rigify needs to know where your knee/elbow is pointing)." Elbows point backward. Since Rigify 0.5 that bend also sets the bone roll for you, because "the generate function will take care of that for you by evaluating it from bend axis".

Legs. Same idea: a straight line from hips to ankle in front view, then a slight forward bend at the knee in side view. Place the foot and toe bones on the actual foot, and set the heel bone in front view so it fills "the foot size from side to side", then in side view "at the point where the heel just touches the ground floor". The leg rig type requires "a chain of four connected bones (thigh, shin, foot, toe) with one unconnected child of the foot to be used as the heel pivot" (Limbs rig types), so don't delete that odd little heel bone.

Fingers. Place knuckle by knuckle. The manual's trick: in the mesh's Edit Mode select the edge loop around a knuckle, Shift-S > Cursor to Selected, then in the armature's Edit Mode select the bone joint and Shift-S > Selection to Cursor. Once all fingers are placed, select every finger bone and run Armature > Bone Roll > Recalculate Roll > Global -Z Axis. The thumb "may require more tweaking", with Global +Y Axis as the suggested start. Keep the palm bones' heads "at a little distance between each other", because Rigify uses that gap to build the palm controls.

Face. Unless you're animating expressions with bones, delete it. Show only the Face bone collection, select all, delete in Edit Mode. Game characters use shape keys or a separate facial rig anyway, and the manual itself says face bones "are almost useless if you plan to make facial animation through shape keys".

Step 4: Generate Rig

Back in Object Mode, with the metarig selected, open the Armature tab in Properties, scroll to the bottom and click Generate Rig. The manual says generation takes "from few seconds to one minute". A new armature called rig appears with coloured control shapes. Don't delete the metarig. Rigify "is designed assuming a workflow where the meta-rig is kept available", so if a knee bends wrong you move the metarig bone and press Generate Rig again, and Rigify overwrites the existing rig "retaining all your modifiers and constraints". For that overwrite to work "you need to have both the rig and the meta-rig visible before generating again".

Step 5: bind the mesh

Select the mesh, then Shift-click the generated rig so the armature is active, then Ctrl-P > With Automatic Weights. Blender's Armature Deform Parent page describes what happens: it "calculates how much influence a particular bone would have on vertices based on the distance from those vertices to a particular bone ("bone heat" algorithm)". Only bones with Deform ticked get vertex groups, and on a Rigify rig those are the ones in the DEF bone collection.

Rigify's own verdict on this step is encouraging: "Usually armature deform with automatic weights does a really good job out of the box if you correctly place your bones (and there is enough topology to work with!)". The parenthesis is the catch. A knee with one edge loop can't crease no matter how good the weights are. Give joints three loops.

Step 6: understand what you got

Rigify generates three kinds of bones, named by prefix in its source: ORG- for original bones copied from the metarig, MCH- for mechanism bones, and DEF- for deformation bones. On top sit the control bones with no prefix: the gear-shaped limb masters, red IK and green FK controls, blue tweak spheres. Select any control and the Item tab of the N panel shows the Rig Main Properties panel with an IK-FK slider that blends "between full IK at 0 and full FK at 1", IK Stretch, a Toggle Pole switch and parent switching (Generated Rig Features).

A game engine wants none of that. It needs the DEF- bones and their weights, nothing else, because constraints and drivers don't survive export and the control bones would add hundreds of useless transforms. Blender's glTF exporter has a checkbox for exactly this under Data, Armature: "Export Deformation Bones only: Export Deformation bones only, not other bones. Animation for deformation bones are baked" (glTF 2.0 exporter). The FBX exporter's Armature panel has Only Deform Bones and Add Leaf Bones (turn the second off) (FBX exporter).

Two things to know before you plan around a Rigify game export. First, Rigify splits each limb into "multiple deform bone segments with tweaks", so you'll have more deform bones per limb than a hand-built skeleton, and they're named DEF-upper_arm.L, DEF-upper_arm.L.001 and so on, not mixamorig:LeftArm. Unity's Humanoid avatar needs "at least 15 bones organized in a way that loosely conforms to an actual human skeleton" (Unity manual), and you'll map them by hand in the Avatar configuration. Second, the exported deform hierarchy isn't the simple hips-to-fingers tree that retargeting tools expect, so plan to animate in Blender and bake, rather than dropping Mixamo clips on the exported skeleton.

Route B: a manual armature with IK

Build your own armature when Rigify gives you too much: a low-poly web character that should ship with 17 bones and a 300 KB file, a creature with a body plan no metarig covers, a mech with rigid parts, or a skeleton whose bone names must match an existing animation set exactly. You trade Rigify's controls for total knowledge of every bone.

The minimal biped

That's 17 deforming bones with shoulders, 15 without, which is exactly Unity's Humanoid minimum. Use the .L suffix on everything on the character's left. Blender's naming conventions accept .L/.R, _L/_R and a few more, and that suffix is what makes mirroring tools work.

Building it

1. Shift-A > Armature in Object Mode with the 3D cursor at the world origin. Rename the object and the armature data to something like Armature_Hero. Set Viewport Display to In Front.
2. Tab into Edit Mode. Move the single bone's head to the pelvis centre and its tail up to the belly: this is hips. Select the tail and press E to extrude spine, chest, neck, head up the torso. Each bone's tail is the next joint.
3. Select the chest tail, extrude shoulder.L out to the shoulder joint, then upper_arm.L to the elbow, forearm.L to the wrist, hand.L to the knuckles. For the leg, Shift-A a new bone at the hip joint, name it thigh.L, set its Parent to hips in Bone Properties with Connected off, then extrude shin.L to the ankle and foot.L to the toes. Give the elbow a slight backward bend and the knee a slight forward bend, for the same reason Rigify wants them.
4. Add the non-deforming bones. Shift-A adds a bone at the cursor. Place foot_ik.L at the ankle and hand_ik.L at the wrist as unparented bones. Place knee_pole.L about half a metre in front of the knee and elbow_pole.L about half a metre behind the elbow. For each, open Bone Properties and untick the Deform checkbox. The manual notes this "also excludes the active bone in the automatic weight calculation" (Deform panel), so these bones won't steal skin.
5. Fix the rolls. Select all bones, Shift-N (Armature > Bone Roll > Recalculate Roll, see the Bone Roll page) and pick one Global axis for the whole chain, then turn on the Axes overlay in Armature Properties, Viewport Display, and check that local X points the same way along every bone of a limb. A limb whose bones disagree about roll will twist when the IK solves.
6. Mirror. Select every .L bone and run Armature > Symmetrize. Blender "mirrors selected bones along the X axis using Blender's bone naming convention", creating the .R side with its constraints and collection assignments mirrored (Symmetrize). Do this after step 7 if you'd rather mirror the IK constraints too.

Adding IK

Blender's IK introduction describes the payoff: IK lets you "position the last bone in a bone chain and the other bones are positioned automatically. This is like how moving someone's finger would cause their arm to follow it."

1. Ctrl-Tab into Pose Mode. Click foot_ik.L, then Shift-click shin.L so the shin is active.
2. Press Shift-I and choose Target Selected Bone (Add IK to Bone). The shin turns yellow: it now carries an Inverse Kinematics constraint targeting the foot control.
3. In Bone Constraint Properties set Chain Length to 2. The constraint page explains the count: "a value of 2 will rotate the bone and its parent", so the chain is shin plus thigh and stops before the hips. Leaving it at 0 "will include all of the bone's ancestors (up to the root)", which drags the whole spine when you move a foot.
4. Set Pole Target to the armature and Bone to knee_pole.L. The pole "determines the roll of the IK chain, or put differently, the position of the elbow", or here the knee. The leg will likely snap sideways: adjust Pole Angle until the knee points at the pole, which often lands at -90 or 90 degrees.
5. Repeat for the arm: hand_ik.L as target on forearm.L, Chain Length 2, elbow_pole.L as pole.
6. Give foot.L a Copy Rotation constraint targeting foot_ik.L so the foot tilts with the control, or simply key the foot directly.
7. Lock what shouldn't bend. In Bone Properties, Inverse Kinematics, tick Lock on the two shin axes a knee doesn't rotate around, leaving only the hinge axis free, with the manual's caveat that "if a Pole Target is used, IK locking will not work on the root bone" of the chain.

Then bind exactly as in Rigify: select the mesh, Shift-click the armature, Ctrl-P > With Automatic Weights. Because the IK and pole bones have Deform off, they get no vertex groups.

Route C: auto-rigging inside Blender

Auto-rigging means software finds the joints and computes the weights, and you check the result instead of building it. Three options fit a Blender pipeline.

The Cinevva Rig add-on. Install it as a standard Blender extension (Blender 4.2 or newer, Windows, macOS, Linux). Select the mesh, pick the front of the character from four rendered views, choose a body plan, press Rig. About fifteen seconds later the character has a skinned, Mixamo-named humanoid armature and is already playing Idle. Rigging runs on your own machine, offline, after a one-time engine download of about 2.4 GB, with no per-rig charge and no count, unlocked by one $29 key (launch price) that activates up to three machines. The panel reports what it built in plain words, including how many fingers it found. Two more parts come free with the download, no key or account needed: 260 CC0 animation clips (walks, runs, idles, combat, climbing, crawling, emotes) that retarget onto the rigged character inside Blender from a browser docked in the viewport, and an Export card that shows where the file's bytes go, then applies Web, Unity, Unreal or Godot conventions in one click. Against a plain Blender GLB export those presets produced files 68%, 89%, 92% and 98% smaller on four real models. Online rigging exists too, billed in Cinevva credits, for machines that shouldn't hold the engine download.

Auto-Rig Pro. The category leader on Superhive, listed there with more than 65,000 sales, at $50 for the Full edition or $25 for Lite, supporting Blender 2.93 through 5.1 (Superhive listing). Its Smart tool "works for biped characters only, the model must be in T-Pose or A-Pose. It detects the feet, legs, spine, arms, fingers position and optionally the facial bones" (Auto-Rig Pro FAQ). Non-humanoids are rigged by placing reference bones yourself, with Human, Dog, Horse and Bird presets. The Full edition adds the Remap retargeter and an FBX/glTF export module with dedicated settings for Unity, Unreal and Godot. If you rig characters weekly and need a production control rig with bendy bones and a picker, it earns its price. What it doesn't ship is an animation library.

The web Auto Rigger. No install. Upload a GLB, FBX or OBJ up to 50 MB, get a rigged GLB back with clips baked in. Your first rigged character is free to download, which makes it the right way to sanity-check a mesh before you commit an evening to Rigify.

For the Mixamo route, know its status in 2026. Adobe's Mixamo FAQ says "the auto-rigger and animation libraries are for bipedal humanoids only", and the official Mixamo Blender add-on, which builds an IK control rig on a Mixamo skeleton, is offered as a Blender 3.6 version. The community "Mixamo Rig" extension on extensions.blender.org describes itself as a "3rd party upgrade to official addon because it is no longer supported", points to Adobe's version for Blender 3.6, and lists Blender 4.2 LTS compatibility with a 1.2.2 release in April 2026.

Test the rig in 60 seconds

A rest pose hides every weighting problem. Before you animate anything, Ctrl-Tab into Pose Mode and run four checks. They apply to all three routes.

Bend an elbow and a knee to 90 degrees. Select the forearm or shin (or the IK control) and rotate. The inside should crease and the outside should keep its volume. A joint that collapses flat is usually one edge loop where three are needed, a mesh problem more than a weight problem.

Raise both arms overhead. Look at the armpits and the side of the chest. If the ribcage lifts with the arm, chest vertices are weighted to the upper arm. If the armpit tears open, shoulder weights are missing from the underarm.

Squat. Look at the hips and crotch. Trouser legs pierced by the thigh mean the clothing shell got different weights from the leg under it.

Twist a wrist 90 degrees along the forearm. If the forearm narrows to a pinched waist halfway along, that's the candy-wrapper artefact of linear blend skinning. Blender's Armature modifier has a checkbox for it: Preserve Volume, which uses quaternions because without it "rotations at joints tend to scale down the neighboring geometry, up to nearly zero at 180 degrees from rest position". Game engines can't read that checkbox, so a shipped rig fixes the same twist with a forearm twist bone, which is why the manual's own IK example "uses two bones to overcome the twist problem for the forearm".

To fix weights by hand, use the workflow the manual gives on its Vertex Groups for Bones page: put the armature in Pose Mode, make sure Edit > Lock Object Modes is unticked, select the mesh and switch it to Weight Paint Mode, tick Bone Selection in the header, then Alt-click a bone to show its weights (blue is 0, red is 1) and paint. Turn on Auto Normalize in the Tool settings so weights at a joint always sum to one, and reach for the Blur brush before anything else. Since Blender 5.1 you can also loop-select vertices in Weight Paint mode with Vertex Selection on (5.1 release notes), which makes isolating a knee loop quick. When a fix takes longer than ten minutes, our weight painting problems guide covers the seven failures that account for nearly all of them.

Common failures and fixes

"Bone Heat Weighting: failed to find solution for one or more bones". The exact message comes from Blender's mesh Laplacian code, and it means the heat solver couldn't reach some vertices from some bones. Causes, in order of likelihood: overlapping duplicate vertices (Mesh > Clean Up > Merge by Distance), interior faces or non-manifold geometry, a bone entirely outside the mesh, or a mesh so dense the solve gives up. Try again on a lower-resolution copy, or bind with a Decimate modifier temporarily applied. This message is common enough that a paid add-on exists to sidestep it: Voxel Heat Diffuse Skinning ($30 on Superhive, more than 12,500 sales) lists solving this exact error as its first selling point.

The mesh doesn't move at all. The Armature modifier is missing (check the Modifier tab, the Object field should name your rig), or the bones have Deform off, or the vertex group names don't match bone names. Blender's Armature modifier binds by name: "a bone named "forearm", will only affect the vertices in the "forearm" vertex group".

A limb drags the wrong body part. Two bones were too close when the heat solve ran (a hand resting on a thigh, fingers touching). Re-pose the mesh into a proper A-pose and rebind, or paint the stray weight out.

Rigify fingers curl on the wrong axis. Rolls were inconsistent. Select the finger bones in the metarig, Recalculate Roll > Global -Z Axis, regenerate, and if they still rotate wrong, change Bend Rotation Axis under Rigify Type on the first finger bone.

Rigify says it can't overwrite the rig. Unhide both the metarig and the generated rig before pressing Generate Rig. The manual is explicit that both must be visible.

The character is tiny or huge in Blender. You imported at centimetre scale. Scale in Object Mode until Dimensions read about 1.8 m, then Ctrl-A > All Transforms, and rig after that, never before.

The character lies on its back or is 100 times too big in Unity or Unreal. Blender is Z-up and Y-forward. The FBX exporter's Forward and Up axes exist to convert: "Blender uses Y Forward, Z Up. For example, it's common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed." Unity wants FBX with Forward -Z, Up Y, Apply Scalings set to FBX All. Unreal wants Forward -Y, Up Z, Apply Scalings All Local, Primary Bone Axis Y and Secondary Bone Axis X. Godot's own docs recommend glTF: "glTF 2.0 (recommended)", with FBX supported through ufbx since 4.3 (Godot manual). In every case tick Only Deform Bones and untick Add Leaf Bones. If your pipeline lives on FBX round-trips from Maya or 3ds Max, credit where due: Better FBX Importer and Exporter ($25 on Superhive, more than 12,600 sales) exists because imports stop breaking, and its listing says as much: "If you do everything within Blender, you don't need this add-on."

Your animation vanished after upgrading Blender. Not a rig bug. Blender 4.4 made every Action "slotted", and old files are upgraded automatically with each Action getting one "Legacy Slot" (4.4 release notes). If you assign an existing Action to a new armature, Blender may not auto-pick a slot, so the rig sits still until you select one in the Action Editor. Blender 5.0 also moved bone visibility and selection state onto the pose bone so armature instances stop sharing them (5.0 release notes), a change the notes flag as breaking the Python API for older rig scripts.

Which route should you take?

If you're learning Blender and have an evening, do Rigify once. You'll understand what a rig is, and the control rig it gives you is the best free animation rig there is. Keep the metarig and regenerate as you refine.

If you're building for a web game or a mobile game and every bone costs draw time, build the manual armature. Seventeen bones, your names, your hierarchy, and nothing in the file you didn't put there.

If you have a deadline, a folder of characters, or no interest in rigging as a craft, auto-rig. Inside Blender the Cinevva Rig add-on rigs on your machine for one $29 purchase, plays 260 CC0 clips on the result and exports for your engine. Auto-Rig Pro is the right buy if you want a production control rig with a retargeter and don't mind placing markers. And if you're not sure your mesh will rig cleanly, run it through the free first character on the web Auto Rigger before you spend the evening.

Common Questions

How do I rig a character in Blender?

Prepare the mesh (one shell, A-pose, origin at the feet, Ctrl-A > All Transforms), add a skeleton, bind the mesh, then test. The free built-in route is Rigify: Shift-A > Armature > Human (Meta-Rig), move the bones onto your character in Edit Mode, press Generate Rig in the Armature tab, then select mesh and rig and Ctrl-P > With Automatic Weights. The one-click alternative is an auto-rigging add-on that places and skins the skeleton for you.

How do I use Rigify in Blender?

Enable it under Edit > Preferences > Add-ons, add a metarig from Shift-A > Armature, fit the bones to your mesh with a slight bend at elbows and knees, then click Generate Rig at the bottom of the Armature properties. Rigify creates a separate rig object with IK/FK controls. Bind your mesh to that rig, not the metarig, and keep the metarig so you can regenerate.

Is Rigify good for game rigs?

Yes with one export step. Rigify's control bones, constraints and drivers don't export, so tick Export Deformation Bones only (glTF) or Only Deform Bones (FBX) to ship just the DEF- bones and baked animation. Expect more deform bones than a hand-built skeleton, since limbs are split into segments, and expect to map Unity's Humanoid avatar by hand.

What is the difference between an armature and a rig in Blender?

An armature is the object type: a hierarchy of bones with a rest position you edit in Edit Mode and pose in Pose Mode. A rig is the whole setup built on it: the armature, the constraints and controls that drive it, and the skinned mesh. Rigify's metarig is a plain armature, and the object it generates, called rig, is a rig.

Does Blender have auto rigging?

Blender itself has automatic weights, not automatic bone placement: Rigify still needs you to fit the metarig. Add-ons fill the gap. The Cinevva Rig add-on places and skins a Mixamo-named humanoid skeleton in one click on your own machine for a one-time $29, and Auto-Rig Pro's Smart tool places its markers on humanoids in a T-pose or A-pose.

Does the Mixamo Blender add-on still work?

Adobe's official add-on is offered for Blender 3.6, and the community extension called Mixamo Rig on extensions.blender.org, which describes the official one as "no longer supported", carries it forward with Blender 4.2 LTS compatibility and a 1.2.2 release in April 2026. Mixamo's own auto-rigger remains "for bipedal humanoids only" per Adobe's FAQ.

How do I rig a character in Blender for Unity?

Rig with any route above, make sure the skeleton has the 15 bones Unity's Humanoid avatar needs, then export FBX with Forward -Z, Up Y, Apply Scalings FBX All, Only Deform Bones on and Add Leaf Bones off. In Unity set the Rig type to Humanoid and check the avatar mapping. If the character imports lying down or 100 times too large, you skipped Ctrl-A > All Transforms before rigging.

Related

• How Automatic Rigging Works (and How to Prepare a Model for It): what joints and skin weights are, and the mesh checklist every rigger wants
• Free Character Animations and Auto-Rigging: Mixamo and Its Alternatives: CC0 clip libraries and free riggers, licences checked
• Blender Weight Painting: The 7 Problems Everyone Hits: the bone heat error, bleeding limbs, twisting wrists, and when to skip the step
• Auto-Rig Pro Alternatives for Blender: Rigify, Quick Rig, Voxel Heat and the one-time auto-riggers compared on price and limits
• Cinevva Rig for Blender: one-click rigging on your own machine, 260 CC0 clips, game-ready export presets
• Auto Rigger: rig a GLB, FBX or OBJ in the browser, first character free

Last updated: September 2026.

Mixamo still works in September 2026 and is still free with an Adobe ID, but Adobe's own Blender add-on was built for Blender 3.6 and the community build that replaced it on Blender Extensions lists Blender 4.2 LTS as its compatibility and 5.5 and above as unsupported. If you're on Blender 4.2 through 5.4, install the "Mixamo Rig" extension and you get the control rig and baking workflow back. On anything newer, or if you'd rather not depend on an add-on at all, import the FBX files by hand, fix the 0.01 scale and the mixamorig: bone names once, and stack clips in the NLA editor. If what you actually want is a library of animations on your own character, a CC0 library retargeted inside Blender saves you the Mixamo round trip entirely.

Quick answer

• Blender 4.2 to 5.4, want the control rig: install Mixamo Rig from Blender Extensions (version 1.2.2, April 2026). It's the community continuation of Adobe's add-on, GPL, and does the same one-click IK control rig and bake in and out.
• Blender 5.5 or newer, or no add-on: File > Import > FBX (.fbx), leave Apply Transform off, tick Automatic Bone Orientation on the legacy importer, and don't fight the 0.01 armature scale until every clip is in.
• Several clips on one character: download the character once "With Skin", every animation "Without Skin", import each, assign its action to the main armature by name, Push Down into the NLA, delete the spare armatures.
• Animations won't play, character stays in T-pose: the action isn't assigned, or the bone prefix in the action (mixamorig:) doesn't match the armature. Check the prefix before anything else.
• Root motion: untick "In Place" on Mixamo before downloading, then bake the hips' horizontal motion into a root bone. The Import Mixamo - Root Motion extension automates that on Blender 4.2 LTS.
• Want to skip Mixamo: retarget any clip inside Blender with the free Rokoko plugin or Auto-Rig Pro's Remap, pull clips from Quaternius' CC0 Universal Animation Library, or use the Cinevva Rig add-on, which retargets 260 CC0 clips onto a character it rigged inside Blender, runs on your own machine offline for one $29 launch-price purchase, and supports Blender 4.2 and newer on Windows, macOS and Linux.

Quick reference

Where Mixamo stands in September 2026

Everything Adobe states publicly is on one page, the Mixamo FAQ, and that page was last updated on September 14, 2021. It says Mixamo "is available free for anyone with an Adobe ID and does not require a subscription to Creative Cloud", that it isn't available for Enterprise and Federated IDs, and that it isn't available to users with a country code from China. Characters and animations are royalty free for personal, commercial and non-profit projects, including video games. The auto-rigger and the animation library are for bipedal humanoids only, and the FAQ closes with "Adobe does not support troubleshooting for third-party programs", which covers Blender.

Adobe has announced no shutdown on those pages, and we won't speculate beyond them. What the pages do tell you is that nothing has moved in five years. Treat Mixamo as a working legacy service: fine for downloading what you need, not something to build a pipeline on if you can avoid it. The longer view, with alternatives outside Blender, is in Free Character Animations and Auto-Rigging.

The official Mixamo Blender add-on, and what replaced it

Adobe's Mixamo Blender add-on page still hosts the download and describes it plainly: an auto control-rig add-on for characters that were auto-rigged with Mixamo, which "provides a one-click solution to create an IK control rig and to bake animations in and out of the character control rig and skeleton". It's released under GPL 3.0. That last detail is why it survived Adobe losing interest.

The add-on broke with Blender 4.0. The Blender 4.0 release notes explain the cause: "New bone collections replace both legacy numbered layers and bone groups", and the bone layer operators were replaced by bone collection operators. The Adobe add-on organised its rig into numbered layers, so on 4.0 it errored out. A community fix by Xin, documented by CGDive, moved the rig into three bone collections named Control, DEF and MCH. That GitHub repository now says it's retired and points to the Blender Extensions listing.

Which brings us to the version you should actually install. The Mixamo Rig extension by tyler.tofu describes itself as a "3rd party upgrade to official addon because it is no longer supported" and links Adobe's page for the Blender 3.6 original. Version 1.2.2 shipped on April 16, 2026, the listing shows Blender 4.2 LTS as its compatibility with 5.5 and above marked unsupported, it's GPL 3.0 or later, and it had 69,726 downloads when we checked. The changelog shows someone maintaining it against current Blender: the December 2025 release fixed errors when applying animations to the control rig on Blender 4.4 and reworked F-curve access for Blender 5.0's layered actions, and the April 2026 releases fixed IK/FK snapping and controller scaling.

Installing it takes one drag. Open the listing in your browser, drag the "Get Add-on" button into a Blender window, and confirm. Or go to Edit > Preferences > Get Extensions, search for "Mixamo Rig", and click Install. Offline, download the zip and use Install from Disk from the dropdown in the top right of the same window.

The workflow is the one Adobe designed. Rig your character on Mixamo, download it "With Skin" in the T-pose or with any animation, open the add-on's panel in the 3D viewport sidebar (press N, look for the Mixamo tab), import the FBX through the panel, and press the button that creates the control rig. Import further Mixamo clips through the same panel and they land on the control rig as actions you can bake in and out.

The manual route, step by step

This works on every Blender version, and it's worth understanding even if you use the add-on, because every "Mixamo animations not working" thread ends in one of the details below.

1. Download the right files

On Mixamo, rig or pick your character, then download it once in the T-pose with Format set to FBX Binary and Skin set to With Skin. That file is your character: mesh, materials, skeleton. Then for every animation you want, apply it and download again with Skin set to Without Skin. Those files carry only the skeleton and the motion, so they're small and import fast. For a walk or run you intend to drive from game code, tick "In Place" so the character moves on the spot. If you want the forward motion in the clip so you can bake root motion later, leave it unticked. Keep keyframe reduction at none, since Blender's legacy importer reads FBX curves as baked keys anyway.

2. Import with the right settings

File > Import > FBX (.fbx). On Blender 4.2 through 4.4 that menu item is the Python importer. Blender 4.5 added a second item marked experimental, a new C++ importer built on ufbx that the 4.5 release notes describe as "generally 3x-15x faster than the old one". In Blender 5.0 the release notes make the C++ importer the default and mark the Python one as "FBX (.fbx) (Legacy)". Both handle Mixamo files, and the settings that matter differ slightly.

On the legacy importer, the Blender manual lists the options under Transform and Armature. Leave Manual Orientation off, since the importer reads the file's axes. Leave Apply Transform off. The manual is blunt about that checkbox: "Experimental option, use at own risk, known to be broken with armatures/animations." Under Armature, tick Ignore Leaf Bones so you don't get an extra _end bone at every fingertip, and tick Automatic Bone Orientation, which Rokoko's retargeting guide also asks for because it gives you bone rolls Blender's constraints and retargeters can work with.

On the new importer, the manual page is shorter: a Scale value, Custom Normals, a Material Name Collision option (Make Unique or Reference Existing), an animation Offset, and Ignore Leaf Bones. It also notes that each FBX take "is imported as a separate Action, with each animated object assigned to its own Action Slot", which matters in the next step.

3. Look at what arrived

Select the armature and press N. The Item tab shows Scale 0.010 on X, Y and Z. That isn't a bug. Mixamo works in centimetres, the file says so, and the importer keeps the unit conversion on the armature object rather than rewriting every bone and keyframe. The mesh is parented under it and displays at the right size. Every bone is named mixamorig:Hips, mixamorig:Spine, mixamorig:LeftArm and so on, with the prefix and a colon.

The temptation is to select everything and press Ctrl+A > All Transforms to get a clean 1.0 scale. Hold off until you've imported every clip, and read the scale section below before you do it at all.

4. Bring in the other clips

Import each Without Skin FBX the same way. Each one arrives as its own armature, Armature.001, Armature.002, with an action attached. Because the bone names inside those actions are identical to the ones on your main armature, the actions are interchangeable: an action is just a set of F-curves addressed by bone name.

Select your main armature, open the Dope Sheet, switch it to Action Editor mode, and pick the imported action from the dropdown in the header. The character plays it. On Blender 4.4 and newer, actions have slots, and the imported action's slot needs to be assigned to the armature as well, which the header does for you when you pick it. Once it plays, click Push Down. The manual describes what that does: it "creates a new track below the Action Track and moves the active action into it as a strip, leaving the Action Track empty". Repeat for every clip, then delete the spare armatures. Their actions stay in the file because the strips reference them.

If you want each animation to survive as a separate clip in Unity, Unreal or Godot, leave them as separate NLA strips and tick NLA Strips under Bake Animation in the FBX exporter, or export glTF, whose exporter writes every stashed or pushed-down action as its own animation in the default Actions mode and, in NLA Tracks mode, exports "each NLA Track as an independent glTF animation". If you want one long sequence, drag the strips end to end on one track instead.

5. Root motion

Mixamo bakes forward motion into the hips bone. Game engines want it on a root bone at the character's origin so the engine can read the character's displacement and move the collider. There's no button for this in stock Blender, so you either do it by hand or use the extension built for the job.

By hand: add a bone named root at the armature origin, parent mixamorig:Hips to it, give the root a Copy Location constraint from the hips limited to X and Y, bake the root with Object > Animation > Bake Action (Pose mode, Visual Keying, Clear Constraints), and remove the horizontal location keys from the hips. Once per clip.

With the extension: Import Mixamo - Root Motion by DevilMayCry adds File > Import > Mixamo fbx (folder/*.fbx). It imports a whole folder of Mixamo FBX files in one go, and its listing says it will "batch remove prefix name mixamorig:", rename each action after its file, apply transformations, remove the redundant Armature.00* skeletons, and "batch create root bones to record Root Motion information", with several ways to calculate the baked keys. Version 1.0.4 from November 2025 added a Copy Rotation option so the root also takes the hips' turning. It lists Blender 4.2 LTS as its compatibility and 5.1 and above as unsupported, with 51,467 downloads.

The four things that break

The character stays frozen in T-pose

Nine times in ten the action isn't assigned to the armature you're looking at. Check the Action Editor dropdown. The tenth time, it's the prefix. Mixamo bone names are mixamorig:Hips, and if the action's F-curves address mixamorig1:Hips or plain Hips, none of the curves find a bone and nothing moves, with no error. This happens when the clips were downloaded against a different upload of the same character, or when one file came through a tool that stripped the prefix. Open the Graph Editor, expand a channel, and compare the bone name in the data path with the names in your armature. Fix it by renaming one side. Batch Rename (Edit > Batch Rename, or Ctrl+F2) with Data Type set to Bones handles a whole skeleton with Find mixamorig: and Replace empty, and the root motion extension above does the same as a batch import option.

The character is tiny, or flies away

The tiny character is the 0.01 object scale with the mesh not parented, or a file imported at a Scale value other than 1.0. The flying character is the more interesting one. If you applied scale to your main armature so it reads 1.0, its hips bone now expects location keys in metres. The actions you imported still have location keys in centimetres, so the hips move 100 times too far on every step and the character launches out of frame. Either keep the 0.01 scale on the armature and never apply it, which every engine importer handles, or apply it consistently to every armature before you move any actions across, so the location curves get rescaled along with the bones. Never mix the two states in one file.

Extra bones and wrong orientations

An _end bone on every finger and toe means Ignore Leaf Bones was off on import. Bones pointing the wrong way with rolls all over the place means Automatic Bone Orientation was off. Both are cosmetic for playback and both bite as soon as you retarget or add constraints, so re-import with the boxes ticked rather than fixing bones by hand. If you're round-tripping to another package, the exporter's Add Leaf Bones and Primary/Secondary Bone Axis settings on the same manual page are the mirror image of these.

Textures come in grey or pink

If the mesh renders pink in Material Preview, an image path is broken: File > External Data > Find Missing Files and point it at the folder you unzipped. If it's flat grey, the importer built the material but didn't wire the image, so open the Shader Editor and connect the texture to Base Color.

Exporting what you built

Once the clips are on one armature, the export is a normal Blender export, with the usual per-engine details. Unity and Unreal take FBX (File > Export > FBX (.fbx)), Godot and the web take glTF (File > Export > glTF 2.0 (.glb/.gltf)). Tick Selected Objects and select the armature and mesh only, so the spare cameras and lights from the import don't come along. Under Bake Animation, NLA Strips exports each strip as its own take and All Actions exports every action "compatible with the selected armatures", which is more than you want if the file still holds actions from deleted armatures. Add Leaf Bones off, because the exporter otherwise writes an extra bone at the end of every chain to mark the last bone's length, and engines show it as _end. If your imports keep failing on FBX files from other packages rather than Mixamo, the paid Better FBX Importer & Exporter ($25 for one seat, 12,600+ sales, listed for Blender 3.6 to 5.1) exists because it reads every FBX version from 5.3 to 2020 and exports Unity and Unreal-friendly armatures, and that's what people pay for.

If the export step is what you dread, the Cinevva Rig add-on's export card is free without a key or an account: it reports where the bytes in your file go (geometry, textures, animation, shape keys) and its Unity, Unreal, Godot and Web presets set the axes, scale, bone axes, texture caps and compression for you. Measured against a plain Blender GLB export, the presets produced files 68% to 98% smaller on four real models.

What to use instead of Mixamo

The reason most people go to Mixamo from Blender is the animation library, not the rigging. Blender ships Rigify as a bundled add-on for free, and there are several ways to get a library of clips onto a rig without leaving Blender.

Retarget any clip with the Rokoko plugin. Rokoko's Studio Live plugin for Blender is open source on GitHub and its retargeting guide states that "the retargeting feature is not a paid feature and does not need a premium account". The steps: import the FBX with Automatic Bone Orientation ticked, open the Retargeting panel, pick the animated armature as source and yours as target, press Build Bone List, check the pairings, tick Auto Scale if the two skeletons differ in size, make sure both are in the same pose, and press Retarget Animation. If feet sink or the hips stay put, Rokoko says to try turning Auto Scale off or switching Use Pose to Current. It's the cheapest way to move a Mixamo clip onto a Rigify or custom rig.

Retarget with Auto-Rig Pro's Remap. Auto-Rig Pro is the category leader on Superhive, with over 65,000 sales and a listed range of Blender 2.93 to 5.1. The Lite edition is $25 and covers the rig itself. Remap, the retargeter, is in the $50 Full edition alongside the Smart biped detection and the FBX and glTF export presets for Unreal and Unity. The product page describes Remap as retargeting "any armature action to another one, with different bone names and bone orientations", and names Mixamo files as the example. If you already own ARP, this is your retargeter.

Retarget with constraints and a bake. Blender can do it with no add-on: give each bone on your rig a Copy Rotation constraint targeting the matching Mixamo bone, a Copy Location on the hips, then Object > Animation > Bake Action with Visual Keying and Clear Constraints. It's tedious for a full skeleton, and you'll set it up again for every skeleton pair.

Use a CC0 library instead of Mixamo's. Quaternius' Universal Animation Library (March 2025, 120+ clips) and Universal Animation Library 2 (January 2026, 130+ clips) are CC0, ship as FBX, GLB and .blend, and were built on one humanoid rig "ready for retargeting" into Unreal, Godot and Unity. Locomotion in eight directions, jog, sprint, crawling, swimming, melee and armed combos, parkour, farming, fishing, zombie sets. CC0 is a public domain dedication, so nothing follows the clip into your game, and you can redistribute the raw files, which Mixamo's terms don't allow. You still retarget them onto your character with one of the tools above.

Skip the round trip. The Cinevva Rig add-on does the rig and the library in one place. Select a mesh, press Rig, and you get a skinned humanoid armature with Mixamo bone names, so every workflow on this page still applies. Then a browser docked in the viewport previews 260 CC0 clips (walks, runs, idles, combat, climbing, crawling, emotes) and one click retargets the clip onto your character inside Blender, with foot planting and floor contact handled during the retarget. Rigging runs on your own machine after a one-time engine download of about 2.4 GB, offline, with no per-rig count, for a single $29 launch-price purchase that activates up to three machines. It supports Blender 4.2 and newer on Windows, macOS and Linux and installs as a standard extension. If you'd rather not install anything, the same 260 clips retarget onto an uploaded rigged GLB or FBX in the browser at the animation library, and Prompt Animations turns a sentence into a clip for the odd motion no library has.

If the rig is what you'd redo. Mixamo's skin weights are what they are, and repainting them is the job people pay to skip. Voxel Heat Diffuse Skinning ($30, 12,500+ sales, Blender 3.6 to 5.1) re-skins a mesh to any armature with a voxel heat solve, and it's the standard answer when Mixamo's automatic weights pinch a cloak or a skirt.

Common Questions

Is there a Mixamo add-on for Blender 4.2?

Yes. Adobe's original was written for Blender 3.6 and broke on 4.0's bone collections, but the community continuation is on Blender Extensions as Mixamo Rig, version 1.2.2 from April 2026, listed for Blender 4.2 LTS with 5.5 and above marked unsupported. It does the same one-click IK control rig and bakes animations in and out. Install it from Edit > Preferences > Get Extensions.

Is Mixamo still free in 2026?

According to Adobe's Mixamo FAQ, Mixamo is free for anyone with an Adobe ID and needs no Creative Cloud subscription, with the exceptions that Enterprise and Federated IDs can't use it and it isn't available to accounts with a China country code. Characters and animations are royalty free for commercial projects including games. The FAQ was last updated in September 2021, and Adobe says it doesn't support troubleshooting in third-party programs such as Blender.

How do I import a Mixamo animation into Blender?

Download the character once With Skin and each animation Without Skin, then File > Import > FBX (.fbx) for each file with Apply Transform off and, on the legacy importer, Automatic Bone Orientation and Ignore Leaf Bones on. Select your main armature, pick the imported action in the Action Editor dropdown, and press Push Down to store it as an NLA strip. Delete the extra armatures when you're done. Blender 5.0 and newer default to the faster C++ importer and keep the Python one as "(Legacy)".

Why is my Mixamo character so small in Blender?

Mixamo files are in centimetres, so the importer sets the armature object's scale to 0.010 and parents the mesh under it, which displays at the right size. It looks tiny only when the mesh isn't parented or you changed the importer's Scale value. Don't apply the scale to one armature and not the others, because the imported actions keep hips location keys in centimetres and the character will fly 100 times too far.

Why are my Mixamo animations not working in Blender?

The character stays in T-pose when no action is assigned to that armature, or when the bone names in the action don't match the armature's. Mixamo bones are mixamorig:Hips and friends, and if one file came back as mixamorig1: or had the prefix stripped, none of the F-curves find a bone and nothing moves, with no error. Check the Action Editor dropdown first, then compare a bone name in the Graph Editor's data path against the armature, and use Ctrl+F2 Batch Rename to make them match.

How do I get root motion from Mixamo in Blender?

Download the clip with "In Place" unticked so the forward motion is in the hips, then move the hips' horizontal location into a root bone and bake it. The Import Mixamo - Root Motion extension does this for a whole folder of files at once, strips the mixamorig: prefix, and names each action after its file. It's listed for Blender 4.2 LTS with 5.1 and above unsupported, so on newer Blender you do it by hand with a Copy Location constraint and Bake Action.

What's the best Mixamo alternative for Blender?

For the animations, Quaternius' CC0 Universal Animation Library gives you 250+ clips you can ship and redistribute with no licence line, retargeted onto your rig with Rokoko's free plugin or Auto-Rig Pro's Remap. If you'd like the rig and the library in one add-on, the Cinevva Rig add-on rigs a mesh and retargets 260 CC0 clips onto it inside Blender, on your own machine, for one $29 purchase, on Blender 4.2 and newer. Mixamo itself is still fine for grabbing a clip or two.

Related

• Cinevva Rig for Blender: rig a mesh, play 260 CC0 clips on it, export game-ready files, all inside Blender.
• Free Character Animations and Auto-Rigging: Mixamo's status and every free library and rigger, with licences verified.
• How Automatic Rigging Works: what an auto rigger does to your mesh and how to prepare a model for it.
• AI Animation Generators for 3D Characters: text to motion, video mocap and library tools compared.
• Character Animation Library: upload a rigged GLB or FBX and preview 260 CC0 animations on it in the browser.
• Prompt Animations: describe a movement and get a clip retargeted onto your character.

Last updated: September 2026.

To optimize a GLB for the web, work in this order: shrink the textures first (cap them at 1024 or 2048, re-encode as WebP for download size or KTX2 for GPU memory), quantize the vertex data, compress the geometry with Meshopt (or Draco when the last few hundred kilobytes matter more than decode time), simplify the mesh if the triangle count is still silly, then prune, dedupe and join what's left. One command does most of it: gltf-transform optimize in.glb out.glb --texture-compress webp. The order matters because textures are usually 80 percent or more of the file and all of the video memory.

Quick answer

• Texture-heavy model (most models): resize to 1024 or 2048, then gltf-transform webp. If it stutters or crashes on phones, convert to KTX2 instead, in the browser with the KTX2 compressor or with gltf-transform etc1s/uastc.
• Geometry-heavy model (scans, CAD, AI-generated): gltf-transform simplify, then meshopt. Draco compresses a bit smaller but decodes slower and needs a ten times larger decoder.
• Animated character: Meshopt, not Draco. Draco leaves animation tracks and morph targets untouched.
• File has to open in an engine you don't control: gltf-transform quantize. No decoder, only KHR_mesh_quantization, which every loader here reads.
• No terminal: the GLB optimizer runs prune, weld, join, simplify, texture resizing to WebP and Meshopt in your browser with a size readout per step.

Quick reference

The same numbers as bars, with the gltfpack and simplify results from the bake-off alongside.

Where the bytes go in a GLB

Run gltf-transform inspect model.glb before anything else. It lists every mesh with vertex count and attribute types, every texture with its encoded size and gpuSize, and every animation with its keyframe count. The numbers in this guide come from the tool docs and extension specs plus a bake-off we ran this week with gltf-transform 4.5.0 and gltfpack 1.2 on two real files, and they show the two shapes you'll meet.

A 2.2 MB Sketchfab prop (a low-poly cup) had 680 triangles and 39 KB of geometry. The other 2.18 MB was three 1024×1024 PNGs, so textures were 98 percent of the file, and inspect estimated 5.59 MB of VRAM for each once mipmapped. That's the common case for hand-made assets.

A 28.7 MB TRELLIS.2 output was the opposite: 978,226 triangles and 27.5 MB of float32 geometry with only 1.1 MB of textures. But those two textures were 4096×4096, which inspect puts at 89.5 MB of VRAM each. Models from the 3D model generator and its peers routinely arrive like this, dense and over-textured, so they need the geometry steps as well as the texture steps.

Note that encoded texture size and GPU size are unrelated. A 4 MB PNG and a 200 KB WebP of the same 2048×2048 image both become about 22 MB in video memory, raw pixels plus mipmaps. Only KTX2 changes that number.

The six steps below run in this order because each one shrinks what the next has to work on.

Step 1: textures

Two separate problems, two separate fixes.

Download size is fixed by resizing and re-encoding. Few props need more than 1024×1024, and a hero character rarely needs more than 2048. gltf-transform resize --width 1024 --height 1024 caps dimensions without ever upscaling, and gltf-transform webp re-encodes with sharp. On the cup, WebP alone took the file from 2.23 MB to 246 KB. Resizing to 512 first took it to 96 KB with no visible change on a prop that size. WebP needs EXT_texture_webp, which the web engines read and Unity's glTFast does not (its feature table says it "will not become supported").

GPU memory and upload time are fixed only by KTX2 with Basis Universal supercompression, which keeps the texture in a GPU block format all the way into VRAM at 4 to 8 times less memory than raw RGBA. It gets its own section below because the settings matter.

One caution from the bake-off: gltf-transform optimize defaults to --texture-compress auto, which re-encodes textures in their original format. On the cup that made the PNGs larger and the file grew from 2.2 MB to 2.8 MB. Pass webp or ktx2 explicitly.

Step 2: quantize

Quantization stores each vertex attribute in fewer bits. A position goes from three 32-bit floats to three 16-bit integers with the scale and offset folded into the node transform (or into inverseBindMatrices for skinned meshes). The KHR_mesh_quantization spec puts a typical vertex at roughly 20 bytes instead of 48. It's a ratified Khronos extension with no decoder: the GPU reads the integer attributes directly, so quantized files are cheaper in VRAM as well as on the wire.

glTF-Transform's defaults are 14 bits for positions, 10 for normals and tangents, 12 for UVs, 8 for colors and weights. gltfpack's are 14, 8, 12 and 8. Both are invisible except on a giant single mesh, where 14 bits across the whole extent can show as faceting. Alone, quantization is modest: our 28 MB model dropped to 22.8 MB raw and 8.1 MB gzipped. Its real job is to be the first half of Meshopt, and the safe output when the destination loader is uncertain. Draco quantizes internally with the same defaults, so don't run quantize before draco.

Step 3: Meshopt or Draco

Both are lossy geometry codecs that decode to plain buffers before GPU upload, so neither makes the model render faster. They shrink the download. The differences are what they compress, how fast they decode, and how much decoder you ship.

Meshopt (EXT_meshopt_compression) works at the bufferView level, so vertex attributes, indices, morph target deltas and animation keyframes all get compressed. It's designed to sit on top of quantization and under gzip or brotli: the codec makes the bytes regular and the CDN's general-purpose compressor does the rest. The spec quotes decode speeds around 1 GB/s with WebAssembly SIMD, and the three.js decoder is a single 32 KB module. On the test model: 5.1 MB raw, 3.3 MB gzipped, at the default --level high.

Draco (KHR_draco_mesh_compression) compresses triangle-mesh primitives only. Animation, morph targets, points and lines pass through untouched. It compresses harder, 2.6 MB on the same model, and gzip barely helps because the output is already dense. The cost is decode time and decoder weight: glTF-Transform's docs say plainly that Meshopt decoding is considerably faster, and the WASM decoder three.js bundles is 286 KB (192 KB for the glTF-branch build) plus a 58 KB wrapper, with a 719 KB JavaScript fallback. Draco also reorders and can change the number of vertices.

So: Meshopt for anything animated, anything with morph targets, anything where load time on a phone is the point, and anything served with brotli on. Draco when the asset is a static mesh, geometry dominates, and 20 to 30 percent off the wire is worth a slower first frame. Not sure? Meshopt. gltfpack's -cc (Meshopt in its stronger mode) landed at 4.4 MB raw and 3.1 MB gzipped on the same file.

Step 4: simplify

If the model is still large after compression, it has too many triangles, and no codec fixes that. Both tools use the meshoptimizer simplifier, which takes a target ratio and an error bound and stops at whichever it hits first.

gltf-transform simplify --ratio 0.25 --error 0.01 aims for 25 percent of the vertices within 1 percent of the mesh radius of deviation. On the 978k-triangle model that gave 244,556 triangles and 8.1 MB before compression, identical at game distance. The optimize defaults are more aggressive than you'd guess: --simplify-ratio 0 with --simplify-error 0.0001, meaning "remove as much as possible within 0.01 percent error". On the same over-tessellated model that collapsed it to 6,582 triangles, because the generator had spent nearly a million triangles on flat surfaces. Weld before simplifying (optimize does), because split vertices stop the simplifier at seams.

gltfpack's -si 0.25 is the same idea, with -se 0.01 as the default error limit, -sa to hit the ratio regardless of quality, and -slb to lock border vertices so modular meshes don't open gaps. Hard-surface props tolerate 50 percent easily, scanned and AI-generated meshes usually tolerate 90 percent removal, and rigged characters need care near joints because collapsing vertices also collapses skin weights.

Step 5: prune, dedupe, join, instance

These are free wins and optimize runs all of them. prune removes materials, textures, accessors and nodes nothing references, and converts single-colour textures into material factors. dedup merges identical accessors and textures an exporter wrote twice. flatten collapses the hierarchy and join merges meshes that share a material, which is what turns 200 draw calls into a handful. instance (from 5 copies up) converts repeated meshes into EXT_mesh_gpu_instancing, and palette merges materials that differ only in colour.

Don't join or flatten a rigged character or anything your game moves in parts, because the parts vanish into one mesh. gltfpack's escape is -kn (keep named nodes) and -km (keep named materials).

Step 6: animation

Exporters often bake a keyframe on every frame. gltf-transform resample drops keyframes that sit on the line between their neighbours (tolerance 1e-4 by default), which is lossless in practice. gltfpack's -af 30 resamples every track at 30 Hz and quantizes translations to 16 bits, rotations to 12 and scale to 16 (-at, -ar, -as) before Meshopt compresses them. On a typical character with a handful of clips this is a small step. On a motion library it can be most of the bytes.

The command lines

glTF-Transform's CLI is npm install --global @gltf-transform/cli, or npx @gltf-transform/cli. One shot:

gltf-transform optimize in.glb out.glb --texture-compress webp --texture-size 1024

That runs, in order, dedup, instance, palette, flatten, join, weld, simplify (ratio 0, error 0.0001), resample, prune, sparse, texture compression at a 1024 cap, and Meshopt at level high. Add --compress draco for Draco, --compress quantize for quantization only, --no-join --no-flatten for rigged or articulated models, --simplify false if the silhouette matters more than the bytes, and --texture-compress ktx2 if KTX-Software is installed.

The individual steps when you want control:

gltf-transform inspect in.glb
gltf-transform resize in.glb a.glb --width 1024 --height 1024
gltf-transform webp a.glb b.glb --quality 80
gltf-transform weld b.glb c.glb
gltf-transform simplify c.glb d.glb --ratio 0.5 --error 0.001
gltf-transform meshopt d.glb out.glb --level high

Swap the last line for gltf-transform draco d.glb out.glb (--encode-speed and --decode-speed run 0 to 10, default 5, lower is smaller) or gltf-transform quantize d.glb out.glb.

gltfpack is npm install -g gltfpack or a native binary from the meshoptimizer releases, which the README recommends for large files. Its defaults already quantize, optimize vertex order for the GPU cache and merge meshes:

gltfpack -i in.glb -o out.glb -cc -si 0.5 -tw -tl 1024 -kn

-cc is Meshopt in the higher compression mode (-c is the fast mode, -cf adds an uncompressed fallback for loaders without the decoder). -si 0.5 halves the triangles within -se 0.01. -tw converts textures to WebP and -tl 1024 caps their size. -kn keeps named nodes. For KTX2 swap -tw for -tc (ETC1S) or -tc -tu (UASTC), which needs a gltfpack build with Basis Universal linked in.

If neither CLI is an option, the browser tool runs the same sequence.

KTX2: ETC1S or UASTC

KTX2 is Khronos's container for GPU textures. With Basis Universal supercompression the texture is transcoded at load time to whatever block format the device has (BC on desktop, ASTC or ETC2 on mobile) and stays compressed in memory. The glTF extension is KHR_texture_basisu.

Basis has two modes. ETC1S is the small one: the Basis README puts it at roughly 0.3 to 3 bits per pixel on disk with a JPEG-like quality dial (1 to 255, default 128), and it lands in memory at 4 bits per pixel in formats like BC1 and ETC1. Use it for base colour on props. UASTC is the quality one: 8 bits per pixel in memory, a 19-mode subset of ASTC 4×4, quality levels 0 to 4 (default 2, which glTF-Transform's help lists at 47.47 dB). UASTC files are large on disk, so pair them with Zstandard: glTF-Transform's uastc defaults to --zstd 18, and ktx create --zstd takes 1 to 22.

The arithmetic for a 2048×2048 texture with mipmaps: about 22 MB as RGBA8, about 5.6 MB as UASTC, about 2.8 MB as ETC1S transcoded to a 4 bpp format.

Three rules bite. Normal and data maps want UASTC and linear. glTF-Transform warns that RGB normal maps and occlusion/roughness/metalness maps can look bad under ETC1S, and the spec requires colour textures tagged sRGB and non-colour data tagged linear. glTF-Transform sets that per slot for you. In the KTX2 compressor it's the sRGB toggle, on for colour, off for normal and data maps. Dimensions must be multiples of 4, powers of two recommended. Generate mipmaps. The spec says a KTX2 used with mipmapped minification should carry the full pyramid, or the engine has to decompress and build them at runtime. Mipmaps are on by default in glTF-Transform and the browser tool, and --generate-mipmap in ktx create.

The glTF-Transform commands need the ktx binary from KTX-Software, 4.4.0 or later:

gltf-transform uastc in.glb a.glb --level 2 --zstd 18 --slots "{normalTexture,occlusionTexture,metallicRoughnessTexture}"
gltf-transform etc1s a.glb out.glb --quality 128

UASTC on the data slots first, ETC1S on the rest. That split, ETC1S for base colour and emissive and UASTC for normals and ORM, is the usual one.

Loading the result

Every codec except quantization needs a decoder on the client.

three.js. GLTFLoader reads KHR_mesh_quantization and EXT_texture_webp with no setup. For the others you attach decoders, which ship in the three package under examples/jsm/libs/ as draco/, basis/ and meshopt_decoder.module.js. Copy draco/ and basis/ to a public path, then:

import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'
import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js'
import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js'
import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js'

const draco = new DRACOLoader().setDecoderPath('/libs/draco/')
const ktx2 = new KTX2Loader().setTranscoderPath('/libs/basis/').detectSupport(renderer)
const loader = new GLTFLoader()
  .setDRACOLoader(draco)
  .setKTX2Loader(ktx2)
  .setMeshoptDecoder(MeshoptDecoder)

DRACOLoader picks the WASM decoder when the browser supports it and falls back to JS. detectSupport(renderer) lets KTX2Loader choose the transcode target for the device's GPU.

Babylon.js. The glTF loader handles Draco, Meshopt (since 5.0, no setup) and KTX2 by downloading decoders from https://cdn.babylonjs.com and running them in web workers. To self-host, set Tools.CDNBaseUrl, or point the individual configs: DracoDecoder.DefaultConfiguration (wasmUrl, wasmBinaryUrl, fallbackUrl), MeshoptCompression.Configuration.decoder.url, and KhronosTextureContainer2.URLConfig for the KTX2 transcoder set. With npm, @babylonjs/ktx2decoder bundles the transcoders.

PlayCanvas. Draco is configured with dracoInitialize({ jsUrl, wasmUrl, numWorkers, lazyInit }), and the Editor can Draco-compress at import. KTX2 goes through basisInitialize({ glueUrl, wasmUrl, fallbackUrl }). EXT_meshopt_compression is not in the GLB parser as of engine 2.x (the 2020 feature request is still open), so for PlayCanvas pick Draco or quantization-only output.

Unity. The official importer is glTFast (com.unity.cloud.gltfast). KHR_mesh_quantization works out of the box, Draco needs com.unity.cloud.draco, KTX2 needs com.unity.cloud.ktx, and Meshopt needs com.unity.meshopt.decompress. WebP is unsupported by design, so for a Unity target use KTX2.

Targets for a mobile web game

There's no spec for this, but there are numbers that keep phones happy. Keep the whole first scene under about 10 MB over the wire and stream the rest (the streaming asset loading tutorial covers the tiers and the code). Keep texture VRAM under 150 to 200 MB, which is four or five 2048 textures as RGBA8 or thirty as ETC1S. Keep props under 5,000 triangles, a hero character under 30,000 to 50,000, and draw calls in the low hundreds. Use 1024 textures for props and 2048 only for what the camera gets close to. Serve GLBs with brotli or gzip on, because Meshopt and quantized output rely on it.

Verify before you ship

File size is the easy number. Open the result in the GLB viewer and read the rest: the Extensions panel confirms EXT_meshopt_compression, KHR_draco_mesh_compression or KHR_texture_basisu actually made it into the file, the Textures tab lists each texture with its real VRAM cost largest first, and the status bar shows live draw calls and triangle count. Then check silhouettes and UV seams for simplification artefacts at the distance the player sees them, and play any animations to make sure joining didn't fuse a part that should move. If the source wasn't a GLB to begin with, run the FBX or OBJ through the FBX to GLB converter first, so you're compressing the file you'll actually load.

Common Questions

How do I reduce GLB file size?

Run gltf-transform inspect to see whether textures or geometry dominate. If textures, resize to 1024 or 2048 and convert to WebP or KTX2. If geometry, simplify and then compress with Meshopt or Draco. gltf-transform optimize in.glb out.glb --texture-compress webp does the whole sequence, and the browser GLB optimizer does it with no install.

Draco vs Meshopt: which is better?

Meshopt for most web games. It decodes far faster, ships a 32 KB decoder instead of a few hundred kilobytes of WASM, and compresses animation and morph targets, which Draco skips. Draco produces smaller files for static meshes (2.6 MB against 3.3 MB gzipped on our 28 MB test model) and is the one PlayCanvas supports, so it wins when the asset is a static scan and geometry is most of the bytes.

What is KTX2 and how is it different from Basis?

Basis Universal is the compression codec, with two modes, ETC1S and UASTC. KTX2 is the Khronos container file that holds Basis-compressed texture data plus mipmaps and metadata, and it's what glTF references through KHR_texture_basisu. Older pipelines used a bare .basis file. Use .ktx2.

Should I use ETC1S or UASTC?

ETC1S for base colour and anything not seen up close: small files and 4 bits per pixel in VRAM. UASTC for normal maps, roughness/metalness/occlusion and hero textures, with Zstandard supercompression on so the download stays reasonable. Tag colour textures sRGB and data textures linear, or the normals will shade wrong.

How do I compress glTF textures?

For download size, gltf-transform resize then gltf-transform webp. For GPU memory, gltf-transform etc1s or uastc with KTX-Software installed, or drop the PNGs on the KTX2 compressor. Cap dimensions first either way: a 4096 texture is 89 MB of VRAM as RGBA8 and there's almost never a reason to ship one in a browser.

Why is my GLB too large for three.js on mobile?

Usually it isn't the file size, it's texture memory. Four 2048 RGBA textures are about 90 MB of VRAM before the scene has drawn anything, and phone browsers kill the tab past a few hundred. Convert to KTX2 so textures stay compressed on the GPU, cap them at 1024 where you can, and call KTX2Loader.detectSupport(renderer) so it transcodes to the device's format.

Does gltfpack do the same thing as gltf-transform?

Mostly. gltfpack is a single native binary from the meshoptimizer project that quantizes, reorders vertices for the GPU cache, merges meshes and Meshopt-compresses by default. glTF-Transform is a Node library and CLI with the same operations as separate scriptable steps, plus Draco output, which gltfpack doesn't write. On our test file their Meshopt outputs landed within about 10 percent of each other.

Related

• Streaming asset loading for web games: tiers, priority queues and progress bars for the files you just shrank
• Web Games Tech Stack in 2026: WebGL, WebGPU, Wasm and asset formats at the API level
• Free 3D Model Sites: where the models come from, and why they arrive heavy
• Best AI 3D Model Generators: what the generators output and how dense it is
• Three.js vs Babylon.js: both load Draco, Meshopt and KTX2, with different setup
• PlayCanvas vs Three.js: engine versus library, including asset pipelines

Last updated: September 2026.

If a game or 3D page says your browser doesn't support WebGL 2 or WebGPU, the cause is almost always one of four things: hardware acceleration is switched off, your GPU or driver is on the browser's blocklist, the browser is too old for the API, or you're in a virtual machine or remote desktop session with no real GPU. Turn hardware acceleration on, update the graphics driver, update the browser, and confirm the result with a capability test. For WebGPU, also check the platform: as of September 2026 Firefox only ships it on Windows and Apple Silicon Macs, and Chrome on Linux only on Intel Gen12+ and recent NVIDIA hardware.

This is the troubleshooting page. To understand the two APIs and pick one to build on, read WebGPU vs WebGL for Games.

Quick answer

• Diagnose first: open the WebGL and WebGPU checker. It shows whether WebGPU, WebGL 2 and WebGL 1 work and names the GPU your browser is using. If the renderer says SwiftShader, llvmpipe or "Software", you're on CPU rendering and the fixes below apply.
• Chrome and Edge: Settings, System, turn on "Use graphics acceleration when available", relaunch. Check chrome://gpu (or edge://gpu). If WebGL is "Software only" or "Unavailable", update the GPU driver. Last resort: chrome://flags/#ignore-gpu-blocklist.
• Firefox: Settings, General, Performance, untick "Use recommended performance settings", tick "Use hardware acceleration when available". Check about:support, Graphics. Last resort: about:config, webgl.force-enabled to true.
• Safari: update to Safari 26 for WebGPU and Safari 15 or newer for WebGL 2. There's no acceleration toggle to flip.
• The Unity "does not support graphics API WebGL 2" message means canvas.getContext('webgl2') returned nothing. Same fixes, and on Safari it means a version older than 15.
• Work or school device, VM, remote desktop: the GPU is blocked by policy or isn't there. Ask IT, or play on a device with a real GPU.

Quick reference

WebGPU support as of September 2026, from the WebGPU implementation status wiki (updated August 13, 2026), Firefox and WebKit release notes, and caniuse.

WebGL 2 is the baseline. Per caniuse it's in Chrome 56+, Edge 79+, Firefox 51+, Safari 15+ and iOS Safari 15+, and Unity's compatibility page lists Chrome 58+ on Android. If WebGL 2 fails on any current browser, the problem is the machine, not the browser version.

The 30-second diagnosis

Start with the WebGL and WebGPU checker. It runs when the page loads and uploads nothing. Read three things off it.

On a machine with the problem, the page looks like this.

Which APIs pass. If WebGL 2 works and only WebGPU fails, go to the table above, because WebGPU depends on browser, OS and GPU together and the answer may be "not on this platform yet". If WebGL 2 also fails, keep reading: that points at acceleration, drivers or a blocklist.

The renderer line. A real GPU shows up as something like "ANGLE (NVIDIA, NVIDIA GeForce RTX 4060 ...)" or "Apple M2". SwiftShader, llvmpipe, "Microsoft Basic Render Driver" or anything with "software" in it means your browser is drawing on the CPU. Games crawl, and WebGPU won't appear.

The browser's own GPU page. In Chrome type chrome://gpu into the address bar (Edge: edge://gpu). "Graphics Feature Status" lists WebGL and WebGL2 as "Hardware accelerated", "Software only, hardware acceleration unavailable" or "Unavailable", and "Problems Detected" further down says why, usually naming a blocklist entry or a driver. In Firefox, about:support has a Graphics section where "Compositing" shows whether acceleration is on and a Failure Log or Decision Log explains any block. Safari has no equivalent page.

"Software rendering" means this: browsers keep a list of GPU and driver combinations known to crash or misrender, and when your machine matches an entry they disable the feature or fall back to a CPU rasterizer. Chromium's blocklist disables all GPU acceleration for the Microsoft Basic Render Driver ("GPU access is blocked if users don't have proper graphics driver installed after Windows installation"), for VMware and VirtualBox, and for old Intel and NVIDIA drivers. Entries are keyed on driver versions, which is why "update the driver" fixes so many of these.

One thing changed in 2026. Chromium used to fall back to SwiftShader, a CPU implementation of WebGL, whenever the GPU was blocked, so WebGL "worked", slowly. Microsoft's Edge policy docs state that starting in version 144 SwiftShader is deprecated and "WebGL context creation fails in scenarios where SwiftShader is used", and Chromium's SwiftShader doc says the same for Chrome, with --enable-unsafe-swiftshader as the opt-in. A blocklisted machine that used to get a slow game now gets a "not supported" error.

Put together, the diagnosis is three questions asked in a fixed order, and each one has a single fix attached.

Chrome and Edge

Chrome and Edge share the Chromium engine, so everything here applies to both. Swap chrome:// for edge:// where needed.

The hardware acceleration toggle

Open Settings, then System, and make sure "Use graphics acceleration when available" is on (in Edge it's under System and performance). Relaunch, because the setting only applies after a restart. It's off surprisingly often, because a lot of "fix Chrome flicker" advice says to turn it off. Then open chrome://gpu. If WebGL and WebGL2 say "Hardware accelerated", you're done. If not, the browser is refusing your GPU on purpose, and the reason is under "Problems Detected".

Windows

The usual culprit is a stale or generic driver. If the renderer says "Microsoft Basic Render Driver", Windows has no real driver for your GPU at all, and Chromium treats that as "block everything". Install the driver from NVIDIA, AMD or Intel directly rather than waiting on Windows Update. On a laptop with two GPUs, Windows Settings, System, Display, Graphics lets you pin the browser to the high-performance GPU. A browser on the integrated chip passes the checker but can crawl in a heavy game.

Windows on ARM (Snapdragon laptops) is a WebGPU special case: the implementation status wiki lists it as behind chrome://flags/#enable-unsafe-webgpu or the --enable-unsafe-webgpu switch. WebGL 2 works normally there.

macOS

Macs rarely hit this because Apple ships the driver with the OS. If Chrome on a Mac reports software rendering, suspect the acceleration toggle, an ancient macOS, or a virtual machine. Updating macOS is the driver update.

Linux

Linux is where WebGPU has the most caveats. Per the wiki, Chrome ships WebGPU by default on Linux for Intel Gen12 and newer from Chrome 144, and for NVIDIA with driver 535.183.01 or newer under Wayland from Chrome 147. Everything else (AMD, older Intel, NVIDIA on X11) needs the flag stack the wiki lists: --enable-unsafe-webgpu --ozone-platform=x11 --use-angle=vulkan --enable-features=Vulkan,VulkanFromANGLE. The rollout runs WebGPU on Vulkan while the rest of the browser stays on OpenGL, which is why it's gated per GPU family.

For WebGL 2 on Linux, the question is whether Mesa is using your GPU or the llvmpipe software rasterizer. If the renderer says llvmpipe, update the Mesa drivers for your GPU (or the NVIDIA proprietary driver).

The blocklist override

chrome://flags/#ignore-gpu-blocklist ("Override software rendering list") makes Chrome use your GPU even when it's on the blocklist. It's the right move when the list wrongly rejects your GPU, or when you'd rather have occasional glitches than no WebGL. It's the wrong move when the block exists because the driver crashes, so try the driver update first.

Android Chrome

WebGL 2 has been in Android Chrome since version 58, so on any current phone a WebGL 2 failure usually means a blocklisted GPU driver, which on Android you can't update separately. Check for a system update, then try chrome://flags/#ignore-gpu-blocklist, which exists on Android too.

WebGPU on Android arrived in Chrome 121 for Android 12 or newer with ARM, Qualcomm or Intel GPUs, and in Chrome 139 for Imagination GPUs on Android 16 or newer. The wiki still lists Samsung's Xclipse GPUs (Exynos Galaxy phones) as in progress, so a fully updated Exynos Galaxy can report no WebGPU. That's not a bug on your end.

Firefox

Hardware acceleration and the override

Open Settings, General, scroll to Performance, untick "Use recommended performance settings", and make sure "Use hardware acceleration when available" is ticked. Restart Firefox. Then check about:support, Graphics: "Compositing" should say WebRender, and a blocked WebGL shows up in the Failure Log or Decision Log with the driver or feature that was blocked.

Mozilla's blocked graphics drivers page documents the overrides. In about:config, set webgl.force-enabled to true to override a WebGL block and layers.acceleration.force-enabled to true to override a compositing block. Mozilla's wording: "do this at your own risk. There usually are good reasons why features are blocked". Update the driver first.

WebGPU: which Firefox on which OS

Firefox is where "WebGPU not supported" is most often just the platform. From the release notes: Firefox 141 (July 22, 2025) enabled WebGPU on Windows. Firefox 145 (November 11, 2025) added macOS 26 Tahoe on Apple Silicon. Firefox 147 extended that to "devices with Apple Silicon processors on all supported macOS versions". Intel Macs, Linux and Android are still out: MDN's experimental features page says that for "other platforms such as Linux and macOS on Intel Silicon it is enabled in nightly", and the wiki lists Linux as expected in 2026 and Android as behind a flag.

The preference is dom.webgpu.enabled in about:config. On a platform Firefox hasn't shipped, flipping it to true in the release build exposes an implementation Mozilla hasn't finished for that OS, so expect crashes. If you want WebGPU on Linux Firefox today, use Nightly, where it's on by default. Caniuse marks Firefox "disabled by default" because it tracks flags per browser, not per OS, so don't let that page tell a Windows user they lack it.

Safari

Safari has no acceleration toggle and no blocklist you can override. The version is the whole story.

WebGL 2 needs Safari 15 or newer on macOS and iOS. Unity's compatibility page puts it plainly: "Apple Safari doesn't support WebGL 2 in versions before Safari 15". A Mac stuck on an old macOS can't get a newer Safari, so the fix is a macOS update or installing Chrome or Firefox, which run WebGL 2 on older macOS.

WebGPU shipped in Safari 26.0 on September 15, 2025 on macOS Tahoe, Sequoia and Sonoma, plus iOS 26, iPadOS 26 and visionOS 26, on by default. WebKit's release post says WebGPU "supersedes WebGL on macOS, iOS, iPadOS, and visionOS and is preferred for new sites and web apps". If you're on Safari 26 and WebGPU still fails, check that the page is served over HTTPS (WebGPU only works in secure contexts in every browser) and that it isn't inside an embedded web view.

On Safari 17 and 18, WebGPU exists behind a feature flag. On macOS, open Safari Settings, Advanced, tick "Show features for web developers", and a Feature Flags tab appears where you can turn on WebGPU. On iOS 18 the path is Settings, Apps, Safari, Advanced, Feature Flags (older iOS: Settings, Safari, Advanced). That's the pre-release implementation, fine for a demo, not something to ship a game against.

Whichever browser you fixed, reload the checker. A healthy result looks like this.

Work laptops, school Chromebooks, VMs and remote desktop

If the toggles are missing or don't stick, look at who manages the device.

Managed browsers can have acceleration turned off by policy. Chrome and Edge both have a HardwareAccelerationModeEnabled policy, and Microsoft's documentation says that when it's disabled the browser "turns off graphics acceleration". The Settings toggle greys out or reverts, and chrome://policy lists what's applied. Since Chromium 144 there's also EnableUnsafeSwiftShader, a temporary policy that keeps the old CPU fallback alive on machines with no GPU. If you administer a school lab that just lost every WebGL site, that policy is the stopgap while you sort out drivers.

Virtual machines present a virtual GPU that browsers refuse. Chromium's blocklist has explicit entries ("Do not use GPU accelerated rendering with VMware on Windows", "VirtualBox driver is unstable on linux", "Parallels drivers older than 7 are buggy"), all disabling every accelerated feature. Enable 3D acceleration in the VM settings with current guest tools, or accept that the VM is for testing the no-GPU path and play on the host.

Remote desktop is the same problem in a different costume. An RDP session, a Citrix or Horizon desktop, or a cloud PC typically exposes a basic display adapter, so the browser sees no usable GPU. Run the browser on the local machine instead of inside the session.

Chromebooks are the easy case: ChromeOS has had WebGPU since Chrome 113, so a failure there is almost always policy or a device past its update date.

The Unity "does not support graphics API WebGL 2" error

The exact text players see:

Your browser does not support graphics API "WebGL 2" which is required for this content.

It comes from Unity's web loader when the webgl2 context request returns null. Unity's browser compatibility page says Web builds need a browser that is "WebGL 2 capable", with WebGL 2 as the default graphics API, so the loader has nothing to fall back to unless the developer added one.

If you're the player, the causes in order of likelihood: hardware acceleration is off, the GPU driver is blocklisted (and since Chromium 144 no longer rescued by SwiftShader), you're in a VM or remote session, or you're on Safari 14 or older. If the checker passes WebGL 2 but the game still fails, the page is probably in an embedded frame or web view without GPU access, and opening the game's URL directly fixes it.

If you're the developer, the Graphics APIs list in Player Settings, Web, Other Settings decides how often players hit this. With Auto Graphics API on, Unity tries WebGL 2 first, and community threads note the same warning appears when the fallback to WebGL 1 succeeded but WebGL 2 didn't, so the message alone doesn't tell you whether the game ran. A Linear color space forces WebGL 2 only. Adding "WebGL 1 (Deprecated)" keeps very old browsers playable at the cost of post-processing and texture formats, for roughly 1.5 MB more in the data file by one developer's measurement. Unity 6 also lets you add WebGPU, still marked experimental, and its enabling guide says Unity uses the first API in the list and falls back down it, so the safe order is WebGPU, then WebGL 2. Whatever you pick, replace the default error text in your template with something a player can act on.

Symptom to cause

Black or blank canvas, no error. A context was created but the GPU isn't drawing. Usual causes: a context lost right after creation, a GPU that can't handle the shader, or a privacy extension that spoofs WebGL. Try a private window with extensions off, then read the console for "context lost" or shader compile errors.

"WebGL context lost" mid-game. MDN's context loss notes list the reasons: pages competing for the GPU, a laptop switching between integrated and discrete GPUs, the browser resetting the GPU to break a stall from another tab, or a driver updating in the background. Close other GPU-heavy tabs, plug the laptop in so it stops switching GPUs, and reload. If it happens every time, the game is running out of GPU memory on your device, which is a game bug rather than a browser setting.

Runs at 1 to 5 fps. Software rendering. Check the renderer for SwiftShader, llvmpipe or "Software", then fix acceleration or drivers. On a phone, a 3x device pixel ratio means nine pixels drawn per CSS pixel, and a game that doesn't cap its resolution will crawl, which is on the developer.

WebGPU missing on a machine with working WebGL 2. Check the table first. Then the URL: navigator.gpu is undefined on plain http:// pages. Then look for a WebGPU line in Graphics Feature Status. On Linux Chrome and non-Windows Firefox the answer is usually "not on this platform yet".

For developers: detect, fall back, and tell the player

Detect both APIs before loading anything heavy, and make the failure path a message rather than a blank page. MDN's pattern for WebGPU is to check navigator.gpu, then call requestAdapter(), which resolves to null when no adapter is available. For WebGL, getContext('webgl2') returns null on failure.

async function pickRenderer(canvas) {
  if (navigator.gpu) {
    const adapter = await navigator.gpu.requestAdapter()
    if (adapter) return { api: 'webgpu', adapter }
  }
  const gl2 = canvas.getContext('webgl2', { failIfMajorPerformanceCaveat: true })
  if (gl2) return { api: 'webgl2', gl: gl2 }
  const gl2soft = canvas.getContext('webgl2')
  if (gl2soft) return { api: 'webgl2', gl: gl2soft, software: true }
  return { api: null }
}

Two details matter. failIfMajorPerformanceCaveat: true makes getContext fail instead of handing you a software-rendered context, so you can detect "this will run at 2 fps", warn the player, and then decide whether to accept the software context anyway. And a canvas holds exactly one context type, so decide before you create it or use separate canvases. requestAdapter() also accepts featureLevel: 'compatibility', a restricted WebGPU subset for OpenGL ES 3.1 and Direct3D 11 class hardware.

Handle context loss too. Listen for webglcontextlost, call preventDefault() so the browser knows you intend to recover, and rebuild GPU resources in webglcontextrestored. Games that skip this show the "black canvas, no error" symptom every time a laptop switches GPUs.

canvas.addEventListener('webglcontextlost', (e) => {
  e.preventDefault()
  pauseGame()
})
canvas.addEventListener('webglcontextrestored', () => {
  recreateGpuResources()
  resumeGame()
})

Tell the player something useful. "WebGL 2 not supported" is a dead end for a twelve-year-old on a school Chromebook. A better message names what you detected (browser, OS, whether WebGL 1 worked, whether the renderer looked like software), gives the one-line fix for their browser, and links to a page like this one or the checker so they can confirm the fix. Log the same result to analytics, because the share of players failing WebGL 2 tells you whether a lighter fallback is worth building.

Engines handle most of this. Three.js's WebGPU renderer, Babylon.js and PlayCanvas fall back to WebGL 2 automatically, and the web games tech stack guide covers which does what. If you're writing to the APIs directly, the WebGPU getting started and WebGL fundamentals tutorials both start from a working detection block.

Common Questions

How do I check if WebGPU is enabled in my browser?

Open the WebGL and WebGPU checker, which reports WebGPU as supported or not along with the adapter vendor and architecture. In Chrome or Edge, chrome://gpu lists WebGPU under Graphics Feature Status, and in the console navigator.gpu is undefined when the API isn't exposed. It only works on HTTPS pages.

How do I enable WebGL in Chrome?

Go to Settings, System, turn on "Use graphics acceleration when available", and relaunch Chrome. Then open chrome://gpu and confirm WebGL and WebGL2 say "Hardware accelerated". If they don't, update your GPU driver, and as a last resort enable chrome://flags/#ignore-gpu-blocklist.

How do I enable WebGPU in Firefox?

On Windows it's on by default since Firefox 141, and on Apple Silicon Macs since Firefox 145 (macOS 26) and 147 (all supported macOS versions). On Linux, Intel Macs and Android it hasn't shipped: the dom.webgpu.enabled preference in about:config exposes the unfinished build, and Firefox Nightly has it on by default, so use Nightly if you need it there today.

Does Safari support WebGPU?

Yes, since Safari 26.0 (September 15, 2025) on macOS Tahoe, Sequoia and Sonoma, iOS 26, iPadOS 26 and visionOS 26, on by default. Safari 17 and 18 had it behind a feature flag under Settings, Advanced, "Show features for web developers". WebGL 2 needs Safari 15 or newer.

Why does WebGL say blocked or software rendering when hardware acceleration is on?

Your GPU or its driver is on the browser's blocklist, so the browser refuses it even with acceleration enabled. chrome://gpu under "Problems Detected" or Firefox's about:support Graphics section names the entry. Update the driver from the GPU maker, and if the block is stale, override it with chrome://flags/#ignore-gpu-blocklist or Firefox's webgl.force-enabled.

Why is my Unity WebGL game not working in the browser?

If the page shows "Your browser does not support graphics API WebGL 2", the browser couldn't create a WebGL 2 context. Turn on hardware acceleration, update the GPU driver, make sure you're not in a VM or remote desktop session, and on Safari update to version 15 or newer. If the checker shows WebGL 2 working but the game still fails, open the game's URL directly rather than inside an embedded frame.

Does WebGL 2 work in Chrome on Android?

Yes, since Chrome 58, so on any current phone it works unless the GPU driver is blocklisted, which you fix with a system update or chrome://flags/#ignore-gpu-blocklist. WebGPU is separate: Chrome 121+ on Android 12+ with ARM, Qualcomm or Intel GPUs, Chrome 139+ for Imagination GPUs on Android 16+, and Samsung Xclipse GPUs are still in progress.

Related

• WebGL Test and WebGPU Checker: see what your browser actually exposes, with GPU name and limits
• WebGPU vs WebGL for Games (2026): what the two APIs are and which to build on
• Web Games Tech Stack in 2026: WebGL, WebGPU and Wasm, and which engines use which
• WebGPU getting started: your first WebGPU code, starting from detection
• WebGL fundamentals for games: the baseline API, with code
• Cross-Origin Isolation Checker: the other "why won't this game load" test, for SharedArrayBuffer and threads

Last updated: September 2026.

"AI animation generator" means three different things in 2026, and picking the wrong kind is the most common way to waste an afternoon. Text-to-motion tools turn a sentence ("a person crouches, then leaps forward") into skeletal animation, and Cinevva's Prompt Animations does that in the browser with BVH and GLB export on a free account. Video motion capture tools (DeepMotion, Plask, Rokoko Vision) turn a phone video of you moving into animation, which is the right tool when you can perform the motion yourself. Auto-rig plus library tools (Meshy, Tripo, Mixamo, and our own Animation Library) don't generate motion at all; they rig your model and apply one of hundreds of existing clips, which covers most of what a game actually needs. Cascadeur sits apart as AI-assisted keyframing for people who want to animate by hand, faster.

Here's each tool, what it produces, what it costs and what you can ship, from their pages in September 2026.

Quick picks

• A motion that doesn't exist yet, from a sentence: Cinevva Prompt Animations. Text to motion, 1 to 10 second clips, retargets onto your humanoid GLB, exports BVH or GLB. Free account.
• Walk, run, idle, attack, and 250 more, on your own model, for free: Cinevva Animation Library. 260 CC0 motions retargeted in the browser.
• You can perform the motion: Rokoko Vision (free, single camera) or Plask (free 15 seconds a day, then $18 a month).
• Video mocap with hands and face: DeepMotion Animate 3D. Free 60 seconds a month for non-commercial use, paid from $15.
• Rig a generated model and animate it in one place: Meshy. 600+ preset clips, auto-rig in under 30 seconds, FBX and GLB.
• Hand animation with physics doing the hard part: Cascadeur. Free version, Indie plan around €12 a month.
• The classic free library: Mixamo. Thousands of clips, free with an Adobe account, in maintenance mode.
• Skip the pipeline: describe the game in the game creator and the characters arrive animated.

Quick reference

The three kinds, and which one you need

Text to motion is the newest and the one the phrase "AI animation generator" usually means. You write what the body does, a model trained on motion capture produces a skeletal clip, and you retarget it onto your character. It's the only route to a motion nobody has captured: your specific creature's attack, a stylised victory dance, a fall that matches your level geometry. Quality varies with how concrete the prompt is ("crouches and slowly stands up" works, "stand-up animation" doesn't), and clips are short, one to ten seconds.

Video motion capture replaces the mocap suit with a phone. You act the motion, the tool tracks your body (and on some tiers hands and face) and exports a clip. It's the right tool when the motion is human, you can perform it, and you want it to feel like a person rather than a preset. The failure mode is foot sliding and jitter on fast motion, which the paid tiers smooth.

Auto-rig plus library is the boring answer and the one that covers 80% of a game: the character walks, runs, idles, jumps, swings and dies, and every one of those has been captured a thousand times. Upload a model, get a skeleton with skin weights, pick from the library, export. Where the tools differ is licence and price of the clips, and whether the rigger handles your model at all.

Most games use all three. The library for locomotion, video mocap for the cutscene gesture, text to motion for the one move that makes the game yours.

Cinevva Prompt Animations

Our Prompt Animations tool is text to motion in the browser. Describe a movement, watch it play on a stick figure, then drop in a rigged humanoid GLB and it auto-detects the skeleton (Mixamo, Tripo, Reallusion, Unreal and generic humanoid naming) and retargets the motion onto your character. Clips run from 1 to 10 seconds. Export is BVH for Blender, Maya, Cascadeur or Unreal, or a GLB with the animation baked in for Unity, Godot, Three.js and Babylon.js. It runs on a free account and the output is yours.

Prompts that work describe the body concretely and one action at a time. "A person picks up a heavy box from the floor and carries it forward" beats "carry animation". Generate three or four variations, keep the best, and clean the foot contacts in your editor if the motion is fast.

Cinevva Animation Library

The Animation Library is the library half of the same pipeline. Upload a rigged GLB or FBX and preview 260 CC0 character animations retargeted onto it in the browser, walk and run cycles, combat, traversal, emotes, reactions. Nothing is uploaded to a server; the retargeting runs locally. Preview is free on your own model, and exporting the GLB with the clips baked in is part of the Standard and Pro plans. Because every clip is CC0, there's no attribution and no redistribution worry, which is the thing Mixamo can't offer.

If your model isn't rigged yet, the Auto Rigger does that first, for humanoids and quadrupeds, and hands the result straight to the library. Blender users can skip the browser: the Cinevva Rig add-on rigs on your own machine and plays the same 260 clips on the result inside Blender.

Meshy and Tripo

Both are text-to-3D generators that grew animation features, and both take the auto-rig plus library approach. Meshy auto-rigs humanoid, biped, quadruped and stylised characters in under 30 seconds and offers more than 600 preset clips (walks, combat, idles, emotes, jumps, dances), exporting FBX or GLB with conventional bone hierarchies. The free plan is 100 credits a month with CC BY 4.0 output, so credit Meshy if you ship it; Pro at $20 a month gives full ownership. Neither Meshy nor Tripo generates motion from text.

Tripo's animation works the same way: generate or upload, auto-rig, apply from its library, download FBX with animation data or GLB. If you're already generating models in either, animating them there is convenient. If you aren't, our library does the same job on a model from anywhere, with CC0 clips.

Mixamo

Mixamo is the library everyone started with: thousands of motion-captured clips, an auto-rigger, free with an Adobe account. The licence allows commercial use in games with no attribution. What it doesn't allow is redistributing the raw animation files, which matters if you're building a tool or an asset pack rather than a game. Adobe has kept it running without adding to it for years, so treat it as a fixed catalogue. It exports FBX only, and its auto-rigger is humanoid only.

DeepMotion Animate 3D

DeepMotion is the most complete video-mocap tool for a solo developer. Film yourself, upload, and get body animation with optional hand and face tracking, exported as FBX, GLB or BVH. Pricing is by credit, one credit per second of animation or per 3D pose, with hands and face costing half a credit each on top. The free tier is 60 seconds a month for personal, non-commercial use. Paid plans run from about $15 to $300 a month, with the higher tiers adding resolution, frame rate, smoothing and priority, and a Studio plan with unlimited credits at lower priority past a threshold. Commercial rights come with the paid plans.

Plask and Rokoko Vision

Plask is browser-based video mocap with full body and hand capture, multi-person tracking, and FBX, GLB and BVH export. The free tier is 15 seconds of capture a day with 1 GB of storage. Standard is $18 a month billed annually for 10 minutes of capture a month, Pro is $50 for an hour. Check the terms for commercial use on the tier you pick; the pricing page doesn't state them.

Rokoko Vision is the free option from a company that sells mocap suits. Single-camera video capture is free, dual-camera capture needs a paid subscription, and the output drops into Rokoko Studio (also free) for cleanup and FBX or BVH export. For a first pass at "does video mocap work for my game", it's where to start.

Cascadeur

Cascadeur is animation software, not a generator, and it's here because its AI is doing something the others don't: making hand keyframing fast. AutoPosing fills in a believable pose from a few controllers, AutoPhysics makes jumps, falls and spins obey gravity and momentum, and the result is that a non-animator can produce a physically plausible action sequence in an afternoon. It also imports video mocap for cleanup.

There's a free version for learning and non-commercial use, an Indie plan at around €12 a month for developers under a revenue cap, and a Pro plan at around €49. Prices here are from Cascadeur's published plans as reported in 2026; check the current page, since the tiers have changed more than once.

Motorica

Motorica generates locomotion by synthesising from motion-capture data with style controls: pick a walk, choose from more than 150 styles or supply your own capture, draw a path, and get a grounded, reactive clip that blends styles without the foot sliding that stitching library clips produces. It targets studios (Epic is a customer), integrates with Unreal, Unity, Godot, Maya and Blender, and offers a Free Lite tier with pricing for the rest by demo. If your game's feel depends on locomotion variety, it's the specialist.

How to judge a generated clip in 30 seconds

• Watch the feet. Sliding, floating or a foot that passes through the floor is the most common defect in every kind of tool. Our free animations and rigging guide explains why it happens and how a retargeter fixes it.
• Watch the hips. A generated motion whose pelvis bobs or drifts reads as drunk. Good clips keep the root steady and let the limbs do the work.
• Loop the cycle. Walks and runs must return to their first pose. Trim to the cycle in an editor, or use a tool that exports loops.
• Check the rig it expects. BVH is universal; a GLB with baked animation is tied to the skeleton it was made on. Retarget before you judge.
• Check the licence on the clip, not the tool. Library clips carry their own terms. CC0 and Mixamo are fine in a game; Meshy's free tier needs attribution.

Licences in 30 seconds

• Cinevva Prompt Animations: output is yours. Animation Library: CC0 clips, anything, no credit.
• Mixamo: commercial use in games, no attribution, no redistributing the files.
• Meshy free tier: CC BY 4.0. Paid: yours. Tripo: check the tier.
• DeepMotion free tier: non-commercial. Paid: commercial.
• Plask, Cascadeur Indie: read the current terms and revenue caps.
• Rokoko Vision: free single-camera output is yours to use.

Common Questions

What is the best AI animation generator for 3D characters?

For text to motion, Cinevva's Prompt Animations, free in the browser with BVH and GLB export. For video mocap, DeepMotion for completeness or Rokoko Vision for free. For rigging and standard motions, Meshy if you generate models there, or Cinevva's Animation Library with 260 CC0 clips on any model.

Can AI generate 3D animation from text?

Yes. Text-to-motion models trained on motion capture produce short skeletal clips from a description. Results are best for concrete, single-action prompts of one to ten seconds, and they need retargeting onto your character's skeleton, which the better tools do for you.

Is there a free AI animation generator?

Cinevva's Prompt Animations and Animation Library preview are free. Rokoko Vision is free for single-camera capture. Mixamo is free with an Adobe account. DeepMotion and Plask have small free tiers for non-commercial use.

Do I need a rigged character?

For text to motion and libraries, yes, a humanoid rig with standard bone naming. If your model isn't rigged, an auto-rigger does it in a minute: Cinevva's Auto Rigger, Meshy, Tripo or Mixamo. Video mocap tools export the animation on their own skeleton and you retarget from there.

Can I use Mixamo animations in a commercial game?

Yes, with no attribution. You can't redistribute the raw Mixamo files as assets or in a tool. That distinction is why Cinevva's library ships CC0 clips only.

Related

• Free Character Animations and Auto-Rigging - the library and rigging side in depth
• Best AI 3D Model Generators - where the characters come from
• Free Rigged 3D Character Models for Games - characters that arrive rigged and animated
• Cinevva Prompt Animations - text to motion, BVH and GLB export
• Cinevva Animation Library - 260 CC0 clips retargeted in the browser
• Cinevva Auto Rigger - rig a static model first
• Free 3D character models - browse the free library

Last updated: September 2026.

The best AI skybox generator in 2026 is Blockade Labs' Skybox AI if you need production 8K panoramas with a Unity plugin and a paid plan behind them, and Cinevva's Skybox Generator if you want 8K 360° skies with depth maps on a free account and in the browser. Hyper3D's OmniCraft is the one to try when you need a true 32-bit HDR file for lighting rather than a backdrop. And for realistic skies, the free CC0 libraries at Poly Haven and ambientCG are still better than anything generated, because they're photographs.

A skybox is one of the highest-leverage assets in a 3D game. It's a single image, it fills most of the pixels on screen in any outdoor scene, and it sets the mood before the player has moved. It's also one of the assets AI is genuinely good at, because a sky has no topology to get wrong. Here's what each tool produces, what it costs, and what a browser game can actually use, checked in September 2026.

Quick picks

• Production skyboxes with engine plugins: Blockade Labs Skybox AI. 8K, Unity plugin, Blender and Unreal export, from $20 a month.
• 8K skyboxes with depth maps, free account, in the browser: Cinevva's Skybox Generator.
• A real HDR file for image-based lighting: Hyper3D OmniCraft. 8K PNG plus a 32-bit EXR and a depth map per unlock.
• Realistic skies for free: Poly Haven and ambientCG HDRIs, CC0, hundreds of them.
• Stylised skies for free: Kenney's Skyboxes pack, CC0, five cubemaps in the Kenney style.
• The game around the sky: describe the scene in the game creator and it generates the sky with the level.

Quick reference

What a game needs from a skybox

Three properties decide whether a generated sky is usable, and the marketing pages rarely mention them.

Projection. Almost every generator outputs an equirectangular panorama, a 2:1 image that wraps around a sphere. Three.js, Babylon.js, PlayCanvas and Unity all load it directly. Older pipelines and some mobile-first engines want a cubemap, six square faces, which you convert from the equirect in Blender or with a small script. Kenney's pack ships as cubemaps.

Dynamic range. A standard PNG or JPG skybox is a backdrop: it looks like a sky but can't light the scene. A 32-bit HDR (EXR or .hdr) carries the real brightness of the sun and is what image-based lighting uses to make a chrome sphere look like it's outdoors. If you want the sky to light your models, you need HDR. Blockade's Standard tier, OmniCraft and the photo libraries provide it. Cinevva's generator and most others produce LDR.

Resolution and size. 8K sounds like the number to want, and for a browser game it's usually too big. An 8K equirect is 8192 by 4096 pixels, which is 128 MB uncompressed and 10 to 20 MB as a JPG, on a page that's already loading a game. Most web games ship a 4K sky compressed to KTX2, which the KTX2 Texture Compressor does in the browser. Generate at 8K if it's offered, then downscale for the web.

Seams. The left and right edges of the equirect have to meet. Every dedicated tool here handles that. A general image generator prompted for "360 panorama" almost never does, and the seam sits right where the player turns around.

Blockade Labs Skybox AI

Skybox AI is the established name. It generates seamless 360° environments from a text prompt and a rough sketch, in dozens of art styles, and it's built for pipelines: a native Unity plugin, direct exports to Blender and Unreal, MCP support, and a Business tier with full API access.

The free plan is 5 credits a month and is preview only, with no exports, so it's for evaluating the tool rather than using it. Essential is $20 a month per seat on an annual plan (or $24 month to month) for 100 credits and 8K exports. Standard, at $48 annual or $60 monthly, adds 300 credits, HDRI lighting output and 3D skybox meshes, which is the tier a game project actually wants. Business, at $112 to $140, raises resolution to 16K and adds the API. Every paid plan carries a full commercial licence.

It's the tool to pay for if you're producing skies for a shipped game in Unity or Unreal and want them in the engine in a click. For a browser game the 8K export needs downscaling anyway, so the resolution advantage matters less than the style range and the depth and mesh options.

Cinevva Skybox Generator

Our own Skybox Generator produces 8K 360° skyboxes from a text description, in multiple art styles, with a depth map for parallax and 3D integration. It runs in the browser on a free account and the output is yours.

What it doesn't do is HDR: the skies are LDR images, so they're backdrops rather than light sources. For a stylised game that's rarely a problem, because stylised games light their scenes with a couple of directional lights and use the sky for mood. For a realistic outdoor scene where you want the sun in the sky to be the light on the ground, use an HDR source from the next two sections.

If the sky is part of a game you're building rather than an asset on its own, the game creator generates it as part of the scene when you describe the setting ("a desert canyon at golden hour").

Hyper3D OmniCraft

Hyper3D, the company behind the Rodin 3D generator, has an HDRI generator inside its OmniCraft toolset. It turns a prompt or a reference image into a seamless equirect, previews it as a skybox in a live viewer, and on unlock hands you three files: an 8K PNG, a 32-bit EXR for lighting, and a panoramic depth map. Previews and regenerations are free; unlocking the full pack costs one credit for regular members or is included on a subscription, with a 7-day trial.

That EXR is the reason to use it. It's the only AI generator here that gives you a real HDR lighting file on the entry tier. Check the terms of use for the commercial licence before shipping, since the page doesn't state it as plainly as Blockade does.

A few other sites offer "free AI HDRI generators" with bold claims about commercial rights and hundreds of millions of generations. Treat those numbers as marketing. Generate a preview, check the seam and the sun, read the terms, and only then rely on it.

The free libraries

For a realistic sky, a photograph beats a generation, and the two big CC0 libraries are the answer.

Poly Haven has several hundred HDRIs shot with a proper bracketed workflow, at resolutions up to 16K and beyond, all CC0. They're categorised by time of day, weather and location, and each one comes with a tone-mapped preview so you can judge the mood before downloading. For image-based lighting there is nothing better at any price.

ambientCG is the other CC0 source, with a smaller but growing HDRI collection alongside its textures, also up to 16K.

Kenney's Skyboxes pack is five stylised cubemap skies, day and night variants, CC0, in the same flat style as Kenney's models. If your game uses Kenney assets, it's the matching sky.

Our free HDRI skies, sunset, night and studio HDRI pages let you browse these by mood, and the free textures and HDRIs guide covers the libraries in depth.

How to judge a generated skybox in 30 seconds

• Load it on a sphere and turn around. The seam is behind you. Every dedicated tool passes; general image generators don't.
• Look straight up and straight down. The poles of an equirect are where generators pinch and smear. A good sky has a clean zenith and a plausible ground or horizon fog at the nadir.
• Find the sun. If there's a sun, there should be one, with a plausible position relative to the lighting on the clouds. Two suns, or lit clouds with no source, is a common failure.
• Check the horizon line. It should sit exactly at the vertical centre of the image. A tilted or offset horizon makes the whole scene feel wrong without the player knowing why.
• Check the file you'll ship. 4K KTX2 for the web. If the tool only gives you 8K JPG, downscale before you compress.

Licences in 30 seconds

• Blockade Labs: commercial licence on every paid plan. The free plan can't export at all.
• Cinevva Skybox Generator: output is yours.
• Hyper3D: read the current terms.
• Poly Haven, ambientCG, Kenney: CC0. Anything, no credit.

Common Questions

What is the best AI skybox generator?

Blockade Labs Skybox AI for a paid production pipeline with engine plugins, Cinevva's Skybox Generator for free 8K skies with depth maps in the browser, and Hyper3D OmniCraft when you need a real HDR file for lighting.

Is there a free AI skybox generator?

Cinevva's Skybox Generator runs on a free account. Blockade's free plan previews but can't export. Hyper3D previews free and charges a credit to unlock. For fully free skies, Poly Haven, ambientCG and Kenney are CC0.

Can I use AI skyboxes in a commercial game?

Yes, on Blockade's paid plans and with Cinevva's generator. Check Hyper3D's terms. The CC0 libraries have no restrictions at all.

Do I need an HDR skybox?

Only if you want the sky to light the scene through image-based lighting. For a backdrop behind a stylised game lit with directional lights, an 8-bit skybox is fine and much smaller.

What resolution skybox should a browser game use?

4K (4096 by 2048) compressed to KTX2 is the usual ceiling. 8K is 10 to 20 MB even as a JPG, which is too much for a web page to load before the player can move.

Related

• Free PBR Textures, Materials and HDRIs for Games - Poly Haven and ambientCG in depth
• Best AI Texture Generators for Games - the ground under the sky
• Best AI Asset Generators for Games - the whole AI asset stack
• Cinevva Skybox Generator - 8K skies with depth maps on a free account
• KTX2 Texture Compressor - shrink the sky before it hits a web build
• Free HDRI skies, sunset, night and studio HDRIs - browse the free library

Last updated: September 2026.

The best AI sound effect generator for a game is ElevenLabs if you want punchy, game-style one-shots from a short prompt (impacts, footsteps, UI clicks, spell casts, gunfire), and Adobe Firefly if you already live in Premiere and want to act the timing of a sound into a microphone. Stable Audio is stronger on layered textures and ambient beds than on single hits. Krotos Studio isn't a generator at all, it's performed sound design over real recordings, and it belongs in the comparison because it's what people reach for after prompt-based tools burn them. And the free CC0 libraries are still the right answer for the sounds every game needs, because a recorded door is a recorded door.

Sound is the asset category where AI generation has quietly become good enough. A prompt like "heavy wooden chest opening, creak then thud" gets you a usable clip in seconds from three different services, and the questions that matter are the boring ones: what does a generation cost, can you ship it commercially, and how do you get a clean loop. Here's each tool, with prices and licence terms from their pages in September 2026.

Quick picks

• Game one-shots from a prompt: ElevenLabs. Fast, forgiving prompts, 200 credits a generation.
• The same model on a free account, in the browser, with exact durations: Cinevva's Sound Effects Generator, 0.5 to 30 seconds per clip.
• Perform the timing yourself: Adobe Firefly. Describe the sound, then act its rhythm into a mic. 10 credits a generation.
• Ambient beds and layered textures: Stable Audio. Longer clips, more structure, commercial rights on the $12 tier.
• Hands-on control instead of prompts: Krotos Studio. Real recordings shaped live, game rights on the Pro plan.
• Free and offline: Meta's AudioGen, but only for non-commercial work.
• Free and recorded: Freesound and the CC0 packs in our free sound effects guide.
• Skip the audio pipeline: describe the game in the game creator and it generates the sound effects with the game.

Quick reference

What an AI sound effect has to get right

Before the tools, the four things that separate a usable game SFX from a demo.

The transient. A hit, a click or a footstep lives in its first 20 milliseconds. Generators that smear the attack produce sounds that feel late no matter how you time them. Listen to the onset at half speed before you listen to anything else.

The tail. Game sounds end. A generated clip that fades into two seconds of room tone or noise floor has to be trimmed, and if the noise floor is high the trim is audible. Prompt for "dry, no reverb" and add the space in the engine.

Loop points. Ambiences, engines and hums need to loop without a click. Only Stable Audio produces clips long enough to find a clean loop region in; for the others, generate ten seconds and crossfade the ends in an editor.

Format and size. Every service hands you MP3 or WAV. A browser game wants OGG or Opus at 48 to 96 kbps, and a one-shot should be under 50 KB. Convert before it goes near a build. Our Web Audio API tutorial covers loading and playing them.

ElevenLabs Sound Effects

ElevenLabs is better known for voices, and its sound effects model has become the default for game one-shots because it understands game vocabulary: "8-bit coin pickup", "sci-fi door hiss", "sword unsheathe, metallic ring" all land close to what you meant on the first try. Generations are fast and the prompt control is forgiving.

Pricing is by credit across the whole platform. The free plan is 10,000 credits a month, Starter is $6 for 30,000, Creator is $22 for 121,000 and Pro is $99 for 600,000. A sound effect generation costs 200 credits, so the free plan is about fifty generations a month and Starter about 150. The catch on free is the licence: commercial use starts at Starter, so nothing generated on the free plan can go in a released game.

Its weaknesses are the other side of its strengths. Long, evolving ambiences aren't the point, and it produces one clip per prompt with no way to perform or shape it after the fact.

Cinevva Sound Effects Generator

Our Sound Effects Generator runs the same class of prompt-to-audio model in the browser on a free account, with two things the raw service doesn't give you: an exact duration control from 0.5 to 30 seconds, so a footstep is a footstep and not a footstep plus a second of silence, and a prompt-influence slider that trades literal interpretation for variation when you want five different versions of the same hit. The output is yours.

It's also the tool the game creator uses when it builds a game: describe the game and the sound effects are generated and wired to events along with the code, the models and the music. If you found this page because a game needs sounds rather than because you're building a sound library, that's the shorter path.

Adobe Firefly Generate Sound Effects

Firefly's sound effects tool went broadly available in August 2026 alongside Adobe's music and speech generation, and it has one feature nobody else does: you describe the sound, then record yourself acting its timing and intensity into a microphone ("whoosh... whoosh... BANG") and the generated effect follows your performance. For anything that has to hit on a visual beat, that's the fastest workflow on this list.

Firefly Standard is $9.99 a month for 2,000 generative credits, Pro is $29.99 for 7,000 and Premium is $199.99 for 50,000. Sound effects cost 10 credits a generation, so even Standard is 200 sounds a month, far more per dollar than ElevenLabs. There's a free tier with a limited number of credits. Adobe describes the audio outputs as commercially safe, trained on licensed and public domain material, which is the strongest licence statement in this comparison.

The trade-off is that it lives inside Adobe's ecosystem. If your work happens in Premiere and After Effects, it's the obvious pick. If it doesn't, the round trip is a tax.

Stable Audio

Stability's audio model competes on control rather than snap. It produces clips up to three minutes on paid plans, with more structure and layering than the one-shot tools, which makes it the one to reach for when you need an ambient bed (rain on a tin roof, cave drips, a distant crowd) that has to loop and evolve.

The free tier is reported as ten clips a month cropped to 30 seconds for personal use only, and free credits have been unavailable to new signups in some regions. The Professional plan is $12 a month for around 500 tracks with commercial use included for individuals under a revenue cap, and there's a higher tier around $30. Stable Audio Open, the open-weights model, runs locally for free under Stability's community licence, which permits commercial use below a revenue threshold you should read before relying on it.

For single hits and UI sounds it's overkill and slower than ElevenLabs. For everything longer than five seconds it's the better tool.

Krotos Studio

Krotos Studio is here because it's the answer to "AI sound effects sound samey and I can't control them". It isn't generative. It's a library of real recordings you perform live through XY pads while watching your footage, plus a video-to-sound mode that analyses picture and lays matching effects from the library. The result is that the sound is under your hands rather than behind a prompt.

There's no free tier, only a five-day trial. Studio is $19.99 a month, or $9.99 a month billed annually, and its licence covers YouTube, social and client work. Games need Pro, at $49.99 monthly or $23.33 annually, which adds commercial rights for film, TV, games and advertising, stem access and the plugin versions. Max, at $83.33 a month annually, adds a 60,000-effect library and broadcast clearance.

If you have more than a few dozen sounds to design and you care how they feel rather than how fast they arrive, this is the professional's tool on the list.

Meta AudioGen

AudioGen is the text-to-sound model in Meta's AudioCraft release. The code is MIT licensed and the weights are free to download, so it runs on your own GPU with no account and no per-generation cost. The quality is a generation behind the commercial services and clips are short.

The reason it's last is the licence. The model weights are released under CC BY-NC 4.0, which forbids commercial use, so anything it generates can't ship in a game you sell or monetise. It's a research and prototyping tool, and a fine one.

The free libraries

For the sounds every game needs (doors, footsteps, UI, weather, impacts), a recording beats a generation, and the CC0 sources are large. Freesound has hundreds of thousands of clips with a licence filter, Kenney's audio packs are CC0 and game-ready, and the Sonniss GDC bundles are tens of gigabytes of professional recordings, royalty-free. Our Free Sound Effects and Music for Games guide covers all of them with the licence terms checked, and the free footstep, UI, explosion and ambient pages let you browse by category.

The working pattern most small teams settle on: library for the everyday sounds, generation for the ones that don't exist yet (the alien door, the magic spell, the specific creature), and an editor to make the two sit together.

Licences in 30 seconds

• ElevenLabs free plan: no commercial licence. Starter and up: yes.
• Adobe Firefly: commercially safe on every plan, per Adobe.
• Stable Audio free tier: personal only. Professional and up: commercial under a revenue cap. Stable Audio Open: community licence, read the threshold.
• Krotos Studio: games need Pro or Max. Studio covers video and social only.
• Meta AudioGen: weights are CC BY-NC. No commercial use.
• Cinevva Sound Effects Generator: output is yours.
• Freesound and CC0 packs: per clip. Filter for CC0 and it's anything, no credit.

Our Game Asset Licenses Explained guide covers CC0, CC BY and royalty-free in depth, and all of it applies to audio.

Common Questions

What is the best AI sound effect generator for games?

ElevenLabs for one-shots from a prompt, Adobe Firefly if you want to perform the timing, Stable Audio for ambient beds and anything longer than a few seconds. Cinevva's Sound Effects Generator gives you the one-shot workflow on a free account with exact duration control.

Is there a free AI sound effect generator?

Cinevva's Sound Effects Generator runs on a free account. ElevenLabs' free plan gives about fifty generations a month but no commercial licence. Firefly has limited free credits. Meta's AudioGen is free to run locally but non-commercial. For free sounds you can ship, the CC0 libraries are the answer.

Can I use AI sound effects in a commercial game?

Yes, on ElevenLabs Starter and up, every Firefly plan, Stable Audio Professional and up, and Krotos Pro and up. Not from ElevenLabs' free plan, Stable Audio's free tier, or AudioGen. Keep a record of which sounds were generated where, since some storefronts ask.

How do I make AI sound effects loop?

Generate longer than you need (Stable Audio is the tool for this), find a region where the start and end are similar, and crossfade the last 50 to 100 milliseconds into the first in an editor like Audacity or Reaper. Prompting for "seamless loop" rarely produces one on its own.

What format should game sound effects be?

OGG Vorbis or Opus at 48 to 96 kbps for browser games, with one-shots under 50 KB. Every generator outputs MP3 or WAV, so convert before you ship. Our Web Audio API and Tone.js tutorials cover loading and playback.

Related

• Free Sound Effects and Music for Games - the recorded, CC0 alternative
• Best AI Music Generators for Games - the music side of the same question
• Best AI Asset Generators for Games - the whole AI asset stack
• Game Asset Licenses Explained - what a free tier actually lets you ship
• Cinevva Sound Effects Generator - prompt to sound, 0.5 to 30 seconds, free account
• Web Audio API for games - loading and playing the clips
• Free footstep, UI, explosion and ambient sounds - browse the free library

Last updated: September 2026.

The best free rigged 3D characters for games come from four sources that ship them already animated: KayKit's character packs (CC0, five rigged adventurers with weapons in the free tier), Quaternius's Ultimate Animated Character Pack (50-plus animated characters), Polygonal Mind's 100 Avatars (167 rigged CC0 characters across two rounds), and Kenney's animated character packs (CC0, in Kenney's blocky style). Mixamo adds a few dozen rigged humanoids free with an Adobe account, and Poly Pizza and Sketchfab's CC0 filter cover thousands more if you're willing to sort. Everything here is free for commercial use. Where a licence has a condition, I've said so.

A rigged character is the difference between a model and a game. A skeleton with skin weights means it can walk, and a model that arrives with animations means it walks today. Here's every source worth bookmarking, what each pack actually contains, and what to do when the character you want has no bones.

Quick picks

• Complete, consistent, ready to drop in: KayKit Character Pack: Adventurers (CC0). Five rigged, textured, animated characters plus 25 weapons and accessories, free; three more for $7.95.
• The biggest single animated set: Quaternius Ultimate Animated Character Pack. 50-plus animated characters, FBX, OBJ and Blend, free.
• Realistic-proportion humanoids that work with Mixamo clips: 100 Avatars R1 and R2 (CC0), 167 rigged characters in FBX and glTF.
• Blocky and cheerful, matches every other Kenney pack: Kenney's Animated Characters (CC0).
• A rigged base to test your pipeline: Mixamo's character roster, free with an Adobe account.
• Thousands to sort through: Poly Pizza and Sketchfab, filtered to CC0.
• A character with no rig: Cinevva's Auto Rigger, free in the browser, then the Animation Library for 260 CC0 clips.
• Skip the asset hunt: describe the game in the game creator and the characters arrive rigged and animated.

Quick reference

KayKit

Kay Lousberg's KayKit packs are the best-organised free characters in game development. The Character Pack: Adventurers gives you five fully textured, rigged and animated fantasy characters with basic movement animations and more than 25 weapons and accessories, in FBX and glTF for Unity, Godot, Unreal and Roblox. The EXTRA tier adds three more characters for $7.95 and the SOURCE tier adds the Blender files for $11.95, but the free tier is a complete, shippable set.

The Character Animations pack is a separate free download of additional clips that fit every KayKit character, and the Skeletons and other character packs share the same rig, so animations carry across. Everything KayKit publishes is CC0: personal and commercial use, no attribution. The models share a small gradient atlas texture (1024 pixels, and KayKit notes it can be shrunk to 128 without visible loss), which keeps a whole party of characters under a megabyte.

Quaternius

Quaternius has released hundreds of low-poly packs over a decade, and the Ultimate Animated Character Pack is the one to start with: more than 50 rigged characters with animations, in FBX, OBJ and Blend. The Animated Men, Women, Robot, Zombie, Knight and Alien packs each add a themed set on the same rig, and the Universal Base Characters and Modular Character Outfits packs let you build your own.

One licence note. Quaternius packs were CC0 for years and the pack pages still say so, but the site now publishes a Quaternius Asset Licence (QAL v1.0) that applies going forward: free for personal, educational and commercial projects including games, no attribution required, no fees or royalties, and you may not resell or redistribute the assets themselves as a standalone pack, stock file or template. For a game, nothing changes. For an asset tool or a bundle, read it. Patreon supporters get bonus source kits, but the packs above are free.

100 Avatars

Polygonal Mind's 100 Avatars project released two rounds of rigged low-poly humanoids under CC0, 73 in round one and 94 in round two, in FBX and glTF, on Sketchfab and Poly Pizza. They're humanoid-proportioned rather than chibi, which means Mixamo clips and our Animation Library retarget onto them cleanly, and the variety (professions, sports, fantasy) covers a crowd or a multiplayer roster without repeats. Being CC0, they're also the safest base for a character customiser, since you can redistribute modified versions.

Kenney

Kenney's character packs come in the same flat, blocky style as the rest of Kenney's CC0 catalogue, which is the point: if your props and environment are Kenney, these match. Animated Characters Protagonists, Animated Characters Retro and Animated Characters Survivors each ship rigged and animated characters in several formats, and Blocky Characters and Mini Characters add unanimated variants you can rig yourself. All CC0.

Mixamo

Mixamo is an animation library first, but it also hosts a few dozen rigged, textured humanoid characters that you can download with any of its clips applied, free with an Adobe account. The licence allows commercial use in games with no attribution and forbids redistributing the raw files, so the characters are fine in a shipped game and not fine in an asset pack. Adobe hasn't added to Mixamo in years, so what's there is what there is. It's the fastest way to get a rigged test character into a pipeline.

Poly Pizza and Sketchfab

Poly Pizza hosts more than 10,600 free low-poly models, including the archived Google Poly collection and years of community uploads, with a licence filter for CC0 and CC BY. Rigged characters are a minority and you'll sort, but the 100 Avatars bundles live there, and the site's own bundles collect character sets by creator.

Sketchfab still allows free downloads of models their creators marked downloadable, and its CC0 filter is the way to search it. Rigged and animated models show up in the filters too. Check each model's licence line before downloading, because CC BY and CC BY-NC are common and the second is off-limits for a game you sell.

Our free 3D character models page collects the packs above with their licences, and the Best Free 3D Model Sites guide covers the sources for everything that isn't a character.

When the character you want has no rig

Most of the free 3D models in the world are static. A downloaded character, a Sketchfab find, a model out of a generator: none of them arrive with a skeleton. Rigging by hand in Blender is a day's work for a beginner.

Cinevva's Auto Rigger does it in the browser for free: upload a GLB, FBX or OBJ, pick humanoid or quadruped, and get back a rigged GLB with skin weights. From there the Animation Library previews 260 CC0 clips on your character, and Prompt Animations generates a motion from a sentence when the library doesn't have it. If the character is already open in Blender, the Cinevva Rig add-on does the same rig and the same clips inside Blender, on your own machine, for a one-time $29 launch price. Our Free Character Animations and Auto-Rigging guide compares every auto-rigger, including Mixamo's and the ones inside Meshy and Tripo.

For the best result, upload a clean single mesh in a T-pose or A-pose with the arms away from the body. Characters with crossed arms, merged limbs or heavy skirts need a cleanup pass afterwards.

How to judge a rigged character in 30 seconds

• Play the walk. Feet should plant. Sliding or floating means the rig or the clip is off.
• Bend the elbows and knees. Pinching or candy-wrapper twisting at the joints means poor skin weights, which is fixable in Blender but tedious.
• Count the bones. Around 20 to 65 for a game humanoid. More than 100 means facial or finger bones you may not need and a heavier file.
• Check the bone names. Mixamo-style or Unreal-style naming retargets everywhere. A rig with Bone.001 names retargets nowhere.
• Look at the file size. A rigged low-poly character should be under 2 MB as a GLB. Larger means an oversized texture or an unoptimised mesh; the GLB Optimizer fixes both.

Licences in 30 seconds

• KayKit, 100 Avatars, Kenney: CC0. Anything, no credit, redistribute freely.
• Quaternius: free commercial use, no attribution, don't redistribute the assets as assets.
• Mixamo: commercial use in games, no attribution, no redistribution of the files.
• Poly Pizza, Sketchfab: per model. Filter for CC0; CC BY needs a credit line; CC BY-NC can't ship in a paid game.

Our Game Asset Licenses Explained guide covers the differences in depth.

Common Questions

Where can I get free rigged 3D characters for games?

KayKit, Quaternius, 100 Avatars and Kenney all ship rigged and animated characters free for commercial use. Mixamo adds rigged humanoids free with an Adobe account. Poly Pizza and Sketchfab have thousands more behind a CC0 filter.

Are free rigged characters OK for a commercial game?

Yes, from every source above. KayKit, 100 Avatars and Kenney are CC0. Quaternius and Mixamo permit commercial use in games without attribution but not redistributing the files themselves. Check per-model licences on Poly Pizza and Sketchfab.

Do free rigged characters come with animations?

KayKit, Quaternius and Kenney include animations. 100 Avatars are rigged for Mixamo-style clips. For any rigged humanoid, Cinevva's Animation Library retargets 260 CC0 clips in the browser, and Mixamo applies its library on download.

What if the character I want isn't rigged?

Auto-rig it. Cinevva's Auto Rigger handles humanoids and quadrupeds in the browser for free, Mixamo's rigger handles humanoids, and Meshy and Tripo rig models generated on their platforms.

What format should I download?

glTF or GLB for browser games and modern engines, since the mesh, textures, skeleton and animations travel in one file. FBX for Unity and Unreal pipelines and for anything heading into Blender for edits. The FBX to GLB converter handles the crossover.

Related

• Free Character Animations and Auto-Rigging - the clips and riggers in depth
• Best Free 3D Model Sites for Games - everything that isn't a character
• Best AI Animation Generators for 3D Characters - text to motion and video mocap
• Game Asset Licenses Explained - CC0, CC BY and the rest
• Cinevva Auto Rigger - rig a static character in the browser
• Cinevva Animation Library - 260 CC0 clips on your own model
• Free 3D character models and low-poly packs - browse the free library

Last updated: September 2026.

The best AI pixel art generator for a game is PixelLab if you need animated characters, because it's the only one that treats a sprite as a skeleton you can pose and rotate rather than a picture. Retro Diffusion is the best pick if you already work in Aseprite and would rather pay once than subscribe. Ludo, Scenario and Layer are the studio options for keeping hundreds of assets in one style, and Sprite-AI and Sprixen are the cheap way in if you want to try the idea for less than ten dollars.

The reason to be picky here is that pixel art is unforgiving. A generated sprite that's "in a pixel art style" at 1024 pixels is not pixel art. Real pixel art sits on a grid, uses a small palette, has a consistent outline and reads at 16, 32 or 64 pixels tall, and most image generators produce none of that until you downscale, quantise and clean up by hand. The tools below are ranked partly on how much of that cleanup they save you.

For each tool I went through the pricing page, the licence terms, and the documented features in September 2026. Prices move often, so treat them as the shape of the tiers rather than a quote.

Quick picks

• Animated characters with poses and rotations: PixelLab. Skeleton animation, 4 and 8 direction rotation, tilesets, an Aseprite plugin.
• Pay once, generate locally inside Aseprite: Retro Diffusion's extension. $20 Lite or $65 full, no credits.
• One tool for sprites, backgrounds, icons and everything else: Ludo. Thirty-plus styles including 8-bit and 16-bit.
• The same style across a whole game: Scenario or Layer, both trained on your reference art. Sprixen's Style Lock is the budget version.
• Cheapest way to try it: Sprite-AI's free tier, then $8 a month.
• Editing and finishing everything above: Aseprite, $19.99, or Libresprite and Piskel for free.
• Concept art and backgrounds on a free account: Cinevva's Image Generator, then downscale and quantise in Aseprite.
• Skip the asset pipeline and make the game: describe it in the game creator and it builds the playable thing, art included.

Quick reference

What "pixel art" means to a generator

Three things separate a real pixel art tool from an image model with a retro prompt.

Grid. Pixel art is drawn at its display resolution. A 32 pixel sprite has 32 pixels. Image models generate at 512 pixels or more and then, if they're pixel-aware, downscale to a grid; if they aren't, you get a blurry painting of pixels. PixelLab, Retro Diffusion, Sprixen and Sprite-AI output on a true grid. Ludo, Scenario, Layer and Leonardo can be prompted toward it and usually need a downscale pass.

Palette. Good pixel art uses eight to thirty-two colours. Generators that respect a palette produce sprites you can edit; generators that don't produce thousands of near-identical shades that fall apart the moment you recolour a shirt.

Animation. A walk cycle is six to eight frames of the same character in the same style. Only PixelLab, Retro Diffusion and Ludo produce frame sets, and only PixelLab does it from a skeleton you can pose, which is the difference between "generate walking" and "generate this character walking, then swinging a sword, then facing left."

PixelLab

PixelLab is the specialist and the tool with the largest user base among dedicated pixel art generators. It generates characters from text, then lets you animate them with skeleton-based animation, rotate them into four or eight directions, generate tilesets and inpaint corrections, all on a real pixel grid. There's an Aseprite plugin and an API.

The free trial is 40 fast generations with no card. Pixel Apprentice is $12 a month for up to 2,000 generations, Pixel Artisan is $24 with a priority queue, images up to 400 by 400 and early access to experimental tools, and Pixel Architect is $50 for 10,000 generations with twenty simultaneous jobs. Annual billing takes about a quarter off, and the price drops further the longer you stay subscribed.

If your game has more than a couple of animated characters, this is where the time saving actually shows up. Check the current terms for the commercial licence on the tier you pick before shipping.

Retro Diffusion

Retro Diffusion, by the developer Astropulse, is the other dedicated pixel art model and it takes the opposite business model. The Aseprite extension is a one-time purchase, $65 for the full version or $20 for Lite, and generates on your own machine with no credits and no subscription. That makes it the cheapest serious option over any period longer than a few months, and the only one where your prompts and your art never leave your computer.

There's also a web app that runs on credits, from $5 for 250 up to $50 for 3,500, with 50 free credits when you create an account. A credit covers a small sprite and larger images cost more. It handles animation and tilesets, and because it lives inside Aseprite the generate-then-fix loop is as short as it gets.

The trade-off is that the extension needs a reasonable GPU for local generation, and you need Aseprite, which is another $19.99.

Ludo

Ludo is a game ideation platform that happens to include a strong sprite generator. It produces characters in more than thirty styles, including 8-bit and 16-bit pixel art, and animates them, alongside concept art, icons, backgrounds and a market research tool. If you want one subscription for every 2D asset in a game, it's the one.

There's no free tier. Indie is $15 a month billed annually for 3,000 credits a year, Pro is $35 a month annually with unlimited image generation in the web app plus API and MCP access, and Studio is $300 a month for ten seats. Sprite generation on Indie draws from the shared credit pool, so the effective cost per sprite is higher than the headline suggests.

Scenario and Layer

Neither is a pixel art tool. Both are studio platforms whose selling point is training a model on your own reference images so every asset matches your art direction, and if you have a pixel art style already, that's exactly what you feed them.

Scenario's Starter plan is $15 a month for 1,500 credits and Pro is $45 for 5,000 with custom model training. The free tier gives 50 credits a day for personal and evaluation use only, so nothing from it can go in a released game. Layer has no tiers, just consumption from $10 a month for 300 creative units, with a commercial licence for everyone and no seat fees.

For a solo developer these are overkill. For a team with an art bible and a few hundred sprites to produce, they're the two that solve the consistency problem rather than promising to.

Sprixen and Sprite-AI

These are the budget tools, and they're better than that sounds.

Sprixen is $10 a month with six free credits on signup, and its one distinctive feature is Style Lock, which pins palette, resolution, proportions and art direction across every sprite in a project. It produces small animated sprites on a real grid and is the cheapest route to consistency without training a model.

Sprite-AI starts free with 15 generations, then $8 a month for Creator, $24 for Studio and $50 for Production. It's pixel art only, on a grid, with a built-in editor. It doesn't animate and it doesn't enforce style across sprites, so it's a fast way to get static props, items and icons rather than characters.

Leonardo

Leonardo is a general image generator with game-tuned models, including a pixel art preset, and it's on this list because a lot of people already have it. The free tier is 150 tokens a day and its outputs are non-commercial. Paid plans start at $12 a month (Apprentice, 8,500 tokens), then $30 and $60, all with commercial rights.

Treat its pixel output as concept art. It doesn't sit on a grid, so every sprite needs a downscale, a palette reduction and outline cleanup before it's usable. For backgrounds and key art in a pixel-adjacent style it's fine.

Aseprite and the free editors

Whatever generates the sprite, something has to finish it. Aseprite is the standard, $19.99 on Steam or itch.io, and you can compile it from source for free for personal use (the built binary can't be redistributed). Libresprite is a free fork of an older Aseprite and Piskel is a free browser editor. The generate-then-clean loop is the whole workflow here, so budget the editor before the generator.

Where Cinevva fits

Cinevva's Image Generator is an image model, not a pixel art model. Prompt it for "16-bit pixel art, limited palette" and you'll get convincing concept art and backgrounds at up to 1440 pixels that need the same downscale and quantise pass as Leonardo's output. It runs on a free account, with seeds for reproducible variations, which makes it a decent source of background and key-art candidates.

If you found this page because you want a game and not a sprite sheet, the game creator is the shorter path. Describe the game and it builds the playable thing, generating the art, sound and code together. Our 100 AI game prompts are one-click starting points.

How to judge an AI sprite in 30 seconds

• Zoom to 800%. Every pixel should be a whole pixel. Half-tones, anti-aliased edges and blurry gradients mean it wasn't generated on a grid.
• Count the colours. Open it in Aseprite and look at the palette. Under 32 is editable. Over 200 is a painting.
• Check the outline. Consistent one-pixel outlines (or a consistent absence of them) across a set of sprites is the hardest thing for a generator to hold. Compare two sprites side by side.
• Look at frame two. In an animation, the second frame is where a tool that's really generating variations rather than animating gives itself away: the proportions shift, a colour changes, a detail vanishes.

Licences in 30 seconds

• Scenario free tier and Leonardo free tier: personal or non-commercial only. Nothing from them can ship.
• Layer: commercial licence on every plan.
• Retro Diffusion extension: generated locally, output is yours.
• PixelLab, Ludo, Sprixen, Sprite-AI: read the current terms for the tier you're on; the licence changes more often than the price.
• Hand-made free alternative: Kenney, Pixel Frog, Ansimuz and 0x72 release full CC0 pixel art packs. Our free 2D sprites guide covers them, and the free platformer sprites and free tilesets pages let you browse.

Common Questions

Which AI pixel art generator is best for animation?

PixelLab. It animates from a skeleton, so you pose the character rather than describing the motion, and it rotates the same character into four or eight facing directions. Retro Diffusion and Ludo also produce animation frames but from prompts rather than a rig.

Is there a free AI pixel art generator?

Sprite-AI gives 15 free generations, PixelLab gives 40 trial generations, Retro Diffusion gives 50 web credits, and Sprixen gives 6. Leonardo's free tier is non-commercial. For genuinely free pixel art, the CC0 packs from Kenney and the itch.io creators in our free sprites guide are still the answer.

Can I sell a game made with AI-generated sprites?

On paid tiers, yes, subject to each tool's terms. Not from Scenario's or Leonardo's free tiers. Some storefronts and jams ask you to disclose AI-generated assets, and Steam requires a disclosure on the store page, so keep a record of what was generated where.

Do AI sprite generators make tilesets?

PixelLab and Retro Diffusion do, on a grid, with the tile edges designed to meet. The general tools don't, and a tileset generated as one image almost never tiles cleanly.

How do I make AI output look like real pixel art?

Downscale to the target size with nearest-neighbour sampling, reduce to a fixed palette (Aseprite's indexed mode or Lospec palettes), then redraw the outline by hand. That last step is the one people skip, and it's the one that makes the difference.

Related

• Best Free 2D Sprites, Pixel Art and Tilesets - the hand-made, CC0 alternative
• Best AI Asset Generators for Games - the wider AI asset stack
• Best 2D Game Engines for 2026 - where the sprites end up
• Game Asset Licenses Explained - what a free tier actually lets you do
• Cinevva Image Generator - concept art and backgrounds on a free account
• Free platformer sprites, tilesets, UI sprites and game icons - browse the free library

Last updated: September 2026.

The best AI texture generator for a game depends on which of two jobs you're doing. If you need to texture a model you already have, Meshy is the strongest pick because it paints a full PBR set onto the mesh's existing UVs instead of handing you a flat square. If you need seamless tileable materials for terrain, walls and props, Polycam's material generator produces real base color, normal, roughness and height maps that tile without a visible seam, and the free, open-source Material Maker turns any base color into a full material or builds one procedurally. Everything else in this guide sits somewhere between those two, and a few tools that market themselves as texture generators are image generators with a tiling checkbox.

For each tool I went through the pricing page, the licence terms on the free tier and the published sample output, and I checked what a texture needs to have before a PBR shader in a browser scene will render it correctly. Prices are what the pricing pages said in September 2026. They change often, so treat them as a guide to the tier structure rather than an exact quote.

Quick picks

• Texture an existing 3D model: Meshy. Mesh-aware, full PBR, free tier for testing.
• Seamless tileable PBR materials, realistic: Polycam. Trained on scanned materials, so the tiling and the roughness map are believable.
• Seamless PBR for free, offline: Material Maker. Open source, node-based, no account, exports for Godot, Unity and Unreal.
• A consistent style across hundreds of textures: Scenario or Layer, both of which let you train on your own reference art.
• Stylised albedo and concept textures on a free account, in the browser: Cinevva's Image Generator, then finish the maps in Material Maker.
• You just want the game built, textures included: describe it in the game creator and let it generate and apply the materials for you.

Quick reference

The two kinds of "texture generator"

Before the tools, one distinction that saves a lot of wasted credits.

A mesh texturer takes a 3D model and a prompt and paints the model. It has to understand the UV layout, hide seams where the UV islands meet, and keep texel density even across a character's face and their boots. Meshy, 3D AI Studio and Tripo do this. The output is a set of textures that only make sense on that one model.

A material generator produces a flat square that tiles in every direction and comes with the maps a PBR shader needs: base color, normal, roughness, and usually height or ambient occlusion. Polycam, Material Maker and the Substance tools do this. The output works on any surface with tiling UVs, which is most of an environment.

Most of the disappointment I see with AI textures comes from asking one kind of tool to do the other job. A material generator can't texture your hero character, and a mesh texturer produces a wall texture that won't tile.

Meshy

Meshy started as a text-to-3D generator and its texturing tool is the part most game developers end up using. Upload a GLB, FBX or OBJ, describe the look, and it paints a full PBR set (base color, normal, roughness, metallic) directly onto the model's existing UVs. It handles UV projection, seam placement and texel density on its own, so there's no unwrapping step first.

The free plan gives you 100 credits a month and licenses the output under CC BY 4.0, which means commercial use is fine but you have to credit Meshy. The Pro plan at $20 a month raises that to 1,000 credits, gives you full ownership of the output and adds API access. Credits reset monthly and don't roll over.

Where it falls down is the second job. Meshy is not built for standalone tileable materials, and asking it for "seamless brick texture" gets you an image, not a material. For characters, props and vehicles it's the tool I'd reach for first.