Binary Explorer

IDA-style reverse engineering in the browser: x86/x64 + ARM64 disassembly, PE/ELF/Mach-O parsing, function & xref discovery, linked hex view, strings, imports/exports. 100% client-side.

Tool Media & Files Updated May 22, 2026
How to Use
  1. Drop an executable (.exe, .dll, .so, .dylib, ELF, Mach-O) or any .bin/.raw file.
  2. The Disassembly tab opens at the entry point. Click any call/jmp target to follow it.
  3. Use the Functions, Imports, Strings, and Xrefs panes to navigate.
  4. Goto box accepts hex VAs (0x401000), offsets (@0x200), or function names.

Binary Explorer

Binary
⚙
Drop executable or .bin file
PE / ELF / Mach-O auto-detected. Raw binaries treated as flat. Nothing leaves your browser.
Try it with a sample
File
—
Format
—
Arch
—
Bits
—
Entry
—
Image base
—
Size
—
—
View
±600 window
Load a binary to begin.

Inspector

cursor
—

Selection

—
—
View
±2 KB window
Load a binary to begin.
No functions discovered yet.
No strings extracted yet.
Hex pattern like 48 8B ?? C3 (?? = any byte), or switch to Text / UTF-16. Click a hit to jump to it.
Output

          
No imports table parsed.
No exports table parsed.
No sections parsed yet.
PE resource tree (.rsrc): version info, manifest, icons, string tables. Load a PE file.
Click an address in the disassembly to see xrefs.
Load a binary to see headers.
Press B on any disasm row to add a bookmark.
Place the cursor inside a function and switch to this tab to render its control-flow graph.
Pseudocode view — place the cursor inside a function and switch to this tab.
Stack-machine decompiler — best results on JVM, CIL (.NET), Python bytecode, and WASM. Place the cursor inside a function and switch to this tab.
Settings (API key, model)
Key stays in your browser's localStorage. Requests go straight to api.anthropic.com from your browser — no server in between.
Triage panel: PE imphash, Rich header, suspicious APIs. Load a PE file.
Computing file hashes…

Sliding-window entropy

High plateau (~8.0) = compressed / encrypted / packed. Mid (~4-6) = code. Low (<3) = data/text/zeros.

Byte histogram

Counts of each byte value 0x00–0xFF across the whole file.
Right-click any disasm row to rename or add a comment. All annotations are saved per-file in your browser.
Heavy on huge binaries — limited to top 200 most-referenced functions.
Click "Render call graph" above.
Drop a second binary to diff
Matches functions by byte hash and name. Side-by-side comparison.
No second binary loaded.

File layout

Proportional view of the file's sections / segments. Click any band to jump to its disassembly.

Function name signatures

Built-in FLIRT-lite library plus user-loadable IDA-format .pat files. Patterns matching at a discovered function head rename the function.

No custom signatures loaded. Built-in patterns still apply.

What it analyses

Containers
PE (EXE/DLL/SYS), ELF, Mach-O — header, sections, segments, entry point, image base
Disassembly
x86, x86-64, ARM64 (AArch64) — operand-formatted with linked jump/call targets
Symbols
PE imports/exports, ELF dynamic symbols + dynstr, Mach-O exported symbols
Functions
Entry-point seeded, exported-symbol seeded, plus prologue-pattern scanning
Xrefs
Call/jmp/branch targets collected during disasm; click any address to see who points to it
Strings
ASCII + UTF-16LE extraction with virtual addresses + xrefs back into code
Navigation
Goto by VA / @offset / name, back/forward history, bookmarks, follow-jump
Hex view
Linked to current VA, cursor shows int8/16/32/64 LE+BE, float, double

Reverse-engineering primer

Every executable starts with a container header (PE on Windows, ELF on Linux, Mach-O on macOS) that points at sections of code (.text), read-only data (.rodata), and writable data (.data/.bss). The entry point is the first instruction the OS runs after the loader maps the file into memory at the image base. The disassembler walks that code byte-by-byte, decoding each instruction into a mnemonic plus operands, while collecting cross-references wherever it sees a call or branch. Together those let you trace control flow from any starting point — entry, exported function, or a string you found suspicious.

Worked Example

Following a call. At virtual address 0x401000 the bytes are E8 0B 00 00 00. E8 is the x86 near call with a 32-bit relative offset. The call instruction is 5 bytes long, so the next instruction is at 0x401005, and the target is 0x401005 + 0x0B = 0x401010. That is the address the Disassembly pane links to when you click the operand.

From a virtual address to a file offset. Say the image base is 0x400000, and the .text section has virtual address 0x1000 and raw pointer 0x400. For VA 0x401010 the RVA is 0x401010 − 0x400000 = 0x1010, and the file offset is 0x1010 − 0x1000 + 0x400 = 0x410. The Goto box accepts either form: 0x401010, or @0x410.

The common mistake: reading data as code. A disassembler decodes whatever bytes it is pointed at. Jump tables, strings and padding sitting between functions turn into plausible but meaningless instructions. If a listing suddenly fills with odd mnemonics after a ret, check the Strings pane and the hex view before believing it.

Show Work

OpcodeE8 followed by 4 bytes, little-endian 0B 00 00 00 = call, offset 0x0000000B (11)
Next instruction0x401000 + 5 bytes = 0x401005
Call target0x401005 + 0x0B = 0x401010
RVA0x401010 − 0x400000 = 0x1010
File offset0x1010 − 0x1000 + 0x400 = 0x410
A typical function start55 48 89 E5 = push rbp; mov rbp, rsp

Formulas

x86 relative call or jump
target = address + length + offset
The offset is signed and counted from the end of the instruction
VA to RVA
RVA = VA − image base
PE files store addresses relative to the image base
RVA to file offset
offset = RVA − section RVA + section raw pointer
Valid inside one section
ARM64 branch
target = address + (signed imm26 × 4)
Every ARM64 instruction is 4 bytes long

Executable Formats and Instruction Sets

Three container formats cover most desktop software: PE (Portable Executable) on Windows, ELF on Linux and most other Unix systems, and Mach-O on macOS and iOS. They all describe the same things, where the code and data sections go in memory, where execution starts and which libraries are imported, but with different headers.

The instruction sets differ too. x86 and x86-64 instructions are variable length, from 1 to 15 bytes, so a disassembler must decode from a known start point and can easily go out of step. ARM64 instructions are always 4 bytes, which makes decoding simpler but means constants are built from several instructions. This is why the tool starts at the entry point and at exported or detected function starts instead of decoding from the top of the file.

About This Tool

Binary Explorer is a reverse-engineering workbench in a single page. It parses PE, ELF and Mach-O containers, disassembles x86, x86-64 and ARM64 with clickable jump and call targets, finds functions and cross-references, extracts ASCII and UTF-16 strings, and keeps a hex view linked to the current address.

Everything runs in your browser and nothing is uploaded. It is for malware analysts doing a first look, CTF players, firmware tinkerers and anyone curious about what is inside an executable. It is quick to open for orientation before you reach for a dedicated desktop tool.

Related tools: File Inspector, Hex Editor, Checksum Calculator and APK Analyzer.

Frequently Asked Questions

Does it upload my binary?

No. Everything runs in your browser — no server analysis, no telemetry.

How complete is the x86/x64 decoder?

It covers integer ops, common SSE moves, control flow, and most prologue/epilogue patterns. Exotic AVX-512 and uncommon escapes show as "db" placeholders rather than misleading mnemonics.

Can it disassemble stripped binaries?

Yes. Function detection runs a prologue scan in addition to using exported symbols and the declared entry point.

Architectures supported?

x86, x86-64, and ARM64 (AArch64). 32-bit ARM is on the roadmap.

Max file size?

Container parsing is instant up to a few hundred MB; disassembly is lazy per-function so huge binaries stay responsive.

How do I use the Binary Explorer?

Simply type your numbers and read the result, which refreshes the instant you change something. There is nothing to submit and nothing to wait for.

Is it free? Does it work without internet?

Yes to both. It is free with no sign-up, and once the page has loaded it keeps working even with no internet.

Where does my data go?

Nowhere — every calculation runs on your own device. Nothing you enter is uploaded, logged, or stored.

Common Use Cases

Malware triage

Spot suspicious imports, packer signatures, and entry-point shellcode in seconds.

CTF reversing

Browser-based RE without installing IDA, Ghidra, or radare2.

Firmware peek

Disassemble ARM64 firmware blobs and locate strings + function boundaries.

Library archaeology

Inspect .dll/.so exports, look at the actual instructions behind a function name.

Last updated: