Script Safety Manager: check untested funscripts before your device plays them
GitHub: GitHub - wilmgard/script-safety-manager · GitHub
Free, open source, runs locally and offline (no uploads, no account).
Why I’m making this
Lately we’ve seen more scripts released by new authors that clearly haven’t been tested on real hardware. A funscript is just a list of positions and times. Nothing in the file stops it from asking for a full stroke in 5 ms, or actions 1 ms apart.
On the Handy I’m not too worried. Its firmware caps speed at around 500 units/s and rewrites anything faster. That behaviour has been tested thoroughly by people here, so I trust it.
Some homebrew devices are untested, so they carry some degree of risk. Not every device has a firmware limit the community has checked, and some play every command as fast as their motor can go. I wanted a safety layer for those: something that checks a script before it’s played and saves a capped copy.
Tools that already exist
This isn’t the first safety tool, and it’s not meant to replace them:
- OFS extension: StrokeLimit, easily set max stroke speeds lets you cap stroke speed inside OpenFunscripter, while making or editing a script. by @gayrobot
- funscript.io’s “Modify script” tab has a Limiter with a Handy preset.
Script Safety Manager is aimed at the other side: people playing scripts they downloaded. You don’t need a script editor. Open the file, pick your device, and it tells you in plain words what’s wrong for that device, shows where on a graph, and saves a fixed copy.
What’s been tested before (and what this builds on)
This is built on community testing and discussion about how devices play scripts, not my own guesses:
- The Handy vs the OSRs at playing scripts: an observation
- FUNSR1 In Action: Beats the Handy?: recordings of devices playing the community stress-test script.
- Handy’s firmware blends slow actions, and the follow-up feedback that the firmware’s limiter shortens strokes toward their start. That can move a beat-synced bottom, so the stroke lands off the beat.
What I’ve tested so far:
- Every check and fix against the community stress-test script, for every device profile. With all fixes on, every profile goes from a score of 0 to 100.
Stroker_Stress_Test.funscript (138.4 KB) built by @Falafel - 54 automated tests, including deliberately broken and hostile files.
- The desktop app on Windows.
What it does
Open a script, choose your device, and it shows a score for the original and for the fixed copy, plus a list of problems in plain words. Click a problem to jump to it on the graph.
It checks for:
- Too fast for this device. The stress test has moves up to 17,000 units/s.
- Actions too close together. It has actions 1 ms apart.
- Starts or restarts at full speed after a pause.
- Would play off the beat on the Handy. It simulates the firmware’s limiter.
- Too slow for the Handy. The firmware re-times strokes under about 33 units/s.
- Long, very intense sections.
- Broken files: out-of-range positions, unsorted or duplicate timestamps.
And it can fix them:
- Cap the speed at a limit you choose. For homebrew devices the default is 500 units/s, matched to the Handy, because that’s the limit the community has tested. Set it lower if you want it gentler.
- Choose how too-fast strokes are shortened. Keep bottoms (or tops) on the beat keeps beat-synced thrusts exactly where the scripter put them, unlike the Handy firmware’s method.
- Merge actions that are too close together, ease in after pauses, fix slow strokes for the Handy, and optionally tone down long intense sections.
- Save safe copy writes
NAME.safe.funscriptnext to the original. The original is never changed.
What it doesn’t do
- It’s not a guarantee. The speed cap is a choice, not a measured safe limit for your device. Still start with your device’s stroke length and speed turned down, and keep the stop control in reach.
- Single-axis (stroke) scripts only. Multi-axis files (roll/twist/pitch) aren’t supported. I don’t own a multi-axis device to test with, but PRs are very welcome.
- It’s not a script editor. For capping speeds while you script, use StrokeLimit in OFS.
- No video or device preview. It works on the script file only.
- It doesn’t judge script quality, only whether a device can play it safely and as written.
- No installer yet. You need Python for now (instructions are in the README).
What’s next
- Repair broken scripts on open: remove invalid actions (with your OK) instead of refusing the file.
- Windows installer: a single
.exe, no Python needed. - Batch mode: check a whole folder and see which scripts are unsafe, worst first.
- Profile editor in the app: save and share your own caps and settings.
- Track Handy firmware changes using the official firmware change logs, since the homebrew default is matched to the Handy.
Feedback very welcome, especially:
- scripts it gets wrong (false alarms, or problems it misses);
- how the fixed scripts feel on your device;
- whether the 500 units/s default feels right as a safety cap.
Issues and PRs: GitHub - wilmgard/script-safety-manager · GitHub
Windows app, no Python needed
Check a whole folder
Broken scripts can now be opened
Safer with hostile files
Device profiles