We use cookies.This website uses essential cookies to operate core features. With your consent, we also use analytics cookies to understand traffic and improve the service. For more details, see our .
We use cookies.This website uses essential cookies to operate core features. With your consent, we also use analytics cookies to understand traffic and improve the service. For more details, see our .
Was this tool helpful to use?
Your feedback helps us make it better
Inspect Lua compiled bytecode locally in your browser, including function prototypes, instructions, constants, and control flow.
Choose filesClick or drag to upload a .luac or .out file
Supports standard Lua, LuaJIT, and Luau bytecode
Max 1 MB
A browser Worker parses the selected file locally. The page loads the decompiler WASM engine, but does not upload the bytecode file.
Functions, instructions, and constants appear here
Choose a .luac or .out file to inspect function prototypes, raw instructions, the constant pool, and control-flow structure.
Overview
Understand what the tool solves, how it works, and the boundaries of its data.
The Lua bytecode viewer parses function prototypes in a compiled artifact and displays readable instructions, the constant pool, and basic control-flow relationships when available. Select a function to review its parameter count, upvalues, instruction count, and constants. These details help explain how a compiler represents a program or verify file structure alongside a decompiler result.
The page reuses structural parsing from a Lua bytecode decompilation engine. Its output is an analysis view, not the original source. Compilation commonly removes comments and changes local-variable information, so function names, variable names, and source lines may only be partly available. Format details, instructions, and readable output depend on the Lua version and compiler options.
Guide
Follow the workflow and verify inputs and outputs with practical examples.
Select a .luac or .out bytecode file from a trusted source. The page accepts one file up to 10 MB. Source files, archives, and custom encrypted containers are not standard bytecode inputs.
Start with automatic version detection. If the header is incomplete or the detected version is unexpected, select the Lua dialect and version used to produce the file. A mismatch can cause a parse error or misleading field interpretation.
Choose Inspect, select the main function or a nested function, and switch between instruction, constant, and control-flow views. Edges help trace jumps; constants can reveal strings, numbers, booleans, and other stored values.
Compare the view with the compiler version, decompiler output, and the original program's behavior. If you need readable source, try the Lua bytecode decompiler separately; this viewer does not export a runnable reconstruction.
Use cases
See how the tool fits into real work and everyday tasks.
When learning the Lua virtual machine, compare instructions produced by a small expression, a loop, and a function call. Observe how registers, constants, and jumps are organized. Basic blocks and control-flow edges also make it easier to reason about how branches and loops are represented in bytecode.
When a decompiler result looks unexpected, check whether the file contains the expected function, constant, or child prototype, and distinguish a version mismatch from a damaged file. Confirm that you have permission to inspect third-party artifacts. The viewer does not attempt to bypass encryption, commercial packers, or virtual-machine obfuscation.
Q&A
Find concise answers to common questions and confusing cases.
No. It displays function metadata, instructions, constants, and a control-flow summary. Use a decompiler to attempt readable reconstruction; comments, original local names, and formatting are generally not recoverable from compiled bytecode.
The file may use an unsupported version, truncated data, a custom compiler header, or a protection layer. Confirm the Lua implementation and version that produced it, then select the matching dialect. Encrypted artifacts and custom formats are not standard bytecode.
An edge is a basic-block jump relationship recognized by the parser. It helps outline branches and possible paths, but it is a static structural hint and does not simulate runtime input, dynamic loading, or execution results.
Notes
Review scope, result limitations, and important precautions before use.
The selected bytecode is parsed locally by a browser Worker and is not uploaded as a file to the server. The browser does download the parser's WASM engine. Only inspect files you are authorized to analyze, and keep an original copy. The 10 MB limit is a page constraint; it does not mean every file size or format is supported.
Standard Lua, LuaJIT, Luau, and different Lua releases do not share one identical bytecode format. A successful parse does not guarantee that every metadata field can be recovered, and instruction readability depends on engine support and available file information. Artifacts with encryption, compression, private headers, or a custom virtual machine require specialized tools; this viewer cannot determine their safety or behavior.
Related
Discover related tools, collections, and available API capabilities.
Lua Bytecode DecompilerTry to reconstruct readable Lua source from standard Lua, LuaJIT, or Luau bytecode in your browser, then copy or download the result.
Lua / Luau Formatter and Syntax CheckerPaste Lua or Luau source, choose a dialect and style options, then format it or check syntax without changing the input.Lua Code MinifierTrim comments and whitespace from Lua source, compare the before-and-after text length, and copy the compact result for review.Luau Static Analyzer and Type CheckerAnalyze Roblox Luau snippets in the official Luau Playground and review type diagnostics and editor hints.Random Email Address GeneratorGenerate single or bulk email-format test data with RFC-reserved example domains, or add domains you own or are authorized to test.