Advanced Roblox Custom Meshes: PBR, Rigging & LOD

Written by: Nuno Leiria, Founder & CEO @ Nilo | Last updated: July 1, 2026

Key Takeaways

• Advanced Roblox custom meshes work best when you bake tangent-space normal maps from high-poly to low-poly models, then export PBR maps with exact naming so Roblox imports them cleanly.

• Layered clothing only deforms correctly when you rig to R15 bone names and label your InnerCage and OuterCage meshes exactly as Roblox expects.

• Roblox Studio importer settings for scale, rig type, and CollisionFidelity need to match your export, or you risk silent errors and hidden performance problems.

• EditableMesh API limits, RenderFidelity choices, and 2026 triangle and LOD budgets all shape how far you can push visuals without breaking performance or hitting rejections.

• Nilo automates retopology, LOD, and export prep so you can spend more time designing and less time fixing meshes by hand.

High-to-Low Poly Baking and Normal Maps for Roblox Meshes

High-to-low baking starts with a detailed high-poly mesh that holds all your tiny surface details. You then project that detail onto a lighter low-poly mesh as a normal map, which fakes depth and lighting without extra geometry. Roblox reads this tangent-space normal map at runtime and restores the visual complexity your low-poly mesh cannot carry alone.

Follow this sequence to avoid bake errors and wasted time:

1. Align your high-poly and low-poly meshes at the same world origin before baking, because misalignment makes projection rays miss surfaces completely.

2. Once aligned, set ray distance (cage offset) to just above the largest gap between the two meshes. This distance controls how far the baker searches for high-poly detail. Too small causes missed rays, while too large creates projection errors on concave areas.

3. With ray distance set, bake in object space first to verify coverage, then switch to tangent space for the final export. Roblox expects tangent-space normal maps.

4. Choose a 2048×2048 or 1024×1024 texture resolution. Roblox caps most textures at 1024×1024, so baking at 2048 gives you a clean downsample and sharper detail.

5. Flip the green channel (Y-axis) if your baking tool uses OpenGL convention, because Roblox expects DirectX-style normal maps.

If you generate meshes with AI tools like Meshy or Tripo and then try to bake them, you often hit broken UVs or overlapping islands. That is where most aspiring builders or already builders like you lose significant time before a single import. Nilo’s automatic UV unwrapping and retopology let you skip that manual bake-and-fix loop entirely.

Exporting PBR Maps Roblox Reads Correctly

PBR means physically based rendering, where separate texture maps control color, reflectivity, roughness, and surface normals. Roblox’s SurfaceAppearance object reads these maps in a specific order. Wrong names or formats often cause silent failures that leave your mesh looking flat.

Export and name your maps in this order so Roblox picks them up reliably:

• ColorMap controls base color (albedo) with no lighting baked in. Use the file name AssetName_ColorMap.

• NormalMap holds the tangent-space normal map from your high-to-low bake. Use the file name AssetName_NormalMap.

• RoughnessMap is grayscale where white means rough and black means smooth. Use the file name AssetName_RoughnessMap.

• MetalnessMap is grayscale where white means metal and black means non-metal. Use the file name AssetName_MetalnessMap.

To reduce draw calls, you can pack RoughnessMap into the green channel and MetalnessMap into the blue channel of a single ORM texture. Roblox Studio accepts both separate maps and ORM-packed textures. Use PNG for lossless export, because JPEG compression adds color artifacts that break metalness thresholds.

Rigging, Weight Painting, and Cage Names for Layered Clothing

An armature is a skeleton of bones that deforms your mesh when you animate it. Weight painting gives each vertex a blend of influence from nearby bones, which controls how the surface bends at joints. For layered clothing, Roblox also expects a cage mesh that guides how the garment wraps around the avatar.

A cage mesh is a slightly inflated copy of your clothing mesh that defines wrap behavior. Roblox needs two cages for every layered clothing item:

• Inner cage wraps around the body or the layer underneath. Name this mesh exactly InnerCage.

• Outer cage defines the surface that other layers wrap around. Name this mesh exactly OuterCage.

These names are case-sensitive and cause many import failures when typed incorrectly. Your armature also needs Roblox’s standard R15 bone names, such as UpperTorso, LowerTorso, and LeftUpperArm, so the importer can map deformation correctly. Smooth weight painting across joints keeps elbows and knees from creasing sharply when your character moves.

Roblox 3D Importer Settings You Should Match

Roblox Studio’s 3D importer can override your export if settings do not match your file. You avoid most surprises by checking these options before every import.

• File format: Use FBX for rigged meshes, because it handles bones and animation reliably. Use glTF for static props.

• Scale: Keep scale at 1.0 in the importer. Roblox uses studs, where 1 stud is about 28 cm. If you modeled in meters, scale by 28 in your export settings first.

• Rig type: Choose R15 for humanoid characters and layered clothing. Choose Custom for props and accessories.

• Texture import: Enable “Import textures” and confirm that each PBR slot maps to the correct file after import.

• Collision: Set CollisionFidelity in the importer or on the MeshPart after import, using the decision table below as a guide.

After import, open the Output window and scan for warnings. You often see missing cage names, bone name mismatches, or triangle counts above the per-mesh limit.

EditableMesh API Limits and Practical Example

The EditableMesh API lets you create and modify mesh geometry at runtime inside your Roblox experience. You can use it for procedural terrain, destructible objects, or dynamic props that change shape. An EditableMesh attaches to a MeshPart and you edit it through scripts.

Keep these constraints in mind while you plan:

• EditableMesh only works in experiences where the AllowEditableMeshes capability is enabled.

• The maximum vertex count per EditableMesh is 60,000, and going over that limit throws a runtime error.

• EditableMesh supports skinned meshes at runtime, so you can deform rigged geometry through scripts.

• Changes do not replicate automatically, so you must handle replication yourself when you need server and client to stay in sync.

Here is a basic vertex weld example in Luau:

local AssetService = game:GetService("AssetService") local meshPart = workspace.MyMeshPart local editableMesh = AssetService:CreateEditableMeshFromPartAsync(meshPart) -- Weld two vertices by position threshold local vertices = editableMesh:GetVertices() for _, vA in ipairs(vertices) do for _, vB in ipairs(vertices) do if vA ~= vB then local posA = editableMesh:GetPosition(vA) local posB = editableMesh:GetPosition(vB) if (posA - posB).Magnitude < 0.001 then editableMesh:MergeVertices(vA, vB) end end end end

For performance, batch all edits before calling ApplyMesh. Calling apply inside a loop forces a re-render every time and drops frame rate on complex meshes.

Choosing RenderFidelity and CollisionFidelity Per Asset

Once your mesh lives in Roblox, RenderFidelity and CollisionFidelity decide how much performance budget it uses at runtime. Wrong choices waste resources or create invisible collision walls that frustrate players. RenderFidelity controls how closely the rendered mesh matches the original geometry at distance, while CollisionFidelity controls the shape used for physics.

Asset Type	RenderFidelity	CollisionFidelity	Reason
Hero prop (close-up)	Precise	Box	Full visual detail with simple collision that keeps physics cost low
Environment decoration	Automatic	Box or Hull	LOD handles distance, and a convex hull stays fast for irregular shapes
Walkable terrain chunk	Automatic	Precise	Players need accurate footing, while visual LOD can drop at distance
Background filler	Performance	Box	Lowest cost, because detail is not visible far from the camera

Precise CollisionFidelity on complex meshes often causes unexpected frame-rate drops. Save it for surfaces that players or projectiles touch directly.

Triangle Targets and LOD Budgets for 2026

Roblox enforces triangle limits per mesh at import and applies level of detail automatically based on screen size. Hitting these targets before export keeps your assets from being rejected and reduces lag in live experiences.

Asset Category	Max Triangles	LOD 0 (full detail)	LOD 2 (far distance)
Avatar / character	10,000	8,000–10,000	500–1,000
Layered clothing item	4,000	3,000–4,000	200–400
Hero prop	5,000	3,000–5,000	300–600
Environment / terrain chunk	20,000	15,000–20,000	1,000–2,000

These targets follow Roblox’s documented mesh limits and community performance standards for 2026 on mobile and mid-range hardware. Aim to keep your total scene triangle count low enough that mobile players stay above your target frame rate.

Manual retopology to hit these numbers, rebuilding mesh geometry edge by edge, often takes 30 minutes to several hours per asset in Blender. Try Nilo’s real-time LOD system for free, which adjusts polygon counts automatically so your exports land inside budget without extra cleanup.

Nilo Export Path for Faster Roblox-Ready Meshes

Once you understand the manual pipeline, you can decide when to automate and when to keep full control. You should look at four things when you compare tools for your Roblox custom mesh workflow. Check how much manual cleanup the tool needs before a Roblox-ready export, whether it handles PBR naming and cage rigging in one place, how well it fits your collaboration style, and whether the output stays portable to engines like Unity or Blender if your project grows.

This table shows how common options stack up on those points:

Tool	Roblox Optimization	Ease of Use	Flexibility / Portability
Nilo	Automatic LOD, polycount control, one-click FBX or glTF export	Browser-based with no install, real-time retopology built in	Exports FBX, OBJ, STL, and glTF that work in Unity, Blender, Unreal Engine, and VRChat
Blender	Manual retopology, manual LOD, and manual export settings	Steep learning curve that takes months to reach production speed	Very high flexibility with full control over every mesh parameter
Sloyd	Procedural generation with limited Roblox-specific optimization	Simple interface focused on model creation only	Standard format export without a full rigging or animation pipeline
Lemonade.gg	Roblox Studio plugin that creates assets inside Studio	Familiar for Studio users but depends on a local Studio install	Locked to the Roblox ecosystem with no cross-platform export
Rosebud AI	Prompt-to-game focus with limited mesh-level control	Very easy entry with fewer advanced mesh settings	Limited portability outside its own environment

Nilo helps you cut polycount so models work directly in Roblox Studio and other platforms without extra steps. In a 2026 Nilo survey, 93% of builders said they would recommend Nilo to a friend, and 82% rated their experience as “Awesome” or “Good.” One builder summed up the speed difference clearly: “I do not have to spend hours on 3D modeling the simplest things, now I can use Nilo and do it in 15 seconds.”

If you already know Blender well and want maximum mesh-level control, Blender stays the most flexible choice. If you want to skip the Blender grind and export Roblox-ready assets directly from your browser, Nilo stands out as a fast path from AI-generated mesh to optimized Roblox asset. PlayCanvas also runs in the browser but focuses on professional developers and now sits inside Snapchat, so its consumer roadmap feels less clear. Rosebud AI focuses more on code generation than on detailed mesh production.

When you evaluate tools, walk through a short checklist instead of guessing. Check whether it handles retopology automatically, whether it exports with correct PBR naming, whether you can rig and cage-name in the same place, and whether the output passes Roblox’s importer without manual fixes. Those four checks quickly reveal which tool fits your pipeline.

Frequently Asked Questions

What is the difference between RenderFidelity and CollisionFidelity in Roblox?

RenderFidelity controls how much detail the graphics engine renders for a MeshPart at different camera distances. Precise keeps full geometry detail at all distances. Automatic lets Roblox swap in lower-detail versions as the camera moves away. Performance always uses the simplest version. CollisionFidelity is separate and controls the shape the physics engine uses to detect collisions, which affects performance but not visuals. A mesh can look detailed with Precise RenderFidelity while using a simple box for collision with Box CollisionFidelity, which works well for most hero props.

Why does my layered clothing deform incorrectly after import into Roblox Studio?

The most common causes are incorrect cage mesh naming, bone names that do not match Roblox’s R15 skeleton, or weight painting that gives too much influence to a single bone. Check that your inner cage is named exactly InnerCage and your outer cage exactly OuterCage, because these names are case-sensitive. Verify that every bone in your armature uses Roblox’s standard R15 naming convention. If joints crease sharply during animation, smooth your weight painting across the joint so multiple bones share influence gradually.

Can I use the EditableMesh API for multiplayer experiences?

You can, but you need to manage replication yourself. EditableMesh changes made on the server do not automatically reach clients. Use RemoteEvents or RemoteFunctions to send mesh state changes, or apply the same edits on both server and client. For performance-heavy multiplayer scenes, consider pre-generating mesh variants and swapping MeshPart assets instead of editing geometry at runtime, because EditableMesh operations on complex meshes can cause frame spikes if you do not batch them.

What is the fastest way to get an AI-generated mesh into Roblox without manual retopology?

The standard daisy-chain of generating in Meshy or Tripo, cleaning up in Blender, exporting FBX, and importing to Roblox Studio works but often costs 30 minutes or more per asset. Nilo removes the Blender step. You generate your mesh, use the built-in LOD slider to hit your triangle budget, and export a Roblox-ready FBX or glTF directly from the browser. The output passes Roblox’s importer without manual fixes. When you need advanced cage rigging or custom weight painting beyond what automated tools provide, Blender still fits that step, but for most props, characters, and accessories, automated optimization gets you to a production-ready file faster.

Do Roblox’s triangle limits apply per mesh or per experience?

Roblox applies limits at both levels. You face a per-mesh import limit of 10,000 triangles for avatars and characters and up to 20,000 for environment meshes. You also face experience-level performance budgets that affect frame rate on lower-end devices. Staying under the per-mesh limit gets your asset through the importer. Staying under the total scene budget for your target hardware keeps your experience playable. Use Roblox Studio’s performance stats panel to watch total triangle count and find which meshes consume the most budget.

Conclusion and Next Steps for Your Mesh Pipeline

A production-ready Roblox custom mesh pipeline in 2026 means baking tangent-space normal maps from high-to-low pairs, exporting PBR maps with exact names, rigging to R15 bones with correctly named cages, matching Studio import settings, respecting EditableMesh limits, choosing RenderFidelity and CollisionFidelity per asset type, and staying inside triangle and LOD budgets before you publish.

Every step in that pipeline can steal your time through broken UVs, cage naming mistakes, polycount rejections, and Blender cleanup loops that pull you out of creative flow. The technical rules matter and are worth learning, because they keep your assets stable in live experiences. Your real goal stays simple though: get your asset into Roblox and start building the world you imagined.

Nilo takes care of the optimization layer, including retopology, LOD, and export prep, so you spend more of your time designing instead of debugging polycounts. Start building in Nilo’s open beta today, with no install and a free way to try it.