Transform Skin Resize

Transform_SkinResize is the node you use to change the thickness of a Blender Skin modifier's "bones." If you've never touched the Skin modifier, here's the thirty-second version: it turns a bare point cloud of vertices into an organic tube-shaped mesh, with each vertex acting like a joint and the radii controlling how fat the tube is at that joint. Resizing those radii is how you sculpt the silhouette - fatten a torso, taper a limb. This node is Blender's bpy.ops.transform.skin_resize, wrapped up for ComfyUI.

When you'd use it

Skin-based meshes aren't the main path in the stock avatar templates - those build flat textured layers for face rigging - but they're a great way to prototype a body or an armature for an avatar, because you can block out a whole figure from a handful of vertices and then inflate it. Transform_SkinResize is how you shape that inflation programmatically. It's also the kind of node you reach for when a skin mesh comes out of some other step looking like a stick figure and you need to put meat on it.

How it works

The node is an auto-generated wrapper over the skin_resize transform operator, built from the transfrom_api list in blender/ops_mesh.py. Because it's a transform operator, it inherits from EditOps - so it deselects everything, makes your object active, drops into edit mode, runs the resize, and returns to object mode before handing the object back.

The input that does the actual work is value (a B_VECTOR3): the scale multiplier applied to the selected skin vertices' radii, per axis. Everything else on the node is the standard transform-operator furniture - orient_type (GLOBAL/LOCAL/NORMAL/GIMBAL/VIEW/CURSOR/PARENT), constraint_axis, mirror, proportional editing controls (use_proportional_edit, proportional_edit_falloff, proportional_size, use_proportional_connected), and the snap settings. In practice you'll set value, possibly flip on use_proportional_edit to make the resize taper smoothly across nearby vertices, and ignore the rest.

Inputs and outputs

• BPY_OBJ (optional) - the skin mesh to resize.
• value - the per-axis resize amount (B_VECTOR3).
• orient_type / constraint_axis - which space the resize happens in and which axes are locked.
• use_proportional_edit + proportional_edit_falloff + proportional_size - for a smooth falloff instead of a hard cut.

Output: BPY_OBJ, the same object, now with fatter or thinner skin geometry. The mutation happens in the scene, not on the handle.

Install and gotchas

Same pack, same drill:

cd ComfyUI/custom_nodes
git clone https://github.com/avatechai/avatar-graph-comfyui.git
cd avatar-graph-comfyui && python -m pip install -r requirements.txt

or ComfyUI Manager → search "Avatar Graph". Needs Python 3.10 (bpy==3.6.0), and the first launch downloads the ~2.5GB SAM checkpoint plus mediapipe models. Remember the scene resets to factory settings every run - skin, radii, and all - and live preview needs --enable-cors-header.

One genuinely useful tip: because the resize scales selected vertices, and the wrapper deselects everything before running, you need to make sure the right vertices are actually selected at the point this node fires in your graph. Otherwise you'll resize nothing and wonder why the node is a no-op.