Skip to content
Early development · now: M3 Decompiler core, standalone

Reverse engineering, rebuilt in Rust.

Basilisk is a reimplementation of Ghidra — loaders, SLEIGH, p-code, analysis, the decompiler and a desktop interface. It reads Ghidra’s processor specifications unchanged. Today it decodes instructions and lifts them to p-code for every processor Ghidra ships; the decompiler is being ported.

basilisk sleigh decode
$ basilisk sleigh decode --language x86:LE:64:default \
    --base 0x401000 --hex 554889e58b45fc83c0015dc3 \
    --format text --no-pcode
0x401000  55         PUSH RBP
0x401001  48 89 e5   MOV  RBP,RSP
0x401004  8b 45 fc   MOV  EAX,dword ptr [RBP + -0x4]
0x401007  83 c0 01   ADD  EAX,0x1
0x40100a  5d         POP  RBP
0x40100b  c3         RET

Works today, for all 150 of Ghidra’s processor languages. Column spacing is trimmed here; the text is the command’s. Try it

Basilisk's main window: Program Trees and Symbol Tree on the left, the Listing in the centre, the Decompiler on the right and the Console below, showing the function main of the demo program.Basilisk's main window: Program Trees and Symbol Tree on the left, the Listing in the centre, the Decompiler on the right and the Console below, showing the function main of the demo program.
The CodeBrowser layout Ghidra users know: Listing, Decompiler, trees and tables, on Basilisk’s built-in demo program.

0x10 The interface

If you know Ghidra, you already know Basilisk.

The windows are where Ghidra puts them, with Ghidra’s names, menus and default keys. It runs on a built-in demo program until Basilisk can load real binaries.

Ghidra’s keys

Go to, rename, comment and the rest keep Ghidra’s default bindings, taken from its source.

A palette for everything

One field searches every action, function, label, string and address.

Panes that move

Dock, stack and split any pane, or pop it out into its own window; the layout is remembered.

Calm, in two themes

Both themes use the same twelve syntax colours, one per kind of token.

0x20 Listing and Decompiler

Colour that means something.

Put the cursor on a statement in the Decompiler and the Listing marks the instructions it came from. Each of the twelve kinds of token has its own colour, checked for contrast in both themes.

Listing: licd
1000018d7  48 89 df           MOV     RDI,RBX1000018da  e8 81 f6 ff ff     CALL    config_defaults1000018df  48 8d 4d d8        LEA     RCX,[RBP + -0x28]1000018e3  44 89 ff           MOV     EDI,R15D1000018e6  4c 89 f6           MOV     RSI,R141000018e9  48 89 da           MOV     RDX,RBX1000018ec  e8 af fe ff ff     CALL    parse_args1000018f1  e8 8a f7 ff ff     CALL    decode_strings1000018f6  e8 65 ff ff ff     CALL    print_banner1000018fb  e8 30 f7 ff ff     CALL    check_debugger100001900  85 c0              TEST    EAX,EAX100001902  74 1e              JZ      LAB_100001922100001904  48 8d 35 7b 05 …   LEA     RSI,[s_tracing_detected_100001e86]10000190b  41 be 03 00 00 00  MOV     R14D,0x3100001911  bf 03 00 00 00     MOV     EDI,0x3100001916  31 c0              XOR     EAX,EAX100001918  e8 33 ed ff ff     CALL    log_msg
Decompile: main - (licd)
1/* Entry point. Reads /etc/licd.conf, checks the licence key, */2/* activates against the server and then sends heartbeats. */34int main(int param_1,char **param_2)5{6  int iVar1;7  char *local_20;89  local_20 = "/etc/licd.conf";10  config_defaults(&g_config);11  parse_args(param_1,param_2,&g_config,&local_20);12  decode_strings();13  print_banner();14  iVar1 = check_debugger();15  if (iVar1 != 0) {16    log_msg(3,"tracing detected");17    return 3;
mnemonicregisternumberlabelfunctionglobalvariableparameterkeywordtypestringcomment

Set as text from the demo program the interface ships with. Real binaries arrive with the program model (milestone M4).

0x30 Where it stands

Early, and honest about it.

Basilisk is built from the bottom up: language files, then SLEIGH, then the decompiler, then programs and analysis. The summary on the right is generated from the project’s parity matrix (updated 2026-11-15).

Full status matrix

Works today

  • The desktop interface on a built-in demo program: Listing, Decompiler view, trees, tables, search, Go To, the palette, rename and comment dialogs, docking and pop-out windows.
  • Instruction decoding and p-code for every processor Ghidra ships: basilisk sleigh decode decodes bytes with any of the 150 SLEIGH languages, with the same result as Ghidra’s engine.
  • The SLEIGH compiler: basilisk sleigh compile produces the same .sla content as Ghidra’s compiler for all 150 specifications, in under five seconds for the lot.
  • The first parts of the decompiler: types, value ranges, calling conventions and control-flow structuring, each checked against Ghidra’s decompiler.
  • Foundations: Ghidra’s language and compiler specifications read unchanged, ELF parsing, the p-code model and float formats.
Framework6/14 modules started
Decompiler (C++)5/8 modules started
Features3/33 modules started
Processors1/4 modules started
Debug, Extensions0/3 modules started
Ghidra's GPL modules1/3 modules started

One segment per Ghidra module or part in docs/PARITY.md; the count is how many have been started.

Done 1Partial 12Reused 1Replaced 2Missing 49

Not yet

  • Opening a real binary, analysis, decompiling a function and Python scripting. Each has its milestone on the roadmap.
  1. M0Foundations7/7
  2. M1SLEIGH runtime4/5
  3. M2SLEIGH compiler3/4
  4. M3Decompiler1/9
  5. M4Program model
  6. M5Disassembly and auto-analysis
  7. M6Headless core complete
  8. M7egui UI
  9. M8Projects and collaboration
  10. M9Plugin API
  11. M10Remaining modules

0x40 Why Basilisk

Everything Ghidra does. Then better.

150 / 150
SLEIGH specifications compile to the same content as with Ghidra’s compiler
39
processor families decode and lift to p-code like Ghidra’s engine
2,400+
tests, most of them comparing against Ghidra on the same input
3
systems built and tested on every change: Linux, macOS, Windows

Parity first

Module by module, headless core first. Ghidra’s processor specifications work unchanged, and each feature lands with Ghidra’s own tests for it ported.

Better where it can be

Behaviour comes from Ghidra and structure from Rust. Each deliberate difference is recorded with its reason.

Fast, and never waiting

Language load, disassembly and decompilation at least as fast as Ghidra’s, analysis in parallel where safe, and an interface that never blocks.

Trustworthy

Parsers are fuzzed and must return an error, not crash, on a malformed file. Output is compared with Ghidra’s on the same input.

Python plugins

Scripts, analyzers, loaders and exporters in Python through an embedded interpreter, and Basilisk importable from Python. Planned for milestone M9.

One binary, three systems

Windows, macOS and Linux are built and tested on every change. Basilisk is a single binary.

0x50 Try it

Build it from source.

There are no releases yet. Building takes a Rust toolchain and a few minutes.

  1. Install Rust with rustup; it picks up the pinned toolchain from rust-toolchain.toml.
  2. Clone and run. The interface opens on its demo program.
  3. Find your way with the keys you know from Ghidra.
  4. Disassemble something. Your first disassembly takes five minutes.
shell
$ git clone https://github.com/tatupesonen/Basilisk
$ cd Basilisk
$ cargo run --release -p basilisk
# the interface opens on its built-in demo program

# or decode bytes with one of Ghidra's languages
$ basilisk sleigh decode --language x86:LE:64:default \
    --hex 554889e5c3 --format text --no-pcode
0x0  55                       PUSH RBP
0x1  48 89 e5                 MOV RBP,RSP
0x4  c3                       RET
Command palette
Go to
Rename
Set comment
Back / forward
References to

Ctrl is Cmd on macOS, as in Ghidra. Build instructions · Documentation

0x60 Credit

Standing on Ghidra’s work.

Basilisk reimplements Ghidra, the software reverse-engineering framework developed at the National Security Agency and published under the Apache License 2.0. Basilisk ports its behaviour and its tests, and reads its processor specifications as they are.

Basilisk is an independent project. It is not affiliated with, sponsored or endorsed by the NSA or Ghidra’s authors. It is free software under the GPL, version 3 or later; see the notice.