Turn compiled binaries back into readable C.

Jicama is a decompiler that runs on macOS, Linux and Windows. Give it an app, a library or a command-line tool, and it rebuilds the functions, types and structures as C-like code you can read, search and check.

Run it from the terminal, or let an AI agent drive it. In development, not yet released.

Machine code (arm64)

_buffer_append:
    stp   x22, x21, [sp, #-48]!
    stp   x20, x19, [sp, #16]
    stp   x29, x30, [sp, #32]
    add   x29, sp, #32
    mov   x19, x2
    mov   x20, x1
    mov   x21, x0
    ldp   x8, x9, [x0, #8]
    add   x1, x8, x2
    cmp   x1, x9
    b.ls  LBB0_2
    mov   x0, x21
    bl    _buffer_grow
    tbz   w0, #0, LBB0_3
    ldr   x8, [x21, #8]
LBB0_2:
    ldr   x9, [x21]
    add   x0, x9, x8
    mov   x1, x20
    mov   x2, x19
    bl    _memcpy
    ldr   x8, [x21, #8]
    add   x8, x8, x19
    str   x8, [x21, #8]
    mov   w0, #1
LBB0_3:
    ldp   x29, x30, [sp, #32]
    ldp   x20, x19, [sp, #16]
    ldp   x22, x21, [sp], #48
    ret

What Jicama shows you

struct buffer {
    char *data;
    size_t length;
    size_t capacity;
};

bool buffer_append(struct buffer *buf, const char *bytes,
                   size_t count)
{
    if (buf->length + count > buf->capacity) {
        if (!buffer_grow(buf, buf->length + count))
            return false;
    }
    memcpy(buf->data + buf->length, bytes, count);
    buf->length += count;
    return true;
}

An illustration: a small function from an arm64 binary, and the C that comes back.

What we are aiming for

Output you can trust: Correct comes before clever. When Jicama cannot tell what something is, it says so plainly instead of guessing, so confident-looking code does not mislead you.
Fast on large binaries: Decompiling a whole library should take seconds. Jicama is written in Rust and built to stay quick and light on memory as binaries get bigger.
Built for people and agents: Use the jicama command yourself, or connect an AI agent through its MCP server or batch protocol. An agent can open a binary, look up its functions and read their code, the same way you would.
No specialist needed: You should not need years of reverse-engineering experience to understand a binary. The goal is code a developer or researcher can follow without a guide.

What it reads

Processors: arm64 (including Apple Silicon) and x86-64
File formats: Mach-O (macOS), ELF (Linux) and PE (Windows)
What it recovers: Functions and their signatures, types and structures, C++ classes and virtual calls, Objective-C and Swift metadata
Debug information: Uses DWARF when the binary includes it

Where it stands

Jicama is in development. We test it against Ghidra, the widely used open-source decompiler, and check both against the original source code of the programs in our test set.

Decompiling every function in SQLite, a large library with its symbols stripped, in our tests:

Jicama: About 2 seconds
Ghidra: About 80 seconds

Also in our tests:

It uses far less memory doing it.
Checked against the original source, it is already ahead of Ghidra at recovering function parameters and return types, pointer types and integer widths.
It rebuilds C++ classes and virtual calls more often.
Its code is easier to read, with fewer gotos and leftover artifacts.
Its output recompiles and behaves the same as the original program in our tests.

These results come from our own test corpus while Jicama is still changing. They are not a promise about every binary.

Jicama is not available yet. This page will say when it is.