Reclass

A structured binary editor for reverse engineering — inspect raw bytes as typed structs, arrays, and pointers.

A complete overhaul of the popular "reclassing" tools

Download · Build Instructions · MCP Integration · Alternatives

Reclass helps you inspect raw bytes and interpret them as types (structs, arrays, primitives, pointers, padding) instead of just hex. It is essentially a debugging tool for figuring out unknown data structures — either at runtime from a live process, or from a static source like a binary file or crash dump.

Built with C++17, Qt 6, and QScintilla. The entire editor surface is rendered as formatted plain text with inline editing, fold markers, and hex/ASCII previews.

Features

Structured binary view — render raw bytes as typed fields (integers, floats, pointers, vectors, matrices, strings, booleans, padding)
Struct & array nesting — define nested structs and arrays with collapsible fold regions
Inline editing — click to edit type names, field names, values, and base addresses directly in the editor
Undo/redo — full undo history for all mutations via command stack
Split views — multiple synchronized editor panes over the same document
Type autocomplete — popup type picker when changing field kinds
Hex + ASCII margins — raw byte previews alongside the structured view
MCP bridge — expose all tool functionality to AI clients via Model Context Protocol
Plugin system — extend with custom data source providers via DLL plugins; following ship by default
- Process plugin — access memory of live processes on Windows and Linux
- WinDbg plugin — access data sources live in WinDbg debugging sessions
- ReClass.NET compatibility layer — load existing .NET and native ReClass.NET plugins

Data Sources

File — open any binary file and inspect its contents as structured data
Process — attach to a live process and read its memory in real time
Remote Process — connect to a process on another machine over shared memory
WinDbg — load .dmp crash dump files or connect to live debugging sessions

Screenshots

MCP Integration

Built-in Model Context Protocol bridge via ReclassMcpBridge. The server does not start by default and can be toggled from the File menu. It exposes all tool functionality to any MCP-compatible client (e.g. Claude Code) and falls back to UI prompts when the client requests something not yet covered by tools. To connect, add this to your MCP client config (e.g. .mcp.json):

{
  "mcpServers": {
    "ReclassMcpBridge": {
      "command": "path/to/build/ReclassMcpBridge",
      "args": []
    }
  }
}

Build

Prerequisites

Qt 6 with MinGW — Qt Online Installer (select MinGW kit + CMake/Ninja from the Tools section)
CMake 3.20+ — cmake.org (bundled with Qt)
Ninja — bundled with the Qt installer

Quick Build

git clone --recurse-submodules https://github.com/IChooseYou/Reclass.git
cd Reclass
.\scripts\build_qscintilla.ps1
.\scripts\build.ps1

The build script auto-detects your Qt install location.

Manual Build

Clone with --recurse-submodules (or run git submodule update --init --recursive after cloning)
Build QScintilla: qmake + mingw32-make in third_party/qscintilla/src

Configure and build:

cmake -B build -G Ninja -DCMAKE_PREFIX_PATH=/path/to/Qt/6.x.x/mingw_64
cmake --build build

Optionally run windeployqt on the output executable

Running Tests

ctest --test-dir build --output-on-failure

Alternatives

_{MIT License}

4.7 KiB Raw Blame History