ScriptCompiler vs OpenFunscripter

Quick comparison

Where OpenFunscripter wins

OFS is the editor most experienced scripters learned on, and there are real reasons to stay with it.

• Open source under GPL-3.0. You can read the code, fork it, ship your own build, and audit exactly what runs on your machine. If long-term self-hostability matters to you, OFS is the only option in this comparison.
• Native desktop performance. OFS is written in C and C++ on top of OpenGL, SDL2, and libmpv. The renderer and the video pipeline live in the same process, so scrubbing and frame-stepping on a high-resolution local file feel direct in a way browser editors cannot fully match.
• Mature Lua scripting API. OFS exposes a stable Lua interface that long-time scripters have built their own helpers and macros around. If you have years of personal scripts and bindings, switching means leaving those behind.
• Direct local file ownership. Every project, backup, and heatmap lives in a folder on your disk that you control end to end. No browser sandbox, no cloud, no syncing.
• Longer track record. OFS shipped its first releases in 2021 and was the de facto standard until the project was archived. A large portion of community guides, tutorials, and forum posts reference its keybindings and workflow specifically.

Where ScriptCompiler wins

ScriptCompiler is the choice when you want a working editor in under a minute and you want automation to do more of the heavy lifting.

• Zero install, runs anywhere with a browser. Open the site, drag in a video, start scripting. macOS, Chromebook, iPad, an unfamiliar Windows machine, a friend's laptop. There is nothing to download.
• Active development. ScriptCompiler is shipping releases. As of this writing the public version is 1.43.x, with new tools and device support added on a regular cadence.
• Drawing mode. Hand-draw a motion curve over the video timeline and have it converted into action points. There is no equivalent feature documented in OFS.
• Built-in motion tracking (Script Sniper). Select a region with a rectangle lasso and have ScriptCompiler track motion and generate points from the video itself. OFS users typically reach for external MTFG or other community tools for this. ScriptCompiler ships it in the editor.
• Music Scripter. Generate beat-aligned scripts from audio. Useful for music videos and rhythm-driven scenes. Not a documented OFS feature.
• Generation and transformation toolset. Wave Generator (sine, square, triangle), Ramp Generator, Pattern Repeater, Fap Generator, Position Multiplier, Time Stretcher, Smoothing, Mirror, Position Inverter, Alternate, and more, all built in.
• Direct browser-to-device control. ScriptCompiler connects to compatible Bluetooth devices over the Web Bluetooth API and to The Handy over its internet API, with no intermediate desktop application required.
• Device Emulator. Test how a script will feel without owning the device, useful when authoring for hardware you do not personally have.
• VR video support in the browser. Open and script against VR video formats directly.

Feature-by-feature breakdown

Editor and timeline

Both editors are built around a frame-synced timeline. You add action points, drag them, snap to the playhead, and watch the funscript curve update in real time against the video. OFS gives you the responsiveness of a native renderer and a few decades of desktop application convention. ScriptCompiler gives you the same core flow in the browser with a UI that scales down to a tablet. For straight-line point editing, both are competent. The difference shows up in the auxiliary tools, not in the basic place-a-point workflow.

Automation tools

This is the largest practical gap between the two. ScriptCompiler ships an explicit toolbox: Wave Generator for sine, square, and triangle wave patterns. Ramp Generator for eased transitions. Pattern Repeater. Fap Generator. Fill Between for inserting points between two selected points. Smoothing to reduce point count without losing the curve shape. Mirror, Position Inverter, Alternate, Position Multiplier, Time Stretcher, plus selection helpers like Select by Range and alignment tools like Align and Distribute. OFS exposes its automation primitives mostly through its Lua API: power users write or import scripts that do similar things, but the work of finding, loading, and wiring up those scripts is on you.

Motion tracking

ScriptCompiler has Script Sniper, a rectangle-lasso motion tracker built into the editor. You drag a box around the region you want to track and it generates action points from the video. OFS does not ship motion tracking in the editor; users historically pair it with external tools like MTFG or run separate computer-vision pipelines. If you want one place that handles tracking end to end, ScriptCompiler is the simpler path.

Devices and output

Both tools output the standard .funscript JSON format, so any device or player that reads funscripts can consume their output. Where they differ is in direct device control during authoring. ScriptCompiler can drive supported devices straight from the browser: Web Bluetooth for devices like Kiiroo KEON, Kiiroo Control, Kiiroo Pro Wand, Euphoria F1, Lovense Exomoon, and FapRing, and the internet API for The Handy. OFS focuses on script creation and leaves the live device link to companion software and its Lua API. Both approaches are valid. The browser path is more convenient. The desktop path gives you finer control if you write your own integration.

Video handling and VR

OFS uses libmpv for playback. That is excellent for esoteric codecs and very large local files, but adds an installation surface (the libmpv build that ships with OFS dates from 2022). ScriptCompiler uses the browser's video pipeline, which keeps things simple and adds modern format support as browsers add it. ScriptCompiler explicitly supports VR video formats, and tools like the Music Scripter and Script Sniper work over the same browser video element. OFS does not document VR support.

Extensibility

OFS wins this category. Its Lua API is real and has been used by the community for years to build custom helpers, exporters, and tooling. ScriptCompiler does not currently expose a public scripting API. If your workflow depends on running your own scripts inside the editor, OFS is the better fit.

File management

OFS reads and writes files on your local disk like any desktop app, with project files, backups, and exported assets sitting in a folder you choose. ScriptCompiler runs in the browser sandbox and uses standard file pickers and downloads, plus an optional ScriptCompiler Bridge companion that gives the browser editor local file system access and a few performance-sensitive features. If you want strict separation of every project into its own folder on disk with no browser involved, OFS is the more natural fit.

Which one should you pick?

Can you use both?

Yes, and a lot of scripters do. The .funscript format is a portable JSON schema, so a file you start in one editor opens cleanly in the other. A common workflow looks like this. Use ScriptCompiler to do the heavy lifting that needs automation: track motion with Script Sniper, draw rough curves with drawing mode, generate beat-aligned base patterns with the Music Scripter. Export the .funscript. Open it in OFS for fine-grained point cleanup using the Lua macros and keybindings you already know. Or do the reverse: capture the bulk of a script in OFS using your existing Lua setup, then pull it into ScriptCompiler to smooth, ramp, or extend it before publishing. The tools cover different parts of the same job. You do not have to choose only one.