Which architectures and binary formats does ZathuraDbg support?
ZathuraDbg currently supports four instruction set architectures — Intel x86_64, ARM 32-bit, Thumbv7m, and AArch64 — and it does not debug binaries at this time. If your goal is to step through assembly instructions in an emulated environment, ZathuraDbg can help on those four architectures. If your goal is to attach to or load a compiled executable (ELF, PE, Mach-O, etc.), ZathuraDbg is not the right tool yet.
Supported architectures
According to the site, ZathuraDbg supports:
| Architecture | Status |
|---|---|
| Intel x86_64 | Supported |
| ARM 32-bit | Supported |
| Thumbv7m | Supported |
| AArch64 | Supported |
| Other architectures | Under development |
The homepage headline emphasizes x86_64, while the FAQ and feature list confirm the broader set above. Support for additional architectures is described as in progress, so treat the list as a snapshot rather than a fixed ceiling.
Binary format support
ZathuraDbg does not support debugging binaries at the moment. The FAQ states this directly and notes that binary debugging "may be added in a future release." There is no announced format list (ELF, PE, Mach-O) because the capability itself is not yet available.
This matters for how you choose the tool:
- Assembly emulation and learning — ZathuraDbg is built for this. It is an emulation-based debugger powered by the Icicle emulator, Capstone engine, and Keystone engine, so you work with assembly instructions rather than a loaded executable.
- Debugging a compiled program — not supported today. You would need a different debugger for that workflow.
What this means in practice
ZathuraDbg is positioned as a GUI debugger for assembly emulation, aimed at learning, editing, and mastering assembly. Its feature set reinforces that scope:
- No setup needed — launch and debug, per the site.
- Built-in hex editor — edit memory live as code runs.
- Time travel debugging — step backward through execution while preserving memory and stack integrity, with a few megabytes of overhead.
- Beginner-friendly interface — commands explained clearly.
Because it is emulation-based rather than a native process debugger, the architecture list is the relevant compatibility question, not the binary format. You choose an architecture, work with assembly in the emulator, and use the GUI to inspect and edit state.
Common points of confusion
- "Can I open my compiled program in it?" No — binary debugging is not supported at this time.
- "Does it support syscalls and OS-level APIs?" Not fully. The site says implementation for common syscalls is under development, so don't expect complete OS-level behavior.
- "Is x86_64 the only option?" No — ARM 32-bit, Thumbv7m, and AArch64 are also supported, with more architectures in development.
If your task is learning or experimenting with assembly on one of the four supported architectures, ZathuraDbg fits. If your task depends on loading and debugging a real binary or on full syscall/OS API coverage, wait for those features or use a tool designed for that purpose.