EVM Bytecode Disassembler

How to Use the EVM Bytecode Disassembler

The EVM bytecode disassembler turns a hex string into a list of low-level instructions. Paste the bytecode into the text field and click the Disassemble button. The result appears on the page as a list of consecutive rows.

When the page loads, the tool immediately disassembles the sample bytecode. That way you can see what the output looks like before you paste your own data. To check your own contract, replace the sample value with your bytecode and run the disassembly again.

The default example produces 21 instructions. If you paste different bytecode, the instruction count depends on its contents and on the display limit.

• Paste the bytecode into the text field.
• Click Disassemble.
• Read the result in the consecutive list rows.
• Check the summary: the instruction count and the unknown-byte note.

Each row shows a position, an operation name, and an argument if the operation requires one. Longer contracts make for long lists, so the tool shows a maximum of 2,000 instructions.

Hex Input Format and Whitespace

The input is bytecode written as a hex string. The field contains a sample value starting with 0x, and you paste your own bytecode in the same format. The tool strips whitespace, so you can paste everything on one line or split it across many lines.

Whitespace has no effect on the result. Spaces, tabs, and line breaks are ignored, and only the order of the hex characters matters. Two hex characters equal one byte, and each byte becomes one step of the analysis.

Paste plain hex strings with no extra descriptions. The tool does not interpret comments or function names, because it expects nothing but bytecode as input. That lets you focus on the instructions rather than on source-language syntax.

The sample bytecode in the text field produces 21 instructions. It is a convenient starting point: first you check how the list looks, then you swap in your own data.

Reading PC, Opcodes, and PUSH Arguments

Each row of the output describes a single operation. The first column is the position, known as the PC counter. The counter starts at zero and grows after every instruction and after its argument. That lets you return to a specific spot in the bytecode and compare it with another listing.

The second part of the row is the opcode name, meaning the EVM operation. You will see arithmetic operations, logic operations, jumps, memory operations, and typical contract instructions, among others. An argument may appear next to the name if a given operation requires one.

PUSH arguments are shown as a hex string. PUSH1 carries one byte, PUSH2 two bytes, and PUSH32 as many as thirty-two bytes. The larger the number after PUSH, the more data moves on for further processing.

If an argument does not fit within the available bytecode, the tool adds (truncated). That is a signal that the material you pasted ends in the middle of an operation. In that case, check whether the bytecode was copied in full.

The default example has 21 instructions. The number of rows depends on how many opcodes there are and how long the PUSH arguments are, which is why longer contracts take up more space in the list.

Unknown Opcodes, Data, and Metadata

Not every byte in bytecode maps to a known EVM operation. If the tool cannot find an opcode name, it shows the raw hex with the label (unknown). That byte counts toward the total number of unknown bytes in the summary.

Unknown bytes do not have to mean an error. Contracts often contain data, constants, addresses, fragments of compiler metadata, or other information stored alongside the actual code. A disassembler reads bytecode linearly, so some data may look like instructions even though it plays a different role.

The summary shows the instruction count along with the unknown-byte note. When unknown bytes appear, you will see a note that these are often data or compiler metadata. That is a hint not to treat every row as an executable operation.

When analyzing a contract, pay attention to the end of the list. Compiler metadata and supporting data are often found at the end of the bytecode. If you only care about the logic, you can skip the trailing fragments that do not look like typical opcodes.

Limitations and What the Tool Does Not Compute

The EVM bytecode disassembler shows low-level instructions, but it does not reconstruct source code. You will not get ready-made Solidity, function names, comments, or project structure. This is a tool for inspecting bytecode, not a decompiler.

The tool does not execute the contract. It does not simulate transactions, check contract state, analyze security, or detect vulnerabilities. It does not compute the results of function calls or the values stored in the contract. It is not a financial calculator.

The result depends on what you paste. If the bytecode is incomplete, the list will be incomplete too. If it contains data stored between instructions, the tool will show it linearly and some of it may look like opcodes. Check that the fragment you are analyzing comes from the right contract.

The tool shows a maximum of 2,000 instructions. With longer bytecode, the summary adds a note that the first 2,000 were shown. It does not fetch code from the blockchain network - you have to paste the bytecode you want to analyze yourself.

It runs locally, so it does not send the pasted bytecode to external servers. It does not connect to a blockchain, does not look up contract addresses, and does not verify the source. Base your final interpretation of the instructions on your own knowledge or additional analysis.

Do not count on the tool to reveal the contract author's intent. The opcode list is raw machine notation. Only context, the order of operations, and knowledge of the EVM let you draw further conclusions.

Frequently Asked Questions

The tool runs locally in your browser, and its output is informational only and does not replace a contract security audit.