Complete guide to all 14 HaptiQ funscript transformation plugins. Learn what each plugin does, recommended settings, how to chain them, and how to save presets for your workflow.
A raw funscript -- whether hand-crafted or AI-generated -- is rarely perfect on the first pass. It might have noise from motion tracking, speeds that exceed device capabilities, or an intensity that does not match your preference. This is where HaptiQ's 14 funscript transformation plugins come in. Each plugin addresses a specific aspect of script quality, and they can be chained together in any order to produce polished, device-optimized output. This guide covers every plugin in detail: what it does, when to use it, recommended settings, and how to combine plugins effectively.
HaptiQ includes 14 transformation plugins split between server-side (backend) and client-side (runs in your browser) execution. All HaptiQ Pro users have access to all 14 plugins. Free tier users have access to 3 basic plugins (smooth, amplify, invert).
| # | Plugin | Category | Execution | What It Does |
|---|---|---|---|---|
| 1 | Smooth (Moving Average) | Noise Reduction | Client | Averages nearby keyframes to reduce jitter |
| 2 | Savitzky-Golay Smooth | Noise Reduction | Client | Polynomial smoothing that preserves peaks |
| 3 | Anti-Jerk | Motion Quality | Client | Eliminates unrealistic acceleration spikes |
| 4 | Amplify | Intensity | Client | Scales position values around the midpoint |
| 5 | Invert | Orientation | Client | Flips the script (100 - pos for every action) |
| 6 | Clamp | Range Control | Client | Restricts positions to a min/max range |
| 7 | Speed Limiter | Device Safety | Client | Caps movement rate to device max speed |
| 8 | Time Shift | Timing | Client | Offsets all timestamps by a fixed amount |
| 9 | RDP Simplify | Optimization | Client | Reduces keyframe count using Ramer-Douglas-Peucker |
| 10 | Randomize | Variation | Server | Adds controlled random variation to positions |
| 11 | Quantize | Precision | Server | Snaps positions to discrete step levels |
| 12 | Halve | Intensity | Server | Reduces amplitude by 50% |
| 13 | Double | Intensity | Server | Doubles amplitude (clamped to 0-100) |
| 14 | Metronome | Pattern | Server | Generates rhythmic pattern at specified BPM |
The simplest smoothing algorithm. For each keyframe, it replaces the position value with the average of the surrounding N keyframes (the window size). This effectively filters out high-frequency noise and jitter, producing a smoother motion curve.
Parameters:
When to use: Quick cleanup of AI-generated scripts where you want overall smoothness and do not mind slightly reducing peak positions. Best for gentle, flowing content.
Trade-off: Moving average reduces all peaks and valleys equally. Fast direction changes get rounded off, which can make the script feel less responsive.
A more sophisticated smoothing algorithm that fits polynomial curves to local neighborhoods of keyframes. The Savitzky-Golay filter preserves the shape of peaks and valleys while removing noise between them. This makes it superior to simple moving average for haptic scripts where you want to keep the intensity of fast movements while cleaning up the transitions.
Parameters:
When to use: The recommended smoothing filter for most scripts. Particularly effective for VR content and AI-generated scripts where you want to remove tracking noise without flattening the motion.
Recommended settings: Window 7, polynomial order 3 for general use. Window 11, order 3 for VR content. Window 5, order 2 for minimal smoothing.
Jerk is the rate of change of acceleration -- the snap you feel when a device suddenly reverses direction. In funscript terms, jerk occurs when the script demands an instant direction change (e.g., going from rising at full speed to falling at full speed with no transition). The anti-jerk plugin detects these sharp reversals and inserts transitional keyframes that create a brief deceleration/acceleration curve.
Parameters:
When to use: Essential for scripts that will be played on mechanical stroking devices (The Handy, Keon, OSR2+). These devices have physical inertia and cannot reverse direction instantly. The anti-jerk filter makes the script physically achievable and reduces mechanical stress on the device.
When to skip: Vibration-only devices do not need anti-jerk because they have no mechanical inertia.
Scales all position values around the midpoint (50). An amplification factor greater than 1.0 increases the distance between each position and 50, making strokes longer and more intense. A factor less than 1.0 compresses the range, producing gentler movements. The result is always clamped to 0-100.
Parameters:
When to use: When the AI-generated script feels too subtle (amplify > 1.0) or too intense (amplify < 1.0). Also useful for adapting scripts between devices with different stroke lengths.
Recommended settings: 1.2-1.5 for mild intensification, 0.5-0.8 for gentler output, 2.0+ for maximum range utilization.
Flips every position value by computing 100 - pos. A position of 80 becomes 20, 30 becomes 70, and so on. The motion pattern is identical but reversed in direction.
Parameters: None (toggle on/off).
When to use: When the device moves in the opposite direction from what the video suggests. This can happen if the video was recorded with an inverted perspective or if your device is mounted differently than the script assumed.
A simple preset that reduces amplitude by 50%. Equivalent to using Amplify with a factor of 0.5. Useful as a quick one-click intensity reduction without configuring parameters.
Doubles the amplitude (equivalent to Amplify with factor 2.0), clamped to the 0-100 range. One-click intensity boost for scripts that feel too mild.
Restricts all position values to a specified minimum and maximum range. Any value below the minimum is set to the minimum; any value above the maximum is set to the maximum. This is useful for limiting the device's stroke range to a comfortable subset.
Parameters:
When to use: When you want to limit the physical stroke range. For example, clamping to 20-80 prevents the device from hitting the extremes, which some users find more comfortable. Also useful for fixing out-of-range values from poorly formatted scripts.
Caps the rate of position change between consecutive actions to a maximum speed value. If two actions demand movement faster than the device can physically achieve, the speed limiter adjusts the target position to be achievable within the time window. This prevents the device from falling behind the script and losing synchronization.
Parameters:
When to use: Always recommended for mechanical devices. Different devices have different speed limits:
| Device | Recommended Max Speed | Notes |
|---|---|---|
| The Handy | 300-400 | Conservative for longevity |
| Kiiroo Keon | 350-450 | Slightly faster than Handy |
| OSR2+ | 500-700 | Servo speed varies by build |
| SR6 | 400-600 | 6-axis load slows servos |
| Lovense Max/Solace | 250-350 | Slower motor mechanism |
Adds or subtracts a fixed number of milliseconds to every timestamp in the script. Positive values shift the script later (device responds after the visual cue); negative values shift it earlier (device responds before the visual cue).
Parameters:
When to use: To fix synchronization mismatches between the script and video. Common with VR content where the video has an intro sequence, or when different players have slightly different playback timing. Also useful in Couples Play to compensate for network latency between partners.
The RDP algorithm reduces the number of keyframes in a script by removing points that fall within a specified distance of the line between their neighbors. It preserves the overall shape of the motion curve while eliminating redundant intermediate points.
Parameters:
When to use: After all other plugins have been applied, as a final optimization step. Reduces file size by 40-80% depending on the epsilon value. Essential for scripts that will be uploaded to The Handy via HSSP mode (which has a file size limit).
Recommended settings: Epsilon 1.5-2.5 for general optimization. Epsilon 0.5-1.0 for high-fidelity scripts where every nuance matters. Epsilon 3.0-5.0 for aggressive file size reduction.
Adds controlled random variation to position values. Each keyframe's position is offset by a random amount within the specified range. This breaks up mechanical-feeling patterns and adds organic variation.
Parameters:
When to use: To add variety to scripts that feel too robotic or repetitive. Particularly effective for AI-generated scripts from videos with consistent, rhythmic motion that produces very uniform keyframe spacing.
Snaps position values to the nearest multiple of a specified step size. For example, with a step of 10, positions are rounded to 0, 10, 20, ..., 90, 100. This creates a staircase-like motion pattern that some users prefer for certain content types.
Parameters:
Generates a rhythmic oscillation pattern at a specified beats-per-minute rate. Unlike the other plugins which transform existing scripts, the metronome replaces the script with a generated pattern. Useful for testing device response, creating background haptic patterns, or generating baseline scripts for manual editing.
Parameters:
Plugins execute sequentially in the order you arrange them in HaptiQ's plugin chain editor. Each plugin receives the output of the previous one as its input. The order significantly affects the final result:
Here are proven plugin chain configurations for common workflows. You can save these as presets in HaptiQ's chain editor for one-click application.
HaptiQ's plugin chain editor is accessible from the editor toolbar and the project page. It provides a drag-and-drop interface for arranging plugins, live preview of the transformation on the timeline, and parameter sliders for each plugin.
HaptiQ Pro unlocks all 14 transformation plugins, the chain editor, and preset management. Free tier includes smooth, amplify, and invert.
HaptiQ includes 14 backend plus 9 client-side transformation plugins that modify a .funscript in deterministic, reversible ways. Smoothing plugins (moving average, Savitzky-Golay) reduce noise; anti-jerk inserts transitional keyframes at physically impossible direction reversals; speed-limiter caps position-change rate to per-device maxima; RDP-simplify reduces keyframe count while preserving motion shape; amplify scales values around the 50-midpoint for stronger or gentler strokes; invert flips the script vertically; clamp restricts values to a custom range; time-shift offsets all keyframes by a constant delay; rhythm-detect extracts and aligns beats. Each plugin has its own configurable parameters. Plugins execute server-side via the /api/plugins endpoint or client-side in the Zustand pluginStore for instant preview without server round-trip.
Open the Plugin Chain Editor from any funscript in HaptiQ. Drag plugins from the library into the chain in the order you want them to run — each plugin receives the output of the previous one as its input. A typical post-AI-generation chain is: RDP-simplify (reduce redundant keyframes) → Savitzky-Golay smooth (eliminate noise) → anti-jerk (fix sharp reversals) → speed-limiter set to 400 units/sec (device compliance) → amplify at 1.1x (slightly bolder motion). The editor shows a live preview of the cumulative effect on the timeline, so you can adjust parameters and reorder instantly. Save any chain as a preset via the Save Preset button — presets persist to your account and can be applied to future projects with one click. The pluginStore tracks chain state with undo/redo.
The free tier includes 3 basic client-side plugins: invert, clamp, and amplify — enough to test the plugin system and perform common tweaks. HaptiQ Pro at $9.99/month unlocks all 14 backend plugins plus the remaining 6 client-side plugins. The Pro-only set includes the full smoothing suite (moving average and Savitzky-Golay), anti-jerk, speed-limiter, RDP-simplify, time-shift, rhythm-detect, peak-enhance, dead-zone-fill, and multi-axis-specific plugins for T-code refinement. Pro also unlocks unlimited preset saves, chain sharing between projects, and the plugin API for programmatic batch application across entire video libraries. Every plugin that exists in the web app also exists as a native Swift port in the iOS app, running entirely offline via the client plugin engine shipped in v2.5.0.
Yes, and preview is instant. The Plugin Chain Editor renders the before/after waveform live as you adjust parameters — no "Apply" button needed for preview. Client-side plugins run in the browser using the same Swift-ported logic as the iOS app, so preview matches the final output exactly. Backend-only plugins (the ones that need more compute, like full-pipeline rhythm detection) preview on a cached sample section first with a small lag, then update the full timeline when you commit. The Quality Report Panel, driven by useScriptAnalysis, scores the script 0–100 before and after your chain — so you can see if smoothing improved or degraded overall quality. All plugin operations are reversible via undo, and no changes persist to the stored funscript until you click Save.
Create a free HaptiQ account to generate a funscript from your own video.