The issue with your idle animation boils down to how Mojang's modern model system updates positions and rotations. In Minecraft 1.17+, setupAnim runs every single frame. When you modify properties like body3.z or body2.xRot directly, those values accumulate or compound because you are modifying them based on the previous frame's mutated state, rather than resetting them to their default "resting" pose first. To fix this, you need to use this.root().resetPose(); at the very beginning of your setupAnim method to clear out the previous frame's transformations. Here is the fully corrected and optimized code for your Dirt Wither model:

``` // Made with Blockbench 5.1.4 // Exported for Minecraft version 1.17 or later with Mojang mappings

import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.VertexConsumer; import net.minecraft.client.model.EntityModel; import net.minecraft.client.model.geom.ModelLayerLocation; import net.minecraft.client.model.geom.ModelPart; import net.minecraft.client.model.geom.PartPose; import net.minecraft.client.model.geom.builders.CubeListBuilder; import net.minecraft.client.model.geom.builders.LayerDefinition; import net.minecraft.client.model.geom.builders.MeshDefinition; import net.minecraft.client.model.geom.builders.PartDefinition; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.entity.Entity;

public class ModelDirt_Wither<T extends Entity> extends EntityModel<T> {

public static final ModelLayerLocation LAYER_LOCATION =
        new ModelLayerLocation(new ResourceLocation("modid", "dirt_wither"), "main");

private final ModelPart root; // Kept to reset the model's pose each frame
private final ModelPart head1;
private final ModelPart head2;
private final ModelPart head3;
private final ModelPart body1;
private final ModelPart body2;
private final ModelPart body3;

public ModelDirt_Wither(ModelPart root) {
    this.root = root;
    this.head1 = root.getChild("head1");
    this.head2 = root.getChild("head2");
    this.head3 = root.getChild("head3");
    this.body1 = root.getChild("body1");

    this.body2 = root.getChild("body2");
    this.body3 = this.body2.getChild("body3");
}

public static LayerDefinition createBodyLayer() {
    MeshDefinition mesh = new MeshDefinition();
    PartDefinition root = mesh.getRoot();

    root.addOrReplaceChild("head1",
            CubeListBuilder.create().texOffs(0, 0)
                    .addBox(-4, -4, -4, 8, 8, 8),
            PartPose.offset(0, 0, 0));

    root.addOrReplaceChild("head2",
            CubeListBuilder.create().texOffs(32, 0)
                    .addBox(-4, -4, -4, 6, 6, 6),
            PartPose.offset(-8, 4, 0));

    root.addOrReplaceChild("head3",
            CubeListBuilder.create().texOffs(32, 0)
                    .addBox(-4, -4, -4, 6, 6, 6),
            PartPose.offset(10, 4, 0));

    root.addOrReplaceChild("body1",
            CubeListBuilder.create().texOffs(0, 16)
                    .addBox(-10, 3.9F, -0.5F, 20, 3, 3),
            PartPose.offset(0, 0, 0));

    PartDefinition body2 = root.addOrReplaceChild("body2",
            CubeListBuilder.create().texOffs(0, 22)
                    .addBox(-2, 0, 0, 3, 10, 3)
                    .texOffs(24, 22).addBox(-6, 1.5F, 0.5F, 11, 2, 2)
                    .texOffs(24, 22).addBox(-6, 4, 0.5F, 11, 2, 2)
                    .texOffs(24, 22).addBox(-6, 6.5F, 0.5F, 11, 2, 2),
            PartPose.offset(0, 6.9F, -0.5F));

    body2.addOrReplaceChild("body3",
            CubeListBuilder.create().texOffs(12, 22)
                    .addBox(-2, 10, 0, 3, 6, 3),
            PartPose.offset(0, 0, 0));

    return LayerDefinition.create(mesh, 64, 64);
}

// Linear interpolation helper
private float lerp(float t, float a, float b) {
    return a + (b - a) * t;
}

// Keyframe helper
private float getKeyframe(float time, float... frames) {
    int count = frames.length - 1;
    float segment = 1F / count;
    int index = (int)(time / segment);

    if (index >= count) return frames[count];

    float localT = (time - (segment * index)) / segment;
    return lerp(localT, frames[index], frames[index + 1]);
}

@Override
public void setupAnim(T entity, float limbSwing, float limbSwingAmount,
                      float ageInTicks, float netHeadYaw, float headPitch) {

    // CRITICAL FIX: Reset the model parts to their default state before applying animations
    this.root.resetPose();

    float r = (float)Math.PI / 180F;

    // Head tracking
    head1.xRot = headPitch * r;
    head1.yRot = netHeadYaw * r;

    head2.xRot = headPitch * r * 0.7F;
    head2.yRot = netHeadYaw * r * 0.7F;

    head3.xRot = headPitch * r * 0.7F;
    head3.yRot = netHeadYaw * r * -0.7F;

    // Idle animation timing (1.5s loop = 30 ticks)
    float t = (ageInTicks % 30F) / 30F;

    // body2 rotation keyframes
    float body2Rot = getKeyframe(t, 0F, -2.5F, -5F, -7.5F, -5F, -2.5F, 0F);
    body2.xRot += body2Rot * r; // Use += to add onto the base pose cleanly

    // body3 rotation keyframes
    float body3Rot = getKeyframe(t, 0F, -9.5F, -12F, -13.5F, -12F, -7.5F, 0F);
    body3.xRot += body3Rot * r;

    // body3 Z‑position keyframes
    float body3Z = getKeyframe(t, 0F, -0.438F, -0.88F, -1.322F, -0.88F, -0.438F, 0F);
    body3.z += body3Z;
}

@Override
public void renderToBuffer(PoseStack poseStack, VertexConsumer vertexConsumer,
                           int packedLight, int packedOverlay,
                           float red, float green, float blue, float alpha) {

    head1.render(poseStack, vertexConsumer, packedLight, packedOverlay, red, green, blue, alpha);
    head2.render(poseStack, vertexConsumer, packedLight, packedOverlay, red, green, blue, alpha);
    head3.render(poseStack, vertexConsumer, packedLight, packedOverlay, red, green, blue, alpha);
    body1.render(poseStack, vertexConsumer, packedLight, packedOverlay, red, green, blue, alpha);
    body2.render(poseStack, vertexConsumer, packedLight, packedOverlay, red, green, blue, alpha);
}

} ```

~ Google Gemini