Linux-native · Prometheus-focused

See through the obfuscation.

Epimetheus turns Prometheus-protected Lua and Roblox Luau into cleaner, more understandable source — combining dynamic trace emulation, static constant decoding and token-aware AST optimization.

Get started Explore source

Built for reverse-engineering research and educational analysis.

epimetheus / pipeline

ENGINE READY

$ python3 deobfuscator.py script.lua

[01]

✓ Luau syntax normalized

[02]

✓ Lua 5.1 sandbox initialized

[03]

✓ Execution trace captured

[04]

✓ VM noise filtered

[05]

↻ Reconstructing Lua operations_

Processing obfuscated chunk...

Lua 5.1 + LuauTarget languages

Python 3.9+Runtime requirement

Linux x86_64Supported platform

GPL-3.0Open-source license

Inside the engine

A focused toolkit.
A layered approach.

Instead of relying on a single trick, Epimetheus combines purpose-built modules. Each one handles a different part of the Prometheus pipeline — from Luau syntax to the final reconstructed source.

Luau syntax normalizer

Desugars compound assignments and strips Luau type annotations while preserving strings, comments and nested expressions — preparing code for the Lua 5.1 parser.

engine/syntax_normalizer.py

Controlled trace emulation

A native Lua 5.1 mock sandbox captures observable behavior with execution timeouts and a restricted host environment.

lua_bin/lua5.1 · deobfuscator.py

Streaming trace filter

Removes repetitive VM allocation and unpack noise, compresses consecutive loops and keeps meaningful calls, globals, URLs and closure entries.

engine/trace_filter.py

Static constant decoder

Recovers encrypted Prometheus strings in Python, understands custom Base64/Base85 alphabets and reverses rotated constant arrays.

engine/static_decoder.py

Token-aware AST optimizer

Folds arithmetic and string expressions, propagates safe aliases and removes dead Prometheus watermark guards without rewriting literals or comments.

engine/ast_optimizer.py

Constant inlining & lexer

Unwraps ConstantArray wrappers and proxified locals. A shared lexical scanner keeps token handling consistent across the engine.

engine/constant_inliner.py · lua_lexer.py

Under the hood

Follow the transformation.

Explore each stage of the pipeline. Select a step or play the sequence to see how noisy, protected input becomes structured Lua output.

Epimetheus processing pipeline

Interactive walkthrough · 6 stages

STAGE 01 / 06

Normalize Luau syntax

Luau-specific syntax is transformed into Lua 5.1-compatible code. Compound assignments and type annotations are handled without altering strings or comments.

syntax_normalizer.pyToken-aware

BEFORE → AFTERLUA / LUAU

-- Input: Luau syntax
local total: number = 10
total += 5

-- Normalized output
local total = 10
total = total + 5

Tip: click any stage to inspect it.

Static fallback path — when the VM hits a Lua compiler limit such as “control structure too long”, the Python static decoder can extract constants without running the full VM path.

Measured, not imagined

Less noise.
More signal.

The project includes a benchmark suite for its core processing stages. These figures are reported in the v2.7.0 documentation and reflect the tested workloads.

Performance depends on input size, structure and hardware. Benchmark figures are project-reported measurements, not a universal speed guarantee.

−93.8%Heavy-script report size reduction9.93 MB → 610 KB

18M+Arithmetic expressions evaluated per secondAST math folding

9×Faster alias propagation in the documented test1.80 s → 0.20 s

54Unit tests in the documented suiteRegression + engine coverage

A glimpse of the command-line interfaceCLI PREVIEW / EPIMETHEUS

Epimetheus command-line interface preview

What you get

Three files. A clearer picture.

Each processed script can produce a reconstructed source file, a constants dump and a compact execution report — ready to inspect in your editor.

MyScript.lua.deobf.lua

Reconstructed Lua source with recovered calls, functions, loops, globals and applied optimizations.

MyScript.lua.constants.lua

Extracted and decoded string and numeric constants collected from static analysis and emulation.

MyScript.lua.report.txt

Filtered trace of observed property access, method calls, global updates and detected URLs.

Get started

Ready when Linux is.

Clone the repository, make the bundled Lua runtime executable and run your first target. No external Lua compilation step is required.

Linux x86_64 (Ubuntu, Debian, Fedora, Arch, etc.)

Python 3.9 or newer

Bundled native Lua 5.1 ELF runtime

Linux only. Windows, macOS and BSD are intentionally blocked by the platform check. This is a deliberate runtime requirement, not a missing installer.

Quick installationbash · 3 steps

01 / Clone

$git clone https://github.com/NoName2323-wq/Epimetheus.git
$cd Epimetheus

02 / Permissions

$chmod +x deobfuscator.py format_lua.py lua_bin/lua5.1

03 / Run

$python3 deobfuscator.py target_script.lua
$python3 deobfuscator.py path/to/scripts --jobs 4

Run the test suite: python3 -m unittest discover tests