Auto Jerk Rig Puller: How It Works, Plus a Three.js Version

An auto jerk rig puller is a small motorized unit that pulls the cord on a duck decoy jerk rig for you, so the decoys bob and throw ripples on a steady cycle while you sit still in the blind. This post covers how one works, whether to buy or build one, and the mistakes people make with them. It then switches to game development: if you’re making a duck hunting game, the same motion takes only a few lines of code, and the characters around it can come from an AI pipeline.

What is an auto jerk rig puller?

Start with the jerk rig itself. A jerk rig (also called a jerk string or jerk cord) is a long line anchored out in the water with several decoys tied to it on short drop lines. You hold the free end in the blind. When you pull, the decoys lurch forward, dip and settle, sending ripples across the surface. Calm water with motionless decoys looks fake to birds, and ripples look like live ducks feeding and swimming.

The weak point is you. Pulling a cord for hours is tiring, you move every time you pull, and once you raise the gun the spread goes dead. An auto jerk rig puller takes that job over. A motor, usually a low-RPM 12V unit, drives an arm or pulley that tugs the cord and releases it, over and over. Commercial units mount on a frame or stake, and many have a speed controller so you can make the motion faster or slower. Homemade versions do the same job with salvaged parts.

Put simply, it is a timer with a motor attached to a string. That simple idea is also why it is easy to copy in a game, as later sections show.

How an auto jerk rig puller works

Every auto jerk rig puller, bought or built, has the same five parts:

• Motor. A slow, high-torque motor. Low RPM matters more than power: you want a firm tug every second or two, not a blur.
• Arm or pulley. An offset arm on the motor shaft turns rotation into a pull-and-release stroke. The length of the arm sets how far the cord moves on each pull.
• Power. A 12V battery, or a power tool battery on some commercial units.
• Control. At minimum an on/off switch. Better units add a speed controller or a remote so you can change the rhythm without leaving cover.
• Mount. A stake, pole or frame that holds the unit still. If the mount flexes, the pull goes into wobbling the pole instead of moving the decoys.

On the water side, the main cord runs from the puller out to an anchor weight, and the decoys clip onto it with short drop lines. Each pull tightens the cord, the decoys move toward the puller and nose down, and when the cord goes slack they drift back. The decoy nearest the puller moves first and the farthest one moves a moment later, which gives the spread a natural, uneven look.

Speed and rhythm

Live ducks don’t move like a metronome. A jerk rig looks most convincing with short tugs followed by a pause long enough for the ripples to spread out. A puller running flat out makes the water choppy and the motion mechanical. That is why a speed controller matters on an automatic jerk rig: you set the pace for the conditions, slower on glassy water and a bit faster when there’s chop to cut through.

Buying vs building a DIY auto jerk rig puller

Commercial units sell on build quality: aluminum frames, sealed motors, speed controllers and sometimes remotes. Homemade builds sell on cost and the fun of building one. Here is how the two compare:

	Commercial puller	DIY auto jerk rig puller
Motor	Matched low-RPM 12V motor	Often a salvaged windshield wiper motor
Speed control	Built in on many models	Add your own PWM controller, or run fixed speed
Weatherproofing	Designed in	Up to you: a sealed box and covered wiring
Mounting	Frame or stake included	PVC, wood box on a pole, or a metal stake
Main risk	Cost	Water getting in and failing at dawn

Mistakes people make

• Too much speed. Constant hard tugs look like panic, not feeding. Leave pauses.
• A loose anchor. If the anchor drags, every pull reels the whole spread toward you.
• Skipping waterproofing. Motors and switches at water level get splashed. Seal the box and route the wiring through the bottom.
• Not checking the rules. Waterfowl regulations differ by state and country, and some places restrict powered motion decoys. Check your local regulations before you hunt with a motorized unit.
• Losing manual control. Run the puller for background motion, but keep a way to stop it when birds commit, because a sudden freeze can look as odd as constant motion.

For a longer look at the system as a whole, see our earlier post on the automatic jerk rig system for hunting games.

Auto jerk rig vs auto rig: two different kinds of rig

If you came here from the 3D side, you may have expected something else. In 3D graphics, a rig is the internal skeleton of bones that moves a character’s mesh (the surface made of polygons). Adding that skeleton and deciding how strongly each bone pulls on each part of the surface is called rigging, and that per-bone influence is called weight painting. Wikipedia’s article on skeletal animation covers the idea: a mesh for the visible surface and a hierarchy of bones that drives it.

An “auto rig” tool attaches that skeleton automatically. Auto-Rig Pro is a well-known Blender add-on for this, and Mixamo’s auto-rigger does it for humanoid characters uploaded to the web. None of these have anything to do with an auto jerk rig puller. The overlap is only in the word.

The two topics do meet in one place: a duck hunting game. You need decoys that move like a jerk rig and a rigged hunter character to put next to them. The next two sections cover both.

Building a virtual auto jerk rig puller in Three.js

Decoys are rigid objects. They don’t bend, so they don’t need a skeleton or morph targets (stored mesh shapes you blend between). You move the whole object with code. To build a virtual auto jerk rig puller you need three pieces:

1. A timer that fires a pull every few seconds, with some randomness so it doesn’t feel mechanical.
2. A damped spring on each decoy. A pull gives it a burst of speed, the spring pulls it back, and damping makes it settle instead of bouncing forever.
3. A small per-decoy delay, so the pull travels down the line the way it does on a real cord, plus an expanding ripple ring on each kick.

Here is a complete, runnable example. Boxes stand in for decoy models; swap them for your own GLB files later.

import * as THREE from 'three';

const scene = new THREE.Scene();
scene.background = new THREE.Color(0x9fb8c8);
const camera = new THREE.PerspectiveCamera(50, innerWidth / innerHeight, 0.1, 100);
camera.position.set(0, 6, 10);
camera.lookAt(0, 0, 0);
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
scene.add(new THREE.HemisphereLight(0xffffff, 0x334455, 1.2));

const water = new THREE.Mesh(
  new THREE.PlaneGeometry(40, 40),
  new THREE.MeshStandardMaterial({ color: 0x2f5d6b })
);
water.rotation.x = -Math.PI / 2;
scene.add(water);

// Decoys on the "cord": each one has a spring state and a delay
const decoys = [];
for (let i = 0; i < 6; i++) {
  const decoy = new THREE.Mesh(
    new THREE.BoxGeometry(0.6, 0.3, 1),
    new THREE.MeshStandardMaterial({ color: 0x5a4632 })
  );
  const baseZ = Math.sin(i) * 0.8;
  decoy.position.set(-3 + i * 1.2, 0.15, baseZ);
  decoy.userData = { baseZ, offset: 0, velocity: 0, delay: i * 0.08, kickAt: null };
  scene.add(decoy);
  decoys.push(decoy);
}

// Ripple rings that grow and fade
const ripples = [];
function spawnRipple(x, z) {
  const ring = new THREE.Mesh(
    new THREE.RingGeometry(0.3, 0.36, 32),
    new THREE.MeshBasicMaterial({ color: 0xffffff, transparent: true, opacity: 0.6 })
  );
  ring.rotation.x = -Math.PI / 2;
  ring.position.set(x, 0.01, z);
  ring.userData.age = 0;
  scene.add(ring);
  ripples.push(ring);
}

// The puller: one pull every 2.5 s plus up to 1 s of random jitter
const PULL_EVERY = 2.5;
const JITTER = 1.0;
const STIFFNESS = 20;
const DAMPING = 4;
let nextPull = 1;
let last = performance.now();

function animate(now) {
  requestAnimationFrame(animate);
  const dt = Math.min((now - last) / 1000, 0.05);
  last = now;
  const t = now / 1000;

  if (t >= nextPull) {
    for (const d of decoys) d.userData.kickAt = t + d.userData.delay;
    nextPull = t + PULL_EVERY + Math.random() * JITTER;
  }

  for (const d of decoys) {
    const u = d.userData;
    if (u.kickAt !== null && t >= u.kickAt) {
      u.velocity += 2.5;
      u.kickAt = null;
      spawnRipple(d.position.x, d.position.z);
    }
    const accel = -STIFFNESS * u.offset - DAMPING * u.velocity;
    u.velocity += accel * dt;
    u.offset += u.velocity * dt;
    d.position.z = u.baseZ + u.offset;
    d.rotation.x = u.offset * 0.6; // nose dips on the pull
    d.position.y = 0.15 + Math.sin(t * 1.5 + u.baseZ) * 0.02; // idle bob
  }

  for (let i = ripples.length - 1; i >= 0; i--) {
    const r = ripples[i];
    r.userData.age += dt;
    const s = 1 + r.userData.age * 4;
    r.scale.set(s, s, 1);
    r.material.opacity = Math.max(0, 0.6 - r.userData.age * 0.4);
    if (r.userData.age > 1.5) {
      scene.remove(r);
      r.geometry.dispose();
      r.material.dispose();
      ripples.splice(i, 1);
    }
  }

  renderer.render(scene, camera);
}
requestAnimationFrame(animate);

Tuning it like a real puller

• PULL_EVERY and JITTER are your speed controller. Shorter gaps feel frantic, and longer gaps with jitter feel like feeding birds.
• STIFFNESS sets how sharp the lurch is. DAMPING sets how fast it settles. If decoys keep wobbling after a pull, raise damping.
• The delay per decoy recreates the cord pulling the nearest decoy first.
• For gameplay, tie the timer to a player toggle so the hunter can switch the puller on and off, just as they would in the blind.

This is ordinary procedural computer animation: the motion comes from rules rather than hand-keyed frames. The upside is that it never loops visibly, because the jitter makes every cycle a little different.

Making the hunter and decoy models with 3D Studio

The code covers the decoys’ motion. You still need art, and the hunter is the hard part, because a human character needs a proper skeleton, clean weights and animations. That is the job 3D Studio was built for. It chains the whole character pipeline in the browser, from a text idea to a rigged, animated, game-ready 3D character:

1. Generate. AI image generation turns your prompt into a concept character, for example “duck hunter in camo waders and a brimmed cap, holding a call.”
2. Lift to 3D. One-click image-to-3D turns that concept into a fully textured model. Building it by hand is traditional 3D modeling, which can take an experienced artist a long time.
3. Auto-rig and weight paint. A humanoid skeleton is attached automatically and the weights are refined, which is the same job Mixamo’s or Auto-Rig Pro’s auto rig does in other tools.
4. Text-to-animation and export. Describe the motion, such as “crouch in the blind, then stand and raise the shotgun,” and export to FBX, GLB or GLTF for any engine, including the Three.js scene above.

The 3D Studio overview shows the full pipeline. If you already have a humanoid model from another source, Auto-Rigging handles that step on its own: it auto-rigs humanoid 3D models and includes weight-paint refinement. It needs a paid Sorceress membership (Pro).

Decoys are simpler. They are rigid props, so they need a textured mesh and no skeleton. Any model works, and our guide to making a 3D model from a 2D image compares the options. Drop the GLB into the scene in place of the boxes and keep the same spring code.

If your game is voxel-styled

For a blocky look, Voxel Studio turns images, text prompts or existing 3D models into voxel creations. It automatically rigs humanoids, so your hunter can be voxel too, and it animates with plain-text motion prompts. Every asset exports into game-ready formats. Voxel decoys bobbing on a voxel pond, driven by the same puller code, make a quick game-jam scene.

If you’d rather describe the game than wire it up yourself, WizardGenie, Sorceress’s AI game engine, writes, runs and iterates on the game from your description. Paste in the puller logic above as a spec (“a timer pulls the decoy line every 2 to 3.5 seconds; decoys spring forward and settle; ripples spawn on each pull”) and it has a concrete target to build to. For animating other things from plain text, see our post on text-to-3D animation with Three.js.

Common mistakes when recreating decoy motion in a game

• Rigging the decoys. A decoy doesn’t bend. Giving it bones adds export weight and setup time for nothing. Move the whole object.
• Using a keyframed loop. A two-second animation clip on repeat is easy to spot. A timer with jitter plus a spring never repeats the same way twice.
• Moving every decoy at once. Without the per-decoy delay, the whole spread jumps together like a single object.
• Skipping ripples. On a real pond the ripples are what sell the motion, and the same holds in a game. A ring that grows and fades costs almost nothing to render.
• Frame-rate-dependent physics. Always multiply by dt and clamp it, as the example does, or the spring will explode when a browser tab regains focus.
• Treating the hunter like a prop. The hunter is the one model that does need a full rig. Use an auto-rigged humanoid from 3D Studio or Auto-Rigging, not a static mesh with a gun glued on.

The workflow at a glance

In the field, an auto jerk rig puller is a slow motor, an offset arm, a cord and an anchor, set to a rhythm that looks like feeding ducks. Buy one for reliability and a speed controller, or build one from a wiper motor and a sealed box if you enjoy the project. In both cases, leave pauses, anchor it firmly and check your local rules on powered motion decoys.

In a game, the same auto jerk rig puller becomes a timer with jitter, a damped spring per decoy, a short delay down the line and a ripple ring per kick. The decoys stay rigid. The hunter gets a real skeleton, and the quickest route there is 3D Studio: prompt, lift to 3D, auto-rig with weight painting, text-to-animation, then export to GLB for your Three.js scene. For audio, animation and the rest of the asset list, the Sorceress tools guide lists every tool in one place.