REA (Reverse Engineer Anything) is an MCP server that allows you to reverse engineer software applications, binaries, and behavior in real time. The tool covers the path from application behavior to machine code, and it is convenient to use OpenCode as the agent that manages it.

OpenCode is an open programming agent that lives in the terminal. It reads project files, edits code, runs commands and tests, and most importantly, it supports MCP out of the box, so REA connects to it directly.

What makes REA unique

REA stands out in the field of reverse engineering with comprehensive support for several platforms and types of analysis:

• Native binaries: Hopper, Ghidra, IDA or Kuna for disassembly and decompilation
• JavaScript applications and Electron: static analysis of Electron modules, imports and boundaries
• Managed Code: Analyzing .NET Assemblies
• Real-time analysis: monitoring process behavior
• Network traffic: capture and analysis of HTTP/S requests and responses
• Mobile applications: analysis of APK and IPA files for Android and iOS
• Embedded software: analysis of embedded systems and IoT devices
• Model files: extracting GGUF and safetensors metadata
• GPU code objects: analysis of CUDA and HIP kernels
• Saving games: restoring game logic and executable files

Basic architecture and philosophy

REA follows a three-step research process that makes reverse engineering accessible to developers:

1. Inspection: REA connects to analysis tools and examines targets (binaries, applications, websites)
2. Analysis: traces through the code, determining rules and behavior
3. Recovery: the agent uses the results to explain behavior and build or test an implementation

This process allows the AI ​​agent to answer complex questions, such as: “Understand how search works in the Notes app, show me the evidence, and create a similar feature for my project.”

Practical examples of use

1. Analysis of mobile applications

REA can analyze Android APK files for recovery:

• declarations and permissions in the manifest;
• class methods and dependencies;
• links to native libraries;
• network endpoints and data flows.

For example, an analysis of Aegis Authenticator showed how six-digit authorization codes change every 30 seconds: it examined how time-based code generation (TOTP) works.

2. Desktop Application Function Extraction

Analysis of the % button in Windows Calculator demonstrates the capabilities of REA:

• define different behavior depending on the context (after + or ×);
• parsing assembly instructions to understand the logic;
• extracting and explaining mathematical operations;
• restoring the rules: “After +: 10% of the first number” and “After ×: convert 10% to 0.1.”

3. Restoring Web Application API

REA can record a browser session and reconstruct it as an RL environment where the AI ​​agent performs tasks like working with folders without running the original application.

4. Restoring game logic

The DX-Ball case showed how REA restored the soundscape calculation from the 1996 Windows game by reverse-engineering C code that runs through 3,205 test cases and matches the original compiled code.

Technical capabilities

Native analysis

• Works with Hopper, Ghidra, IDA or Kuna for deep binary file analysis
• Supports ELF, PE, Mach-O and other executable file formats
• Extracts pseudocode, assembler, symbols and calls
• Performs offline analysis without having to launch the original tools

JavaScript Analysis

• Analyzes Node.js and Electron applications
• Tracks module imports and dependencies
• Captures behavior in real time via a browser connection
• Извлекает source maps и минифицированный код

Security

• Static analysis of PE certificates (Authenticode)
• Analysis of defense mechanisms (PIE, NX, RELRO, CFG)
• Mapping imports and DLLs
• Analysis of crash reports (Apple IPS)

What does REA return

REA does not give the agent ready-made conclusions without reason. The result of each query is the findings along with the evidence on which they are based. Depending on the purpose, the response includes:

• Links to code – specific files and lines where the function under study is implemented.
• Pseudocode and assembler – for native binaries: decompiled functions, instructions and connections between calls.
• Application structure – for JavaScript and Electron: modules, imports, routes, IPC and connections with native add-ons.
• Metadata and facts – manifests, certificates, signatures, format headers and other static data.
• Restrictions – places that could not be sorted out, with a note about what exactly remains unknown.

The agent uses this data to explain behavior, answer clarifying questions, or assemble and test its implementation. It is the presence of evidence and explicit limitations that distinguishes an REA result from a simple guess of the model.

Before you begin

It is assumed that OpenCode is already installed and the model is connected to it. Node.js 22.23.4+, 24.22.1+ or 26.12.1+ is needed by REA itself, so check the version:

node -v

Step 1: Connect REA to OpenCode

REA registers with OpenCode as an MCP server. Run in terminal:

npx rea-agents@latest setup

To directly specify OpenCode, use its identifier opencode:

npx rea-agents@latest setup --client opencode

What setup does:

• registers REA as an MCP server;
• adds workflow instructions;
• makes a backup copy of the existing configuration;
• asks for confirmation before applying changes.

Important point:
For the first experiment, you can skip the optional Hopper installation. After setup is complete, restart OpenCode: exit the session and run opencode again.

Check the connection:

npx -y rea-agents@latest doctor --client opencode --json

Successful result: "healthy": true.

Then ask the agent:

“Check that REA is connected and show me which REA tools you can use.”

Step 2: First investigation

REA can analyze applications without launching them.

1. Download the example:

   Download https://rea.tools/examples/notes-example.zip
   

   Unpack the archive into the notes-example.

folder

2. Give the agent a task:
   

   “Use REA to inspect the app at /absolute/path/to/notes-example. Find what happens when I click Export notes. Show where notes.csv is written, which fields it contains, and the relevant files and lines.”

Expected response:

“The button sends a notes:export message. The main process formats the notes as CSV and writes notes.csv in the user’s Downloads folder. The columns are id and title.”

Step 3: Ghidra installation and native analysis

To analyze native binaries (executables and libraries), REA uses an analysis provider. The most affordable free option is Ghidra from NSA. The tool is installed once on the computer where REA runs.

What you need

• 64-bit JDK 21 or later, including Java compiler (javac).
• Ghidra archive from the releases page.

Installation

1. Install 64-bit JDK 21 or later. Select a package for your computer architecture.
2. Download Ghidra from the Assets list on the releases page and unzip the ghidra_…_PUBLIC_….zip archive. Take the release archive, not the “Source code.”
3. Find the unpacked folder that contains ghidraRun or ghidraRun.bat. This path will be needed for the GHIDRA_INSTALL_DIR variable.

Check out Java. The first command prints java.home – this path is needed for JAVA_HOME. The second confirms that the compiler is installed:

java -XshowSettings:properties -version
javac -version

Ghidra connection

Windows (PowerShell):

$env:GHIDRA_INSTALL_DIR = "C:/tools/ghidra_12.1.4_PUBLIC"
$env:JAVA_HOME = "C:/tools/jdk-21"
npx -y rea-agents@latest doctor --provider ghidra --json
npx -y rea-agents@latest setup

macOS / Linux:

export GHIDRA_INSTALL_DIR="/absolute/path/to/ghidra_12.1.4_PUBLIC"
export JAVA_HOME="/absolute/path/to/jdk-21"
npx -y rea-agents@latest doctor --provider ghidra --json
npx -y rea-agents@latest setup

Replace the paths with your own. Keep the commands in one terminal session: after setting the environment variables, re-run setup, confirm the configuration update and restart OpenCode.

The provider check should return a successful report:

npx -y rea-agents@latest doctor --provider ghidra --json

Native analysis example

Give the agent the full path to the executable file and specify the provider:

“Use REA with a configured provider to explore /absolute/path/to/program. List the functions and lines, then explain the part that handles user input, with references to the code.”

Or run the command directly from the terminal:

npx -y rea-agents@latest function "/absolute/path/to/program" main --provider ghidra --json

Replace main with the function name or address from the target program’s list of functions. The result contains pseudocode, assembler, and references between calls.

Analysis of another type of software

Select target software category:

• JavaScript / Electron – requires Node.js and npm. Guide.
• Websites – Requires Chrome, Chromium or Edge browser. Guide.
• Android APK – requires JADX and JDK 17+. Manual.
• Native executables – requires Hopper, Ghidra or IDA. Guide.
• .NET assemblies – requires Node.js and npm. Manual.

Using REA from the terminal

Static analysis of JavaScript/Electron application

npx -y rea-agents@latest analyze-javascript-application "/absolute/path/to/app" --json

Replace the path with the folder with the application or .asar file.

Where to find the Electron application .asar file:

• Windows: C:\Users\<you>\AppData\Local\Programs\<App>\resources\app.asar
• macOS: /Applications/<App>.app/Contents/Resources/app.asar
• Linux: /opt/<App>/resources/app.asar

Global installation of the rea command

npm install --global rea-agents

After this, the rea --help command is available.

Installation via curl (macOS / Linux)

curl -fsSL https://raw.githubusercontent.com/morluto/rea/main/install.sh | bash

After installation, follow the instructions to configure the agent. If the setup menu does not appear, run rea setup.

Update and delete

REA update

npx rea-agents@latest setup

For global installation: rea update

Removing REA

npx rea-agents@latest uninstall

Getting help

• FAQ: rea.tools/faq/ – quick answers about updates, agents and analysis
• Guides: rea.tools/guides/ – examples for binary, Electron and browser analysis
• GitHub Issues: github.com/morluto/rea/issues – report an issue
• Discord: discord.gg/GkcryMnJDM – questions, investigations and work in progress

Typical problems

OpenCode does not see REA

Restart OpenCode after setup. Use the doctor command to test the connection:

npx -y rea-agents@latest doctor --client opencode --json

The provider requires configuration

For Ghidra run:

npx -y rea-agents@latest doctor --provider ghidra --json

The report will show the failed test and the suggested next step.

Windows, WSL and paths with spaces

• Use PowerShell for Windows clients
• If the agent is running inside WSL, install Node.js and REA inside that Linux system and use the Linux paths
• In the terminal, enclose paths with spaces in quotes

Setting up Hopper on macOS

If macOS asks you to allow Automation, allow the app that runs REA in System Preferences: System Preferences → Privacy & Security → Automation, then try again.

Links

https://github.com/morluto/rea
https://rea.tools/
https://rea.tools/get-started/
https://rea.tools/guides/
https://opencode.ai/
https://opencode.ai/docs/
https://opencode.ai/docs/mcp-servers/

maimat (Mass Images Manipulation Tool) is an open source tool designed for batch image processing: resizing and compression. The application is written in Python 3.10+ and uses ImageMagick as the processing engine.

Links

https://github.com/zefir1990/maimat

Aleka is a lightweight, fast drawing app written in Flutter. It works everywhere: in the browser, on the desktop (Windows, macOS, Linux) and on mobile devices (iOS, Android).

Under the hood is pure Dart, Material 3 and attention to detail.

Opportunities

• Freehand drawing: smooth strokes with quadratic Bezier interpolation.
• Palette of 15 colors: quick selection with visual indication.
• Brush size: adjustable with a slider from 1 to 30 px.
• Undo: step back through your strokes.
• Clear the canvas: with one click.
• Flood Fill: BFS with tolerance for smooth edges.
• Saving: format .aleka (JSON).
• Loading: open previously saved drawings and continue.
• PNG export: Capture canvas at 3x resolution.
• 🎬 Animation mode: Frame-by-frame animation with timeline:
  • Adding and removing frames, each with its own design.
  • Frame duration from 50 ms to 5 s.
  • Change FPS: 6, 8, 12, 15, 24, 30 or 60.
  • Export to MP4 (via ffmpeg on desktop, ffmpeg.wasm in browser).
• Dark and light theme: Material 3, follows the system.

Why Flutter?

Flutter allows you to write one application for six platforms without duplicating code. Aleka uses only the native capabilities of Dart and Flutter SDK and a minimum of third-party dependencies: file_picker, image for working with pixels when filling, ffmpeg_wasm for exporting video in the browser.

Architecture

The project adheres to the principles of clean architecture and SOLID:

• PaintCanvasController – controls the state of strokes and fills through the Listener/Observer pattern.
• PaintToolbar – UI component of the palette, slider and buttons.
• AlekaFile – serialization/deserialization in JSON, PNG capture.
• MovieController – model of frames and animation state.
• VideoExport – encapsulates MP4 encoding logic (desktop/web).

I/O functions (saveStrokes, loadStrokes, capturePng, etc.) are made injectable – they can be replaced with mocks during testing. The project has 79 tests: checking serialization, cancellation, loading/saving, PNG and video export, frame model and timeline.

File format .aleka

The .aleka file is readable JSON that can be opened in any text editor:

  "aleka": "1.0",
  "strokes": [
    {
      "color": 4278190080,
      "strokeWidth": 3.0,
      "points": [[100.0, 200.0], [150.0, 250.0]]
    }
  ]
}

Each stroke stores a color (ARGB32), a thickness, and an array of points. The format is versioned by the aleka field.

Animation mode

One of the key features is the built-in frame-by-frame animation editor. You draw a frame, add a new one, draw the next one, and so on. The timeline shows thumbnails and allows you to change the order and duration of frames. The finished animation can be exported to MP4.

The export algorithm iterates through all frames, captures them via RepaintBoundary, collects PNG bytes and transfers them to the encoder. On the desktop, the system ffmpeg is called, in the browser, ffmpeg.wasm is used – a full-fledged port of ffmpeg to WebAssembly, working directly in the browser sandbox.

Flood Fill

The fill implementation uses Breadth First Search (BFS) with a color tolerance (_kFillTolerance = 1000). This allows you to correctly handle smooth edges of strokes – the fill does not flow beyond the outline, but captures translucent pixels on the border. For an empty canvas, a solid fill is created without unnecessary calculations.

Try

Aleka is available on the web and as a native application:

demensdeum.com/software/aleka/

The source code is open under the MIT license:

github.com/demensdeum/Aleka

Mama Calendar is a cross-platform events and reminders application written in React Native (Expo) with two backend implementations: Node.js + MongoDB and PHP + MariaDB.

The application allows you to create events with emoji categorization, select the type of repetition (once, annually, monthly, weekly, daily) and view important events for the next 3 days in a separate “Important Events” tab.

Technology stack

The frontend is written in React Native 0.86 via Expo SDK 57 with TypeScript, Expo Router for navigation and react-native-reanimated for animations. Expo-symbols are used for icons (SF Symbols on iOS, Material icons on Android/Web).

The backend is implemented in two versions:

• Node.js: Express 4, MongoDB 8 via native driver, custom authentication with scrypt + salt, manual token management. Docker Compose brings up the client (nginx), server and MongoDB.
• PHP: PHP 8.2 without frameworks, PDO + MariaDB 11, bcrypt for password hashing, your own router and PSR-4 autoloading via Composer.

Application functions

• Registration and authorization: simple system with username/password and Bearer tokens
• CRUD events: create, view, edit and delete events with date, emoji and repeat type
• Smart filtering: The Important Events tab shows events for the next 3 days, taking into account repetition rules. For example, annual events show the nearest annual occurrence, monthly – by day of the month, weekly – by day of the week
• Emoji picker: 20 preset emoji for quick categorization of events
• Highlighting today’s events: Today’s events are highlighted with a red background (#B71C1C)
• Dark theme: Automatic detection of system color scheme with separate palettes for light and dark theme
• Internationalization: Russian and English languages ​​via React Context
• Анимации: анимированный сплэш-скрин с Keyframe API и упругой интерполяцией, анимированная иконка приложения с вращающимся свечением
• Admin endpoints: managing users, tokens and clearing the database through master tokens

Why two backend implementations?

The Node.js version is the main one, but the PHP version exists as an alternative for more classic hosting. The API is completely identical, which allows you to switch between them without changing the client code.

Infrastructure

The entire stack is raised through Docker Compose: the client is assembled through a multistage build (Expo export → nginx alpine), a server on Node.js, MongoDB 8. For the PHP version there is a separate compose file with MariaDB 11 and phpunit for tests.

The assembly of the web version is automated by a PowerShell script that patches the API_URL before expo export and restores the originals after.

Output

Mama Calendar is a full-featured cross-platform application that covers the full cycle: from mobile and web frontend on React Native to two server-side options. The project is interesting for its architecture, use of modern Expo SDK capabilities and dual backend implementation.

Links

https://github.com/zefir1990/Mama-Calendar
https://demensdeum.com/software/mama-calendar/events

Teflecher is a fast, interactive, cross-platform quiz application built on top of Kotlin Multiplatform (KMP) and Compose Multiplatform. It allows users to intuitively load quizzes from local JSON files or remote URLs, answer multiple-choice questions, see instant feedback on correct answers, and track their results.

Web:
https://demensdeum.com/software/teflecher/

GitHub:
https://github.com/zefir1990/teflecher

Also a quiz editor in the Teflecher Editor format based on Ionic + Capacitor technologies

Web:
https://demensdeum.com/software/teflecher-editor/

GitHub:
https://github.com/zefir1990/teflecher-editor

Ghost Contacts is a simple web application designed to hide your contacts from standard system APIs and phone books. All information is stored exclusively locally in your browser and is not transferred to external servers.

Main features

• Hiding from system APIs:Your contacts are not synced with the standard system contacts APIs and device phone book.
• Panic Password: A special password, when entered, the entire contact database is instantly and irrevocably deleted.
• Import and export: Convenient transfer of contact database via CSV files for creating backup copies.

Online application:
https://demensdeum.com/software/ghost-contacts/

GitHub:
https://github.com/demensdeum/GhostContacts

Raiden Video Ripper is an open source project designed for video editing and format conversion. It is created using Qt 6 (Qt Creator) and allows you to edit and convert videos to MP4, GIF and WebM formats. You can also extract audio from videos and convert it to MP3 format.

Microsoft Store:
https://apps.microsoft.com/detail/9nvzjs98smgc

GitHub:
https://github.com/demensdeum/RaidenVideoRipper/releases

Ushki-Radio is a cross-platform radio player for online radio, made with a focus on simplicity and listening pleasure. No unnecessary functions, no overloaded interfaces – just turn it on and listen.

https://demensdeum.com/software/ushki-radio

The project uses the open source Radio Browser, making thousands of radio stations from all over the world available in the application. You can search for them by name, genre or popularity, add them to your favorites and quickly return to your favorite stations.

Ushki-Radio is perfect for the role of a background radio player: it remembers the last station, allows you to control the volume and does not require complex settings. The interface is concise and understandable – everything is done so that nothing distracts from music, conversations and broadcasting.

Technically, the project is built on React Native and Expo, so it works both in the browser and as a native application. Under the hood, expo-av is used to play audio, and user settings are stored locally. There is support for several languages, including Russian and English.

Ushki-Radio is a good example of what a modern Internet radio player can be: open, lightweight, expandable and focused primarily on the listener. The project is distributed under the MIT license and is perfect for both personal use and as a basis for your own experiments with audio applications.

GitHub:
https://github.com/demensdeum/Ushki-Radio

Google Play:
https://play.google.com/store/apps/details?id=com.demensdeum.ushkiradio

Glazki TV is a modern, high-performance player for Internet television (IPTV), built on the basis of React Native and Expo. The project is focused on ease of use and speed, providing a convenient interface for viewing IPTV channels both on mobile devices and in the browser.

Main features

• Channel Browsing: Browse thousands of channels, categorized for easy navigation.
• Search: Quickly find the channels you need by name.
• Favorites: Save your favorite channels for quick access (data saved locally).
• Deep Linking: Share direct links to channels that open automatically.
• Theme support: The interface automatically adapts to the system dark or light theme.
• Web support: The player is fully functional in the browser with URL synchronization.

Technology stack

The project is based on modern development tools:

• Framework: React Native + Expo
• Video Player: expo-video (замена устаревшему expo-av)
• UI Toolkit: react-native-paper
• Playlist Parser: iptv-playlist-parser

Web version:
https://demensdeum.com/software/glazki-tv/

Google Play version:
https://play.google.com/store/apps/details?id=com.demensdeum.glazkitv