Rig Edit

Give a prop the bones it never had. A bowstring that draws, a cable that swings, an attachment point on a hand - added to the prefab, in the Scene view, without going back to your 3D package.

Most props ship as a single rigid mesh. The moment you want one part of it to move, you are normally looking at a round trip: open the FBX in Blender, add a bone, weight the mesh, re-export, re-import, fix the references. Rig Edit is the short way round for the cases where a full re-rig is more than you need.

What it does

You want	Rig Edit
An attachment point - a socket on a hand, a muzzle on a barrel	Add a bone, name it, place it
A part that moves - a bowstring, a cable, a banner	Add a bone and bind the mesh region to it
Something hung on the character for good - a scabbard, a strap	Drag a prefab onto a bone
To know what a rigged model already does - and change it	The Hierarchy shows every bone's weights; Weights adds the shading and the brush

The last one is worth separating from props in Pose Edit: a prop is scenery you pose against and it never leaves the stage. Geometry attached here is written into the prefab and belongs to the character afterwards.

Getting in

From	How
Project window	Right-click a prefab ▸ Animation Workbench ▸ Rig Edit
Characters window	Right-click a tile ▸ Rig Edit…
Character diagnostics	The Rig Edit… button on findings it can answer
Menu bar	Tools ▸ Animation Workbench ▸ Rig Edit

A prefab without an Animator is not a special case here - it is the main case. The bow, the sword, the crate: things that have no rig yet and are about to get one. That is why the entry is not hidden behind an Animator the way Diagnostics is.

The character opens on an isolated preview stage. The figure you see is a throwaway copy; nothing you do touches your scene.

The badge in the top corner names the character and its rig type - Humanoid, Generic, or No avatar. It matters here: a bone you add is not part of a Humanoid avatar, so Pose Edit keys it as a plain transform curve rather than a muscle. That is expected, and it is the answer when a bone you added behaves differently from the rest of the character.

Nothing is written until you commit

Everything you do collects in a draft. The draft lives in the character database, survives restarts and domain reloads, and shows in the HUD as a pending count. The prefab on disk is untouched the whole time.

That is also what makes Ctrl+Z work normally: creating a bone, moving it, attaching geometry, binding a mesh - all of it is ordinary undo, because none of it has been written anywhere yet.

Bones

+ Bone (B) creates a bone under whatever is selected, or under the root if nothing is.

A fresh bone is called Bone_1, and for a socket the name is the whole product - it is what your code will look up later. Click the name in the bar to rename it, press F2, or rename the object in the Hierarchy; all three end up in the same place.

Select a bone and a handle appears. The chip in the bar switches between Move and Rotate; hold Ctrl while turning to snap to fixed steps (step size in Settings ▸ Rig Edit). For a socket the direction matters as much as the position: which way it points is which way the weapon in it will point.

There is no Scale. A scaled bone scales everything that follows it, and the size of attached geometry comes from its own prefab - both are things you change at the source.

Presets and sockets

Right-click + Bone for the presets:

Preset	For
Bone	A plain bone
Socket	An attachment point - a weapon in a hand
Muzzle	Where something leaves - a barrel, a nozzle
VFX Anchor	Where an effect sits
IK Target	Something to reach for

A preset names itself after the bone it hangs on - a Socket under Hand_R becomes Hand_R_socket - and draws as an axis cross rather than a bone, because on a socket the only thing that matters is which way the axes point.

Same menu, further down: Chain creates 3, 5 or 8 bones in one go, and + / - extend or shorten a chain from the selected bone at any time.

Mirroring

With a bone selected under something that has an opposite side, Mirror creates the counterpart: Hand_R_socket under Hand_R becomes Hand_L_socket under Hand_L.

It is not "negate x". On a generic rig the right side's axes are usually the left side's rotated, not reflected - that is what "duplicate and mirror" in a 3D package produces - so a naively negated socket sits on the right side and points the wrong way. The mirror goes through the rig's actual rest pose, so the counterpart lands correctly in both position and orientation.

If the bone's own name carries no side, the copy keeps the name and is made unique, and the notification says so.

Attaching geometry

Drag a prefab from the Project window onto a bone. The bone under the cursor lights up while you drag, and a row appears under the bar for what you dropped.

Click the row to pick the object up and fit it with the handle. The × takes it off again - nothing has been written, so this costs nothing.

Trace: the chain inside a strand

If what you want to rig is thin - a bowstring, a cable, a strap, a tail - do not place the bones by hand. Press Trace, click one end of it, click the other, and the chain lands inside the geometry, already bound.

Placing a chain on a strand by dragging handles is harder than it looks. A bowstring is a few millimetres across; miss its axis by its own diameter and you need double the radius to catch it, which then catches the bow tips as well. Trace does not guess at the axis, it measures it: it walks the edges between your two clicks - so it follows the string rather than cutting straight through the bow - and takes a cross-section of the strand at every step along the way.

Number of bones	Right-click the chip, or Ctrl+wheel in the scene. One is a bowstring - see below
Backspace or Ctrl+Z	Clears a first point you already set
Escape	Clears the first point, then leaves the tool

Both clicks have to land on the same mesh - a trace follows edges, and those do not cross from one mesh to another.

What comes out is a chain named Strand, a Chain binding on its root, falloff hard, and a radius measured from the strand itself. Everything after that is the ordinary binding row: turn the radius, switch the falloff, drag Test.

One bone: a pull point

Set the count to 1 and a trace lays a single bone in the middle of the strand instead of a chain. That is the rig you would build in Blender for a bowstring: one bone you pull, and the two nocks stay put because their weight is zero there - not because a second bone is holding them.

It works because the two questions are answered by different things. The axis the trace measured says which vertices belong to the strand; the bone says how far they follow it: full at the bone, fading to nothing at the ends of the axis. The binding's shape reads Strand, and it is the one shape you cannot switch - a sphere or a chain is not the same capture.

Why the ordinary one-bone grip will not do this: it is a sphere. On the Frostbound bow the nocks are 0.60 away from the middle of the string and the bow's own grip is 0.19 away, so a sphere big enough to reach the nocks swallows the riser three times over. The axis is what tells the two apart.

There is one visible difference from a chain: with a single bone the drawn string is a smooth curve, not a sharp V. A chain of three gives you the hard corner, at the price of the far nock following the middle bone around.

When your click is off

Two things can go wrong, and they end differently.

You hit next to the strand - the bow tip instead of the string. The path then runs over the bow for a stretch, but the part of it that is a strand is still the string, and the chain is fitted to that part. Hitting the tips of the bow gives the same chain as clicking the string properly.

You clicked something that is not a strand at all - two points on the bow's body, say. Trace refuses, and says what it found instead: how wide the surface is between your two points, and how short. It does not lay a chain with a radius that would capture half the character.

Chain: the chain you point at

Trace only works while the strand is thin compared to its distance to everything else. A bow limb has no such distance - the next thing over is more limb - and Trace either refuses it or lays a chain with a radius that takes half the bow with it. Neither is a bug you can tune away: the cross-section it looks for is not there.

For those parts there is Chain. Click along the part, one bone per click, and press Enter.

Each click	Lands inside the part, halfway between where your ray goes in and where it comes out. A bone on the skin turns the limb about its surface instead of its centre
Number of bones	However many times you clicked. There is nothing to set
Radius	Measured from your clicks - how thick the part was where you clicked through it
Enter	Finishes the chain
Backspace or Ctrl+Z	Takes the last point back, one at a time
Escape	Clears the points, then leaves the tool

The starting radius is a starting radius, not a measurement of the part. Your ray measures the one diameter you happened to look through, and decoration - spikes, plates, trim - stands out past any cross-section anyway. Look at the number of vertices it reports and turn the radius until it is right.

Both tools switch themselves off once the chain is laid, and both write what they did to the console: the bones and where they went, the radius, and how many vertices the grip holds. That is the number to compare after you move the radius.

Turning a chain around

Which end of a chain holds still and which one follows is decided by the order you clicked in - and you notice it the first time you pull. Reverse turns it around: the far end becomes the root, the bones stay exactly where they are, and only the parenting flips. The button appears whenever the selected bone is part of a chain.

It refuses on a chain that is already committed - a bone in the prefab cannot be moved from here - and on one whose links carry a rotation or a scale.

Turning a single relation around

Reverse flips a whole chain, and a chain stays a row. Swap flips exactly one relation: the selected bone takes its parent's place, and the parent becomes its child. Nothing moves - both keep their spot in the figure, and siblings on either side never notice, because their own parent stays where it was.

That is the one that changes the shape of the hierarchy rather than its direction. A three-link chain hangs its last link on the middle one, so pulling the middle drags the end along; lifting the end above the middle with Swap leaves it standing.

Be aware of what it does to a chain binding, though: the binding runs along the chain in hierarchy order, and the weights are handed out along that line. Lift the end above the middle and the line goes top → end → middle, doubling back on itself - the first stretch already covers the whole strand, and a tie goes to the earlier one, so the middle bone ends up holding nothing at all. For a bowstring, bind the two halves separately instead: one trace from the top nock to the middle, one from the bottom nock to the middle, two bones each.

Binding a mesh to a bone

This is the part that makes a mesh move. Trace above does this in two clicks for anything thin; this is the manual way, and the one to use when there is no strand to follow.

Select a bone, press Bind, and pick the mesh that should follow it. If there is only one candidate it is bound straight away; otherwise a menu lists them with their vertex counts.

One mesh can follow several bones - a bowstring has two nocks, and both sit on the same mesh. Select the next bone, press Bind again, and each binding gets its own row with its own radius. The vertex counts show you when two of them start fighting over the same vertices: the weaker one's number drops.

Control	What it decides
Radius	How far around the bone vertices are captured
Falloff	How the influence fades towards the edge - hard or soft
Test	Pulls the bone out of its rest pose while you drag, then puts it back

The count beside the radius is the number that tells you whether you got it right: 4 / 244 on a bowstring is the middle of the string. 244 / 244 would be the whole bow.

Falloff is hard by default, and for a bowstring that is correct - a drawn string is two straight segments, and any transition would bend it into a curve that does not exist. For a cable or a strap, where nothing kinks, turn it up.

Test answers the only question that actually matters before committing: does the right thing move? Drag it and the bound region follows the bone while everything else stays put. Let go and the bone is back where it was. Nothing about it touches the draft.

Dragging the bone itself does the same thing once it holds a mesh - including any link of a bound chain, not just the one the binding sits on. It deforms while you drag and snaps back when you let go.

That is deliberate. Moving a bound bone does not adjust the binding, it wrecks it: a bowstring is captured at a radius of about eight thousandths, and a pull of ten centimetres leaves the chain lying beside the strand it is supposed to hold. Commit that and the bone has nothing to do with what it holds any more. If you really do want the bone somewhere else, press Unbind first. It flashes as the bone snaps back, so the way out is where you are already looking, and it is there for every link of a bound chain - not only for the bone the binding is recorded on. Its tooltip names the root it belongs to.

The radius, without leaving the scene

Hold Ctrl and turn the wheel with a binding selected, and its radius follows - ten percent per notch, so it feels the same on a five-millimetre bowstring as on a limb. The message names the new radius and how many vertices it now holds. Without Ctrl it stays Unity's zoom, and while a tool is armed the wheel belongs to that tool's own number.

Bone or chain

With more than one bone in the chain, a Shape switch appears on the binding:

Shape	Captures	Right for
Bone	A sphere around one bone	A bowstring - the moving part is a small cluster
Chain	A cylinder around the whole run	A cable, a tail, a banner, a strap

In Chain mode every vertex is projected onto the run of bones and handed to the two nearest, so influence passes smoothly from link to link. The captured vertices are coloured by which bone owns them - without that, a six-bone chain is just a cloud of identical dots and you cannot see where one link hands over to the next.

:::note The mesh has to be readable Binding builds a new skinned mesh from the source, and weights cannot be read either without it. If Read/Write Enabled is switched off, Rig Edit says so instead of producing something wrong - as a note in the Rig Inspector and in the weights panel, each with a Make readable button.

The button matters most for a mesh that is not part of a model file. A .mesh asset - one that was extracted from an FBX, or written by another tool - has no import settings at all, so there is no Read/Write Enabled checkbox to find. The flag sits in the asset itself; Rig Edit writes it there, after asking. For a mesh that still lives in an FBX, the same button turns the setting on in the model importer and reimports it. :::

A mesh that is already skinned

You can bind on a finished character too - a new bone that moves a piece of the body, a socket that drags some geometry with it. That case works differently under the hood, and the difference is the point:

• The existing weights stay. Only what falls inside the radius is moved over to the new bone, blended by the falloff. A vertex outside every radius keeps its weights untouched, down to the last bit.
• The new bone has to hang under a bone that this mesh already uses - that is what its bind pose is derived from. Put it somewhere else and Rig Edit says so instead of guessing, because a guessed anchor sits wrong from the first frame in a way that looks plausible.
• Binding to an existing bone works as well: the captured vertices are simply handed to it.

Binding is not painting: a radius captures vertices, it does not set numbers. Setting them is the third layer, further down - what the model came with can be looked at, dropped whole, or changed vertex by vertex.

Adjusting after a commit

A binding stays editable once it is in the prefab. Drag its radius and it counts as pending again; the next commit rewrites that mesh into the same generated asset, so nothing that points at it breaks. The row shows written where the vertex count sits as long as nothing has been changed.

Draw: the whole bow from one slider

Once each limb carries a bound chain and the string has one of its own, Draw on a selected strand binding pulls the whole bow from a single value.

Three chains have to agree in every frame for that, which is nothing to set by hand. The string keeps its length: pull the string of a 1.9 m bow out by 0.30 and it would have to stretch by 11.8 % - or each nock has to travel 54 mm inwards, which is what a real bow does. That is one equation with one unknown, namely how far the limbs bend, and Draw solves it. The limbs bend, the nocks travel, and the string stays on them.

The readout says +12% when you pull further than that bow can go: the string would have to stretch by that much, and there is no bend left to give.

Nothing is written. Draw is a test, like the Test slider next to it, and letting go puts the bow back.

For the game, the same solver runs per frame in the AWBowDraw component - see Script Reference, Bend a bow in your game.

Seeing the weights a model already has

In Rig Edit the Hierarchy is a weight map. Every bone that holds something on the character's skinned mesh gets a bar and its vertex count, right in its row - no mode to turn on:

▸ spine_01     ▬▬▬▬▬     2464
  ▸ spine_02   ▬▬▬▬▬     2341
    ▸ spine_03 ▬▬▬▬▬▬▬   3509
      ▸ head   ▬▬▬▬▬▬▬▬  4181
        jaw    ▬▬▬       1400

Bar length is the share of the strongest bone on that mesh; bar colour is the average weight, from the same ramp as the shading. Length says how much, colour says how strongly. A bone with no bar holds nothing here - an answer a sorted list cannot give you.

The Weights chip opens the view around those numbers. Select a bone - in the Hierarchy or by clicking it in the scene - and the mesh is shaded by weight: blue → cyan → green → yellow → red, with the legend in the scene HUD. Vertices the bone does not touch stay dark grey, so "nothing here" and "a little here" stay apart. The HUD carries what belongs to the mesh as a whole, plus that bone's three numbers:

Weights · body            [ model ]  ▬▬▬▬▬▬
    head    4181 verts   max 1.00 · avg 0.78

The three answer different questions. 4181 verts · max 1.00 · avg 0.78 is a real carrier: it holds 4181 vertices, at least one of them completely, and firmly on average. 1475 verts · max 0.88 · avg 0.26 holds a similar area and carries none of it - it just pulls along a little everywhere.

The average is over that bone's vertices, not over all of them. A bone that holds 4 of 244 vertices completely would otherwise read avg 0.016, which looks like "weak" and means "entirely".

Esc closes the view. The bars stay - they are not part of it - and so does the bone selection: it is what you are working on.

:::note Why the list lives in the Hierarchy It was a panel in the scene HUD first, and on a bow with two bones that read fine. On a character with 84 it was a wall with a lid: twelve rows sorted by vertex count and "… and 70 more" underneath. The Hierarchy scrolls, collapses and searches, it is open anyway - and it lists every bone, so "this one holds nothing here" becomes visible instead of indistinguishable from "cut off". :::

On a character built from several skinned meshes, the bars speak about one of them - the first one, until you pin another in the HUD header. Which one a row means is in its tooltip, along with the exact numbers.

model ▸ now

The view always opens on now: what the next commit would write, bindings and weight changes applied. That is the state that counts, and on a mesh Rig Edit skinned itself it is the only one with anything in it.

Once something on this mesh is in the draft, a switch appears in the HUD:

now	What the next commit would write
model	The weights as the FBX brought them - for comparison

The button below works in either view; the switch answers "and what was there before?", nothing more. With an empty draft the two are the same picture, so the switch stays away.

Drop an influence

The button sits on the selected bone's row in the Hierarchy - not on all of them. Eighty-four rows with a button each would be the wall again; the selection is what you are working on, so that is where it goes. Once a bone has an entry, its row says which one instead: bound or dropped.

The × takes that bone's hold on the mesh away. The remaining weights on each affected vertex are renormalized, so the mesh keeps its shape everywhere something else was already holding it.

Vertices that had nothing else follow the nearest bone above the dropped one that this mesh uses - the thing that was carrying that bone. The message says how many:

'string_bone' influence dropped - 118 vertices renormalized, 12 of them had nothing else and now follow 'bow_root'.

The bar stays on the row and the state reads dropped: until you commit, those weights are still in the model, and the bar shows what is there. × takes the removal back.

Three things it refuses:

• The last bone holding this mesh. Then nothing would carry it at all.
• A bone that already has an entry on this mesh.
• A mesh that is not an asset. After a removal, the way back to the original weights runs entirely through the note Rig Edit keeps about the model mesh - no note, no removal.

Afterwards the bone's row in the Hierarchy reads dropped and its bar is gone - that is the confirmation the removal worked.

:::note This never touches your model file A removal is written into the generated copy next to the prefab, exactly like a binding. The FBX is not modified, Take back restores the model's weights, and even without it: deleting the entry and committing again rebuilds the mesh from the model. :::

Changing the weights by hand

Dropping an influence has a right answer - one bone, one decision, and the mesh either still needs that bone or it does not. Everything else about a weight map is a matter of degree: this shoulder pulls a little too far into the neck, that eyelid barely moves at all. For those there is a third layer, and it works on the vertices themselves rather than on an entry.

It is a layer, not a rewrite. The model's weights stay the model's weights; what you set is kept beside them, in an asset of its own next to the character, and applied on top when the mesh is built. Which means the same thing here as everywhere else in Rig Edit: nothing is written until you commit, and a vertex nobody touched is passed through unchanged - the same influences, in the same order, with the same numbers.

:::note One caveat, and it is Unity's Unity normalises bone weights when a mesh is written. On a 25 652-vertex character, writing the weights back without changing anything at all returns 1436 of them differing in the seventh decimal - at most 1.6 × 10⁻⁷, on vertices whose weights did not already sum to exactly 1. That is a rounding difference some ten thousand times smaller than anything a deformation can show, it happens with or without Rig Edit, and you can see it for yourself: Rig Weights: Check Unity's Write Path, on any skinned mesh. :::

What you set are target values, not nudges. "This vertex follows head at 0.7" survives the next change to its neighbour; "+0.2" would not, because after the renormalisation there is nothing left for it to mean.

Grow and shrink

Grow and Shrink sit in the Weights row in the scene HUD, next to the mesh the view is pinned to.

Grow lets the selected bone reach one row of vertices further, all the way around what it already holds. Shrink takes the outermost row away again, and what it drops goes back to the bones that were already holding it. No dragging, no radius: this is the "a bit more, a bit less" that most weight problems actually are.

They are the same layer the brush writes into, so you can grow twice, then paint the one spot that is still wrong.

The brush

Paint turns the mouse into a brush on the pinned mesh. Drag on the mesh; the ring shows what it will reach.

Add	Builds the weight up towards 1
Subtract	Takes it away, towards 0
Set	Pulls towards the value on the slider
Strength	How much one pass changes - with Set, the value it pulls towards. Shift+Wheel in the scene does the same
Size	The ring, in screen pixels. Ctrl+Wheel in the scene does the same

Both live on the wheel because both are things you change mid-stroke; the trip to the slider in the HUD interrupts the one thing you were doing. Without a modifier the wheel still zooms.

The size is in screen pixels rather than world units on purpose: a brush is a gesture. Zoom in and it gets finer, the way it does in every paint program, instead of covering the same four vertices from closer up.

Each stroke is one undo step - press, drag, release, and Ctrl+Z takes the whole thing back rather than the last thirty mouse events.

Painting works on a rigid mesh too, not only on a skinned one. On a bow that means you can correct the four vertices the radius could not separate, instead of hunting for a radius that has no right answer.

Mirror

Mirror applies every change to the other side as well - for the brush and for Grow/Shrink, because symmetry is a way of working rather than a property of one tool.

It pairs two things at once: the vertex across the character's centre, and the bone whose name is the mirror of the selected one (_l ↔ _r, Left ↔ Right, and the other patterns Pose Edit already knows). A bone with no side in its name - spine_02, head - mirrors onto itself, so a stroke on the chest lands symmetrically on the same bone.

Where it is kept, and what happens to it

The layer lives in its own asset next to the character, one per mesh, referenced from the draft. Two things follow from that:

• Take back keeps it. The generated mesh is a result and can be rebuilt at any time; the layer is the input, and it exists once. Taking a commit back returns your entries to the draft as pending - including this one, with everything you painted still in it. The dialog says so.
• A reimport that changes the topology stops it. The layer remembers the vertex count and a hash over the model mesh's positions. If the model comes back with a different mesh, every index in the layer points somewhere else, and Rig Edit refuses and says so by name - rather than quietly moving the weights of a face onto whatever now sits at those indices.

:::note Where it sits in the stack The order is: the model's weights, then anything that was dropped, then the bindings and their radii, then this layer. Painting last is what makes the number you set the number you get - a radius cannot overrule it. What the layer does not do is spread into vertices you did not touch: outside your strokes the mesh comes out of the build unchanged. :::

Committing

Commit (Ctrl+Enter) writes the draft into the prefab. It asks first, and the dialog names exactly what will happen - including the two things worth knowing in advance:

• Attached geometry goes in as a nested prefab. Later changes to the source prefab carry through.
• Binding creates a skinned copy of the mesh as its own asset next to the prefab, and a rigid mesh's MeshRenderer becomes a SkinnedMeshRenderer. That mesh's link to the model file is cut; the original stays where it is. Several bindings on one mesh share a single copy.

If the target is a model prefab - an FBX you cannot write to - the commit creates a prefab variant instead and continues there. Your source file is never modified.

Once you know what it says

Both questions around a commit can be switched off under Settings ▸ Rig Edit:

Ask before committing	Off means Commit commits. The scene still tells you what was written, and Take back is still the way out
Offer to pack afterwards	Off skips the question and the packing - copying a character's files is a decision about your project's layout, not part of the commit. Pack Character stays in the prefab's context menu

Taking a commit back and applying a rig to several prefabs keep asking. The first cannot be undone; the second shows you a dry run, and that report is the answer, not packaging around it.

Packing afterwards

A committed model prefab ends up as a variant that still depends on the FBX, plus a generated mesh next to it. Right after the commit, Rig Edit offers to pack the character into a self-contained folder. Say no and nothing is copied; say yes and Rig Edit continues on the packed copy, manifest and all.

Already inside a packed folder? Then you are not asked, and the generated mesh is filed into that folder's own layout straight away.

Taking a commit back

A commit is a step you can walk back, not a door that locks behind you.

After committing, the HUD shows an In the prefab list of everything Rig Edit created. Take back removes all of it again and returns the entries to the draft as pending - so you can change a radius, fix a name, and commit once more.

It is deliberately one button for the whole block rather than one per row: things are removed in reverse order, children before parents, and cutting a hole in that order is how you end up with half a rig.

What it protects, and what it cannot:

• If something you did not create now hangs off one of these bones, the whole operation stops and names it. Your work is never deleted along the way.
• Generated mesh assets are deleted - after the prefab has been written successfully, never before.
• Animation curves that already address one of these paths are not carried along. The dialog says so. If you have already animated the socket, renaming or removing it leaves those curves pointing at nothing.

That last point is also why renaming is only possible before a commit: once the bone is in the prefab, its path is what curves address.

The same rig on twenty prefabs

A Synty pack with twenty bows, or twelve swords. Build the setup once, apply it to the rest.

Select the targets in the Project window, then press Apply to… in the HUD - or right-click the source character in the Characters window and choose Apply Rig To Project Selection….

Nothing is written before you have seen the report. Every target is checked first: does the parent path resolve? is the renderer there? is its mesh readable? - and the dialog says "18 of 20 target(s) can take this rig", with the two that cannot, by name. Targets with a problem are skipped rather than half-written.

:::warning Scale is the trap The same bone position in local units means something else on a differently scaled prefab. The report calls out any target whose root scale differs from the source's - it is still written if you agree, because you may well want exactly that, but it is not something to find out afterwards. :::

Each target is written the same way a single commit is: all or nothing per prefab. Each one keeps its own manifest, so Take back works on every one of them individually.

Rig inspector

The Rig chip in the HUD carries the number of things worth knowing about this character. Click it for the list; click any entry to select the object it is about.

Finding	Why it is there
A rigid mesh following no bone	Exactly what Rig Edit can act on - the starting point, not a warning
A mesh with Read/Write disabled	It can neither be bound nor show its weights. Better to know now than at the click - and the note carries the button that fixes it
A SkinnedMeshRenderer with missing bones	A broken rig that otherwise shows up as a distortion
Non-uniform scale on the root	Distorts every binding, and nobody suspects it there
No Animator	Normal for a prop - stated so it does not surprise you later

When the model changes underneath

If the source model is reimported between sessions, the draft can end up describing a hierarchy that no longer exists. Rig Edit checks on entry and warns in the HUD when entries could not be placed, naming them - a commit at that point would quietly skip them.

A reimport that changed nothing relevant says so once and then stops mentioning it.

Hotkeys

Action	Default
Create a bone	B
Extend / shorten the chain	= / -
Rename the selection	F2
Remove the selected draft entry	Delete / Backspace
Commit	Ctrl+Enter
Clear the weight shading, then the selection, then leave	Escape
Frame the selection	F
Undo a draft change, or one brush stroke	Ctrl+Z
Brush size	Ctrl+Wheel
Brush strength	Shift+Wheel
Snap while rotating	Hold Ctrl

All rebindable ones are under Settings ▸ Hotkeys ▸ Rig Edit.

The Move/Rotate switch is a chip in the bar rather than W/E on purpose: those two keys are Unity's flythrough navigation, and a mode that swallows them takes your camera away.

Lite and Pro

Rig Edit is completely free in Lite - no limits, no gates. See Lite & Pro.