Vibration Pattern Test — Pulse, Wave, Custom Rhythms
Run preset rumble patterns or design your own sequences, with 0–100% intensity sliders for each motor. This vibration pattern test reveals how your controller handles changing magnitudes over time, the way real games actually drive rumble during play.
A single steady pulse doesn't tell you much about how your controller will feel during actual gameplay. Real games drive rumble in rhythms — a wave that builds and recedes during an engine rev, a sharp sawtooth attack on every gunshot, a heartbeat pattern when your health is low. Five preset rumble patterns let you feel how your pad handles each rhythm type, and the custom pattern designer lets you build your own multi-step sequences with independent left and right magnitudes per step. The adjustable rumble strength sliders apply across every preset and custom pattern, so you can run the same rhythm at light intensity to confirm the motors respond cleanly, then again at full power to verify peak performance. Every pattern shows live on a scrolling timeline as it plays.
Press a button to begin
Connect via USB or pair over Bluetooth, then press any button so the browser detects your pad. The Gamepad Vibration API is required.
Slide to any value between 0 and 100% for each motor. Patterns multiply their step magnitudes by these values, so the same pattern can be felt at any strength.
Custom intensity sliders multiply every pattern step — a pulse pattern with 60% left and 30% right will run all its preset magnitudes scaled to those values. Loop mode keeps a pattern running until you press Stop, useful for stress-testing motors over longer periods. The custom designer schedules each step as a separate vibration command, so the sequence accuracy depends on browser timing — expect a few milliseconds of variance between adjacent steps, particularly under heavy CPU load.
How rumble motors actually respond to rhythm
A vibration pattern looks like a clean sequence of magnitude values on paper, but motors don't switch instantly between values the way the API command does. There's spin-up time as the motor accelerates, spin-down inertia as it slows, and a meaningful gap between what your code requested and what your hand actually felt. Understanding these three properties is what separates a custom rumble pattern that feels great from one that sounds good in theory and feels muddy in practice.
Motor spin-up time — the lag between command and feel
When the Gamepad API sends a magnitude command, the motor starts from a stop and has to physically spin its eccentric weight up to the requested speed. On standard ERM motors — DualShock 4, Xbox One, Xbox Series — that ramp typically takes 50 to 100 milliseconds before peak rumble is felt. For a 500ms pulse that's barely noticeable, but for a 100ms step you've spent the entire duration ramping and the motor is just starting to feel right when the next step begins. This is why fast pulse patterns often feel weaker than the same magnitude held longer — you never actually reached the requested intensity, you just felt the ramp. The custom pattern designer above lets you experiment with this directly: try a 60ms pulse and a 300ms pulse at the same magnitude and you'll feel the difference clearly.
Spin-down inertia — the tail after the command ends
When a magnitude command ends, the motor doesn't stop instantly. The spinning eccentric weight has rotational inertia and keeps turning for another 60 to 120 milliseconds before friction brings it to rest. For pattern design this means consecutive steps with non-zero magnitudes blend together — the motor never gets to rest between them. If you want a clean rhythm where each pulse feels distinct, you need explicit zero-magnitude rest steps of at least 150ms between active steps. The heartbeat preset in the tool uses exactly this principle: its 80ms gap between the two close pulses is deliberately short to let them merge slightly, and the 520ms gap between heartbeats is deliberately long so each beat feels separate.
LRA fast response — millisecond-scale changes
The PS5 DualSense's linear resonant actuators don't have a spinning weight, so they don't suffer the spin-up or spin-down problem. An LRA can reach peak amplitude in roughly 5 to 15 milliseconds and stop in similar time, which means short fast patterns that feel muddy on Xbox controllers feel crisp and distinct on a DualSense. This is the technical reason PS5 games can use precise haptic patterns for things like rain droplets and footsteps where Xbox One games can't. The trade-off is peak amplitude — LRAs don't hit the same deep mechanical thump that a spinning ERM weight does, so they win on speed but lose on raw rumble force.
Common pattern observations, explained
Running the same preset on different controllers — or the same custom pattern at different intensities — reveals consistent patterns of behaviour that look like faults but are actually motor physics doing what motors do. Here are the three observations that come up most often when people first start designing rumble patterns.
My pulse pattern feels muddy, not sharp
The motor spin-down is overlapping with the next pulse's spin-up. Pulse rhythms with short gaps between active steps — typically anything under 150ms — leave the motor still spinning from the previous pulse when the next command arrives, so consecutive pulses blend into one extended rumble rather than feeling like distinct beats. Two fixes: increase the gap step duration to 200ms or more, or set the gap step to magnitude zero rather than just lower magnitude. The motor needs an explicit off-period to physically stop, not just a quieter command.
Sawtooth feels weaker than pulse at the same magnitude
The sharp attack phase of a sawtooth is too short for the motor to reach peak magnitude. A sawtooth's defining feature is the abrupt jump from zero to full power, but if that full-power step lasts only 80ms the motor is still ramping when the decay begins. By the time the motor would have reached peak amplitude, the command has already dropped to 70% or lower. To get a felt sawtooth attack on ERM hardware, the attack step needs at least 120ms at full magnitude — and even then expect to feel about 75% of the perceived peak you'd get from a 300ms steady pulse at the same magnitude.
Heartbeat feels different on left versus right motor
The two motors have different masses and therefore different spin-up curves. The right motor — the smaller high-frequency one — reaches peak roughly 30% faster than the left, which means short-duration steps land more accurately on the right side than the left. For a 120ms heartbeat pulse, the right motor hits a true 100% peak while the left motor hits closer to 75% perceived intensity. This asymmetry is normal and not a fault. If you want a heartbeat that feels balanced across both sides, set the left magnitude slightly higher than the right in your custom pattern — something like L=1.0, R=0.8 — to compensate for the timing difference.
Building custom patterns that work on real hardware
The custom designer in the tool above lets you build any sequence you can imagine, but not every sequence will feel the way you expect when the motor physics enters the picture. These five guidelines take theory and turn it into patterns that work consistently across DualSense, DualShock 4, Xbox Series, and Xbox One pads.
Don't go shorter than 80ms per active step
On ERM-based controllers — every Xbox pad and the DualShock 4 — the motor takes 50 to 100 milliseconds to ramp from rest. Steps shorter than 80ms never reach their requested magnitude on those pads; you're feeling the ramp, not the target. DualSense LRAs can handle steps as short as 20ms cleanly, but designing patterns that depend on those short steps means your pattern only feels right on PS5 hardware. For cross-controller patterns, 80ms is the practical floor.
Add explicit rest steps between active steps
Two non-zero steps back-to-back will blend on ERM motors because the spin-down from the first overlaps the spin-up of the second. To get distinct rhythm, separate magnitude steps with a zero-magnitude rest of at least 150ms. The pulse preset in the tool uses 240ms rest steps for exactly this reason — they're long enough to let the motor fully stop, so each pulse feels like a discrete event rather than part of a continuous rumble.
Compensate for asymmetric motor response
The left and right motors don't ramp at the same rate. The right motor reaches peak roughly 30% faster than the left, so short steps land with more punch on the right side. For patterns where you want symmetric feel — explosions, impacts, balanced rhythms — boost the left magnitude by 15 to 25% over the right to compensate. For patterns where you want asymmetric feel — left-heavy footsteps, right-heavy weapon haptics — let the asymmetry stand and use it deliberately.
Test in loop mode to catch fatigue patterns
A pattern that feels great on the first playthrough can become irritating after fifty iterations. Loop mode in the tool runs the same pattern continuously, which surfaces two problems that single-play testing misses: motor fatigue (the magnitude felt slowly drops after several cycles as the motor warms and friction changes), and user fatigue (some rhythms that feel exciting once become grating on repetition). Pattern designs intended for in-game use should survive at least 30 seconds of loop playback without becoming annoying.
Save working patterns for game use
The custom designer in the tool above isn't persistent — close the page and your sequence is gone. Once a pattern works, capture it by screenshotting the step list or writing the magnitudes and durations down. Several PC tools (DS4Windows, JoyShockMapper, reWASD) accept custom rumble profiles and can apply them to specific games. For game developers, the same step sequences translate directly into engine-level rumble APIs in Unity, Unreal, and Godot — the magnitude and duration numbers you've tested here are the same units those engines accept.
Vibration pattern questions, answered
Honest answers to the questions pattern designers and players actually ask after running custom rumble sequences — the cross-controller behaviour, the export paths into real games, and the technical limits of browser-based pattern playback.
Can I save my custom patterns and use them later?
The custom designer in the tool above doesn't persist your sequence when you close the page — it lives only in browser memory while you're working on it. To save a pattern, the practical approach is to screenshot the step list while it's built, or write the step values down as a list of triples (left magnitude, right magnitude, duration). Each step in the designer shows exactly those three numbers, so reproducing the pattern later is straightforward. For developers, the same values translate directly into engine-level rumble code in Unity, Unreal, and Godot. For players using PC remapping tools, DS4Windows and reWASD both accept custom rumble sequences with the same three-value format.
Why do my patterns feel different on different controllers?
The motor hardware varies meaningfully between controllers, and the same magnitude command produces different felt rumble depending on which hardware receives it. DualShock 4 and Xbox controllers use eccentric rotating mass motors that take 50 to 100 milliseconds to ramp up to peak — fast pulse patterns lose punch on these pads because the motor never finishes spinning up before the next step. The DualSense uses linear resonant actuators that reach peak in 5 to 15 milliseconds, so the same pattern feels crisp and distinct. Third-party pads use either smaller versions of the same ERM technology or in some cases simpler single-motor implementations that don't respond to left and right magnitudes separately. A pattern designed and tuned on one controller will reliably feel different on another, and there is no universal fix for this beyond designing patterns for the lowest common denominator (80ms minimum steps with explicit rest periods).
What's the difference between vibration and haptic feedback?
The two terms get used interchangeably but they describe different things technically. Vibration is the generic term — any motor-driven shaking, regardless of precision. Haptic feedback refers specifically to precise, controllable tactile output capable of conveying texture, position, or distinct events rather than just "more rumble." Traditional ERM rumble is vibration; the DualSense's LRA-driven fine effects (rain droplets, footsteps on different surfaces, weapon-specific recoil) are haptic feedback in the stricter sense. The Gamepad API exposes only the basic vibration channel, which is why even on a DualSense this tool can drive the actuators with patterns but can't access the textural haptics PS5 games use. Those richer effects need Sony's native DualSense SDK, which web pages don't have access to.
Can I actually use these patterns in real games?
Three practical paths exist. For PC players, remapping tools like DS4Windows,
JoyShockMapper, and reWASD accept custom rumble profiles bound to specific game
events — you can map a designed pattern to trigger when a particular weapon fires
or when health drops below a threshold. For game developers, the magnitude and
duration values from the tool translate directly into Unity's
Gamepad.SetMotorSpeeds, Unreal's SetForceFeedbackValues,
and Godot's Input.start_joy_vibration calls. For console players
without dev tools, there's no path — Sony and Microsoft both lock rumble control
to the game itself, so designed patterns can be tested in browsers but not injected
into running PS5 or Xbox games.
Why does the looping pattern slowly feel weaker over time?
Two things are happening, both physical. The motor warms during sustained use, which changes the friction characteristics of the bearings and the internal viscosity of any lubricant — the same magnitude command produces slightly less rotational acceleration when the motor is warm than when it's cold. Separately, your hand adapts to the sensation through a process called sensory adaptation, the same mechanism that makes a constant sound seem quieter after you've heard it for a while. Both effects are normal and recover within a minute or two of rest. If a looping pattern dramatically drops in intensity within the first 30 seconds, that's the motor; if it drops gradually over several minutes, that's your perception adapting.
My DualSense feels patterns differently here than in PS5 games. Why?
Web browsers access the DualSense through the standard Gamepad Vibration API, which exposes only two channels — the strong magnitude and the weak magnitude. PS5 games access the same hardware through Sony's full DualSense SDK, which exposes the actuators at a much lower level, including direct waveform control, individual actuator addressing, and the adaptive trigger motors. The result is that a PS5 game can produce rumble effects on the DualSense that this tool — and any other browser-based tool — fundamentally cannot replicate. The actuators are capable of those richer effects; the web API just doesn't let you reach them. This is also why DualSense haptics testing on the web tends to feel underwhelming compared to the same hardware in a game like Returnal or Astro's Playroom.
Are there standard rumble patterns I should test against?
Game industry conventions exist for a handful of common patterns and they're the ones the preset library in this tool covers deliberately. Pulse is the standard damage-notification rhythm. Wave is the standard engine-rev or charging-up pattern. Sawtooth is the standard weapon-fire feel (sharp attack, decay to next shot). Heartbeat is the standard low-health warning across most action games. Morse SOS isn't typically used in games but it's a useful timing-recognition test because the rhythm is so recognisable that small timing errors become audible. There's no formal industry specification for rumble patterns, so "standard" here means "what most games actually use" rather than "what a standards body has published" — but the conventions are consistent enough that a designer following them will produce patterns that feel familiar to players.
Can rumble patterns cause hearing or balance issues?
For most players, no — controller rumble at normal magnitudes is safe and games have used it for decades without harm. There are real exceptions worth knowing about. Sustained high-intensity vibration can briefly affect fine motor control in the hand holding the controller, particularly during long loop testing at 100% magnitude — this resolves within a minute of putting the pad down. Users with vestibular sensitivities (some people with migraines, certain inner-ear conditions) can experience nausea from extended exposure to rhythmic vibration, similar to motion sickness. Hearing aid users sometimes report interference from controller rumble held close to the head, which is mechanical resonance rather than electrical. If you experience any of these effects, stop testing and put the controller down; the symptoms clear quickly without treatment. The tool's loop mode is the most likely source of discomfort because it sustains the magnitude longer than any game would, so use it for stress-testing motors rather than casual play.
How accurate is the pattern timing in the browser?
Good enough for pattern design, not good enough for shipping production-quality
haptic timing. The tool schedules each pattern step with JavaScript timers
(setTimeout), which the browser typically honours within 5 to 10
milliseconds under normal load. Under heavy CPU load — other tabs running
intensive work, background downloads, system updates — that variance can rise to
30 milliseconds or more for individual steps. For designing and tuning the feel
of a pattern, this is fine because you're listening to the rhythm rather than
measuring it. For shipping a precisely-timed haptic effect in a game, native engine
APIs are an order of magnitude more accurate because they run on a dedicated audio
thread with much tighter scheduling guarantees than browser JavaScript can offer.
Design here, ship in engine.