For Windows · targets: Windows (x86, x64, ARM, ARM64), DOS, ARM Linux

Asmonite – assembler, debugger and disassembler in one package

Write. Assemble. Debug. Disassemble.

Two small, portable programs instead of a tool chain: Asmonite to write, assemble and debug assembly (x86, x64, ARM32/Thumb-2 and ARM64/AArch64), Dismonite to examine and debug executables – Windows (PE for x86, x64, ARM32 and ARM64/AArch64), DOS (MZ) and ARM Linux (ELF). With built-in instruction info on F1. Unpack, start, done.

⬇ Download Try it in 60 seconds

Version 0.7.6 (test version) · Windows 10/11 · 2.1 MB · no installation · free · no tracking

Asmonite: the debugger stopped at a breakpoint, registers, stack and memory on the right, the output below the code
Asmonite: source and breakpoint, registers, stack and memory on the right, the program output below – all in one window, debug where the code is written.

What's inside

Everything you need to write, assemble, debug and disassemble assembly programs.

📝

Editor and assembler

Syntax highlighting for x86 assembly, C and Pascal. Ctrl+F9 builds the EXE next to the source file; errors appear in the output window.

Asmonite
🛡️

PE validation

Every generated EXE is checked before it starts: header, sections, entry point, imports – do the DLLs and functions really exist?

Asmonite
🐞

Source-level debugger

Breakpoints, step over/into, run to cursor, pause – right in the source. Registers, stack and memory; the program's output live.

Asmonite
💾

DOS programs in QEMU

DOS programs run in QEMU with FreeDOS – with the same debug commands. QEMU starts automatically; a second run needs no new boot.

Asmonite · Dismonite
🔍

Disassembler with a way back

Analyze, comment and export PE, MZ and ELF files as .asm that assembles back into the same file, byte for byte.

Dismonite
🍓

Debug ARM Linux programs

32-bit ARM programs run through gdbserver in Raspberry Pi OS under QEMU. A script downloads and sets up the guest; Dismonite starts it on request.

Dismonite
💡

Instruction info on F1

One key press explains the instruction, the imported Windows function (with its parameters), the DOS interrupt, the directive – and error messages too. German and English.

Asmonite · Dismonite
🧩

ARM assembler (Thumb-2)

After .arch thumb Asmonite writes ARM Thumb-2 code; the editor colours it as ARM. Dismonite exports Windows on ARM programs as .asm that assembles back into the same file.

Asmonite · Dismonite
🖥️

Debug Windows on ARM

Dismonite runs 32-bit ARM programs on a real Windows on ARM computer and debugs them there: breakpoints, steps, registers. The small server asmodbg runs on the ARM computer.

Dismonite
🧮

x64 and ARM64 assembler

After .arch x64 or .arch arm64 Asmonite writes 64-bit code; .format pe makes a PE32+ file that Windows (x64) or Windows on ARM64 runs. Every result is read back to check it.

Asmonite
🚀

Debug x64 and ARM64

x64 programs run on this computer, ARM64 programs on a Windows on ARM computer (ssh, directly on the network or locally): breakpoints, steps, 64-bit registers, stack and memory – in Asmonite on source lines. Before a jump the row says whether it is taken and where to.

Asmonite · Dismonite
🗂️

Resources and message texts

Dismonite reads the resource directory of PE files: string tables are recognized text by text, with a label and a number; a constant before a call that loads a message shows the text as a hint.

Dismonite

Runs on – and debugs

Runs on (host)Programs you build or examine with it (target)
AsmoniteWindows 10/11, 32 or 64 bitWindows (PE, PE32+) from i386, x64 and ARM64 assembly; DOS programs in QEMU; write ARM Thumb-2 code
DismoniteWindows 10/11, 32 or 64 bitWindows PE (x86, x64, ARM, ARM64), DOS MZ (16-bit), ARM Linux ELF (32-bit)
asmodbgWindows 10 on ARM (runs where the ARM program runs)32-bit ARM programs (PE), controlled by Dismonite over the network or ssh
asmodbg64Windows on ARM64 (runs where the ARM64 program runs)ARM64 programs (PE), controlled by Asmonite and Dismonite over ssh or the network
asmodbgx6464-bit Windows (helper in the debugserver folder, starts by itself)x64 programs (PE32+) on this computer or, with --listen, on another 64-bit Windows computer in the network
QEMU64-bit Windows (only needed for DOS and ARM; the scripts offer to install it)FreeDOS (720 KB floppy), Raspberry Pi OS Buster (ARM)

Who is Asmonite for?

For everyone who wants to understand what the processor really does – from the first mov to someone else's EXE.

🎓

Learning assembly

  • Write a program, F9, done
  • Step through the code
  • See registers and flags change
  • Understand stack and memory
  • F1 explains every line
⚙️

x86, x64 and ARM64 development

  • Assembler with PE output (PE32+ too), import table included
  • PE check before every start
  • fast cycle: change, assemble, debug
  • asmoc for the command line
🔬

Examining programs

  • PE, MZ and ELF structures with field names
  • Follow code from the entry point and exports
  • Mark, comment, rename
  • Export as assemblable .asm
🕹️

Retro and embedded

  • Debug DOS programs in FreeDOS
  • 16-bit registers, segment:offset
  • ARM programs in the Raspberry Pi guest or on Windows on ARM
  • DOS and ARM locally in QEMU

In 60 seconds

From the ZIP to the first breakpoint – with the example that comes with it.

  1. Unpack and start Asmonite.exe. No installation; File > Open starts in the program's folder.
  2. Open examples\windows_intel\demo.asm. A small program: counts from 1 to 5 and calls printf.
  3. Press F5 to set a breakpoint on the line call [printf].
  4. Press F9. Asmonite assembles, checks the EXE and stops at the breakpoint.
  5. Watch the registers: continue with F8; changed values turn red.
  6. Stack and memory are on the right below the registers – the program's output is below the code.
  7. F1 on a line explains it: the instruction, the call of printf with its parameters – in the help on the right.

It works without preparation too: in a new file the single line mov eax, 1 is enough – Ctrl+F9 makes a Windows program of it (without .arch and .format Asmonite assumes 32-bit Windows).

Next: open examples\windows_intel\demo.exe in Dismonite and debug the same file without source with F7.

Asmonite – the editor

Clean, fast and tailored to assembly.

  • Syntax highlighting for x86 assembly (Intel syntax), C and Pascal
  • Gutter with line numbers, breakpoints and execution line
  • Undo/redo – continuous typing counts as one step
  • x86 and ARM in one file: after .arch thumb the editor colours the lines as ARM
  • Find and replace – forward, backward, whole word, “replace all” as one undo step
  • Assembler: .format pe generates header and import table, or write every byte yourself
  • Own editor component, no third-party libraries
  • Instruction info on F1 in the column on the right – see below
Asmonite: editor with an assembler program
The editor with a small program: a loop, a call of printf through the import table.

Asmonite – the debugger

Step through your own program – with registers, stack and memory in view.

Windows programs

  • Breakpoints (also while the program runs), step over/into, run to cursor, pause, stop
  • Registers with flags; changed values are red
  • Stack: 32 dwords from ESP, with hints to labels and code lines
  • Memory: hex dump from an address, a label or esp/ebp/eip
  • Program output live in the output window; load errors as readable messages

DOS programs in QEMU

  • Starts in QEMU with FreeDOS – QEMU starts by itself
  • Breakpoints, step over/into, run to cursor and pause on source lines
  • Registers, stack (SS:SP) and memory (segment:offset) in 16-bit
  • Screen output at every stop and at the end in Output
  • Run again in the running QEMU, without a new boot
  • Examples: hello.com.asm and hello_exe.asm – Hello World as .COM and as .EXE, with an explanation of the difference

x64 and ARM64 programs

  • A program with .arch x64 starts with F9 on this computer, one with .arch arm64 on a Windows on ARM computer
  • ARM64: ssh, directly on the network or locally; the target under Debug > Debug target Windows on ARM
  • Breakpoints, step over/into, run to cursor and pause on source lines
  • Registers rax…r15 or x0…x30 with flags, stack as 64-bit values, memory with 64-bit addresses
  • Not yet: keyboard input for the program

Instruction info – F1

One key press explains what the line under the cursor does – no manual, no search engine.

  • Instructions (x86 and ARM Thumb-2): syntax, allowed operands, flags and an example
  • Windows functions: for call [ExitProcess] the DLL, the calling convention, every parameter with type and meaning and the result – over 230 functions (kernel32, user32, msvcrt …)
  • DOS and BIOS interrupts: for int 21h the function, whose number the info finds in the lines before, with input and output registers
  • Directives: .arch, .format, .import, section and the other peculiarities of the assembler
  • Error messages: F1 on a line of the output window or on the line marked red explains what the message means, what usually causes it and how to fix it
  • German and English, switchable in the Help menu; without a choice the language follows Windows
  • In Dismonite the same texts are in the Info tab; they follow the cursor unless you switch that off
Asmonite: the help on the right explains call and the printf function
F1 on call [printf]: on the right the instruction call and the function printf – DLL, calling convention, parameters, result.
Asmonite: an unknown instruction marked red, the help explains the message
A typo in the instruction: the line is red, F1 explains the message – with the usual causes and an example.

Dismonite – disassembler and debugger

Understand executables, watch them in the debugger and turn them back into source – for Windows (PE: x86, x64, ARM, ARM64), DOS (MZ) and ARM Linux (ELF).

Dismonite has a page of its own: dismonite.com

From the EXE back to source

EXEexecutable
→
Dismoniteanalyze, comment
→
.asmwith labels
→
asmocassembler
→
EXEidentical, byte for byte
  • Analysis: follows code from the entry point, exports and TLS callbacks (PE) or CS:IP (MZ), and from the relocation targets
  • Labels instead of addresses; Ctrl+click jumps to the target, Alt+← back
  • File structures (PE header, sections, imports, exports, resources, ELF program headers and symbols) with field names as comments
  • String resources (RT_STRING): each text on its own, with the label str_<number>; in the code a constant before a call that loads a message shows the text as a hint
  • Shows addresses, bytes, instruction and comment – even for large files (tested up to 64 MB)
  • Mark elements as code, byte, word, dword, qword, ASCII or UTF-16; comments and comment lines
  • Marks and comments are saved in <program>.dmon next to the program
  • Export as .asm with labels, which the Asmonite assembler turns into the same file again
Dismonite: code at the entry point with labels
After the analysis: the code at the entry point start, jump targets and addresses as labels.
Dismonite: the import table with field names
The import table: every field with its size and name, RVAs as labels, padding as one align line.

The debugger in Dismonite

Windows (PE)

Starts the program directly on Windows. Breakpoints, step over/into, run to cursor, pause; the program's console appears in the output view.

DOS (MZ)

Starts QEMU with FreeDOS by itself; 16-bit registers, addresses as segment:offset. A second run starts in the running QEMU.

ARM-Linux (ELF)

Copies the program into the Raspberry Pi guest over ssh and debugs it through gdbserver. If no guest runs, Dismonite asks and starts it.

Windows on ARM (PE)

Copies the 32-bit ARM program to a real Windows on ARM computer and debugs it there through the small server asmodbg – either over ssh or directly on the network with a pairing code. “Search LAN” finds running servers on the local network.

x64 (PE32+)

Starts the 64-bit program on this computer; the small helper asmodbgx64 runs as a child process. Registers rax…r15, stack and memory with 64-bit addresses.

ARM64 (PE)

Debugs on a Windows on ARM computer through the server asmodbg64 – ssh, directly on the network or locally if Dismonite itself runs there. Registers x0…x30, sp, pc, flags.

Dismonite: debugging demo.exe with registers, stack, memory and output
Windows: demo.exe in the debugger without source – stopped after the first printf: registers and stack on the right, below the memory of the data section and the output “Number 1”.
Dismonite: a DOS program stopped at a breakpoint, QEMU window with its output
DOS: a Turbo Pascal program at a breakpoint in its loop; QEMU with FreeDOS, the numbers also in the output view.
Dismonite: an ARM Linux program after a step over printf, ARM registers and stack
ARM Linux: hello-arm in the Raspberry Pi guest, after a step over printf – ARM registers, the stack from sp and the memory there.

One package instead of a tool chain

There are good tools for every single task. Asmonite brings them together for everyday assembly work – one way to operate them and no installation.

TaskAsmonite + DismoniteUsual tool chain
Write source✓ editor with highlightingtext editor
Assemble✓ built in, plus asmocseparate program (e.g. NASM) and linker
Debug Windows programs✓ on source lines and without sourceseparate debugger (e.g. x64dbg)
Debug DOS programs✓ QEMU + FreeDOS, starts by itselfemulator with its own debugger, set up by hand
Debug ARM Linux programs✓ the guest is set up by a scriptQEMU, gdbserver and gdb by hand
Debug Windows on ARM programs✓ server asmodbg on the ARM computer, controlled from Dismoniteset up a remote debugger and a development environment on the ARM computer
x64 and ARM64 programs✓ assembler, disassembler with export and debuggerseparate tools per architecture
Look instructions up✓ F1 on the line: instruction, Windows function, interrupt, error messagemanual or search engine in another window
Disassemble✓ export that gives the same file againdisassembler; the export usually needs rework
Installation✓ none – one ZIP, under 2 MBseveral programs

What Asmonite does not do (yet)

Keyboard shortcuts

The most important commands at a glance. The debug keys are the same in both programs.

KeyAsmonite and Dismonite
F1Instruction info: instruction, function, interrupt, directive, error message
F5Toggle breakpoint
F9Start / continue
F8 / F7Step over / step into
F4Run to cursor
Strg+F2End the debug session
Strg+F9Assemble (Asmonite only)
Strg+F · F3Find · find next
Strg+HReplace (Asmonite)
Strg+GGo to line (Asmonite) / address (Dismonite)
Strg+Z / Strg+YUndo / redo (Asmonite)
KeyDismonite
Cmark as code
B W D Qbyte, word, dword, qword
A / UASCII / UTF-16 text
; / EnterComment / comment line before
NRename label
Strg+RReferences to this place
Strg+F3Next string
Alt+← / Alt+→Back / forward

Download

One ZIP archive – unpack and start, no installation.

Test version – feedback welcome

Asmonite 0.7.6

Asmonite (editor, assembler, debugger), Dismonite (disassembler and debugger), asmoc (assembler on the command line), the QEMU scripts for FreeDOS and Raspberry Pi OS, the debug servers asmodbg, asmodbg64 and asmodbgx64 (Windows on ARM, ARM64, x64), the instruction info (German and English) and examples for Windows (x86, x64), DOS and ARM (Thumb-2, ARM64).

Windows 10 (1809 or later) / 11 Program: English · documentation: German / English 2.1 MB Date: 2026-10-31
SHA-256: 2484d078507abefc2c0b2cd27c8bddaeb464dd6b329ee617369b41c22c10ef90
License (freeware) Scan at VirusTotal ↗
⬇ Download

What the programs do – and what not

  • No installation, no registry entries: Asmonite keeps its settings in Asmonite.ini next to the EXE, Dismonite its marks in <program>.dmon next to the examined program.
  • No telemetry, no ads, no phoning home.
  • Only the QEMU scripts go online – and only after asking: QEMU (winget), the FreeDOS floppy, Raspberry Pi OS. Dismonite talks over ssh only to its own guest at 127.0.0.1. To debug on Windows on ARM it connects only to the computer you name; “Search LAN” asks the local network once by UDP for that.
  • To remove it, delete the folder.

Check the download

  • The checksum in a command prompt: certutil -hashfile Asmonite-0.7.6.zip SHA256 – it must match the value above.
  • The programs are not signed. Windows may therefore ask on the first start (“Windows protected your PC” → “More info” → “Run anyway”).
  • Docs, examples and all versions also on GitHub.
  • Questions, bugs, wishes: mail@asmonite.com