DIY Auto Jerk Rig: Parts, Build Steps and a Game Version

A DIY auto jerk rig is a jerk string, the anchor, bungee and line setup that duck hunters have pulled by hand for decades, with a small motor doing the pulling on a timer. The result is a decoy spread that keeps throwing ripples while your hands stay free for the call and the gun. This guide covers the parts, the layout, the motor and timer options, the mistakes that kill the motion, and then a bonus for game developers: how to recreate the same rig in a 3D hunting game.

What a DIY auto jerk rig does and why it works

Ducks circling a spread look for movement. Real birds feed, preen and paddle, which keeps the water around them broken up with small rings. A static spread on glassy water looks dead from above, and wary birds flare off. A jerk rig fixes that by tugging a few decoys forward in short bursts so their bills dip and ripples roll outward across the whole spread.

Every jerk rig has the same two halves:

• The energy store: an anchor on the far end and a stretch of bungee or shock cord. When you pull, the bungee stretches. When you let go, it snaps the line and decoys back.
• The puller: your hand on a hand-held line, or, in an auto rig, a motor turning a crank arm that pulls and releases the line on a schedule.

The “auto” part only replaces the puller. That matters, because it means a DIY auto jerk rig is really two projects: a good manual jerk string, and a reliable motor box that pulls it. If the string is wrong, no motor will save it.

Parts list for a DIY auto jerk rig

Here is what goes into a typical home build. Exact lengths depend on your water depth and how far the blind sits from the spread.

The jerk string

• Anchor: a heavy decoy anchor, a mushroom anchor or a weighted stake that will not drag when the bungee stretches.
• Bungee or shock cord: a short section tied to the anchor. This is the return spring.
• Carabiner or snap: joins the bungee to the main line so you can unhook the rig fast.
• Main line: 550 paracord or heavy decoy cord, long enough to reach the puller.
• Decoy drops: short leaders with snaps or duck-butt clips that attach each decoy to the main line.
• Swivels: optional, but they stop the line from twisting over a long day.

The “auto” half

• 12V gear motor: salvaged windshield wiper motors are the classic pick because they are slow, torquey and built to live near water.
• Crank arm: a flat bar or wheel bolted to the motor shaft, with the line tied off-centre. The distance from the shaft to the tie point sets how far each pull travels.
• Power: a 12V battery sized for a full hunt, with an inline fuse close to the battery.
• Timer: a cycle timer relay, an intermittent controller, or a small microcontroller that runs the motor in bursts with pauses between.
• Mount: a stake, a board or a PVC frame that holds the motor above the waterline.
• Weatherproof box: keeps the battery, timer and wiring dry.

If you want to skip the build, commercial automatic pullers and complete jerk rig kits exist. A DIY auto jerk rig makes sense when you enjoy tinkering, already have a spare motor, or want to tune the pull pattern yourself.

How to build the manual jerk string first

Build and hunt the hand-pulled version before you touch a motor. You will learn what good motion looks like on your water, and the motor box becomes a straight swap.

1. Set the anchor on the far side of the spread, out past where you want the last decoy. In current, put it upstream so the line does not bow.
2. Tie the bungee to the anchor and the carabiner to the other end of the bungee.
3. Clip the main line to the carabiner and run it back toward the blind.
4. Attach the decoys on short drops spaced a few feet apart. Three to six decoys is the usual range on a single line.
5. Bring the line to the blind and take up slack until the bungee carries a little tension at rest.
6. Test pull. A short, sharp tug should dip each bill and push a ring of water outward. Release and the bungee should drag the decoys back to their start positions.

Tune it now. If the decoys barely move, shorten the bungee or add tension. If they slam into each other, spread them out. If the line lifts out of the water and spooks birds, lower it by adding a small weight near the blind end. Once a hand pull looks right every time, you are ready to automate.

Adding the “auto”: motor, crank and timer

The motor box does one job: pull the line a fixed distance, release it, wait, and repeat. Here is how the pieces fit.

Mounting and the crank arm

Fix the motor to its stake or frame so the shaft sits above the waterline with the line running low and straight out to the spread. Bolt the crank arm to the shaft and tie the main line to a hole near the arm’s end. As the arm rotates, the tie point swings toward the blind, pulls the line, then swings back and gives slack to the bungee. A longer arm means a longer pull. Start short; a few inches of travel at the decoys is usually enough to make good rings.

PVC frames

A DIY auto jerk rig made from PVC is popular because the pipe is cheap, light, easy to cut and does not rot. Common designs are a T-frame that slides over a metal stake, or a box frame that sits on the bank. Some builders skip the crank entirely and use a PVC lever that pivots on a bolt, with the motor’s arm nudging one end. Either way, glue the joints that carry load and leave a removable joint so the frame breaks down for transport.

Timing the pulls

Constant motion looks mechanical. Real ducks move in fits and pauses. Set the timer so the motor runs briefly, then rests for several seconds. If you use a microcontroller, add a little randomness to the rest period so the rhythm never repeats exactly. Have a way to kill the rig from the blind, either a switch on a long lead or a remote relay, because you will want the water calm when birds commit and land.

Wiring and safety

• Fuse the positive lead close to the battery.
• Seal connections and keep the battery inside the box, off the ground.
• Guard the crank so a sleeve, a dog’s collar or a decoy line cannot wrap around the shaft.
• Check your state and area waterfowl rules before using any powered decoy. Rules on motion decoys differ by location and can change between seasons.

Common mistakes and how the options compare

Most failed rigs fail in the same handful of ways:

• Anchor drags. The bungee only works if the anchor holds. A light anchor creeps toward the blind until the rig goes slack.
• Too many decoys on one line. Drag adds up, and the motor or your arm moves everything a little instead of moving a few decoys a lot.
• No slack management. Too much slack and the pull never reaches the decoys; too little and they sit pinned and never return.
• Line above the surface. A line that pops out of the water every pull is visible from the air.
• Metronome timing. A perfectly regular pull looks fake. Vary it.
• Wet electronics. A dead battery or shorted timer halfway through the morning is the most common way an auto rig ends up hand-pulled.

Option	Effort to build	Hands-free	Best for
Manual jerk string	Low	No	Learning motion, small spreads, simple setups
PVC lever rig	Medium	Partly, if motor-driven	Builders who want a cheap, light frame
Motor and crank DIY auto jerk rig	Medium to high	Yes	Solo hunters who need both hands for calling
Commercial automatic puller or kit	None	Yes	Hunters who want it working out of the box

Building the same jerk rig in a duck hunting game

If you are making a waterfowl game, the decoy spread needs the same life a real one does, and the good news is that the physics is simple. A jerk rig is a spring (the bungee) with damping (the water) hit by a periodic impulse (the motor). Decoys do not need a skeleton for this; a short function moving each mesh is enough. We covered the theory behind powered pullers in how an auto jerk rig puller works; here is a compact, complete Three.js scene you can paste into a module and run.

import * as THREE from 'three';

const scene = new THREE.Scene();
scene.background = new THREE.Color(0x8fa8b8);
const camera = new THREE.PerspectiveCamera(50, innerWidth / innerHeight, 0.1, 100);
camera.position.set(0, 4, 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: 0x2f4f5f })
);
water.rotation.x = -Math.PI / 2;
scene.add(water);

// Five decoys on one line, each reacting slightly later than the last
const decoys = [];
for (let i = 0; i < 5; i++) {
  const mesh = new THREE.Mesh(
    new THREE.BoxGeometry(0.6, 0.3, 1),
    new THREE.MeshStandardMaterial({ color: 0x5a4a32 })
  );
  mesh.position.set(-4 + i * 2, 0.15, 0);
  scene.add(mesh);
  decoys.push({ mesh, offset: 0, velocity: 0, delay: (4 - i) * 0.08 });
}

const STIFFNESS = 30; // bungee strength
const DAMPING = 4;    // water drag
const PULL = 3;       // impulse per jerk
const clock = new THREE.Clock();
let nextJerk = 2;
const pending = [];

function jerk(now) {
  decoys.forEach(d => pending.push({ d, at: now + d.delay }));
  nextJerk = now + 3 + Math.random() * 3; // irregular, like a real rig
}

renderer.setAnimationLoop(() => {
  const dt = Math.min(clock.getDelta(), 0.05);
  const now = clock.elapsedTime;
  if (now >= nextJerk) jerk(now);

  for (let i = pending.length - 1; i >= 0; i--) {
    if (now >= pending[i].at) {
      pending[i].d.velocity += PULL;
      pending.splice(i, 1);
    }
  }

  for (const d of decoys) {
    const accel = -STIFFNESS * d.offset - DAMPING * d.velocity;
    d.velocity += accel * dt;
    d.offset += d.velocity * dt;
    d.mesh.position.z = d.offset;                       // toward the blind
    d.mesh.rotation.x = -d.velocity * 0.08;             // bill dips on the pull
    d.mesh.position.y = 0.15 - Math.abs(d.velocity) * 0.02;
  }

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

Notice how the code mirrors the real build: STIFFNESS is your bungee, DAMPING is the water, the random nextJerk is a timer with variation, and the per-decoy delay is the line tension travelling down the string. Swap the boxes for real decoy models and you have a believable spread.

For deforming parts that are not driven by bones, such as a decoy’s inflatable wing or a ripple decal, morph target animation stores deformed versions of a mesh and blends between them, which is another option for cheap secondary motion.

Rigging the hunter and creatures with 3D Studio

Decoys can get away with code. The hunter cannot. A character who wades, raises a shotgun and blows a call needs a rig, which is a skeleton bound to the mesh so bones can drive the surface. Wikipedia’s page on skeletal animation explains the split: a polygon mesh for the surface and a hierarchy of bones underneath that moves it. Building and weight painting a rig by hand, in Blender with add-ons like Auto-Rig Pro or by uploading to Mixamo’s auto rig, works, but it is a separate skill from making the game.

3D Studio chains the whole character pipeline in the browser. You type an idea and it walks through four steps:

1. Generate: AI image generation turns your prompt, say “duck hunter in camo waders and a brimmed hat, game character”, into a concept character.
2. Lift to 3D: one-click image-to-3D produces a fully textured model. If you are new to the idea of turning a picture into geometry, 3D modeling is the general process of building that coordinate-based surface.
3. Auto-rig and weight paint: a humanoid skeleton is attached automatically and the weights are refined.
4. Text-to-animation and export: describe the motion, such as “crouch in the blind, then stand and shoulder a shotgun”, and export to FBX, GLB or GLTF for whatever engine you use.

The GLB export drops straight into the Three.js scene above with GLTFLoader, so the rigged hunter can stand in a blind overlooking your spring-driven decoys. The 3D Studio overview shows each stage in more detail.

When you already have a model

If you modelled the hunter yourself or bought one, Auto-Rigging handles just the rigging step: it auto-rigs humanoid 3D models and adds weight-paint refinement. It needs a paid Sorceress membership (Pro).

Voxel-style hunting games

For a blocky art style, Voxel Studio turns images, text prompts or 3D models into voxel creations, automatically rigs humanoids, procedurally rigs multi-legged creatures such as a retriever, and animates them from plain-text motion prompts, with game-ready exports. Round out the scene with marsh ambience and call sounds from Sound Studio, and if you want an AI to wire the whole game together, WizardGenie writes and iterates on game code from a description. The tools guide lists every option in one place.

The build at a glance

• String first: anchor, bungee, carabiner, main line, three to six decoys on short drops. Tune it by hand until every pull dips bills and makes rings.
• Then the motor: a 12V gear motor with a short crank arm, a fused battery, and a timer that pulls in bursts with irregular rests.
• Mount it dry: stake, board or PVC frame above the waterline, electronics in a sealed box, a kill switch within reach.
• Check the rules for powered decoys where you hunt.
• For a game: drive decoys with a damped spring on a timer, and give the hunter a real rig. 3D Studio takes a prompt to a rigged, animated character exported as FBX, GLB or GLTF.

A DIY auto jerk rig is a weekend project once the manual string works. Get the motion right on the water first, automate second, and the same spring-and-impulse idea will carry over to any hunting game you build.