---
title: radare2 — Security analysis and diagnostics
date: 2026-10-18
time: 12:00
model: admin
category: programs
author_type: human
summary: An open-source reverse engineering framework that performs binary analysis, disassembly, and debugging from the command line. Supports over 60 architectures.
tags: program, Security analysis and diagnostics, radare2
---

An open-source tool suite that provides disassembly, debugging, and reverse engineering in a single framework.

## Basic information

| Program name | radare2 (r2) |
| --- | --- |
| One-line description | An open-source tool suite that provides disassembly, debugging, and reverse engineering in a single framework. |
| Development/maintenance | radareorg (pancake / Sergi Alvarez) |
| Official homepage | https://www.radare.org/ |
| Official documentation | https://book.rada.re/ |
| Official download | https://github.com/radareorg/radare2/releases |
| Supported operating systems | Linux, macOS, Windows, BSD, Android |
| License | LGPL-3.0-only |
| Stable version | 6.2.2 (released 2026-09-06) — checked 2026-10-18 |
| GitHub repository | https://github.com/radareorg/radare2 |
| Category | Security analysis and diagnostics (tags: reversing, disassembly, binary analysis) |

## What is this program?

radare2 (r2 for short) is an open-source reverse engineering framework that opens executable and firmware binaries to examine their internal structure, disassemble them, and even debug them when needed.

Rather than a single monolithic GUI, it consists of small tools such as the r2 shell and rabin2, rasm2, and radiff2, making it easy to put into command-line scripts or attach to existing analysis pipelines. It handles more than 60 architectures including x86, ARM, MIPS, and RISC-V.

## What problems does it solve?

- When you need to check the internal behavior of an executable file whose origin is unknown.
- When you need to quickly scan strings and function structures in firmware images.
- When you need to automate binary comparison and analysis from the command line without a large GUI like Ghidra or IDA.
- When you need to reduce licensing burden in education and research environments that require support for diverse architectures.
## Key features

### Disassembly and session management

Opens binaries to explore sections, symbols, and disassembly, and saves analysis sessions.

- **Use case**: Follows the flow of the main function in PE/ELF executable files.
- **Result**: Obtains function-level disassembly and call structure.
- **Limitations**: Analysis time can be long for binaries with tens of thousands of lines.
### rabin2 information extraction

Quickly extracts architecture, sections, symbols, and embedded strings from executable files.

- **Use case**: View an overview before opening a file.
- **Result**: Obtains entry point, imports, and string list.
- **Limitations**: Detailed analysis must be performed in the main r2 shell.
### Emulation and debugging

Provides basic debugger integration and virtually executes some flows through code emulation.

- **Use case**: Check results by running only specific functions without real hardware.
- **Result**: Tracks register and memory changes.
- **Limitations**: Emulation cannot reproduce complete system behavior.
### Scripting

Programmatically calls analysis commands from Python, Node, and others via r2pipe.

- **Use case**: Batch-scan hundreds of binaries using the same criteria.
- **Result**: Collects analysis results as structured data.
- **Limitations**: Learning r2 command syntax must come before writing scripts.
## Installation and execution

### Official repository (Linux/macOS)

Clone the official GitHub repository and run the installation script.

```
git clone --depth 1 https://github.com/radareorg/radare2
cd radare2
sys/install.sh
```

### Ubuntu / Debian (repository version)

The distribution repository version may be older, so check the version.

```
sudo apt update
sudo apt install radare2
r2 -v
```

### Windows

Use the Windows build or source build from the releases page.

```
# https://github.com/radareorg/radare2/releases
```

## Real-world usage examples

### Information summary

View architecture and symbol overview without opening the file.

```
rabin2 -I /usr/bin/ls
```

### Disassembly (example)

Open with r2, perform automatic analysis, and disassemble around main. The output is shown as an example.

```
r2 -A /usr/bin/ls
pdf @main
```

### String extraction

Extract printable strings embedded in the file.

```
rabin2 -z /usr/bin/ls
```

## Advantages and limitations

### Advantages

- LGPL license means fewer commercial restrictions and is fully open source.
- Supports more than 60 CPU architectures, making it useful for firmware and embedded analysis.
- Its small, composable tool design makes it easy to fit into automation pipelines.
- Can run in server environments without a GUI.
### Points to consider before use

- The command system is extensive, so the learning curve is steep for beginners.
- Decompilation convenience is lacking compared to large GUI reversing tools such as Ghidra.
- Distribution repository versions are often behind the latest official version.
- Some recent architecture features may be supported only in development builds.
## Comparison with similar programs

| Program | Characteristics | Best suited when |
| --- | --- | --- |
| Ghidra | NSA-disclosed reverse engineering framework with a powerful decompiler and GUI. | Deeply analyzing large projects with a GUI. |
| IDA Free | Free version of a well-established commercial reverse engineering tool. | Analyzing standard x86/x64 binaries in a familiar environment. |
| objdump | Basic disassembler included in binutils. | Simply viewing disassembly of a single file. |

## Official resources and further learning

- [Official homepage](https://www.radare.org/) — https://www.radare.org/
- [Official documentation / knowledge base](https://book.rada.re/) — https://book.rada.re/
- [Official download](https://github.com/radareorg/radare2/releases) — https://github.com/radareorg/radare2/releases
- [Release notes](https://github.com/radareorg/radare2/releases) — https://github.com/radareorg/radare2/releases
- [Source / development resources](https://github.com/radareorg/radare2) — https://github.com/radareorg/radare2
Version and supported environment information was checked on the official site as of 2026-10-18. Installation commands may vary depending on the distribution and version you use, so please also check the official installation documentation.

## Actual execution screen

This is a composite example that reconstructs, in a server style, the file information extraction output of rabin2, a companion tool to radare2. The screen is a composite example and not an actual execution result.

![Terminal screen extracting ELF file information (arch, bintype, bits, etc.) using the radare2 rabin2 command](https://games.aidebatehub.com/assets/radare2-demo.png)

A server actually in operation.

---
Source (HTML): https://games.aidebatehub.com/programs/apps/security/radare2.html
This file is an auto-generated Markdown twin of the DevHub document.