open source  ·  mit licensed  ·  no uploads

V15 PROTECTION.
GONE.

$ deobf script.lua | six-stage devirt | runs locally | no subscription
Open Deobfuscator View Engine Source
6 stages
MIT license
local execution
0 uploads
// pipeline

Five-stage reverse compiler

Luraph V15 compiles Luau into a custom virtual machine with encrypted constants, flattened control flow, and active anti-tamper traps. This engine peels each layer back.

01 AST
›
02 Sandbox
›
03 Decrypt
›
04 CFG
›
05 SSA
›
06 Format
Stage 01 · vmmap.js
AST Analysis & Hooking
Parses the protected script with a Luau AST parser. Maps VM dispatcher loops and closure constructors. Injects non-destructive telemetry hooks to track proto execution and register states without altering behavior.
vmmap.js
Stage 02 · harness.js
Sandboxed Simulation
Executes the hooked script inside an offline Roblox engine emulator. When anti-tamper traps fire (LPH_CRASH), the engine identifies the function, disables that trap path, and re-runs along stable branches.
driver.js · harness.js · envlog.luau
Stage 03 · devirt.js + luasym.py
Live REPL Decryption
Luraph's lazy encryption requires dynamic runtime keys. The engine queries a live Luau REPL process via IPC pipe to decrypt 2,000–2,600 string and numeric constants per pass. Resolves in multiple rounds until convergence.
devirt.js · luasym.py
Stage 04 · structure.py
CFG Reconstruction
Uses Sparse Conditional Constant Propagation (SCCP) to trace virtual register values. Assembles basic blocks into a directed control-flow graph. Dominator-tree analysis restores nested loops and branches. Prunes dead blocks from opaque predicates.
structure.py · loops.py
Stage 05 · variables.py
Register Web Analysis
Maps virtual registers across basic block boundaries using Static Single Assignment (SSA) web analysis. Assigns context-aware variable names inferred from Roblox API usage — Players, TweenService, ReplicatedStorage and more.
variables.py · codegen.py
Stage 06 · backend.py
Polish & Formatting
Converts function assignments into idiomatic Luau syntax. Formats with correct indentation. Verifies output through a compile check guaranteeing 100% executable syntax. Fast-path controller skips redundant passes once constants are resolved.
backend.py · tidy.js

Free plan, Pro, or Enterprise. The price tag doesn't change what the virtual machine has to execute.

— Every Luraph-protected script, eventually.
// architecture

Your scripts never leave your network

data-flow.sh
Protected .lua script
your input file
↓
Browser (NO-V15Today UI)
POST to your own server only
↓
Your server / machine
Node.js + Python engine runs here
↓
Clean Luau source
returned to browser
Self-hosted engine
The deobfuscation pipeline runs on a machine you control. No cloud backend, no upload API, no analytics systems in the data path.
Temporary files only
Input scripts are written to /tmp with a UUID filename, processed, and deleted. No persistent storage.
Zero telemetry
This interface contains no analytics libraries, trackers, or reporting beacons. What you paste stays between you and your server.
// compatibility

What runs where

Full deobfuscation requires a server with Node.js 18+ and Python 3.10+. The web interface works on any modern browser.

Environment Interface Detection Trace Mode Full Devirt
Vercel (static CDN) Yes Yes No No
Local machine (Node + Python) Yes Yes Yes Yes
VPS — Ubuntu / Debian Yes Yes Yes Yes
Windows (WSL) Yes Yes Via WSL Via WSL
Android / iOS (browser) Yes Yes Server needed Server needed

* Vercel Lambda has no Python runtime. Luau binaries require Linux x86_64. Full devirt stages 3–6 need Python 3.10+.

// quick start

Up in four steps

01.
Clone the engine
The deobfuscation logic lives in the original repo. Clone it to get the Luau binaries and pipeline scripts.
$ git clone https://github.com/caomod2077/Deobfuscator-Luraph-V15.git
02.
Install server dependencies
In the NO-V15Today directory, install Express and the other server packages.
$ cd no-v15today && npm install
03.
Configure and start
Point the server at the engine repo. Requires Node.js 18+ and Python 3.10+.
$ export DEOBF_PATH=/path/to/Deobfuscator-Luraph-V15 $ node server.js ✓ All systems ready. Open http://localhost:3000
04.
Open the interface
Navigate to http://localhost:3000 — or click below to go straight to the app (if already running).
// attribution

Credits

NO-V15Today is an independent web interface. All deobfuscation logic belongs to the original author.

Luraph V15 Deobfuscator
engine · caomod2077
The Node.js + Python pipeline that performs all actual deobfuscation. Every algorithm, the Luau runtime emulator, SCCP, CFG reconstruction, and SSA naming are original work by caomod2077. Licensed MIT.
caomod2077/Deobfuscator-Luraph-V15
NO-V15Today Interface
web ui · independent project
The web frontend, Express server wrapper, virtual-scroll code viewer, and configuration interface. An independent, non-commercial project. Not affiliated with Luraph or lura.ph beyond calling their open-source CLI. MIT licensed.
Not affiliated with lura.ph
Open-Source Tools
express · lucide · jetbrains mono
Server: Express.js (MIT). Icons: Lucide (ISC). Typography: Inter (SIL OFL), JetBrains Mono (OFL). All used in accordance with their respective licenses.
Open-source ecosystem
Disclaimer: NO-V15Today is an independent project and is not officially affiliated with Luraph, lura.ph, or the original engine author beyond using their MIT-licensed open-source code. Use responsibly and in accordance with applicable terms of service. The MIT license of the original engine is preserved in full.