Hair is one of the hardest surface types to get right in real-time 3D. Done wrong, it tanks your frame rate and breaks immersion. Done right, it defines your character's personality and makes players stop and stare. This guide walks you through both primary techniques — particle hair and hair cards — and gives you a clean export path to Unity, Unreal Engine 5, and Godot 4.
Understanding the Two Approaches: Particles vs. Hair Cards
Blender gives you two ways to build hair for games, and they serve different use cases. Particle hair (now also handled by the Geometry Nodes Hair system in Blender 3.5+) is ideal for close-up hero characters where individual strand fidelity matters. Hair cards — flat planes with alpha-masked hair textures — are the industry standard for game engines because they're cheap, predictable, and universally supported.
Particle hair can be converted to mesh and exported, but the poly count and draw calls it generates make it impractical for most real-time scenarios unless you're targeting a cinematic-quality tier. For most game pipelines, you'll author hair in Blender using the particle system as a styling guide, then convert to cards for the actual asset.
Key decision points:
- Hero character with <5ms hair budget: Hair cards, 4–8 texture sheets
- Background/NPC characters: 2–4 card planes, single alpha atlas
- Stylized or toon characters: Solid-mesh hair clusters, no alpha needed
- Cutscene-only assets: Particle mesh at ~5k–15k tris acceptable
Setting Up Particle Hair in Blender for Styling
Even if your final output is hair cards, you want to style using Blender's particle system first. It gives you natural falloff, clumping, and motion that's nearly impossible to fake by hand.
Workflow:
- Add a Particle System to your character mesh. Set Type to Hair, set count to 1000–2000 for styling (not final).
- Enable Children with Interpolated mode. Set Clump to 0.6–0.8 and Roughness to 0.05–0.15 for natural variation.
- Use Particle Edit mode (comb, cut, smooth) to sculpt the flow direction, part lines, and silhouette.
- Once happy, use Convert → Mesh (Ctrl+Alt+C in older Blender, or via Object menu) to get an editable mesh.
For the Geometry Nodes hair system (Blender 3.5+):
```python
# Access hair curves via Python for batch operations
import bpy
hair_obj = bpy.data.objects['Hair']
curves = hair_obj.data # type: bpy.types.Curves
print(f"Curve count: {len(curves.curves)}")
print(f"Point count: {len(curves.points)}")
# Resample all curves to uniform segment count before card baking
bpy.ops.curves.select_all(action='SELECT')
bpy.ops.curves.subdivide() # or use Resample Curves GN node
```
Target 8–12 segments per strand before baking — enough to capture the curve shape without blowing out geometry.
Converting to Hair Cards: The Core Technique
Hair cards are rectangular planes UV-unwrapped to a hair texture atlas. Each card represents a clump of strands and uses an alpha mask for the silhouette.
Card creation workflow:
- Create a plane (2m × 0.05m typical), duplicate it across the scalp following your styled hair flow.
- UV unwrap each card to a region of your hair texture atlas. A standard atlas is 2048×2048 with a 4×4 grid of hair strip variations.
- Assign the hair shader: Base Color (hair gradient texture) + Alpha channel (strand mask) + Normal Map (faked strand depth).
| Texture Channel | Purpose | Recommended Resolution |
|---|---|---|
| Base Color + Alpha | Strand color and cutout mask | 2048×512 per strip |
| Normal Map | Fake strand depth | 1024×256 per strip |
| AO / Root Gradient | Root darkening, tip lightening | Can bake into Base Color |
| Flow Map (optional) | Anisotropic highlight direction | 512×128, R=U, G=V |
Alpha setup matters: Use Hashed transparency in Blender's material for viewport accuracy. In Unity, set Rendering Mode to Cutout with Alpha Cutoff at 0.3. In UE5, use Masked blend mode on the Material. In Godot 4, enable Transparency and set Alpha Cut to Discard.
Baking Hair Textures from Particle to Cards
The most time-consuming step is baking your particle-styled hair onto the card UVs. Use Blender's Cycles baking with a custom cage:
```python
# Bake script for hair cards
import bpy
# Set up bake settings
bpy.context.scene.render.engine = 'CYCLES'
bpy.context.scene.cycles.samples = 64 # Sufficient for hair bake
bpy.context.scene.render.bake.use_selected_to_active = True
bpy.context.scene.render.bake.cage_extrusion = 0.02
bpy.context.scene.render.bake.max_ray_distance = 0.05
# Select: source (particle mesh) + active (hair cards)
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects['HairMesh'].select_set(True) # particle-converted mesh
bpy.data.objects['HairCards'].select_set(True) # active
bpy.context.view_layer.objects.active = bpy.data.objects['HairCards']
# Bake diffuse color only (no lighting)
bpy.ops.object.bake(type='DIFFUSE', pass_filter={'COLOR'})
```
After baking, run the alpha through Blender's Node Wrangler to create a proper cutout mask: use a Color Ramp node set to Constant interpolation, clamped at 0.2–0.4 to eliminate anti-aliased fringe on card edges.
Export Settings for Each Engine
Unity:
- Export as FBX with "Apply Transform" checked
- Material mode: FBX (not Embedded)
- In Unity: set Texture Type to Default, Alpha Source to Input Texture Alpha, Alpha is Transparency ✓
- Use URP Lit shader with Rendering Mode: Cutout, Smoothness ~0.05
Unreal Engine 5:
- Export as FBX, scale 100× (UE5 is cm-based)
- Create a Master Material with Masked blend mode and Two Sided enabled
- Use a Material Instance per LOD level with adjustable Opacity Mask Clip Value
- Enable Nanite only for solid-mesh hair clusters, NOT for alpha-heavy card meshes
Godot 4:
- Export as GLTF 2.0 (best round-trip fidelity from Blender)
- In Godot: assign StandardMaterial3D, enable Transparency → Alpha Scissor
- Set Alpha Scissor Threshold to 0.3
- Enable Cull Mode: Disabled (Two-Sided) to prevent card z-fighting
LODs and Performance Targets
Hair is typically your most expensive transparency cost. Target these budgets:
| LOD | Distance | Card Count | Triangle Count |
|---|---|---|---|
| LOD0 | 0–3m | 60–120 cards | 8k–15k tris |
| LOD1 | 3–8m | 30–60 cards | 3k–6k tris |
| LOD2 | 8–20m | 10–20 cards | 800–2k tris |
| LOD3 | 20m+ | Texture-only cap | <200 tris |
Generate LODs in Blender by manually reducing card count at each level, or use Auto LOD in UE5's Static Mesh editor as a starting point (then tweak by hand — auto LOD handles alpha cards poorly).
Pre-built and optimized character hair packs — including rigged heroes with LODs already set up — are available at the BitSoul marketplace. Pulling a proven asset lets you validate your pipeline before building custom hair from scratch.
Closing: Ship Hair That Performs
Game-ready hair comes down to: style with particles, bake to cards, handle alpha correctly per engine, and build your LOD chain before you're in production. The difference between hair that tanks performance and hair that ships is almost always the LOD0→LOD2 triangle count discipline and the alpha cutout threshold.
Need a starting point? Browse rigged character assets with pre-built hair setups at the BitSoul marketplace — study the card topology and texture layouts on production-grade assets to shortcut the learning curve considerably.