Radare2

No entries match these filters. Clear filters

1. 6.2.4 Oct 5, 2026 · issue 096

   Radare2 6.2.4 adds new commands (iw., /xs, iicl, r2pm -b), RBin plugin for project headers, Mach-O and ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. weak/strong symbol writes, and ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead. pointer-auth prelude detection.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch 6.2.4 https://github.com/radareorg/radare2.git
   # already have the repo? check out this version:
   $ git checkout 6.2.4

   • Adds iw. command to show try/catch blocks of the current function only.
   • Adds /xs sparse gap search command.
   • Adds iicl command to list imports by class.
   • Adds r2pm -b to install released binary packages.
   • Adds compact try/catch metadata commands (iw now shows readable try/catch regions).

   +16 more show less

   • Adds fh address and JSON tree output.
   • Adds A-key pointer authentication function prelude recognition for ARM64.
   • Adds DW_OP_call_frame_cfa DWARF location kind support instead of faking a bp offset.
   • Adds an RBin plugin for binary project headers.
   • Adds Mach-O weak import writing support.
   • Adds reversible Mach-O weak dylib load operation.
   • Adds weak/strong symbol manipulation for ELF.
   • New supported platformAdds the Swift linkage name role classifier for binary analysis.
   • Adds the gettext family to the type database.
   • New supported platformAdds fpret register names in calling convention definitions.
   • Tracks stack frames larger than 8 KiB.
   • Records stack allocation, red zone, and return mechanism per calling convention.
   • Sparse gaps in pxs/xs are now tied to hex.cols and hex.gaplines config keys.
   • Shows all unique .comment strings in the ELF compiler field.
   • Lists symbol-less TLS module relocs in ir.
   • Lists s390 jump slot relocs named by their import.

   21 details in Everything

   • New supported platform s1c88 CPU architecture support
   • New supported platform A64 fallback: CHKFEAT, GCSB DSYNC, CLRBHB, PACM instructions
   • Updated supported platform BookE enabled on 64-bit PPC with Capstone 6
2. 6.2.2 Sep 6, 2026 · issue 067

   Radare2 6.2.2 adds a JNIJNIJava Native Interface, a standard Java SE feature that lets Java code call and be called by native C or C++ libraries, giving cyber tools a bridge between JVM-hosted logic and low-level system code. analysis plugin, NVIDIA PTXPTXA low-level parallel thread execution ISA and virtual machine defined by NVIDIA, used as an intermediate representation for GPU code so tools can compile, inspect, or instrument GPU kernels without targeting specific hardware generations. SASSSASSA CSS preprocessor that adds variables, nesting, and functions to stylesheets, compiling to plain CSS; cyber tools use it to keep UI styling maintainable at scale. support, Haiku debugger, CIL/ESIL for .NET, and s390 pseudo-code.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch 6.2.2 https://github.com/radareorg/radare2.git
   # already have the repo? check out this version:
   $ git checkout 6.2.2

   • Adds the jni analysis plugin to resolve typed JNI table calls, interface tables, indirection, and materialize JNI native methods during analysis.
   • Adds initial encode/decode/pseudo support for NVIDIA PTX SASS architecture.
   • Adds native debugger support for Haiku (x86-32/64), including data watchpoints and asynchronous thread exit handling.
   • Adds CIL token resolution and stack ESIL for .NET/CLR binaries.
   • Adds s390 pseudo-code parser.

   +11 more show less

   • Adds support for Android-specific ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. relocations.
   • Adds full expansion of ELF RELR bitmap relocations.
   • Adds sideloading of Mach-O dSYM files matched by architecture slice and UUIDUUIDA universally unique identifier, usually a 128-bit value used to identify an object across systems. It is designed to make independently generated identifiers unlikely to collide..
   • Adds structured Java and JNI descriptor parsing.
   • Adds parsing of CLR exception clauses in .NET method bodies.
   • Adds parsing of Itanium exception regions from ELF eh_frame.
   • Adds RBinSymbol.hsize field for header metadata paddings.
   • Adds pcappcapA packet capture, recorded network packets that can be inspected later. Analysts use it to reconstruct communication and investigate protocol behavior or suspicious traffic. stream selection support.
   • Adds dyncc floating-point argument registers to calling convention analysis.
   • Adds arm64 Swift calling convention support for FPU arguments.
   • Handles subregister arguments on x64 during variable recovery.
   • Adds the jni analysis plugin to resolve typed JNI table calls, interface tables, indirection, and materialize JNI native methods during analysis.
   • Adds initial encode/decode/pseudo support for NVIDIA PTX SASS architecture.
   • Adds native debugger support for Haiku (x86-32/64), including data watchpoints and asynchronous thread exit handling.
   • Adds CIL token resolution and stack ESIL for .NET/CLR binaries.
   • Adds s390 pseudo-code parser.

   +6 more show less

   • Adds sideloading of Mach-O dSYM files matched by architecture slice and UUIDUUIDA universally unique identifier, usually a 128-bit value used to identify an object across systems. It is designed to make independently generated identifiers unlikely to collide..
   • Adds parsing of CLR exception clauses in .NET method bodies.
   • Adds parsing of Itanium exception regions from ELF eh_frame.
   • Adds RBinSymbol.hsize field for header metadata paddings.
   • Adds pcappcapA packet capture, recorded network packets that can be inspected later. Analysts use it to reconstruct communication and investigate protocol behavior or suspicious traffic. stream selection support.
   • Adds arm64 Swift calling convention support for FPU arguments.

   5 more in Everything

3. advisory CVE-2026-108387 Sep 3, 2026 · issue 128
   • CVE-2026-108387: Remote code executionRemote code executionRemote code execution, the ability to run attacker-chosen code on another system through a vulnerability. Its impact depends on the permissions and access that code receives. when loading Pebble/SMD binary (affects < 6.2.2)⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
4. advisory CVE-2026-81885 Aug 14, 2026 · issue 128
   • CVE-2026-81885: Infinite relocation-chain loop causes denial of service in radare2 NE parser (CVSSCVSSCommon Vulnerability Scoring System, a method for describing a vulnerability's characteristics and severity. Its score is not the probability that attackers will exploit it. 5.5, affects <6.1.9)⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
5. advisory CVE-2026-81886 Aug 14, 2026 · issue 128
   • CVE-2026-81886: Uncontrolled memory allocation in radare2 dmp64 parser (CVSSCVSSCommon Vulnerability Scoring System, a method for describing a vulnerability's characteristics and severity. Its score is not the probability that attackers will exploit it. 5.5, affects <6.1.9)⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
6. advisory CVE-2026-81879 Aug 14, 2026 · issue 128
   • CVE-2026-81879: Heap out-of-bounds read in radare2 ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. PN_XNUM handling (CVSSCVSSCommon Vulnerability Scoring System, a method for describing a vulnerability's characteristics and severity. Its score is not the probability that attackers will exploit it. 5.5, affects <6.1.9)⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
7. 6.2.0 Aug 7, 2026 · issue 039

   Radare2 6.2.0 adds Rust v0 demangling, resource extraction commands, WebAssemblyWebAssemblyA binary instruction format that runs in browsers and server runtimes at near-native speed, letting developers compile C, Rust, or other languages into a portable, sandboxed module any compliant host can execute. type support, PPC64 ELFv2 calling convention, struct synthesis, and more.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch 6.2.0 https://github.com/radareorg/radare2.git
   # already have the repo? check out this version:
   $ git checkout 6.2.0

   └──▷ TRY IT
   Seed a PIC base register before ESIL-based analysis so position-independent code resolves correctly.
   copy

   $ r2 /bin/firmware.elf
   > e anal.gpseed=0x10000
   > aaa

   Extract all embedded resources from a PE binary directly from the command line.
   copy

   $ rabin2 -xU malware.exe

   Synthesize struct types from pointer-argument access patterns after analyzing a function to recover unknown data structures.
   copy

   $ r2 /bin/target
   > aaa
   > s sym.process_packet
   > afts

   • Adds iuo command to open binary resources inline and ix command to extract sections, segments, and resources.
   • Adds iU command (with iUx extraction) and rabin2 -xU flag for listing and extracting binary resources; old iR is renamed to iU and old iU moved to iu.
   • Adds anal.gpseed config key to seed a PIC base register during ESIL analysis.
   • Adds asm.cmt.reguse config key to emit register-use comments in disassembly.
   • Adds dir.binsdb config key (from binpath/dirprefix) for PE/MDMP ordinal lookups.

   +23 more show less

   • Adds types.fields config key to gate propagation of callee types into struct and union fields during aaft.
   • Adds scr.drag config key to enable click-and-drag scrolling in disasm, hex, and graph views.
   • Adds Lcc command to list all plugins registered with the new command API.
   • Adds RArchOpMask.STATEFUL and RArchSession.reset for stateful architecture decoding in plugins.
   • Adds r_anal_cc_argslot and r_anal_cc_argval APIs for resolving calling-convention stack argument slots.
   • Adds r_anal_cc_isclobber API for querying whether a register is clobbered by a calling convention.
   • Adds struct type synthesis from pointer-argument access patterns via the afts command.
   • Adds && and || short-circuit command chaining support in the r2 shell.
   • Adds reguse analysis hints and exposes dyncc register role APIs.
   • Supports the ppc64 ELFv2 calling convention, selected automatically from the ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. ABI.
   • Adds initial Rust v0 symbol demangler, making Rust binaries easier to analyze.
   • Adds v128, ref, and reftype support for WebAssembly binaries.
   • Adds generic binary resource API with support for GLib Resources in ELF, Macho code signatures, PE/CLR resources, PE resources from MDMP, OS/2 LE/LX resources, QNX LMF resources, and Pebble resources.
   • Supports && and || after literal commands in the shell pipeline.
   • Adds auth protection to r2agent web session spawns.
   • Protects r2agent with an HTTP auth file; empty lines in the auth file now block all access rather than allowing any password.
   • Selects the MIPSMIPSA RISC processor architecture originally developed at Stanford and commercialized by MIPS Technologies, widely used in embedded and network devices; cyber tools target it to analyze or exploit routers, cameras, and similar hardware. calling convention automatically from the ELF o32/n32 ABI.
   • Adds callconv definitions (clobber and preserve registers) for all supported architectures, including PPC and ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware..
   • Adds PPC64 TOC pointer base-register tracking, gated by RArchOpMask.STATEFUL and wired into aar.
   • Removes Capstone v3 support; Capstone v4 is now the minimum required version.
   • Makes RBin demanglers pluggable and selectable.
   • Adds MiKNix platform support in the build system.
   • Adds dist/jslinux target using temu/rv64 for JavaScript-based Linux builds.

   28 details in Everything

   └──▷ BREAKING ON UPGRADE

   • !The iR command is renamed to iU; the old iU command is moved to iu; the rabin2 -u flag behavior is moved to an environment variable.
   • !Capstone v3 support is removed; Capstone v4 is now the minimum supported version.
   • !RBinPluginAny is renamed to "null" and no longer uses LibMagic.
   • !Empty lines in the r2agent HTTP auth file now deny all access (previously they permitted any password through).
8. 6.2.0 Aug 7, 2026 · issue 007

   Radare2 6.2.0 adds Rust v0 demangling, resource extraction commands, WebAssemblyWebAssemblyA binary instruction format that runs in browsers and server runtimes at near-native speed, letting developers compile C, Rust, or other languages into a portable, sandboxed module any compliant host can execute. type support, PPC64 ELFv2 calling convention, struct synthesis, and more.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch 6.2.0 https://github.com/radareorg/radare2.git
   # already have the repo? check out this version:
   $ git checkout 6.2.0

   └──▷ TRY IT
   Seed a PIC base register before ESIL-based analysis so position-independent code resolves correctly.
   copy

   $ r2 /bin/firmware.elf
   > e anal.gpseed=0x10000
   > aaa

   Extract all embedded resources from a PE binary directly from the command line.
   copy

   $ rabin2 -xU malware.exe

   Synthesize struct types from pointer-argument access patterns after analyzing a function to recover unknown data structures.
   copy

   $ r2 /bin/target
   > aaa
   > s sym.process_packet
   > afts

   • Adds iuo command to open binary resources inline and ix command to extract sections, segments, and resources.
   • Adds iU command (with iUx extraction) and rabin2 -xU flag for listing and extracting binary resources; old iR is renamed to iU and old iU moved to iu.
   • Adds anal.gpseed config key to seed a PIC base register during ESIL analysis.
   • Adds asm.cmt.reguse config key to emit register-use comments in disassembly.
   • Adds dir.binsdb config key (from binpath/dirprefix) for PE/MDMP ordinal lookups.

   +23 more show less

   • Adds types.fields config key to gate propagation of callee types into struct and union fields during aaft.
   • Adds scr.drag config key to enable click-and-drag scrolling in disasm, hex, and graph views.
   • Adds Lcc command to list all plugins registered with the new command API.
   • Adds RArchOpMask.STATEFUL and RArchSession.reset for stateful architecture decoding in plugins.
   • Adds r_anal_cc_argslot and r_anal_cc_argval APIs for resolving calling-convention stack argument slots.
   • Adds r_anal_cc_isclobber API for querying whether a register is clobbered by a calling convention.
   • Adds struct type synthesis from pointer-argument access patterns via the afts command.
   • Adds && and || short-circuit command chaining support in the r2 shell.
   • Adds reguse analysis hints and exposes dyncc register role APIs.
   • Supports the ppc64 ELFv2 calling convention, selected automatically from the ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. ABI.
   • Adds initial Rust v0 symbol demangler, making Rust binaries easier to analyze.
   • Adds v128, ref, and reftype support for WebAssembly binaries.
   • Adds generic binary resource API with support for GLib Resources in ELF, Macho code signatures, PE/CLR resources, PE resources from MDMP, OS/2 LE/LX resources, QNX LMF resources, and Pebble resources.
   • Supports && and || after literal commands in the shell pipeline.
   • Adds auth protection to r2agent web session spawns.
   • Protects r2agent with an HTTP auth file; empty lines in the auth file now block all access rather than allowing any password.
   • Selects the MIPSMIPSA RISC processor architecture originally developed at Stanford and commercialized by MIPS Technologies, widely used in embedded and network devices; cyber tools target it to analyze or exploit routers, cameras, and similar hardware. calling convention automatically from the ELF o32/n32 ABI.
   • Adds callconv definitions (clobber and preserve registers) for all supported architectures, including PPC and ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware..
   • Adds PPC64 TOC pointer base-register tracking, gated by RArchOpMask.STATEFUL and wired into aar.
   • Removes Capstone v3 support; Capstone v4 is now the minimum required version.
   • Makes RBin demanglers pluggable and selectable.
   • Adds MiKNix platform support in the build system.
   • Adds dist/jslinux target using temu/rv64 for JavaScript-based Linux builds.

   28 details in Everything

   └──▷ BREAKING ON UPGRADE

   • !The iR command is renamed to iU; the old iU command is moved to iu; the rabin2 -u flag behavior is moved to an environment variable.
   • !Capstone v3 support is removed; Capstone v4 is now the minimum supported version.
   • !RBinPluginAny is renamed to "null" and no longer uses LibMagic.
   • !Empty lines in the r2agent HTTP auth file now deny all access (previously they permitted any password through).
9. 6.1.8 Jun 23, 2026 · release notes

   Radare2 6.1.8 adds new demanglers, JWTJWTAn open standard (RFC 7519) for encoding claims as a signed, optionally encrypted JSON object passed between parties. Cyber tools use it to verify identity and permissions without querying a central session store. decoding, ESIL PPC coverage, new type commands, and more binary format support.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch 6.1.8 https://github.com/radareorg/radare2.git
   # already have the repo? check out this version:
   $ git checkout 6.1.8

   └──▷ TRY IT
   Look up all struct names that match a specific byte size to identify unknown data structures.
   copy

   $ r2 binary.elf -c 'tsn 16'

   Find an enum value by its numeric constant to reverse-engineer protocol or status codes.
   copy

   $ r2 binary.elf -c 'ten 3'

   • Adds Rust, D, C++, IBM XL, and ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. ABI demanglers for richer symbol resolution across more toolchains.
   • Implements pFJ command for decoding JWT tokens directly in the print pipeline.
   • Adds idd command for binary info inspection.
   • Adds ten command for enum lookup by numeric value.
   • Adds tsn command to look up struct names by size.

   +17 more show less

   • Adds FTAB extractor plugin for new binary format support.
   • Adds GNS1 binary loader improvements with better dyldcache false-positive detection.
   • Adds R_DYLDCACHE_NO_DEPS option for shallow dyldcache dependency filtering.
   • Adds ESIL modeling for PPC scalar floating-point load/store/arithmetic/convert operations.
   • Adds ESIL for PPC integer, logical, rotate, and mod operations including isel conditional-select.
   • Adds ESIL for PPC XER.CA carry flag for add/subtract-with-carry and algebraic shift-right.
   • Unifies asm.addr.base10/asm.addr.base36 settings into a single asm.addr.base config key.
   • Supports hexdump/disasm address display in octal base.
   • Adds CLd command for source-baked decompiler output.
   • Adds r2vsql to the fallback command handler for SQL-style binary querying.
   • Ships syscall tables and a Pebble script for stub scans targeting PebbleOS.
   • Adds ldmap.r2.js script to load source-line information from linker map files.
   • Renders array stack variable element accesses as name[i] in disassembly.
   • Adds RTableOptions.wrap and improved Markdown table rendering with ellipsis trim and attribute support.
   • Extends all p-/p= commands with JSON output and improved bounds.
   • Ports r2preload to Windows.
   • Adds Nix flakeNix flakeA Nix packaging construct that pins all dependencies in a lockfile and exposes a standardized interface, giving cyber tools fully reproducible builds across any machine running the Nix package manager. and dev shell support for the build system.

   22 details in Everything

   └──▷ BREAKING ON UPGRADE

   • !The asm.addr.base10 and asm.addr.base36 config keys are unified into asm.addr.base; existing configs using the old keys will break.
   • !The default CPUCPUThe main general-purpose processor in a computer. It runs application instructions and coordinates work with memory and other hardware. for AVR is now ATxmega128a4u; setups relying on the previous default CPU may behave differently.
   • !iz+ now requires spaced arguments; scripts passing unspaced arguments to iz+ will break.
   • !sdb_remove is deprecated as a duplicate of sdb_unset; code using sdb_remove via the ABI may break.
10. 6.1.8 Jun 23, 2026 · issue 007

    Radare2 6.1.8 adds JWTJWTAn open standard (RFC 7519) for encoding claims as a signed, optionally encrypted JSON object passed between parties. Cyber tools use it to verify identity and permissions without querying a central session store. decoding, new demanglers, type-lookup commands, FTAB/idd/R_DYLDCACHE_NO_DEPS, ESIL stepback, and PPC ESIL coverage.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.1.8 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.1.8

    └──▷ TRY IT
    Decode a JWT token found in a binary at the current seek position to inspect its header and claims.
    copy

    $ r2 /path/to/binary
    > s <address_of_jwt>
    > pFJ

    Look up which struct in the type database matches a known size (e.g., 16 bytes) — useful when reversing packed structures with no symbols.
    copy

    $ r2 /bin/ls
    > aaa
    > tsn 16

    Resolve an unknown numeric constant to its enum name to understand protocol or syscall values at a glance.
    copy

    $ r2 /bin/ls
    > aaa
    > ten 3

    • Adds pFJ command for JWT token decoding in the print subsystem.
    • Adds CLd command for source-baked decompiler output.
    • Adds tsn command to look up struct names by size.
    • Adds ten command for enum lookup by numeric value.
    • Adds idd command for binary info inspection.

    +19 more show less

    • Adds R_DYLDCACHE_NO_DEPS option for shallow (dependency-filtered) dyldcache loading.
    • Adds FTAB extractor plugin for new binary format support.
    • Adds Rust, D, IBM XL, ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. ABI, and new C++ demangler support in the binary loader.
    • Adds r2vsql to the fallback command handler in the shell.
    • Adds ldmap.r2.js script to load source-line info from ldscript map files.
    • Adds a Pebble script for stub scans and ships PebbleOS syscall tables.
    • Supports hexdump/disasm address display in octal base.
    • Unifies asm.addr.base10/asm.addr.base36 into a single asm.addr.base config option (breaking change).
    • Extends all p-/p= commands with JSON output and improved bounds handling.
    • Renders array stack variable element accesses as name[i] in disassembly.
    • Adds ESIL lifecycle and stepback support in core ESIL stepping.
    • Adds ESIL modeling for PPC scalar floating-point load/store/arithmetic/convert ops.
    • Adds ESIL for PPC integer/logical/rotate/mod ops and the isel conditional-select instruction.
    • Models PPC XER.CA ESIL for add/subtract-with-carry and algebraic shift-right.
    • Supports union offsets in type member lookup.
    • Adds inline markdown codeblock/span rendering and table trim with ellipsis.
    • Adds Nix flakeNix flakeA Nix packaging construct that pins all dependencies in a lockfile and exposes a standardized interface, giving cyber tools fully reproducible builds across any machine running the Nix package manager. and dev shell support under dist/nix.
    • Exposes addrline DWARF info in the r2 virtual filesystem.
    • Ports r2preload to Windows.

    24 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The sdb_remove function has been deprecated as a duplicate of sdb_unset
    • !The asm.addr.base10 and asm.addr.base36 config keys are unified into asm.addr.base
    • !The esil.verbose config key has been removed
    • !The default CPUCPUThe main general-purpose processor in a computer. It runs application instructions and coordinates work with memory and other hardware. for AVR is now ATxmega128a4u
    • !The iz+ command now requires spaced arguments
11. 6.1.6 Jun 2, 2026 · release notes

    Radare2 6.1.6 adds Zydis x86 backend, dynamic calling convention analysis, multireturn support, and sweeping DEX/Mach-O/ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. improvements.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.1.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.1.6

    └──▷ TRY IT
    Inspect jump/switch table cases for the current function using the redesigned afbt command.
    copy

    $ r2 <binary> -c 'aaa; s sym.main; afbt'

    Parse and display DER code signatures embedded in a Mach-O binary.
    copy

    $ r2 <macho_binary> -c 'iC'

    • Adds opt-in Zydis x86 arch plugin as an alternative disassembly backend.
    • Adds dynamic calling convention parser supporting Java, Dalvik, .NET, Python, and Wasm via RBinPlugin.getCc.
    • Adds initial multireturn support in calling convention analysis.
    • Renames afj to afbt and redesigns/extends the jump/switch table API and commands.
    • Adds afbtj branch-case display in analysis output.

    +26 more show less

    • Adds configurable jumptable maxcases for analysis.
    • Adds static x86 calling convention clobber, preserve, and stack-cleanup metadata.
    • Adds ppc.nz r_asm encoder plugin for PPC assembly.
    • Adds OpType/ESIL support for PPC dword shifts, X-form load/store, cntlz, mulh, and CR moves.
    • Adds RArchInfo.WODST flag for architectures with write-only destination operands.
    • Adds ic[+-] commands to add/remove class fields and inheritance info.
    • Adds ii+ and ii- commands to add/remove imports interactively.
    • Adds ies extension for Dalvik onCreate symbol entrypoints.
    • Adds bin.classes.namesonly option to skip method/field parsing for faster loading.
    • Adds bin.relocs.xrefs config var to skip xref creation from relocations.
    • Adds bin.unnamed option (and RBinOptions.loadUnnamed) to skip loading unnamed symbols across ELF, SOM, dyldcache, and more formats.
    • Adds bin.flags config var to skip loading binary symbol flags.
    • Adds bin.meta config var to disable codemeta info loading.
    • Adds anal.plugins.pre config var.
    • Parses and displays DER signatures in Mach-O via the iC command.
    • Exposes DYLD_ENVIRONMENT, __RESTRICT, and MH_APP_EXTENSION_SAFE Mach-O metadata via sdb.
    • Exposes Mach-O signing type.
    • Recovers ObjC inheritance in analysis classes.
    • Parses valid Wasm sections 12 and 13 (datacount and tag).
    • Updates Wasm3 support for try/MMX ops.
    • Handles more PPC64 relocation types with big-endian-aware reloc patching.
    • Adds r_bin_class_add_method API and surfaces class methods.
    • Supports lazy-loading of DEX addrline debug info for faster loading.
    • Adds support for pining functions with custom emojis.
    • Adds anal.flagbounds (renamed from anal.flagstop) as a function boundary option.
    • Adds command file string API to the ABI.

    31 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The anal.flagstop config variable is renamed to anal.flagbounds; existing configs using anal.flagstop will need to be updated.
    • !The afj command is renamed to afbt; scripts or workflows invoking afj must be updated to use afbt.
12. 6.1.4 Apr 12, 2026 · release notes

    Radare2 6.1.4 adds hardware breakpoints for winkd, new debug session checkpoints, pdub/pdur disasm commands, and JNIJNIJava Native Interface, a standard Java SE feature that lets Java code call and be called by native C or C++ libraries, giving cyber tools a bridge between JVM-hosted logic and low-level system code. autoloading.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.1.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.1.4

    └──▷ TRY IT
    Disassemble a function body stopping at the first return instruction — useful for quick function boundary inspection without knowing the size.
    copy

    $ r2 <binary> -c 'af; pdur'

    Attach to a running process temporarily using the new PID alias to inspect registers without a full debug session.
    copy

    $ r2 -d <binary> -c 'dr @p:1234'

    • Adds hardware breakpoints support for winkd debug backend.
    • Adds single stepping and wait reasons for winkd.
    • Adds branchable debug session checkpoints for snapshot-based reversing.
    • Adds @p:PID, @dr:, and @dp: aliases for temporal process/thread attach.
    • Adds pdub (disassemble until end-of-block) and pdur (disassemble until return) commands.

    +19 more show less

    • Autoloads JNI types when loading Android binaries and lists JNI_* symbols via ies.
    • Adds Analysis.Plugins submenu and filesystem manager (fs and js shells) to the Panels UI.
    • Adds R2_PLUGINS_ORDER environment variable to control plugin load locations.
    • Extends aCe/aCf commands to support plaintext, JSON, and r2 output modes.
    • Adds a:autoname analysis plugin and improves function autoname scoring strategy.
    • Adds RAnalPlugin.thumb to scan code for ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. Thumb mode-switch hints.
    • Adds r_anal_xrefs_setf API for a ~3% analysis speedup by avoiding redundant function lookups.
    • Exposes typed function context with params, stack slots, and base types.
    • Imports C rewrite of the gopcintab plugin.
    • Adds support for NDS32 ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. relocations.
    • Supports more v850 relocations.
    • Extends Swift demangler with additional abbreviation tables and conformance entries.
    • Adds buffer-baked functions in r_magic and restores magic file baked APIs with performance improvements.
    • Implements r_print_code_indent for C-like code indentation via ~:}.
    • Adds initial generic support for camel syntax in the assembler.
    • Automatic scrolling and panning out of screen in menubars panel.
    • Formats uf2:// IO plugin and adds new device family entries.
    • Adds GitHub ActionsGitHub ActionsGitHub's built-in CI/CD system that runs automated workflows triggered by repository events, letting cyber tools automate testing, building, and releasing without managing separate pipeline infrastructure. CI and FilC compilation artifacts.
    • Installs to lib64 on Fedora/RHELRHELRed Hat Enterprise Linux, a commercially supported Linux distribution maintained by Red Hat, chosen by cyber tools for its long support lifecycle, certified hardware compatibility, and enterprise deployment prevalence./SUSE.

    24 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !RCore.cmdCall is renamed to RCore.call; any plugin or script referencing RCore.cmdCall will break.
    • !R_CORE_LOADLIBS_ALL is renamed to R_LIB_LOAD_ALL; code using the old constant will fail to compile.
    • !r_anal_archinfo is removed in favor of r_arch_info; callers of r_anal_archinfo must be updated.
13. 6.1.2 Mar 19, 2026 · release notes

    Radare2 6.1.2 adds Python pseudo-disassembly, new type inspection commands, BrainFuck pseudo plugin, and expanded analysis configurability.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.1.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.1.2

    └──▷ TRY IT
    Delete a stale or incorrect function type definition from the type database.
    copy

    $ r2 <binary> -c 'tf- my_function_t'

    Inspect function arguments and their stack offsets for a function at the current seek.
    copy

    $ r2 <binary> -c 'aa; s sym.target_func; tfv'

    Limit basic block size in graphs to 256 bytes to keep large functions readable.
    copy

    $ r2 <binary> -e graph.bb.maxsize=256 -c 'aa; agf @ sym.main'

    • Adds initial Python pseudo-disassembler plugin for decompiling Python bytecode.
    • Adds bf.pseudo plugin for BrainFuck pseudo-disassembly.
    • Implements ah= command to copy instruction details into analysis hints.
    • Adds anal.vars.maxframe and anal.vars.maxbbsize config vars for fine-grained variable analysis limits.
    • Adds graph.bb.maxsize option to cap basic block size rendered in call/function graphs.

    +17 more show less

    • Adds prj.new config option to use new project file formats.
    • Implements tf- command to delete function type definitions.
    • Implements tfv command to view function arguments and their offsets.
    • Adds anal.types.xrefs config var to enable cross-reference tracking for the tv type commands.
    • Shows xrefs for function signature definitions via tfv.
    • Adds RBinInfo.uncaps field to expose non-encapsulated symbols from binary parsers.
    • Adds missing CSSLOT code signature slot types for Mach-O parsing.
    • Merges pz and p= subcommand capabilities.
    • Adds r2r -1 as an alias for -j1 single-threaded test runs.
    • Adds user plugin support in rafs2.
    • Supports copying to directory and handles errors in the cp shell command.
    • Initial support for $$..XXX addressing syntax in core.
    • Renames anal.types.* config vars to types.* namespace.
    • Adds lazy-loading and caching of types to speed up startup.
    • Includes line number and type name in type parsing failure messages.
    • Supports parsing variadic arguments in function pointers.
    • Supports parsing forward struct declarations.

    22 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The anal.types.* config variables are renamed to types.*; any scripts or configs using the old names will break.
14. 6.1.0 Feb 17, 2026 · release notes

    Radare2 6.1.0 adds DRCOV trace import, source-line breakpoints, ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead. native breakpoints, new string commands, SREC format, and more.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.1.0

    └──▷ TRY IT
    List all strings at the current seek address in quiet JSON format.
    copy

    $ izjq.

    • Adds plugin to import execution traces from DRCOV logs into the analysis pipeline.
    • Adds anal.jmptbl.split option to experimentally resolve missing jump table cases.
    • Adds anal.jmp.pair option to flatten consecutive inverse branch anti-disassembly tricks.
    • Adds afnq command as a refactored helper for function naming.
    • Implements asm.pseudo plugin for .NET CIL disassembly pseudo-syntax.

    +38 more show less

    • Adds camelcase disassembly syntax support.
    • Adds ARC pseudo plugin with updated opcode descriptions and updated ARC disassembler from binutils 2026.
    • Adds izzc and izzzc commands to count raw strings.
    • Implements izjq and its alias izqj for combined JSON/quiet string output.
    • Adds iz+ command and extends iz- command to accept length and type arguments.
    • Adds count and pagination support to iz string listing commands.
    • Adds support for ARM64 GLOB_DAT ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. relocation types.
    • Supports Apple C4000 Baseband firmware (gns1) format in the binary plugin.
    • Adds support for records and invokedynamic in the Java binary parser.
    • Adds support for ACC_HIDDEN Java classes.
    • Supports non-ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. bflt executables.
    • Exposes more native relocation types and the reloc type for REL binaries.
    • Implements native breakpoints support for XNU/ARM64 in the debugger.
    • Adds source-line breakpoints support in the debugger.
    • Implements printing of FPU registers for Linux ARM/ARM64.
    • Adds SREC file format support in the IO layer.
    • Adds mlx command to list deleted files for FAT filesystems.
    • Adds sandbox guards for zip:// IO plugin.
    • Adds wx+ nibble writes that no longer depend on block size.
    • Extends x86 FPU emulation support in ESIL.
    • Supports overlapped strings in the disassembly listing.
    • Supports MDMP RTM revision version information exposure from minidumps.
    • Adds support for CIL/Mono detection extended to exe/dll.
    • Imports function signatures and type definitions from DWARF debug info.
    • Extends iH command to return a string and permit multiple formats.
    • Supports initial third-party plugin builds.
    • Replaces bundled libzip+zlib with otezip, reducing codebase by ~55kLOC.
    • Reduces DEX binary loading memory usage by ten times.
    • Adds r_io_bank_get_regions to speed up io.unalloc operations.
    • Adds rahash2 -R sdb output support.
    • Documents and enforces nibble mask search in rafind2.
    • Adds rafind2 file filtering by rbin info.
    • Supports custom text output for RMuta ssdeep/entropy plugins.
    • Creates unified RMuta.crc plugin covering all 22 supported CRC variants.
    • Ports sha384 and sha512 into RMuta hash framework.
    • Supports subtypes in muta plugins, combining rol/ror variants.
    • Moves p2 and p3 commands into pri2/pri3.
    • Honors cfg.bigendian in cv commands.

    43 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The r_bin_command function is renamed to r_bin_cmd.
    • !RAnalCmd now returns a string instead of bool, changing the API contract for callers.
15. 6.0.8 Dec 30, 2025 · release notes

    Radare2 6.0.8 adds .NET/CIL support, Apple Filesystem, new partition formats, register rainbow coloring, and coredump improvements.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.0.8 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.0.8

    └──▷ TRY IT
    List all available parse plugins in rasm2 to identify supported syntax front-ends.
    copy

    $ rasm2 -LL

    • Adds initial CIL (Common Intermediate Language) disassembler and assembler for .NET PE assembly analysis.
    • Implements working support for .NET PE assemblies including .types for the PDBPDBA debug symbol file format used by Microsoft's toolchain that maps compiled binaries back to source code, function names, and variable types, letting cyber tools resolve symbols during reverse engineering or memory analysis. plugin and a new RBin.pdb plugin.
    • Adds Apple FileSystem (APFSAPFSApple's proprietary filesystem introduced in 2017, replacing HFS+, designed for SSDs with native encryption, snapshots, and space sharing — giving cyber tools reliable forensic primitives on modern Apple devices.) support including reading files in APFS mountpoints and retrieving file sizes.
    • Adds GPT partition table support.
    • Adds BSD DiskLabel partition support.

    +23 more show less

    • Adds APMAPMApplication Performance Monitoring — a category of software that collects metrics, traces, and logs from running applications so developers can detect slowdowns and diagnose their root cause. (PMAP) Apple Classic partition support.
    • Adds EBR partition support alongside existing MBR support.
    • Implements dga command to coredump all memory maps.
    • Adds register rainbow coloring via the scr.rainwbow.regs option.
    • Adds asm.cmt.strings option to disable pointer strings in operation comments.
    • Implements tap:// IO plugin for reading SimH tape images.
    • Adds support for reading pipe/FIFO files with r2 <(command) process substitution syntax.
    • Supports AT&T syntax in x86 disassembly and ESIL generation.
    • Implements @@@m:perm foreach operator in the shell for iterating over maps by permission.
    • Implements typedef union and enum parsing in the KVC types parser.
    • Adds ${pal:} themed color support in scr.prompt.format.
    • Adds scr.vprompt.format option for visual mode prompt formatting.
    • Implements rasm2 -LL to list parse plugins.
    • Adds -hh extended help flag for rabin2 and rasm2.
    • Adds JSON output support to rafs2.
    • Adds R2_DOCDIR and R2PM_DOCDIR environment variables.
    • Colorizes permission fields in iS, dm, dmm, and om commands.
    • Implements bin.str.align option to discard unaligned strings.
    • Adds HTTP session registration APIs.
    • Supports binary data downloads via RSocket.get.
    • Enables raw IO by default.
    • Heavily refactors and improves the Z80 plugin including assembler and disassembler.
    • Exposes rbin metadata for .NET in disassembly output.

    28 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The a2f core plugin is removed; its functionality is now part of the anal component directly.
    • !The blaze analysis has been converted from a core plugin into an analysis plugin.
    • !pf2 is removed; pf is now the unified print format command.
    • !ESIL chevron shift operators are replaced with LSL, LSR, ASR, ROL.
    • !Raw IO is enabled by default (rawio).
16. 6.0.6 Nov 23, 2025 · release notes

    radare2 6.0.6 adds BFS filesystem support, :tls debug commands, JSON output for /s, and scr.prompt.format

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.0.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.0.6

    └──▷ TRY IT
    Format the interactive prompt to show virtual address and relative path when analyzing files
    copy

    $ e scr.prompt.format=${relto} ${vaddr}

    • Initial support for the BeOS Filesystem (BFS) with automagic detection and Miknight Commander (mmc) dual-panel file manager
    • Adds :tls command in mach:// and w32dbg io plugins to print thread info address
    • Adds cfg.regnums setting (default false) to read register values via rnum instead of name
    • Supports JSON output for the /s (string search) command
    • Initial implementation of scr.prompt.format with ${relto}, ${e:EVAR}, vaddr, paddr, and r:reg handlers

    +3 more show less

    • Adds cfg.newpf setting to run pf2 instead of pf for print formats
    • Adds wvg command and cfg.float config to write custom float values
    • Initial implementation of minimal pseudo support for EVM (Ethereum Virtual Machine)

    8 details in Everything

17. 6.0.4 Sep 27, 2025 · release notes

    Radare2 6.0.4 adds sBPF analysis, VAX/SNES/MSP430 pseudo-disasm, MobiCore/XNU IOKit support, r2agent session listing, and dozens of new assembler instructions.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.0.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.0.4

    └──▷ TRY IT
    List active r2agent remote sessions to audit what connections are currently registered.
    copy

    $ r2agent -L

    Control the numeric base used when displaying immediate values in disassembly.
    copy

    $ r2 -e asm.imm.base=16 binary

    • New sBPF (Solana BPFBPFA Linux kernel virtual machine that lets programs attach small, sandboxed bytecode filters to kernel hooks — syscalls, network events, tracepoints — so cyber tools can observe or redirect kernel behaviour without writing a kernel module.) analysis plugin with Rust string resolution, ESIL modelling, and ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. binary detection
    • Adds a:path analysis plugin (initial import)
    • New snes.pseudo ASMASMAttack Surface Management: the continuous practice of discovering, inventorying, and monitoring an organization's externally exposed assets so that cyber tools can flag unknown or misconfigured entry points before attackers find them. plugin for Super Nintendo disassembly
    • New pseudocode plugin for VAX architecture
    • New MSP430 pseudo-disassembler plugin (initial implementation)

    +31 more show less

    • Adds process_vm IO plugin for process memory access
    • Implements XNU IOKit class carving and adds core IOKit types
    • Initial support for MobiCore MCLF binary format (fixes #14879)
    • Supports assembling extended BPF64 instructions and integrates BPF assembler into the Capstone plugin
    • Implements ST/LD classic BPF instruction assembly
    • Adds ldm/stm support for ARM32 assembler
    • Adds pld prefetch load for ARM32 assembler
    • Adds umlal and extended msr constructions for ARM32 assembler
    • Adds mrs instruction support in the ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. assembler
    • Implements crc32, rdrand, and rdseed for x86 assembler
    • Adds lzcnt, tzcnt, and popcnt for x86-64 assembler
    • Expands M68K assembler support with more instructions (fixes #21211)
    • Adds r2agent -L to list current remote sessions
    • Registers remote sessions when using r2agent
    • Implements R_IO_SEEK_HOLE for IO layer
    • New asm.imm.base config variable for controlling immediate base display
    • Implements r_flag_closest_with_prefix API and API for nearest flag inside a flagspace
    • Initial implementation of autoflagspaces
    • Adds R2_DEBUG_NOLANG environment variable to suppress RLang plugin loading
    • Adds r2 -H R2_MANDIR to print the man directory path
    • Adds new math operators and sub-expression support for negation operators in the shell
    • Indexes __objc_msgrefs xrefs and parses _selrefs for Objective-C metadata
    • Stores rawname in RFlagItem and exposes it from RBinName
    • Adds RBinClass instance size and type name fields
    • Adds support for HTTP POST on /cmd and r2pipe client APIs over HTTP
    • Implements tfc command without arguments to list all type function callbacks
    • Supports mangled/demangled names in zignatures
    • Implements vmatrix visual mode (initial import)
    • Initial real threaded Core tasks support; aliases fg/bg/jobs for task management
    • Adds VAX ELF reloc 21 support
    • Supports dynamic function prefixes in analysis

    36 details in Everything

18. 6.0.2 Aug 12, 2025 · release notes

    Radare2 6.0.2 adds hexfile:// URI handler, RXML DOMDOMThe browser's in-memory tree representation of a web page's structure, standardized by the W3C, giving cyber tools a programmable interface to read or manipulate page content at runtime. API, temporary block modifiers, and F-key shell shortcuts.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.0.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.0.2

    └──▷ TRY IT
    Open a hex-encoded binary file directly for analysis without pre-converting it.
    copy

    $ r2 hexfile:///path/to/file.hex

    Use the @xf: temporary block modifier to run a command scoped to a specific block context during analysis.
    copy

    $ pd 10 @xf:0x00401000

    • Adds hexfile:// URI handler for opening hex-encoded files directly.
    • Supports R_X86_64_RELATIVE and R_AARCH64_RELATIVE ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. relocation types for improved binary analysis.
    • Introduces @xc: and @xf: temporary block modifiers for scoped analysis commands.
    • Adds F-key (function key) shortcut support in the radare2 shell.

    4 details in Everything

19. 6.0.0 Jul 30, 2025 · release notes

    Radare2 6.0.0 introduces afv*/afvd*, abm, pds*, iSm/ies commands, debuginfod support, and new analysis flags.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 6.0.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 6.0.0

    • Adds afv* and afvd* subcommands for listing analysis plugins with function and variable event wiring
    • Adds pds* command to add comments for emulated strings
    • Adds emu.maxsize config option to allow ESIL emulation to scan large memory sections
    • Adds debuginfod support to download DWARF debug files via the writedwarf plugin
    • Adds iSm and ies commands for mapping symbols in sections and accessing entrypoint symbols respectively

    +1 more show less

    • Adds rasm2 -L [arch] flag to show detailed information for a specific architecture plugin

    6 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !RBinDbgItem is renamed to RBinAddrline
    • !RLang.list() is deprecated
    • !core->offset is renamed to core->addr
    • !RFlagItem.offset is renamed to RFlagItem.addr
20. 5.9.8 Nov 19, 2024 · release notes

    Radare2 5.9.8 adds new analysis commands, crypto plugins, search ops, and visual bit-editor enhancements.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.9.8 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.9.8

    └──▷ TRY IT
    Find all recursive functions in a binary to prioritise reverse-engineering effort.
    copy

    $ r2 -A /path/to/binary -c 'aflmr'

    Search for loops inside the current function to locate iteration logic quickly.
    copy

    $ r2 -A /path/to/binary -c 's main; /abf'

    Persist a config change across sessions without manually editing r2rc.
    copy

    $ r2 -c 'e+ scr.color=2' /path/to/binary

    • Adds aflmr command to list all recursive functions in the binary.
    • Adds aflmu command to list each function call exactly once (deduplication).
    • Adds afln command to list all function names.
    • Makes afvt work with a single parameter to display a variable's type.
    • Adds recursive-call information to afi function info output.

    +26 more show less

    • Adds parse.pickle plugin for disassembly of Python pickle opcodes.
    • Adds gb.pseudo plugin for Game Boy pseudo-disassembly.
    • Adds /abf command to search for loops within the current function.
    • Adds /h* search variant and normalises /h behaviour to match other search commands.
    • Adds asm.cmt.pseudo config option to show pseudo-code in disassembly comments.
    • Adds asm.cmt.wrap config option to suppress right-side comment wrapping on long lines.
    • Adds e+ command to persistently set config variables in r2rc.
    • Adds -e log.level support for string-valued log levels.
    • Adds r2 -1 flag to redirect stderr into stdout.
    • Adds stdouterr directive to rarun2 for unified output capture.
    • Adds SipHash and bech32 encoding/decoding to the crypto plugin suite.
    • Adds SM4 master-key display and offset reporting on hits in search.
    • Adds iic subcommands for listing unique cross-references and classifying imports by category.
    • Improves iS table queries with sha1/sort/inc and entropy columns.
    • Supports table queries for strings via iz, and for classes via ic,.
    • Supports @% syntax for reading shell variables in expressions.
    • Adds yank/paste support in the visual bit editor (Vd1).
    • Adds endian-swap operation in the visual bit editor.
    • Adds Vd1! to toggle all bits in the selected byte.
    • Adds word-size concept and multi-byte increment/decrement (Vd1[+-]) in the visual bit editor.
    • Adds XDGXDGA set of specifications maintained by freedesktop.org that standardise where Linux applications store config, data, and cache files, letting tools respect user-defined paths instead of hardcoding locations. cache directory support exposed via dir.cache for annotations.
    • Adds new project core plugin with save/restore of comments and prj.files support.
    • Adds initial LZ4 compression implementation to the util library.
    • Imports ImHex charset definitions into the print/pattern subsystem.
    • Includes calling-convention information in pdc pseudo-decompiler output.
    • Handles base64: prefix in #!-e scripting expressions.

    31 details in Everything

21. 5.9.6 Oct 13, 2024 · release notes

    Radare2 5.9.6 adds Dalvik disassembler, m68k assembler, Capstone6 arch support, new search commands, crypto ops, and shell improvements.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.9.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.9.6

    • New Dalvik disassembler contributed by NowSecure for Android bytecode analysis.
    • Assembler support added for m68k architecture.
    • Capstone6 support for PowerPC, MIPSMIPSA RISC processor architecture originally developed at Stanford and commercialized by MIPS Technologies, widely used in embedded and network devices; cyber tools target it to analyze or exploit routers, cameras, and similar hardware., and ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead..
    • New /xn command to search for repeated byte patterns.
    • New /xv[s] command to search for value arrays.

    +29 more show less

    • New /V value range support added to rafind2.
    • New ano command to manage function annotations.
    • Adds poE and poD crypto commands.
    • Adds ed25519 private key search capability.
    • Adds CRC search to magic.
    • New test command with -s, -f, -x, and -d flags.
    • New @@f alias for @@c:afla to iterate over functions in inverse recursive order.
    • New f-0x, f-?, and related flag removal commands.
    • Adds io.mapinc config variable for IO map control.
    • Adds scr.prompt.prj config to display project name in the prompt.
    • New dark theme: gruvbox.
    • Exposes scr.color via R2_COLOR environment variable.
    • Adds -e cmd.exit option to run commands before leaving r2.
    • New -A and -H shell commands.
    • Detects Dart ELFs and supports fixed x27 as global pointer reference on Dart binaries.
    • Detects VisionOS binaries.
    • Support for jump table constructions for ARM64 (Swift binaries).
    • Support tail addresses in pdua...
    • Implements pfb bitfield printing improvements in C, ASCII art, and oneliner formats.
    • Horizontal scrolling with Ctrl+wheel in graph and visual modes.
    • Makes -p/-P project commands available directly from the r2 shell.
    • Generic pseudo disassembly for non-supported architectures.
    • Adds scr.css and scr.css.prefix config options for HTML output customization.
    • Initial implementation of HTTP sessions.
    • xmm registers added for FreeBSD debugger.
    • FPU registers st0–st7 and mm0–mm7 added for FreeBSD debugger.
    • Hardware breakpoints (hwbp) used by default on mac-x64.
    • Renames bin.demangle.libs to bin.demangle.pfxlib for clarity.
    • Summarized variable listing enabled by default (asm.var.summary=4).

    34 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The ia command is replaced by iA; ia is deprecated.
    • !bin.demangle.libs is renamed to bin.demangle.pfxlib.
    • !r2pm -HH is removed; use r2pm -H (without argument) instead.
22. 5.9.4 Aug 8, 2024 · release notes

    Radare2 5.9.4 adds UXN/UF2/s390x/STM8 support, Ed25519Ed25519A fast elliptic-curve signature scheme with small keys, the default for new SSH keys and common in code signing. It is not quantum-safe. crypto, jump table analysis, project history, and dozens of new commands.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.9.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.9.4

    └──▷ TRY IT
    Search for assembly patterns using glob matching to catch instruction families in one pass.
    copy

    $ r2 -c '/ad mov eax, *' <binary>

    • Adds initial support for the UXN virtual machine architecture.
    • Adds initial support for the UF2 file format in the IO layer.
    • Adds initial support for native debugger on Linux/s390x.
    • Adds initial support for STM8 pseudo-decompilation.
    • Adds initial support for MIPSMIPSA RISC processor architecture originally developed at Stanford and commercialized by MIPS Technologies, widely used in embedded and network devices; cyber tools target it to analyze or exploit routers, cameras, and similar hardware. jump tables via anal.jmp.tbl.

    +41 more show less

    • Adds initial support for Ed25519 signature verification in the crypto layer.
    • Adds anal.flagends option to stop function analysis when flags are encountered.
    • Adds anal.emu option to run aaef/aef emulation passes inside aaa/af.
    • Adds anal.fixed.* settings (including anal.fixed.arch and anal.fixed.bits) to lock architecture and bits during analysis.
    • Adds iclc command to list classes from binary info.
    • Exposes ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. hash algorithm via rahash2 -a elf.
    • Adds ig command to guess binary size.
    • Supports resizing the BSS section with rabin2 -O.
    • Implements prj.history to save and load per-project command history.
    • Adds fD command to filter and mangle flag names.
    • Adds !! for session history and !. for history save in the shell.
    • Adds -D as an alias for iD in the shell.
    • Adds JSON support to the iD command.
    • Adds rax2 -q for quiet output when printing hexdumps.
    • Adds r2.cmd2[j] APIs for r2js scripting.
    • Adds initial support for base64-encoded r2js scripts.
    • Adds R2_PAPI_SCRIPT environment variable for custom r2papi testing.
    • Adds r_base32 encode/decode APIs.
    • Adds RBin.attr(str2bits) for binary attribute parsing.
    • Implements RBinPlugin commands in the new ABI via the i: interface.
    • Adds dir.sourcebase newabi setting and faster bin.dbginfo on macOS.
    • Adds magic file detection for Flutter binaries.
    • Supports glob matching in /ad (search for assembly patterns).
    • Adds Csp meta type for Pascal strings.
    • Adds phl/phL as aliases for Lh.
    • Adds ?iu command for a one-liner custom UI.
    • Adds Bit Registers panel in visual mode.
    • Implements menu separators, project and analysis options in panels.
    • Adds sfence.vma instruction support for RISC-V disassembly.
    • Adds SMI (small integer) anal hints support in disasm via ahi.
    • Adds double type support in RTable.
    • Supports multiline RCons.message() output.
    • Adds curl POST support in the socket layer.
    • Adds r2r -H flag and honors R2R_JOBS environment variable as a replacement for -j.
    • Adds initial implementation of r2pipe2.
    • Adds il2cpp metadata importer as an r2js script.
    • Adds Visual Studio MAP file parser script.
    • Creates sections for dyldcache stub islands.
    • Adds iP and :iF commands to dsc for authenticated pointer and cache info.
    • Makes anal.vinfun false by default, reducing noise in variable analysis.
    • Renames ib as ooi.

    46 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The ib command is renamed to ooi; scripts using ib will break.
    • !iSm is no longer a valid command (was previously accepted but did nothing).
    • !ihh and iHH aliases are removed.
    • !anal.vinfun default changed to false; setups relying on the previous default true behaviour will see different variable analysis output.
    • !radiff2 -A now runs aa instead of aaa; workflows relying on full aaa analysis via -A will need to adjust.
23. 5.9.2 May 20, 2024 · release notes

    Radare2 5.9.2 adds wcd for patch diffing, wcd project save/load, and r2js CTAGS support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.9.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.9.2

    • Add wcd command for patch diffing instruction and sort wc? lines
    • Add -P flag to r2 project save and error code on project load
    • Initial import of the tags.r2.js script (CTAGS support) via r2js

    3 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The rax2 flags -L, -I, -B, -l, -X, -i, and =<base> have been renamed to -X, -i, -z, -Z, -H, -C, and -b <base> respectively.
24. 5.9.0 Mar 31, 2024 · release notes

    Radare2 5.9.0 adds anfl, aoba, aovv, afba, aax, aaex, abj, abe and backtrace (abt) commands for new analysis workflows.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.9.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.9.0

    └──▷ TRY IT
    Restore the old autoname functionality using the new command and config
    copy

    $ anfl
    anal.slow = true

    List basic blocks in inverse call dependency order to understand dependencies
    copy

    $ afba

    Create functions automatically on every CALL cross-reference
    copy

    $ aax

    • Adds anfl command to restore the old autoname functionality via the anal.slow config var
    • Adds aax command to create a function on each CALL xref
    • Adds aaex command to analyze external references without analyzing any function
    • Adds abe command to manipulate RAnalBlock.esil
    • Adds backtrace API and commands via abt prefix for initial support of backtracing

    5 details in Everything

25. 5.8.8 Jun 8, 2023 · release notes

    Radare2 5.8.8 adds ahb-* analysis, asm.bytes.asbits, r2pm -t for timeless packages and CSS string search

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.8.8 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.8.8

    └──▷ USE IT
    Manage packages that are not tied to a specific version release.
    shell copy

    r2pm -t install <package_name>

    Scan the current section for specific strings without providing a search keyword initially.
    shell copy

    Css <search_term>

    • Adds ahb-* commands for Hopper-style analysis (new capabilities)
    • Adds asm.bytes.asbits=true config key to display instruction bits in binary format
    • Adds r2pm -t flag to manage timeless packages
    • Implements Css (section string scan) and Csz commands, allowing keyword-less searches

    4 details in Everything

26. 5.8.6 May 5, 2023 · release notes

    Radare2 5.8.6 adds dtj (debug traces in JSON), cgfa (graph diff), wao nop/RISC-V support, zip0:// handler, and piE/aeom commands.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.8.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.8.6

    • Adds dtj command to list debug traces in JSON format
    • Adds cgfa command for initial implementation of graph function analysis (GFA) diffing
    • Adds wao nop subcommand to write NOP sleds in RISC-V instructions
    • Adds zip0:// URI handler for io plugin access
    • Adds piE command for byte-oriented print output, like pie but for bytes instead of ops

    +2 more show less

    • Adds aeom command to show memory refs via emulation
    • Implements support for LE/BE 24 bit registers in the register subsystem

    7 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The arch.arm plugin is renamed to arch.arm.nz
27. 5.8.4 Mar 14, 2023 · release notes

    Radare2 5.8.4 adds aarr, Pz[ie], wget, io-write-cache, and NIM scripting via QJS

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.8.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.8.4

    └──▷ TRY IT
    Re-run analysis for all function calls to update cross-references after manual changes.
    copy

    $ aarr

    Package a current radare2 project configuration and history into a zip file for sharing or backup.
    copy

    $ Pzi project.zip

    Download a remote binary or payload directly inside the radare2 session using the new wget command.
    copy

    $ wget http://example.com/payload.bin

    • Adds the aarr command to re-analyze all function references in one go
    • Introduces io-write-cache command for initial implementation of write caching
    • Adds Pz[ie] commands to import or export projects in zip format
    • Adds the wget command to download files directly from http:// within radare2
    • Adds support for NIM scripting on top of the QJS engine via the r_arch plugin interface

    5 details in Everything

28. 5.8.2 Jan 23, 2023 · release notes

    Radare2 5.8.2 adds Plan 9 support, rasm2 .extern directive, and pvp/wvp pointer commands.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.8.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.8.2

    └──▷ TRY IT
    Print the current selected process ID during a debug session.
    copy

    $ dpt.

    Run a QuickJS script directly from the r2 CLI without entering interactive mode.
    copy

    $ r2 -je example.js /bin/ls

    Disassemble code using the new .extern directive in rasm2.
    copy

    $ echo '.extern my_func' | rasm2 -e

    Print the pointer value stored at the current address using pvp.
    copy

    $ pvp

    • Adds dpt. command to print the current selected process in debug mode
    • Adds -j CLI alias for js: to run QuickJS scripts (e.g., r2 -je <script>) and r2.cmd0 / r2.call0 via QJS plugins
    • Implements pvp and wvp commands to print and write pointers respectively
    • Adds initial experimental support for portable QJS packages in r2pm (auto-installs system build deps if possible)
    • Adds Plan 9 calling conventions to the analyzer (r_anal) and DWARF5 line header parsing for binaries

    5 details in Everything

29. 5.8.0 Dec 22, 2022 · release notes

    Radare2 5.8.0 adds aflx/aflxv commands for variable analysis, obm/ob-- for binary object merging, and major arch plugin refactor

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.8.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.8.0

    • Adds aflxv and aflx? commands to list function variables with extra information like noreturn status and stack-relative offsets.
    • Adds the obm command to merge binaries using RBinFile.merge() API, and ob-- to close the last bin object.
    • Introduces anal.noret, anal.vars.newstack, and arch.endian config variables to control analysis behavior for noreturn functions, stack-relative variables, and byte order.
    • Merges RParse into RAsm and consolidates asm/anal plugins into the new arch library structure, adding i4004 as an initial arch-plugin example.

    4 details in Everything

30. 5.7.8 Sep 13, 2022 · release notes

    Radare2 5.7.8 adds aflx for caller re-analysis, pxu unsigned hex dump, drp* register arena flags, and reg:// I/O plugin

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.7.8 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.7.8

    └──▷ TRY IT
    Re-analyze only the callers of a specific function to find updated call sites
    copy

    $ aflx @ 0x1234

    Dump memory as unsigned hex bytes using the new pxu format
    copy

    $ pxu 0x1234 0x10

    Compare two binaries in JSON format using radiff2 with a specified base address
    copy

    $ radiff2 -B 0x1000 -Cj file1.bin file2.bin

    • Adds aflx and aflx* commands to re-analyze function callers
    • Implements drp* and arp* commands to flag the register arena
    • Adds pxu{1,2,4,8} like pxd but unsigned
    • Initial implementation of the reg:// io plugin
    • Adds wcu command to undo cached writes

    +4 more show less

    • Adds ics command to list address of class methods
    • Emits JSON when radiff2 is run with -Cj
    • Adds initial fs.zip plugin for listing zip files
    • Adds SM4 block cipher in crypto module

    9 details in Everything

31. 5.7.6 Aug 1, 2022 · release notes

    Radare2 5.7.6 adds a Python pickle machine (pypm) disassembler, fs.cwd configuration key, and an Assembler panel entry.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.7.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.7.6

    └──▷ TRY IT
    Disassemble a Python pickle stream to reverse engineer deserializationdeserializationTurning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. logic.
    copy

    $ pdmp

    Set the current working directory for ms mount operations in the config file.
    ini copy

    ["fs.cwd = /tmp/workdir"]

    Access the assembler panel through the visual menus.
    📍In the panels UI, press T to open Tools and select Assembler.
    • Adds python pickle machine (pypm) disassembler to the core analysis pipeline
    • Adds fs.cwd config key to define the default path in ms mount commands
    • Adds Assembler entry in the Tools/ menu for the visual panels UI

    3 details in Everything

32. 5.7.4 Jul 6, 2022 · release notes

    Radare2 5.7.4 adds omu command for unique map creation, RABIN2_VERBOSE env var, and SPARC big endian prelude search.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.7.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.7.4

    └──▷ USE IT
    Enable verbose bin output for rabin2 without modifying config files by exporting the variable.
    shell copy

    export RABIN2_VERBOSE=1 && rabin2 -I /path/to/binary

    • Adds omu subcommand in the io namespace to create a unique map
    • Adds RABIN2_VERBOSE environment variable to set bin.verbose=true in rabin2
    • Adds big endian support for arm prelude search

    3 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !rabin2 -qqqqqq no longer swaps between simple and simplest modes (it now consistently uses the simplest mode)
33. 5.7.2 Jun 22, 2022 · release notes

    Radare2 5.7.2 adds stdin:// IO handler and icj class filtering

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.7.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.7.2

    └──▷ TRY IT
    Filter icj graph output to specific instruction classes using the new str argument.
    copy

    $ icj str "branch"

    • stdin:// URI added to io.malloc plugin for reading from standard input

    1 detail in Everything

34. 5.7.0 May 31, 2022 · release notes

    Adds my command for filesystem mounts, ec bgprompt for colored prompts, JSON listing commands (LDj, iz*, etc.), and project save/restore

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.7.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.7.0

    └──▷ TRY IT
    List all installed decompiler plugins in JSON format for programmatic consumption.
    copy

    $ LDj

    Use a colorful prompt in the interactive console for better visibility.
    copy

    $ ec bgprompt

    Configure the tool to restrict searches to a specific flag (e.g., bins) instead of the entire memory space.
    copy

    $ e search.in=flag

    Execute the debug plugin's callback command directly within the current session.
    copy

    $ d:

    • Implements the my subcommand to manage filesystem mounts via the FS layer.
    • Adds d: command to execute the debug plugin's command callback directly.
    • Adds ec bgprompt for colorful shell and visual prompts in the console.
    • Enables JSON output for installed decompilers with the new LDj command.
    • Introduces iz* and izz* commands to list embedded strings (initial implementation).

    +8 more show less

    • Adds JSON listing for installed language plugins via Llj and #!?j.
    • Adds JSON listing for loaded filesystem plugins via Lmj and mLj.
    • Adds gLj and Lgj to list egg engine plugins in JSON format.
    • Implements pdrj with new JSON output grouping instructions by basic blocks.
    • Enables saving and restoring register values within projects (project scripts).
    • Adds P* and P! aliases to dump script and run shell in the project directory.
    • Allows searching within specific flags using the search.in=flag configuration variable.
    • Adds JSON output for version information via the r2 -V flag.

    13 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Deprecates anal.cpu; users must use asm.cpu instead.
    • !Deprecates ESIL's $r and S2D keywords.
35. 5.6.8 Apr 18, 2022 · release notes

    New psa string printer, pp/pfP/pfW formats, relative pointer resolution in pxr, new aabv, curl, cmp, @c: operator, sandbox checks, and Visual Studio 2022 support

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.6.8 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.6.8

    • Adds psa command to print any kind of string
    • Adds pfW format (signed short) for memory formatting in pf
    • Supports relative pointer resolution in pxr
    • Implements pfP for relative pointer format memory formatting
    • Adds cmp command to compare two files (aliases)

    +7 more show less

    • Adds curl command for network requests within the shell
    • Supports @c: temporal seek operator in commands
    • Adds sandbox checks for debugger io plugins
    • Enables hardware single-step (hwstep) on Apple Silicon
    • Adds Visual Studio 2022 support for building
    • Allows multiple -a flags for hash algorithm selection in rahash2
    • Adds -J flag to rahash2 for simplified JSON output with name=hash

    12 details in Everything

36. 5.6.6 Mar 22, 2022 · release notes

    Radare2 5.6.6 adds afiq, dd+, ddf, aaepa, aaep, aeb APIs, ESIL for x86 SSESSEServer-Sent Events, a browser API and HTTP-based protocol where a server pushes a stream of text events to a client over a single long-lived connection, giving tools a lightweight alternative to WebSockets for one-way real-time updates. and ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead. Stlxr

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.6.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.6.6

    • Adds afiq command for quiet function info output
    • Adds dd+ subcommand to open child process files in read-write mode
    • Adds ddf command for debugging file operations
    • Adds aaepa command to set all unknown imports as return 0
    • Extends aep command and adds aaep support for pin-specific commands

    +4 more show less

    • Implements ESIL for x86 SSE float instructions
    • Implements ESIL for the ARM64 Stlxr instructions
    • Adds aeb API-based implementation (previously command-only)
    • Adds scr.notch config to blank N lines on top of the screen

    9 details in Everything

37. 5.6.4 Mar 1, 2022 · release notes

    Adds agfm command for Mermaid CFGs, izz on maddr'd binaries, and aot command

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.6.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.6.4

    • Add agfm command to print cfg graphs using mermaid syntax
    • Find strings on maddr'd binaries with izz
    • Add aot command to show instruction types

    3 details in Everything

38. 5.6.2 Feb 15, 2022 · release notes

    Radare2 5.6.2 adds LZ4 compression support, XALZ binary parsing, w+ write command, and r_inflate_lz4 API

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.6.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.6.2

    └──▷ TRY IT
    Decompress the currently selected memory block using LZ4 via CLI.
    copy

    $ prgl

    Use the new LZ4 inflation API in C code to compress/decompress data.
    c copy

    r_inflate_lz4()

    • Adds r_inflate_lz4 API to reuse LZ4 across all libs
    • Adds lz4 deflating support at API and commandline levels
    • Adds initial support for XALZ binaries from Xamarin
    • Adds w+ command to write a string and seek at the end of the written chunk
    • Adds prgl command to decompress current block using lz4

    5 details in Everything

39. 5.6.0 Feb 2, 2022 · release notes

    Adds aafs command for faster analysis, new loongarch plugin, and experimental project sandboxingsandboxingRunning code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. via prj.sandbox.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.6.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.6.0

    • Adds aafs subcommand to the aa series for orders of magnitude faster binary analysis
    • Initial release of the loongarch architecture support plugin under anal.loongarch and asm.loongarch
    • Add prj.sandbox config key in .radare2rc to enable experimental sandboxed project loading
    • Adds pFB command for Binary PLIST printing and pcc command to print blocks as C char*string

    4 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The wasm plugin has been moved from asm/wasm to the anal subsystem (API break for users referencing it by the old path)
40. 5.5.4 Dec 15, 2021 · release notes

    Adds JSON output to zb commands for machine-readable search results

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.5.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.5.4

    └──▷ TRY IT
    Parse zb search results programmatically in a script using JSON.
    copy

    $ r2 -A <file> 'zb json'

    • Add JSON output to zb commands

    1 detail in Everything

41. 5.5.2 Dec 6, 2021 · release notes

    Radare2 5.5.2 adds Plan 9 symbol parsing, radiff2 symbol diffing, Hexagon VLIW support, and Go/V r2pipe.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.5.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.5.2

    • Adds Plan 9 symbol parsing to the binary parser
    • Implements symbol name list diffing in radiff2
    • Adds initial support for VLIW on hexagon architecture
    • Updates r2pipe to support Go and V
    • Enables mingw32/mingw64 builds as a first-class platform

    5 details in Everything

42. 5.5.0 Nov 14, 2021 · release notes

    Radare2 5.5.0 adds io banks for faster IO, avg/global vars command, iOS15 dyld4 support, seven-segment ?ea, and r2s slides

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.5.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.5.0

    • Use io.banks by default (replacing skyline) for 2-10x faster IO performance
    • New avg command to manage global variables via the RAnal.global API
    • Add support for iOS15 dyld4 Atlas-style shared library cache formats
    • New ?ea command with seven-segment ASCII art alphabet for text titles
    • New r2s (visual slides) feature for interactive content within r2

    +3 more show less

    • New axfm and axtm commands for improved xrefs visualization
    • New dir subcommand as an alias for ls and @@R to iterate over relocs
    • New pve command to print values on any endianness

    8 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The [] and []= esil operations have been removed; size is now mandatory for these operations
    • !IO banks are now used by default, removing io.sky.* search scopes and replacing the skyline backend
43. 5.4.2 Sep 20, 2021 · release notes

    Radare2 5.4.2 adds isotp:// I/O, REXX scripting, next signature types and aeol command

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.4.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.4.2

    └──▷ TRY IT
    Connect to a vehicle CAN bus via isotp.
    copy

    $ r2 isotp://

    Generate signatures for static library archive files using rasign2.
    copy

    $ rasign2 -c lib.a

    Execute an esil expression directly without assembly context.
    copy

    $ aoeq 1+1

    • Add isotp:// io plugin to let r2 talk to your car.
    • Add REXX scripting support
    • Implemented next signature types to detect functions based in context
    • Add aoeq command with just the esil expression
    • rasign2 is now able to generate signatures for archive files (.a)

    +2 more show less

    • Load signatures from sdb file
    • Add s. and s.? commands to reload current block (same as s $$)

    7 details in Everything

44. 5.4.0 Aug 19, 2021 · release notes

    New crypto/search commands, wan nop-patching, vector35 arm64 support, and rvc version control integration in Radare2 5.4.0

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.4.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.4.0

    └──▷ TRY IT
    Find RSARSAThe oldest widely used public-key algorithm, for both encryption and signatures, with security resting on factoring large numbers. A large quantum computer would break it. private keys in memory for forensics or reverse engineering
    copy

    $ /cg

    Pivot to nearby function prelude bytes to locate entry points
    copy

    $ /pp

    Nop-patch a partial instruction at the current address during binary patching
    copy

    $ wan

    • Add /cg, /ck, /ru subcommands to the search surface for finding PGP/RSA keys, crypto constants, and UDS CAN tables
    • Add wan command to nop-partial instructions during binary patching
    • Add mwf command in the fs/io layer to write local files into remote targets
    • Add spp, snp, /bp, /pp subcommands for finding next/previous prelude code sequences
    • Add /ab command to find backward jumps with ^C handling

    +4 more show less

    • Add aaff command and extend afj to handle all jump table parameter options
    • Add afs* command to export function signature info in r2 commands format
    • Add wv1, wv2, wv4, wv8 support for space-separated numbers to write values
    • Add @@== foreach word iterator operator in the shell

    9 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Completely eliminate the deprecated backslash command; use ':' or '=!' instead
45. 5.3.1 Jun 10, 2021 · release notes

    Adds http.basepath for proxying, user-defined REgg plugins, and ARM16/esil fixes in 5.3.1

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.3.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.3.1

    └──▷ USE IT
    Run the r2 http server behind a reverse proxy in a sub-path like /r2/
    shell copy

    r2 -e http.basepath=/r2/ -H

    • Add http.basepath to support sub directory handling for proxying purposes
    • Support user defined REgg plugins

    2 details in Everything

46. 5.3.0 May 31, 2021 · release notes

    Radare2 5.3.0 adds socket:// IO plugin for protocol debugging, Go scripting support, aeis command and multiple new r2 commands.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.3.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.3.0

    • Adds socket:// IO plugin for tcp network protocol debugging that records flags on reads and forwards writes to the endpoint
    • Introduces aeis command to initialize stack for given argc, argv, envp when using ESIL
    • Adds Go scripting support via rlang2
    • Adds new commands: afxm, wcf, aev, and ===stderr
    • Switches Capstone 5 as the default disassembler and analysis library for most architectures

    +3 more show less

    • Adds support for extracting EBCDIC-37 strings in rabin2 honoring cfg.charset and loading MVS OFF S/390 module objects
    • Adds initial support for WAD (DOOM map files) parsing in RBin
    • Adds byte signature diff capability with the zd command

    8 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The newshell parser is removed; backslash and single quote aliases for =! are deprecated in favor of :
    • !The tcp IO plugin is renamed to tcp-slurp://
    • !ESIL REPEAT keyword is deprecated/eliminated
47. 5.2.1 Apr 21, 2021 · release notes

    Radare2 5.2.1 adds bluy theme, ESIL MMX support, faster Linux debugger and Rafind2 grep-like output

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.2.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.2.1

    • Adds bluy color theme for CLI highlighting
    • Extends ESIL support with additional MMX instructions
    • Rafind2 outputs grep-like text by default to aid scripting integration

    3 details in Everything

48. 5.2.0 Apr 11, 2021 · release notes

    radare2 5.2.0 adds new CLI commands (aaw, ageh, omd), ESIL plugin APIs, and cyclic memory layout support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.2.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.2.0

    • aaw command to flag all words pointing to known flags
    • ageh command with configurable node link highlighting in graphs
    • omd command as a simplified version of om for output management
    • slurp:// URI handler plugin for io
    • Add #!*? command to show rlang plugin examples

    5 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The RAnnotationCode struct is renamed to RCodeMeta
    • !The r_io_map_get_for_fd API is renamed to r_io_map_get_by_fd
    • !The r_io_map_resolve API is renamed to r_io_map_get
    • !The r_io_map_get API is renamed to r_io_map_get_at
49. 5.1.1 Feb 11, 2021 · release notes

    Adds /cu UDS search command, =r reverse shell, CSS colors for graph nodes, and 2bpp bitmap search in visual mode.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.1.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.1.1

    └──▷ TRY IT
    Initiate a reverse shell connection to a listener at 192.168.1.100 port 4444.
    copy

    $ =r 192.168.1.100:4444

    Color a graph node using CSS syntax for better visual distinction during analysis.
    copy

    $ afbc #00ff00

    • Adds the /cu, /cq, /cj, and /c* commands to search for Unified Diagnostic Services (UDS) tables, plus the r_search_find_uds API
    • The =r command adds a reverse shell capability by connecting to a specified host:port
    • Extends the afbc graph node command to accept colors by name or CSS syntax
    • Adds 2bpp bitmap search support within the visual mode for GameBoy ROMs
    • Adds pokered charset encoding via the w command and extends decoding in ps

    5 details in Everything

50. 5.1.0 Jan 25, 2021 · release notes

    Radare2 5.1.0 adds SQL export for RTable, ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead. floating-point emulation, and streaming file support

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.1.0

    └──▷ USE IT
    Export all found functions to an SQL file for analysis in SQLite.
    shell copy

    $ r2 -AA /bin/ls
    > afl,:sql > functions.sql

    Enable verbose DEX annotation parsing to view class/method metadata for Android binaries.
    shell copy

    $ r2 -e bin.verbose=true /path/to/app.apk
    > ii~method

    • Adds :sql command modifier to RTable to export any r2 data as SQL statements.
    • Adds floating point arithmetic operations and FPU instruction support in ESIL for ARM64.
    • Implements DEX annotation metadata parsing in the bin plugin, accessible via bin.verbose=true.
    • Enables native Linux/RISC-V support and remote debugging via GDB.
    • Integrates mg-based streaming to handle large files in fs and r2frida.

    5 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The default diffing algorithm in radiff2 has changed from Levenshtein to a faster variant (originally buggy code renamed).
    • !Git support is enabled by default, with backward compatibility transitional code removed.
51. 5.0.0 Dec 21, 2020 · release notes

    Radare2 5.0.0 adds the Comma API, opn/opr/opp file rotation commands, and asm.hint.call.indirect support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 5.0.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 5.0.0

    • Adds the Comma API for programmatic interaction with r2's core subsystems
    • Adds opn, opr, and opp CLI subcommands to rotate between opened files in a session
    • Adds asm.hint.call.indirect evar to make indirect calls follow the target address
    • Adds ?et command to change terminal title from within r2
    • Adds basic block listing commands (abl*) for enumerating and inspecting basic blocks

    +1 more show less

    • Adds tcc-* commands to unload all calling conventions dynamically

    6 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The asm.filter evar is renamed to asm.sub.names
    • !The asm.var.sub evar is renamed to asm.sub.var
    • !The afc= command is deprecated and replaced by the e anal.cc evar
52. 4.5.1 Sep 3, 2020 · release notes

    Radare2 4.5.1 adds Function Name, Constants, Globals and Local Variables to RAnnotatedCode output and backtrace support for Haiku.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.5.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.5.1

    • Adds Function Name, Constants, Globals and Local Variables to the RAnnotatedCode feature in core
    • Adds backtrace support for the Haiku OS in the port subsystem

    2 details in Everything

53. advisory CVE-2020-15121 Jul 20, 2020 · issue 128
    • CVE-2020-15121: Command injectionCommand injectionAn attack that makes an application execute operating-system commands supplied through untrusted input. It often happens when input is passed unsafely to a shell. during opening PE file with malformed debug symbol information (PDBPDBA debug symbol file format used by Microsoft's toolchain that maps compiled binaries back to source code, function names, and variable types, letting cyber tools resolve symbols during reverse engineering or memory analysis.) - idpd command (CVSSCVSSCommon Vulnerability Scoring System, a method for describing a vulnerability's characteristics and severity. Its score is not the probability that attackers will exploit it. 9.6, affects <4.5.0)⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
54. 4.5.0 Jul 18, 2020 · release notes

    radare2 4.5.0 adds axv/afvx for visualizing var R/W accesses and a base type API

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.5.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.5.0

    • Add initial API for base type kinds (enum, struct, union)
    • Add axv, afvx, and afv= commands to visualize variable read/write accesses
    • Add afvxj command to print JSON output of afvx
    • Add dmia command to list all info of a target lib
    • Add zb command to find n closest matching graph zignature

    +21 more show less

    • Add API to print decompiled code
    • Add support for binr/blob and fix android build in meson
    • Add --without-dylink configure flag to disable libdl features
    • Introduce --without-r2r configure option to disable compilation of r2r
    • Add VT sequences input support for Windows
    • Add new fd:// (handle:// on windows) plugin
    • Support self:// plugin for Solaris and Haiku OS
    • Implement RLang.spp for templated scripting
    • Add Android boot image signature
    • Add support for BA2 ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code.
    • Add support for relocation entries for AARCH64 and PPC
    • Add support for glibc heap tcache pre/post glibc version 2.30
    • Add support for multiple PDBPDBA debug symbol file format used by Microsoft's toolchain that maps compiled binaries back to source code, function names, and variable types, letting cyber tools resolve symbols during reverse engineering or memory analysis. symbol servers
    • Add function for reading PDB from buffer
    • Implement rafind2 -F to find the contents of the file
    • Add dumping of FLIRT signatures to rasign2
    • Initial support for git tags in r2pm
    • Add initial refactoring to generate commands help automatically and support argv-style command handlers (e cfg.newshell=true)
    • Add anal.vars.stackname config variable to name variables based on their offset on the stack
    • Add asm.bytes.right config variable to display bytes at the right of the disassembly
    • Add bin.str.enc=ascii as a new option

    26 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The config variable asm.jmpsub is renamed to asm.sub.jmp.
    • !The config variable asm.var.submin is renamed to asm.sub.varmin.
    • !The config variable asm.tailsub is renamed to asm.sub.tail.
    • !The config variable asm.section.sub is renamed to asm.sub.section.
    • !The config variable asm.var.subonly is renamed to asm.sub.varonly.
    • !The config variable asm.regsub is renamed to asm.sub.reg.
    • !The config variable asm.relsub is renamed to asm.sub.rel.
    • !The config variable anal.in=raw is renamed to anal.in=range.
    • !The config variable asm.bytespace is renamed to asm.bytes.space.
    • !The config variable scr.ansicon is renamed to scr.vtmode (only on Windows build).
55. 4.4.0 Apr 14, 2020 · release notes

    radare2 4.4.0 adds block emulation commands (ab, aeb), retrolince analysis, and JSON signature introspection

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.4.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.4.0

    └──▷ TRY IT
    Trace the shortest control flow path from entry to exit
    copy

    $ abt @entry @exit

    Emulate a specific basic block to observe side effects without full emulation overhead
    copy

    $ aeb @<address>

    Get JSON representation of the current function's signature for automated analysis
    copy

    $ afsj @<function_addr>

    • Adds abt command to compute shortest path between basic blocks
    • Adds aeb subcommand to emulate a single basic block
    • Adds aesB command to emulate execution until reaching a specified basic block
    • Adds afs and afsj commands for function signature footprint and JSON introspection
    • Adds acvf command to devirtualize vtable method calls

    +1 more show less

    • Updates install.sh default prefix to /usr/local and purges old /usr installs on upgrade

    6 details in Everything

56. 4.3.0 Mar 4, 2020 · release notes

    Radare2 4.3.0 adds rb rebase command, dbH hw breakpoints, aba alias, Windows Crash Dump and Authentihash PE support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.3.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.3.0

    └──▷ TRY IT
    Rebase all mapped segments to a new base address to align with a different load configuration.
    copy

    $ rb <new_base_address>

    Set a hardware breakpoint on the instruction at RIP for precise execution tracing.
    copy

    $ dbH @ rip

    List all active syntax highlighting rules in JSON format for scripting or debugging themes.
    copy

    $ ecHj

    • Adds dbH subcommand to set hardware breakpoints during debugging sessions
    • Adds aba as a CLI alias for the aeab (analysis by address) command
    • Adds ecHj command to list syntax highlighting rules in JSON format
    • Adds the graph.aeab setting to display ESIL statistics instead of disassembly in graphs

    4 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The function flag previously associated with afn has been renamed (ref #16078)
    • !Deprecated fields prev, jumpbb and failbb have been removed from the RAnalBlock struct
57. 4.2.0 Jan 21, 2020 · release notes

    Adds ccdd for decompiler diff, /cr elliptic key search, reverse debug support, and semver flags.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.2.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.2.0

    └──▷ TRY IT
    Diff the decompiled C code of two functions to identify logic changes.
    copy

    $ ccdd <func_addr1> <func_addr2>

    Search a binary for elliptic curve private keys using the /cr search command.
    copy

    $ /cr

    • Adds ccdd command to diff decompiler output of two functions
    • Adds /cr subcommand in the search system to find elliptic curve private keys
    • Adds reverse step (dsr) and continue (dsc) support to the gdbr debug backend
    • Adds ?V0, ?V1, ?V2 flags for semver-aware conditional execution
    • Adds register listing in table format via new ar and dr commands

    +1 more show less

    • Adds f command to list flags in table format

    6 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Removed Custom Analysis for Java (#15817)
58. 4.1.0 Dec 19, 2019 · release notes

    Radare2 4.1.0 adds or1k disasm support, AES key search, task scheduling API, and zignspace autogeneration.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.1.0

    • Adds auto zignspace generation for the zg command
    • Add support for or1k (OpenRISC) disasm+analysis
    • Introduce tree sitter integration

    3 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Rename asan to sanitize in build configuration
59. 4.0.0 Oct 28, 2019 · release notes

    Radare2 4.0.0 adds aarch64 $x symbol, YARA hex-pair printing pcy, radiff2 -X hexII diffing, and dptj debug threading

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 4.0.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 4.0.0

    └──▷ TRY IT
    Dump binary hexpairs in YARA-compatible format for rapid pattern matching or external analysis.
    copy

    $ r2 -A target_binary.bin
    [0x0]> pcy <offset> <length>

    Perform a hexII diff between two binary outputs using radiff2's new mode for side-by-side hexadecimal comparison.
    copy

    $ radiff2 -X file1.bin file2.bin

    • Adds new special symbol $x on AArch64AArch64The 64-bit execution state of the ARM architecture, defined by Arm Ltd., offering a wider register file and cleaner instruction set than 32-bit ARM; cyber tools target it to run natively on ARM-based servers, phones, and embedded devices. for binary inspection commands (i* etc.)
    • Adds pcy command to print hexpairs in YARA format for integration with pattern-based detection logic
    • Adds -X flag to radiff2 for hexII diffing output mode
    • Adds dptj and dptj <pid> commands to inspect thread state with JSON output
    • Adds support for setting XMM registers via debug commands on Linux targets

    +1 more show less

    • Adds current thread field to the output of dptj command

    6 details in Everything

60. 3.9.0 Sep 17, 2019 · release notes

    Radare2 3.9.0 adds anal.norevisit/nonull flags, ESIL types in zignatures, and shm:// I/O support

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.9.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.9.0

    • Adds anal.norevisit config key to skip re-analysis of visited blocks.
    • Adds anal.nonull config key to avoid analyzing functions starting with zeros.
    • Adds types field support for z-signatures to include type information in analysis data.
    • Supports shm:// prefix using shm_open for shared memory I/O.

    4 details in Everything

61. 3.8.0 Sep 3, 2019 · release notes

    Radare2 3.8.0 adds aflt for function analysis summaries, afisaf for instruction type tables, and RTable API with query/filter support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.8.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.8.0

    └──▷ TRY IT
    List functions sorted by size greater than 200 bytes, displaying name and basic block count.
    copy

    $ r2 -qq -c 'aac; aflt size/gt/200,addr/cols/name/nbbs,nbbs/sort/inc' /bin/ls

    Inspect instruction families and mnemonics for a specific function using the new table queries.
    copy

    $ r2 -qq -c 'afi; afisa' /bin/ls

    • Introduces aflt command to analyze and display function metadata (name, size, basic blocks, etc.) using the new RTable API
    • Adds afisa, afisf, and afiso commands to display instruction type, family, or mnemonic tables via RTable
    • Initial implementation of the RTable API supporting filter, sorting, and query capabilities for structured outputstructured outputForcing a model's response to match a given format or JSON schema, so software can parse it reliably instead of hoping the text is well formed.
    • Adds pv* commands to completely replace previous value dumping methods with column-based filtering via cols query
    • Supports deep JSON format for binary headers in the iHj command

    5 details in Everything

62. 3.7.0 Aug 1, 2019 · release notes

    Radare2 3.7.0 adds afj, icqj, pdsf, and mouse-driven panel interactions.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.7.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.7.0

    • Adds the afj subcommand to analyze jump tables from the shell
    • Adds wao command for Dalvik write operations
    • Introduces tlj and tllj commands for type listing
    • Adds pdsf panel widget for display in panels

    4 details in Everything

63. 3.6.0 Jun 24, 2019 · release notes

    radare2 3.6.0 adds agraph flag graph (fg), ESIL step commands, pV byte printer, and zignature comparison

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.6.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.6.0

    └──▷ TRY IT
    Visualize relationships between named flags using the new graphing command.
    copy

    $ fg <flag_prefix>

    • Adds the fg command to create a graph of flags
    • Adds $O variable pointing at the cursor position in scripts
    • Adds the cmd.esil.stepout configuration option for ESIL emulation control
    • Adds the pV command to print bytes instead of values (like pv but for bytes)
    • Adds Kotlin, Java and Swift support via pc sub-commands in the print plugin

    +4 more show less

    • Adds the zc command to manage zignatures with fuzzy comparison support
    • Adds /cc search alias for case-insensitive instruction searching
    • Adds search.in=bin.segment[.s[rwx]] config key to scope searches to binary segments
    • Adds reset command to reset terminal settings in the console

    9 details in Everything

64. 3.5.1 May 15, 2019 · release notes

    Radare2 3.5.1 adds RISC-V ESIL emulation, configurable popup prompts, and r2frida integration updates

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.5.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.5.1

    • Adds initial ESIL emulation support for the RISC-V architecture
    • Introduces the scr.prompt.popup configuration option to control popup behavior in all color themes
    • Updates r2frida to include Frida 12.5.3 with v8 enabled by default

    3 details in Everything

65. 3.5.0 May 13, 2019 · release notes

    Radare2 3.5.0 adds panels with tabs, dtdi trace diffs, vvs signature editing, yq/yj JSON commands, and ESIL CPUID.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.5.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.5.0

    └──▷ HOW TO FIND IT
    Organize multiple analysis contexts or views in a single window using tabs.
    📍r2 /bin/ls [v:~] # Type t to open new tab, switch with n/N
    • Adds t key support for panel tabs in visual mode, enabling tabbed navigation within the interactive interface
    • Introduces the dtdi command to perform diffs between debug traces
    • Adds the vvs command to edit function signatures directly from the visual interface
    • Implements yq, yj, y*, and y! commands for in-memory JSON querying and manipulation
    • Adds ESIL emulation support for the x86 CPUID instruction

    5 details in Everything

66. 3.4.0 Apr 1, 2019 · release notes

    Radare2 3.4.0 adds wai, dif, p-e, new asm directives and multiple command improvements.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.4.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.4.0

    • New wai command for writing assembly inline in the current instruction
    • New dif command to compare two files using unified diff format
    • New p-e command (entropy bar) for visualizing entropy in the hexdump
    • New .offset RAsm directive for setting the target offset
    • New dri command for manipulating inverse debug registers

    +3 more show less

    • New cmd.esil.step eval variable to control ESIL stepping
    • Support for QNX executable binaries (RBin plugin)
    • Addition of symbols.objects and symbols.sections flag spaces

    8 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !bin.strpurge is now accessed via bin.str.purge
    • !bin.strfilter is now accessed via bin.str.filter
67. 3.3.0 Feb 19, 2019 · release notes

    Radare2 3.3.0 adds aaF, aflm, pgm, /c[vV][j], /ai, ragg2 string append, and DYLDCACHE v3 support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.3.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.3.0

    └──▷ TRY IT
    Generate a Makefile target for every function to parallelize builds or analysis tasks.
    copy

    $ aflm

    Find all infinite loop instructions in the current binary context.
    copy

    $ /ai

    Use ragg2 to construct a payload with appended strings.
    copy

    $ ragg2 -a x86 -b \"hello\" -b \"world\"

    • Add aaF command for fast single-basic-block function boundaries
    • Add aflm command to list functions in make syntax
    • Add pgm command to print visual gadgets
    • Implement /c[vV][j] and /cej search commands to find code immediates
    • Implement /ai search command to locate infinite loop instructions

    +5 more show less

    • Implement /a1 search command to find instructions changing only one byte
    • Add ragg2 support for appending strings
    • Add DYLDCACHE v3 support for iOS analysis
    • Add r_file_copy() implementation using native API
    • Expose WASMWASMA binary instruction format for a stack-based virtual machine, maintained by the W3C, that lets code compiled from any language run at near-native speed inside a sandboxed environment across browsers and servers. exported symbols

    10 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !anal.noncode variable removed; use anal.in=io.maps.x instead
    • !Kill r_json API
68. 3.2.0 Jan 8, 2019 · release notes

    Radare2 3.2.0 adds emu.ssa, /s entropy search, new tc/tsc commands, and tabbed panels.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.2.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.2.0

    └──▷ HOW TO FIND IT
    Create and manage tabs in the Radare2 panels interface to organize multiple analysis views
    📍tT # creates a new tab t=main_analysis # names the current tab t[1] # switches to the first existing tab
    • Adds asm.hint.cdiv config variable to control hint behavior
    • Adds initial implementation of the emu.ssa subsystem for emulation analysis
    • Adds /s and /s* commands to search for sections based on entropy
    • Adds tc, tsc, and tuc commands for type casting and timestamp manipulation
    • Adds tabbed panel support via tT (new tab), t[1-9] (switch), t= (name), t- (close) keys in Visual mode

    +4 more show less

    • Adds hex.hdroff config variable to control header offset visibility
    • Adds scr.dumpcols config variable to support tabs in output
    • Adds scr.wideoff config variable to make offsets and register values depend on asm.bits
    • Adds hex.ascii config variable for hex dump formatting

    9 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !scr.pipecolor config key is renamed to scr.color.pipe
69. 3.1.1 Dec 3, 2018 · release notes

    New afip command for pure function detection, pfq format, and tu* types in r2 3.1.1

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.1.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.1.1

    • Adds afip command to detect and analyze pure functions
    • Implements pfq format command for printing specific data structures
    • Implements tu* without arguments in the types subsystem

    3 details in Everything

70. 3.1.0 Nov 26, 2018 · release notes

    Radare2 3.1.0 adds xref commands, WASMWASMA binary instruction format for a stack-based virtual machine, maintained by the W3C, that lets code compiled from any language run at near-native speed inside a sandboxed environment across browsers and servers. ESIL, type listing and visual panels enhancements

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.1.0

    • Adds axff command to retrieve xrefs from a function
    • Adds initial ESIL support for WebAssemblyWebAssemblyA binary instruction format that runs in browsers and server runtimes at near-native speed, letting developers compile C, Rust, or other languages into a portable, sandboxed module any compliant host can execute. (WASM)
    • Adds tec command to execute type expressions
    • Adds ttc command to dump types in C syntax
    • Adds tt* command to list all types at once

    +4 more show less

    • Adds LL command to lock the visual screen
    • Enables shift-arrow key support in st and rxvt-unicode terminals
    • Implements scr.scrollbar config variable for visual mode UI
    • Implements cmd.hexcursor feature for hex view cursor control

    9 details in Everything

71. 3.0.1 Oct 20, 2018 · release notes

    Radare2 3.0.1 adds Apple Watch arm64_32 mach0 support and r2pm multi-package install arguments.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.0.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.0.1

    └──▷ USE IT
    Install or check multiple r2pm packages in a single invocation.
    shell copy

    r2pm -i pkg1 pkg2

    • Adds arm64_32 macho cputype support for Apple Watch binaries in the bin subsystem
    • Allows multiple packages as arguments for r2pm -i, -c, and -ci commands

    2 details in Everything

72. 3.0.0 Oct 15, 2018 · release notes

    Radare2 3.0 adds aang for Go recovery, cmd.load hook, and improved ESIL/heap capabilities.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 3.0.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 3.0.0

    • Add aang to recover function names from stripped Go binaries.
    • Zignatures now support sha256 bbhash for signature matching.

    2 details in Everything

73. 2.8.0 Aug 7, 2018 · release notes

    Radare2 v2.8.0 adds aecc and Ct commands, esil.breakoninvalid option, and GDB watchpoints support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.8.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.8.0

    • esil.breakoninvalid config key added to break execution on invalid instructions during ESIL analysis.
    • Adds aecc command to continue execution until the next call instruction.
    • Adds Ct command to add type analysis comments based on inferred types.
    • Supports GDB watchpoints in the debugger interface.
    • Initial revival of .NET PE binaries support via the xtr.pemixed plugin.

    +1 more show less

    • Parses sprintf-like format strings to infer argument types during analysis.

    6 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Removed address argument from most ag* commands.
74. 2.7.0 Jul 9, 2018 · release notes

    radare2 2.7.0 adds background tasks, new analysis defaults, and several new commands

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.7.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.7.0

    └──▷ TRY IT
    Set a hint for the return value of a function
    copy

    $ ahr func_name

    Access register values by name using the new syntax
    copy

    $ $r{eax}

    Enable autodetection of strings as immediates via config
    copy

    $ set asm.imm.str true

    • Adds background task system to improve responsiveness in visual mode and r2pipe
    • Enables improved variable detection, type inference, and extended jump table detection by default via the afta command
    • Adds ahr command to set hints for function return values
    • Adds tpx command to accept a sequence of bytes
    • Adds global graph commands agA and agR

    +15 more show less

    • Adds dbi addr and dbi. commands
    • Adds omo, omq., and ompd commands for map operations
    • Adds $r{} syntax to access register values by name
    • Adds {flag} syntax to get flag size
    • Adds -ee flag to rabin2 -g
    • Adds &t command
    • Adds json output for dp* via dp* and debug plugin list via dL
    • Adds wordhl and linehl color theme options
    • Removes anal.split and anal.bb.split config keys
    • Removes unused cmd.graph config key
    • Adds anal.endsize config key
    • Adds asm.imm.str config key to autodetect strings as immediates
    • Adds asm.xrefs.fold config key to fold references
    • Adds asm.flags.real config key to show real flag names
    • Substitutes asm.lines with asm.lines.bb config key

    20 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The anal.split and anal.bb.split config keys are removed
    • !The unused cmd.graph config key is removed
    • !asm.lines is substituted with asm.lines.bb
75. 2.6.0 May 21, 2018 · release notes

    Radare2 2.6.0 adds iOS dyld cache parser, Zig language support, and new graph output formats.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.6.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.6.0

    └──▷ TRY IT
    Visualize data flow graphs and export them as SVG for documentation or sharing.
    copy

    $ aga; wT svg data_graph.svg

    • Adds iOS dyld cache parser to decode Apple binary caches
    • Adds Zig programming language support in the assembler
    • Implements pdRj command to dump disassembly as JSON
    • Enables aga (data graph) with multiple output formats like SVG and PDF
    • Adds import graph visualization via the ag command family

    +6 more show less

    • Implements aaf to analyze all functions using afr and hasnext
    • Adds wtff command to dump strings with file offset in names
    • Supports pf custom format parsing improvements with use-after-free fixes
    • Adds support for temp breakpoint functionality
    • Includes float and double types by default in the type system
    • Adds tss command to show struct sizes

    11 details in Everything

76. 2.5.0 Apr 9, 2018 · release notes

    Radare2 2.5.0 adds gprobe IO plugin, ROP gadget caching, /g path analysis, and new commands like dsuo, pdp, and tt. Breaking changes include ragg2-cc merge.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.5.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.5.0

    • Adds gprobe IO plugin for communication with computer displays via Genesis/STMicro/MegaChips chipsets
    • Stores ROP gadgets in sdb to make subsequent searches instant
    • Adds /g command to find all possible paths from A to B inside a function
    • Enables UTF-8 characters and color scheme support in visual panels
    • Adds dsuo command to step until a specific opcode type

    +5 more show less

    • Adds pdp command to print pointer chains (ROP chains)
    • Adds tt command to show typedefs
    • Adds rfxj output for gcc (via avraj) in afr/analysis commands
    • Merges ragg2-cc into the single ragg2 binary
    • Removes x86.udis from core, moving it to radare2-extra

    10 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !ragg2-cc subcommand is removed; use ragg2 instead
    • !x86.udis is no longer included in the core binary; install via r2pm -ci udis86
77. 2.4.0 Mar 5, 2018 · release notes

    Radare2 2.4.0 adds @@iS foreach operator, @B seek offset, AVR pseudo-code, and new visual browsers

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.4.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.4.0

    • Implements @@iS RBin.Section foreach operator to iterate over binary sections in one pass
    • Adds @B suffix operator to temporarily seek to the Nth basic block
    • Adds initial support for dbg.symstore for symbol storage in debugger sessions
    • Provides pseudo code for AVR instructions movw and st* to improve disassembly readability
    • Adds opcode masking for AVR zignatures to improve signature matching accuracy

    +4 more show less

    • Adds Visual browser for process threads in the UI layer
    • Adds VbC command to browse comments in the visual interface
    • Adds VbF command to browse functions in the visual interface
    • Implements axgj graph visualization command

    9 details in Everything

78. 2.3.0 Jan 29, 2018 · release notes

    Radare2 2.3.0 adds cV command, pdR disassembly, dir.prefix config, and bin.usextr alias

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.3.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.3.0

    └──▷ TRY IT
    Disassemble instructions at the current address without running a full analysis pass first.
    copy

    $ pdR

    Compare two memory regions using the new cV command syntax (note: exact operand syntax not fully detailed in notes, but command is available).
    copy

    $ cV <addr1> <addr2>

    Change the runtime prefix for file paths using the new configuration key.
    copy

    $ e dir.prefix=/new/path

    • Adds cV command to compare values in memory.
    • Adds pdR subcommand that performs disassembly without prior analysis by following non-conditional jumps.
    • Adds dir.prefix configuration key, allowing the prefix path to be changed at runtime instead of only at compile time.
    • Adds -X CLI flag as an alias for setting bin.usextr=false to disable extraneous binary loading.

    4 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Output of rabin2 and the i command is now more compact, which may break existing parsers that do not use the JSON format.
    • !r_str_chop/trim/clean/.. APIs have been unified, constituting an API break.
79. 2.2.0 Dec 24, 2017 · release notes

    Radare2 2.2.0 adds JSON disassembly pdJ, temporary address seeks @.., YARA .NET parser, and apia analysis tool

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.2.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.2.0

    • Add pdJ command to output formatted JSON disassembly
    • Implement io.cache.auto eval option to cache reads for slow IO backends
    • Initial import of apia, the API analysis tool for r2
    • Add anal.rnr eval option
    • Implement asm.emustack support in the assembly subsystem

    +3 more show less

    • Add fdw command
    • Implement afd command
    • Add /O command

    8 details in Everything

80. 2.1.0 Nov 27, 2017 · release notes

    radare2 2.1.0 adds new analysis commands, Windows GDB support, and Rabin NSO/ISO9660 parsing

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.1.0

    └──▷ USE IT
    View analysis data as JSON for piping to external tools or scripts.
    shell copy

    r2 -qc 'pj.' /bin/ls | jq .

    Check the frame rate of the interactive console while running complex analyses.
    shell copy

    r2 -qc 'scr.fps; aaaa' /bin/ls

    • Adds scr.fps command to display frame rate statistics in the console interface.
    • Introduces es command to list evaluation spaces and configuration keys.
    • Adds ff command to calculate the distance between flags.
    • Introduces afCl command to estimate the count of loops within a function.
    • Adds aflc command to count functions in the current analysis context.

    +15 more show less

    • Introduces /s command for searching syscalls in binary data.
    • Adds pj, pj., and pj.. commands to output analysis results in JSON format.
    • Introduces /M command to enhance file system autodetection via r_fs.
    • Adds rh command to display file size in human-readable format.
    • Adds ie and iee commands for interacting with ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. entry points and headers.
    • Adds V\ and Vb commands to interact with the visual graph mode.
    • Introduces /ca command for searching comments or annotations.
    • Adds /c/a command for performing analysis-based searches.
    • Adds anal.searchstringrefs renamed to anal.refstr for searching string references.
    • Adds support for parsing Nintendo Switch NSO static binaries in r_bin.
    • Adds support for Phar Lap TNT PL file format in r_bin.
    • Enables automatic detection and mounting of ISO9660 partitions via r_fs.
    • Enables GDB debugging backend for Windows targets.
    • Adds r2pm -i all command to install all available plugins or tools via the package manager.
    • Adds r2pm suicide command to self-remove r2 from the system and home directory.

    20 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The configuration key cfg.escbslash is renamed to str.escbslash.
    • !The environment variable PDB_SERVER is renamed to RABIN2_PDBSERVER.
81. 2.0.0 Oct 10, 2017 · release notes

    radare2 2.0.0 adds new IO plugins, debugger features, and config vars

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 2.0.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 2.0.0

    └──▷ USE IT
    Enable the new experimental command completion interface.
    shell copy

    r2 -e cfg.newtab=1

    • r2 -e cfg.newtab=1 enables experimental new command completion
    • Supports ar://, lib://, and winedbg:// IO plugins
    • Adds aesb command to step back with ESIL
    • Adds support for IDA FLIRT signatures v10 (IDA 6.8 and higher)
    • rabin2 -H now includes LC_CODE_SIGNATURE for mach0 binaries

    +16 more show less

    • rabin2 gains resources extraction capability
    • Adds support for DEX38 binary format
    • Initial optimization for DEX files
    • Detects Kotlin in Java classes
    • Add radiff2 -ss for Levenshtein edit distance
    • Support for architectures using 9bit bytes middle endian (like CLemenCy)
    • Adds support for IA-64 binary detection
    • Add HP-UX binary detection
    • Adds free to RLibStruct & RLibPlugin
    • Updates lang-python bindings to allow creation of RCore, RAsm and RAnal plugins
    • Expose r2 environment variables to internal r2pipe calls
    • asm.asciidot config var added
    • asm.addrbytes eval config var added
    • dbg.trace.inrange brought back in dtc command
    • Support for hw watchpoint in debugger
    • =!detach command to detach debuggee

    21 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Removes search.count in favor of search.maxhits in /A, /R, and everywhere else
    • !Removes file and io.maps.range search.in config options in favor of io.map
82. 1.6.0 Jul 11, 2017 · release notes

    Radare2 1.6.0 adds Ethereum Virtual Machine, PowerPC VLE, Hexagon CPUCPUThe main general-purpose processor in a computer. It runs application instructions and coordinates work with memory and other hardware., GDB/Server, session save/restore, and wide string support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.6.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.6.0

    └──▷ TRY IT
    Save a debugger session for later inspection
    copy

    $ dtst ~/session.r2s

    Load functions from a PDBPDBA debug symbol file format used by Microsoft's toolchain that maps compiled binaries back to source code, function names, and variable types, letting cyber tools resolve symbols during reverse engineering or memory analysis. file
    copy

    $ idp /path/to/pdb.pdb

    Debug an Android app via gdbserver protocol
    copy

    $ r2 gdb://host:port/pid

    • Adds dtst and dtsf commands to save and restore debugger sessions
    • Adds dh for dL, aea*, psW, axq, /ra, |T, s==, ecH, !-, sj, dsuir, dbta, and aab* commands
    • Adds GDB client/server functionality allowing r2 to act as a gdbserver or debug Android apps via gdb://host:port/pid
    • Adds wide32 (utf32) string support for rabin2 -z and asm.strenc encodings including latin1, utf8, and asciidot
    • Adds cmd.esil.ioer, cmd.esil.todo, aerR, and asm.minvalsub config variables

    +2 more show less

    • Adds idp command to load functions from PDB files and radiff2 -G for custom commands
    • Improves debugger backstep performance via checksumming and diffing changesets instead of full dumps

    7 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !aea command replaced with aea*
    • !dh command replaced with dL
    • !dsb command renewed for new session format
83. 1.5.0 May 30, 2017 · release notes

    Radare2 1.5.0 adds drlj, px* JSON commands, ESIL REPEAT keyword, and Meson build support

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.5.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.5.0

    • Added drlj subcommand for Linux debugger output in JSON format
    • Implemented prc command to print colorful bytes
    • Added pib command for basic block level disassembly
    • Added fss, fssj and fss* commands for flag searching with JSON support
    • Extended ic command with class name argument

    +8 more show less

    • Added iCj command to output signatures in JSON format
    • Added S.j command to print current section in JSON
    • Implemented pxj, p8j, pxwj, pxhj and pxqj commands for various hex dumps in JSON
    • Introduced ESIL REPEAT keyword for loop simulation
    • Added support for loading .py, .js and .lua scripts at startup time via #!python -e etc.
    • Added bin.relocs config variable to load relocs information at startup
    • Added asm.cmtoff config variable to control showing offset comment
    • Added asm.midcursor config variable for mid-line cursor behavior

    13 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Renamed Tp command to L command to be consistent with iL and oL
    • !Removed asm.spacy config variable, integrated logic into asm.bbline when no fcn is found
84. 1.4.0 Apr 18, 2017 · release notes

    Radare2 1.4.0 adds WASMWASMA binary instruction format for a stack-based virtual machine, maintained by the W3C, that lets code compiled from any language run at near-native speed inside a sandboxed environment across browsers and servers. support, new zignature commands, opex, and several CLI flags.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.4.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.4.0

    └──▷ TRY IT
    Generate zignatures for all functions in the current session
    copy

    $ zaF

    Scan a WebAssemblyWebAssemblyA binary instruction format that runs in browsers and server runtimes at near-native speed, letting developers compile C, Rust, or other languages into a portable, sandboxed module any compliant host can execute. binary using radare2
    copy

    $ r2 binary.wasm

    • Adds WebAssembly (WASM) Bin and Disassembler support to handle .wasm binaries
    • Adds zaF command to generate zignatures for all functions
    • Adds zoz command to load zignatures from gzipped sdb files
    • Adds zc command implementation
    • Adds p=z and restores the old p=p output format

    +17 more show less

    • Adds Pn+ command to add text directly from the command line to project notes
    • Adds s! command to show near flag names for history offsets
    • Adds ss (Silent Seek) command to seek without writing to the seek history
    • Adds -Q flag to r2 for faster quits handy for testing
    • Adds ad4 and ad8 commands to analyze data words
    • Adds fd. command to find flags without delta
    • Adds dbh- subcommand to remove breakpoint plugin handler
    • Adds -E xor support to rahash2, plus -S - and -S @ to slurp stdin or files
    • Adds Pn+ pseudopipes (| and |H)
    • Adds /f command to find the contents of a file inside another
    • Adds $ binding to enable pseudocode in visual graph mode
    • Adds esil.stack.{addr,size,depth} config variables to replace hardcoded constants
    • Adds zign.mincc, renames zign.{min,max} to zign.{minsz,maxsz}, and adds zign.metrics.{graph,bytes} for configurable zign matching
    • Adds hex.header configuration variable
    • Adds asm.section.sub config var to prefix offsets with section name in disassembly
    • Adds support for the BND prefix on x86.nz branch instructions
    • Adds initial support for Nintendo Switch NRO binaries

    22 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The z/ command is renamed to zS.
    • !The mention of r2's # command is replaced with ph.
    • !The config variable esil_stack is renamed to esil.ram.
    • !The slurp command <' is removed.
85. 1.3.0 Mar 13, 2017 · release notes

    radare2 1.3.0 adds aab/abb analysis, hex.compact, WebAssemblyWebAssemblyA binary instruction format that runs in browsers and server runtimes at near-native speed, letting developers compile C, Rust, or other languages into a portable, sandboxed module any compliant host can execute. support, rabin2 -L and PNX parsing.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.3.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.3.0

    └──▷ USE IT
    List all loaded rabin2 plugins and their details.
    shell copy

    rabin2 -L

    • Adds aab command to find basic blocks and identify function heads
    • Adds abb command to analyze basic blocks in a range with O(1) performance
    • Adds e!hex.compact option for compact hexdump output
    • Adds initial WebAssembly (WebAsm) parsing support
    • Adds rabin2 -L [plugin] and iL [plugin] to display plugin info

    +5 more show less

    • Adds Pnx command for project note parsing
    • Adds pxx and pxX commands for hex-less hexdumps
    • Adds support for parsing RTTI structures
    • Adds support for decoding punycode emojis in strings
    • Adds PPC(32/64) ESIL emulation support

    10 details in Everything

86. 1.2.1 Feb 5, 2017 · release notes

    Radare2 1.2.1 adds the dce command for Windows debugging and supports WebAssemblyWebAssemblyA binary instruction format that runs in browsers and server runtimes at near-native speed, letting developers compile C, Rust, or other languages into a portable, sandboxed module any compliant host can execute. disassembly.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.2.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.2.1

    • Adds the dce subcommand to r2 -d on Windows to debug processes with exceptions
    • Adds support for analyzing and disassembling WebAssembly (Wasm) binaries via the new Wasm plugin

    2 details in Everything

87. 1.2.0 Jan 30, 2017 · release notes

    radare2 1.2.0 adds r2snow decompiler, native ESIL 64-bit deref, afvR/W variable access listing, dbg.libs, r2core.js API, and pxc hexdump comments.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.2.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.2.0

    • Introduces r2snow, a new decompiler tool in radare2-extras
    • Adds pure JavaScript EMscripten-generated Radare2 API accessible via npm as r2core
    • Enables ESIL to handle 64-bit pointer dereference with the aae and /re commands
    • Implements afvR and afvW commands to list variable read and write accesses
    • Adds dbg.libs and dbg.unlibs debugger commands for listing loaded libraries on Linux

    +2 more show less

    • Adds pxc command in visual mode to display comments in the hexdump view
    • Adds initial support for analyzing and graphing generic switch tables in visual mode

    7 details in Everything

88. 1.1.0 Dec 20, 2016 · release notes

    Radare2 1.1.0 adds recursive help (?*), ragg2/rasm2 preprocessor (spp), new CLI commands, ESIL for Dalvik, and bFLT v4 support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.1.0

    └──▷ USE IT
    Quickly find help for a command without searching documentation manually.
    shell copy

    ?* help

    Automate flag size calculation for all flags matching a specific glob pattern.
    shell copy

    fla *exp*

    • Add ?\* (recursive help) to display help for every single command
    • Add fla command to automatically compute the size of all flags matching a glob
    • Add pdC command to show comments found in N instructions
    • Add pir command as pdr with pI output format
    • Add dmS command for listing sections of mapped libraries

    +6 more show less

    • Add $fl variable to get the flag length (size) at the current address
    • Implement bin.debase64 and RABIN2_DEBASE64 in RBin for r2 and rabin2
    • Add initial support for bFLT v4 (uclinux) file format
    • Add ESIL support for Dalvik (Android DEX)
    • Add ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead. PE binary support
    • Enhance autocompletion after @ in the console

    11 details in Everything

89. 1.0 Nov 9, 2016 · release notes

    Radare2 1.0 adds project containment with GIT/ZIP integration and new CCf command for function comments.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 1.0 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 1.0

    • Adds prj.zip and prj.git commands to package and unpack projects inside a single directory
    • Adds ik* command to load bin headers info directly in r2
    • Adds CCf command to list all comments in the current function
    • Adds ?O command to enumerate all mnemonics
    • Adds ?Od command to list all mnemonics with descriptions

    +2 more show less

    • Adds asm.decoff configuration variable to show offsets in base 10
    • Adds asm.capitalize configuration variable for uppercase mnemonic output

    7 details in Everything

90. 0.10.6 Sep 27, 2016 · release notes

    Radare2 0.10.6 adds zG, ?en, @@b/f/i iterators, and new eval keys for analysis control

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.10.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.10.6

    └──▷ TRY IT
    Filter zignature generation by length using the new eval settings.
    copy

    $ eval cfg.minzlen=4; eval cfg.maxzlen=64

    • Adds zs as an alias for the z/ command to manage zignature scopes.
    • Adds exact-match zignature support via the zG command.
    • Adds a new z. command to perform zignature matching by function, supporting @ addr and @@ fcn* contexts.
    • Adds ?en command to echo text without appending newlines.
    • Adds @@b iterator to walk all basic blocks in the current address space.

    +10 more show less

    • Adds @@f foreach iterator to walk all functions, with @@f: syntax to filter by name.
    • Adds @@i iterator to walk all instructions sequentially.
    • Adds drb[1,2,4,8] commands to display the hexdump of the general purpose register arena for 1/2/4/8 byte widths.
    • Adds Ve$ command to view variables in the visual debugger.
    • Adds av* and avj commands to show virtual method tables in r2 default and JSON formats.
    • Adds rabin2 -X flag for handling FAT and ZIP file formats via the new r_bin_package subsystem.
    • Adds axf command to resolve function names for C references.
    • Adds eval cfg.minzlen and cfg.maxzlen to set minimum and maximum length filters for zignature generation.
    • Adds eval anal.hpskip (false by default) to control high-probability skip behavior in analysis.
    • Adds eval asm.cmtrefs (disabled by default) to show flag and comment references at the current instruction.

    15 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The command Vvm is renamed to Vvr.
    • !The eval setting scr.colorops is renamed to scr.color.ops.
91. 0.10.5 Aug 16, 2016 · release notes

    Radare2 0.10.5 adds dmh heap analysis, new URI handlers, variable/argument analysis, and async r2pipe.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.10.5 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.10.5

    • Add dmh command to show memory heap
    • Implement pxd8 to show data in st64
    • Add $Fb and $Fs variables to handle basicblock address and size
    • Add new URI handlers: waitfor://, pidof://, nocache://, self://, and r2k://
    • Implement arithmetic pattern matching for ROP classification with /R command saving gadgets in rop.db

    +10 more show less

    • Add initial support for variable and argument analysis including type matching and calling convention profiles in SDB
    • Add aad command to analyze data references
    • Add av command to analyze vtables
    • Add support to analyze interrupt handler functions
    • Add new dmh command to analyze the heap on Linux-GlibC
    • Add support for Python3 in r2pipe
    • Add initial implementation of Async Python r2pipe API
    • Add r2pm -r subcommand to run commands in path
    • Add R2PM_GITDIR environment variable for easy packages local testing
    • Show string context in /z and / search commands

    15 details in Everything

92. 0.10.4 Jul 6, 2016 · release notes

    Radare2 0.10.4 adds heap analysis, ESIL/REIL views, r2 -I pre-scripting, and many new CLI commands.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.10.4 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.10.4

    └──▷ USE IT
    Automatically run analysis and print flags when opening a binary.
    shell copy

    r2 -I "aaa; af @@ sym.*"

    View the ESIL representation of the instruction at the current seek.
    shell copy

    aoe

    Disassemble all possible opcodes for the byte at the current offset to find ambiguous instructions.
    shell copy

    pdaj

    • Initial support for heap analysis on linux-glibc
    • New pdaj and pda= commands to disassemble all possible opcodes byte by byte
    • New aoe and aor commands to show ESIL and REIL forms of the current opcode
    • New r2 -I flag for pre-scripting at launch
    • New @o modifier to temporarily switch to another file descriptor

    +13 more show less

    • New fi[jn*] command to list flags in a given range
    • New drp. command to show register profile size
    • New ecoj command to list themes in JSON format
    • New pf [size]D syntax for custom format printing
    • New ah. command to show hints of the current offset
    • New afv[bsr] commands to manipulate args, registers and variables in function
    • New wxs command to write hexpairs and seek to the end
    • New dpc and dpc* commands to select or show recently forked child processes
    • New ecc [arg] command to show color palette with CSS syntax
    • New pch for 2 byte C dump mode
    • Adds core.iorw variable in i command
    • Adds anal.vars variable to toggle variables analysis
    • Better android support with correct disassembly and initial multidex

    18 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Renamed afa, afv and afe to afvb, afvr, and afvs respectively
93. 0.10.3 May 24, 2016 · release notes

    Radare2 0.10.3 adds afCa automating analysis, r2pm home/system installs, iOS entitlements via -OC, and HexII format

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.10.3 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.10.3

    └──▷ USE IT
    Automate the analysis of function arguments and variables in an open binary.
    shell copy

    r2 -c 'afCa' ./target.elf

    Dump entitlements from an iOS binary without needing macOS tools.
    shell copy

    rabin2 -OC ./app.ipa

    Install a package (e.g., r2pipe) into your local home directory instead of system-wide.
    shell copy

    r2pm install r2pipe --home

    • afCa command for enhanced function argument/variable analysis
    • r2pm install <package> can now target home or system prefix
    • -OC flag in rabin2 to dump iOS binary entitlements
    • HexII print format implementation
    • New aav command to find pointers to code/data

    +2 more show less

    • Callgraph navigation view added to the UI
    • Configurable Graphviz colors and current node highlighting

    7 details in Everything

94. 0.10.2 Apr 11, 2016 · release notes

    Radare2 0.10.2 adds aaaa deep analysis, dyldcache extraction, new aex/emulation, r2pm packages, and r2 -d shortcuts.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.10.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.10.2

    • Adds the aaaa command for significantly deeper analysis
    • Adds support for extracting iOS dyldcache files again
    • Adds the aex command to emulate a hexpair of native code
    • Adds r2 -d and -R shortcuts for rarun2 profiles and remote debugging
    • Adds new r2pm packages: ramoji2, www-t, www-p, and syms2elf

    +13 more show less

    • Adds asm.spacy, asm.flgoff, asm.fcnsign for non-windows binaries, and asm.(symbol|section)[.col] configuration options
    • Adds support for Blowfish, RC2, RC4, AES, XOR, ROR, ROL cryptography via woE/woD commands and rabin2 -E
    • Adds support for BOCHS debugging on Linux, Mac and Windows
    • Adds coredump generation and loading for Mach0 binaries on iOS and OSX
    • Adds initial Python bytecode (.pyc) and Flash file (.swf) format support
    • Adds r2 -d gdb:// syntax that no longer requires -D gdb
    • Adds the yl, yw, wz, and ys commands for clipboard interaction
    • Adds the aav command to show all references for a section or map
    • Adds support for Swift-Demangle in analysis output
    • Adds drw/arw commands for debugging register access
    • Adds the aaa verbosity improvements and t command redesign
    • Adds Pds summary mode for disassembly
    • Adds graph support via VVP' and graph.gv variables for custom Graphviz styles

    18 details in Everything

95. 0.10.1 Feb 29, 2016 · release notes

    radare2 0.10.1 adds Lanai and xtensa support, axg for xref graphs, and Vdn flag renaming

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.10.1 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.10.1

    └──▷ USE IT
    Analyze binary code for the newly supported Xtensa architecture.
    shell copy

    r2 -a xtensa malware.bin

    Generate a graph of cross-references leading to a specific address.
    shell copy

    axg 0x401000

    • Adds xtensa CPUCPUThe main general-purpose processor in a computer. It runs application instructions and coordinates work with memory and other hardware. analysis backend
    • Adds Lanai architecture support
    • Adds Vdn command to rename flags, functions, or variables in Visual mode
    • Adds axg command to graph function xrefs to a specific point
    • Adds -C flag to radiff2 for checksum comparison

    +1 more show less

    • Adds opcode descriptions accessible via ?d or e asm.describe=true

    6 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Local variables/arguments format names changed from ebp-0x10, ebp+0x13 to local_10h, arg_13h
96. 0.9.7 Mar 3, 2014 · release notes

    Radare2 0.9.7 adds 8 new architectures, JNA bindings, visual mouse support, ROP gadget search, and a sandbox start flag.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.9.7 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.9.7

    └──▷ USE IT
    Run radare2 in a restricted sandbox environment for safer analysis of untrusted binaries
    shell copy

    r2 -S target_binary.elf

    Apply the new pink color theme in the visual interface
    shell copy

    :ecf pink

    List files with detailed attributes using the new ls command
    shell copy

    ls -l /path/to/files

    • Adds -S CLI option to r2 to start with sandbox enabled
    • Adds OCAML bindings for the radare2 API
    • Adds work-in-progress hand-made JNA (Java Native Access) bindings
    • Adds ability to load multiples Java files at once in analysis
    • Adds support for Gameboy ROMs (loading and analysis)

    +15 more show less

    • Adds COFF binary format support
    • Adds H8/300, T8200, 6502 (Atari, Apple II, Commodore 64), TMS320, NIOS II, SNES, Gameboy, Whitespace, and Malbolge architecture support
    • Adds ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. assembler completeness (complete instruction set)
    • Adds ability to search and filter ROP gadgets
    • Adds ls -l command
    • Adds backward search /b in visual mode
    • Adds less internal pager functionality (^x^e supported in RConsLine)
    • Adds CPUCPUThe main general-purpose processor in a computer. It runs application instructions and coordinates work with memory and other hardware. cycles and fail cycles columns in disassembly output
    • Adds emoji hexdump support
    • Adds ecf pink theme for visual mode
    • Adds mouse wheel support on xterm-compatible terminals in visual mode
    • Enables <Enter> to follow jmp/call/cjmp in visual mode
    • Allows building with Jamroot
    • Renames rdb project directory to projects in ~/.config/radare2/
    • Adds -S option to r2 to start with sandbox enabled

    20 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The project configuration directory is renamed from ~/.config/radare2/rdb to ~/.config/radare2/projects
97. 0.9 Feb 26, 2014 · release notes

    Adds /z string search, /v2/v4/v8 value searches, afi/pdi/pda disassembly commands, ragg2 shellcode compiler, and r_debug_map_protect API

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.9 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.9

    └──▷ TRY IT
    Compile a shellcode payload into a Mach-O64 binary using the new ragg2 engine with XOR encoding and byte patching
    copy

    $ ragg2 -i x86.osx.binsh -b 64 -k osx -f mach064 -o a.out -d -D -w

    • Adds /z command to search for strings in the binary
    • Adds /v2, /v4, /v8 commands to search for values of specific widths (removes /q) in the search engine
    • Adds afi command to show information about functions
    • Adds pdi command to disassemble code showing offset and bytes, analogous to pi
    • Adds pda command to disassemble code byte-by-byte, disobeying instruction length

    +5 more show less

    • Adds dtc and dtg commands to draw execution call graphs from debugger traces
    • Adds /a and /c search aliases (renaming /a to /r is noted but /a is the new usable form for specific searches mentioned alongside progress info)
    • Adds r_debug_map_protect() API bound to the dmp command, available on w32 and osx
    • Adds ragg2 and ragg2-cc shellcode compilers with byte patching support (-d, -D, -w)
    • Adds rax2 hexpair <-> binary conversions using flags -s and -S

    10 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The /q search command is removed; use /v2, /v4, or /v8 for value searches instead
    • !The rasc2 tool has been deprecated and replaced by ragg2; commands like $ ragg2 -i x86.osx.binsh -b 64 -k osx -f mach064 -o a.out are the new way to compile shellcode
    • !The -b flag for specifying blocksize in r2 is now -B
98. 0.9.2 Feb 26, 2014 · release notes

    New embedded HTTP server, ARM64ARM64The 64-bit instruction set architecture from ARM Holdings, used in modern mobile chips, Apple Silicon, and cloud server CPUs; tools target it to run natively on those platforms without emulation overhead. MIPS32 analysis, visual diff mode, and more

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.9.2 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.9.2

    └──▷ TRY IT
    Expose the binary viewer over a local network without starting an external web server.
    copy

    $ r2 -c=H /path/to/binary.bin

    Inspect the layout and size of sections in a Mach-O executable.
    copy

    $ rabin2 -Z /usr/bin/ls

    • Adds r2 -c=H to start an embedded HTTP-1.0 webserver on port 9090 with a basic UI for remote interaction.
    • Adds Visual diff mode in the viewer (press D) to compare two binary views side-by-side with hex columns.
    • Adds om command to create, destroy, and list IO maps, allowing explicit control over memory mapping strategies.
    • Introduces rabin2 -Z (r_bin_size) for displaying binary file sizes and layout information in ELFELFThe standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. and Mach-O formats.
    • Enables binmask searches using /x <pattern>:<mask> to find byte sequences matching specific bit patterns.

    5 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !The ?z command is renamed to ?l for language/environment queries.
    • !The Vw visual mode keybinding is renamed to Vi (write becomes insert).
99. 0.9.6 Nov 11, 2013 · release notes

    Radare2 0.9.6 adds a built-in web UI via =H, an embedded C parser for structs (td), and visual debugger improvements.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch 0.9.6 https://github.com/radareorg/radare2.git
    # already have the repo? check out this version:
    $ git checkout 0.9.6

    └──▷ TRY IT
    Start a remote web interface to control r2 sessions from a browser.
    copy

    $ $ r2 -c=H /bin/ls

    Launch the visual debugger with signal capture capabilities.
    copy

    $ $ r2 -cVpp -d ls

    • Adds the =h and =H commands to start an embedded webserver for remote interaction with r2 sessions.
    • Adds td command (see t?) to define C structs and enums using a reduced libtcc fork, loading them into sdb databases.
    • Adds support for capturing and passing signals to the target process in the debugger.
    • Adds visual debugger launch via the -cVpp -d flag combination (e.g., r2 -cVpp -d <target>).
    • Adds pxa command for annotated hexdumps with cursor-based range selection and colorization.

    +2 more show less

    • Improves Java Class file parser to support Java 7 and adds ARMARMA family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. aarch64, TI c55x+, 8051, and ARCcompact platform support.
    • Allows setting http.public=true via -e to make the web UI public.

    7 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Import PLT addresses are no longer listed with rabin2 -i; imports are now ordinals and PLT entries are listed as symbols.