Asmonite – Assembler, Debugger & Disassembler

Was drin ist

What's inside

Alles, was man zum Schreiben, Übersetzen, Debuggen und Zurückübersetzen von Assembler-Programmen braucht.

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

📝

Editor und Assembler

Editor and assembler

Syntax-Hervorhebung für x86-Assembler, C und Pascal. Strg+F9 erzeugt die EXE neben der Quelldatei; Fehler stehen im Ausgabefenster.

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-Prüfung

PE validation

Jede erzeugte EXE wird vor dem Start geprüft: Header, Sections, Einsprungpunkt, Importe – gibt es die DLLs und Funktionen wirklich?

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

Asmonite

🐞

Debugger auf Quellzeilen

Source-level debugger

Haltepunkte, Step Over/Into, Run to Cursor, Pause – direkt im Quelltext. Register, Stack und Speicher; die Ausgabe des Programms live.

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

Asmonite

💾

DOS-Programme in QEMU

DOS programs in QEMU

DOS-Programme laufen in QEMU mit FreeDOS – mit denselben Debug-Befehlen. QEMU startet automatisch; ein zweiter Lauf braucht kein neues Booten.

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 mit Rückweg

Disassembler with a way back

PE-, MZ- und ELF-Dateien analysieren, kommentieren und als .asm exportieren, das wieder Byte für Byte dieselbe Datei ergibt.

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

Dismonite

🍓

ARM-Linux-Programme debuggen

Debug ARM Linux programs

32-Bit-ARM-Programme laufen über gdbserver in Raspberry Pi OS unter QEMU. Ein Skript lädt und richtet den Gast ein; Dismonite startet ihn auf Wunsch.

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

💡

Befehlsinfo auf F1

Instruction info on F1

Ein Tastendruck erklärt den Befehl, die importierte Windows-Funktion (mit Parametern), den DOS-Interrupt, die Direktive – und auch Fehlermeldungen. Deutsch und Englisch.

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)

ARM assembler (Thumb-2)

Ab .arch thumb schreibt Asmonite ARM-Thumb-2-Code; der Editor färbt ihn als ARM. Dismonite exportiert Windows-on-ARM-Programme als .asm, das wieder dieselbe Datei ergibt.

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

🖥️

Windows on ARM debuggen

Debug Windows on ARM

Dismonite startet 32-Bit-ARM-Programme auf einem echten Windows-on-ARM-Rechner und debuggt sie dort: Haltepunkte, Schritte, Register. Der kleine Server asmodbg läuft auf dem ARM-Rechner.

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- und ARM64-Assembler

x64 and ARM64 assembler

Ab .arch x64 oder .arch arm64 schreibt Asmonite 64-Bit-Code; .format pe erzeugt eine PE32+-Datei, die Windows (x64) oder Windows on ARM64 ausführt. Jedes Ergebnis wird zur Kontrolle wieder zurückgelesen.

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

🚀

x64 und ARM64 debuggen

Debug x64 and ARM64

x64-Programme laufen auf diesem Rechner, ARM64-Programme auf einem Windows-on-ARM-Rechner (ssh, direkt im Netz oder lokal): Haltepunkte, Schritte, 64-Bit-Register, Stack und Speicher – in Asmonite auf Quellzeilen. Vor einem Sprung steht, ob er genommen wird und wohin.

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

🗂️

Ressourcen und Meldungstexte

Resources and message texts

Dismonite liest das Ressourcenverzeichnis von PE-Dateien: Zeichenketten-Tabellen werden Text für Text erkannt, mit Label und Nummer; eine Konstante vor einem Aufruf, der eine Meldung lädt, zeigt den Text als Hinweis.

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

Läuft auf – und debuggt

Runs on – and debugs

	Läuft auf (Host)	Programme, die man damit baut oder untersucht (Ziel)
	Runs on (host)	Programs you build or examine with it (target)
Asmonite	Windows 10/11, 32 oder 64 Bit	Windows (PE, PE32+) aus i386-, x64- und ARM64-Assembler; DOS-Programme in QEMU; ARM-Thumb-2-Code schreiben
Asmonite	Windows 10/11, 32 or 64 bit	Windows (PE, PE32+) from i386, x64 and ARM64 assembly; DOS programs in QEMU; write ARM Thumb-2 code
Dismonite	Windows 10/11, 32 oder 64 Bit	Windows PE (x86, x64, ARM, ARM64), DOS MZ (16 Bit), ARM-Linux ELF (32 Bit)
Dismonite	Windows 10/11, 32 or 64 bit	Windows PE (x86, x64, ARM, ARM64), DOS MZ (16-bit), ARM Linux ELF (32-bit)
asmodbg	Windows 10 auf ARM (läuft dort, wo das ARM-Programm läuft)	32-Bit-ARM-Programme (PE), vom Dismonite im Netz oder über ssh gesteuert
asmodbg	Windows 10 on ARM (runs where the ARM program runs)	32-bit ARM programs (PE), controlled by Dismonite over the network or ssh
asmodbg64	Windows on ARM64 (läuft dort, wo das ARM64-Programm läuft)	ARM64-Programme (PE), von Asmonite und Dismonite über ssh oder im Netz gesteuert
asmodbg64	Windows on ARM64 (runs where the ARM64 program runs)	ARM64 programs (PE), controlled by Asmonite and Dismonite over ssh or the network
asmodbgx64	64-Bit-Windows (Hilfsprogramm im Ordner `debugserver`, startet von selbst)	x64-Programme (PE32+) auf diesem Rechner oder, mit `--listen`, auf einem anderen 64-Bit-Windows-Rechner im Netz
asmodbgx64	64-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
QEMU	64-Bit-Windows (nur für DOS und ARM nötig; die Skripte bieten die Installation an)	FreeDOS (720-KB-Diskette), Raspberry Pi OS Buster (ARM)
QEMU	64-bit Windows (only needed for DOS and ARM; the scripts offer to install it)	FreeDOS (720 KB floppy), Raspberry Pi OS Buster (ARM)

In 60 Sekunden

In 60 seconds

Vom ZIP zum ersten Haltepunkt – mit dem mitgelieferten Beispiel.

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

Entpacken und Asmonite.exe starten. Keine Installation; Datei > Öffnen beginnt im Programmordner.
examples\demo.asm öffnen. Ein kleines Programm: zählt von 1 bis 5 und ruft printf auf.
Mit F5 einen Haltepunkt auf die Zeile call [printf] setzen.
F9 drücken. Asmonite übersetzt, prüft die EXE und hält am Haltepunkt.
Register beobachten: mit F8 weiter; geänderte Werte werden rot.
Stack und Speicher in den Registerkarten unten ansehen – die Ausgabe des Programms steht im Output.
F1 auf einer Zeile erklärt sie: den Befehl, den Aufruf printf mit seinen Parametern – rechts in der Hilfe.

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

Es geht auch ohne Vorbereitung: In einer neuen Datei genügt die eine Zeile mov eax, 1 – Strg+F9 macht daraus ein Windows-Programm (ohne .arch und .format nimmt Asmonite 32-Bit-Windows an).

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).

Danach: examples\demo.exe in Dismonite öffnen und mit F7 dieselbe Datei ohne Quelltext debuggen.

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

Asmonite – der Debugger

Asmonite – the debugger

Schritt für Schritt durch das eigene Programm – mit Register, Stack und Speicher im Blick.

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

Windows-Programme

Windows programs

Haltepunkte (auch während das Programm läuft), Step Over/Into, Run to Cursor, Pause, Stop
Breakpoints (also while the program runs), step over/into, run to cursor, pause, stop
Register mit Flags; geänderte Werte sind rot
Registers with flags; changed values are red
Stack: 32 Doppelwörter ab ESP, mit Hinweisen auf Label und Codezeile
Stack: 32 dwords from ESP, with hints to labels and code lines
Speicher: Hexdump ab Adresse, Label oder esp/ebp/eip
Memory: hex dump from an address, a label or esp/ebp/eip
Programmausgabe live im Ausgabefenster; Ladefehler als verständliche Meldung
Program output live in the output window; load errors as readable messages

DOS-Programme in QEMU

DOS programs in QEMU

Start in QEMU mit FreeDOS – QEMU startet von selbst
Starts in QEMU with FreeDOS – QEMU starts by itself
Haltepunkte, Step Over/Into, Run to Cursor und Pause auf Quellzeilen
Breakpoints, step over/into, run to cursor and pause on source lines
Register, Stack (SS:SP) und Speicher (Segment:Offset) in 16 Bit
Registers, stack (SS:SP) and memory (segment:offset) in 16-bit
Bildschirmausgabe bei jedem Halt und am Ende im Output
Screen output at every stop and at the end in Output
Erneuter Start im laufenden QEMU, ohne neues Booten
Run again in the running QEMU, without a new boot
Beispiele: hello.com.asm und hello_exe.asm – Hello World als .COM und als .EXE, mit Erklärung des Unterschieds
Examples: hello.com.asm and hello_exe.asm – Hello World as .COM and as .EXE, with an explanation of the difference

x64- und ARM64-Programme

x64 and ARM64 programs

Ein Programm mit .arch x64 startet mit F9 auf diesem Rechner, mit .arch arm64 auf einem Windows-on-ARM-Rechner
A program with .arch x64 starts with F9 on this computer, one with .arch arm64 on a Windows on ARM computer
ARM64: ssh, direkt im Netz oder lokal; das Ziel unter Debug > Debug target Windows on ARM
ARM64: ssh, directly on the network or locally; the target under Debug > Debug target Windows on ARM
Haltepunkte, Step Over/Into, Run to Cursor und Pause auf Quellzeilen
Breakpoints, step over/into, run to cursor and pause on source lines
Register rax…r15 bzw. x0…x30 mit Flags, Stack als 64-Bit-Werte, Speicher mit 64-Bit-Adressen
Registers rax…r15 or x0…x30 with flags, stack as 64-bit values, memory with 64-bit addresses
Noch nicht: Tastatureingabe für das Programm
Not yet: keyboard input for the program

Befehlsinfo – `F1`

Instruction info – `F1`

Ein Tastendruck erklärt, was die Zeile unter dem Cursor tut – ohne Handbuch, ohne Suchmaschine.

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

Befehle (x86 und ARM Thumb-2): Syntax, erlaubte Operanden, Flags und ein Beispiel
Instructions (x86 and ARM Thumb-2): syntax, allowed operands, flags and an example
Windows-Funktionen: für call [ExitProcess] die DLL, die Aufrufkonvention, jeden Parameter mit Typ und Bedeutung und das Ergebnis – über 230 Funktionen (kernel32, user32, msvcrt …)
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- und BIOS-Interrupts: bei int 21h die Funktion, deren Nummer die Info in den Zeilen davor findet, mit Ein- und Ausgaberegistern
DOS and BIOS interrupts: for int 21h the function, whose number the info finds in the lines before, with input and output registers

Direktiven: .arch, .format, .import, section und die anderen Besonderheiten des Assemblers
Directives: .arch, .format, .import, section and the other peculiarities of the assembler
Fehlermeldungen: F1 auf einer Zeile des Ausgabefensters oder auf der rot markierten Zeile erklärt, was die Meldung bedeutet, woran es meistens liegt und wie man es behebt
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
Deutsch und Englisch, umschaltbar im Menü Help; ohne Auswahl richtet sich die Sprache nach Windows
German and English, switchable in the Help menu; without a choice the language follows Windows
In Dismonite stehen dieselben Texte im Reiter Info; sie folgen dem Cursor, wenn man es nicht abschaltet
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` auf `call [printf]`: rechts der Befehl `call` und die Funktion `printf` – DLL, Aufrufkonvention, Parameter, Ergebnis. `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 — Ein Tippfehler im Befehl: die Zeile ist rot, `F1` erklärt die Meldung – mit den häufigen Ursachen und einem Beispiel. A typo in the instruction: the line is red, `F1` explains the message – with the usual causes and an example.

Dismonite – Disassembler und DebuggerDismonite – disassembler and debugger

Fertige Programme verstehen, im Debugger beobachten und wieder in Quelltext verwandeln – für Windows (PE: x86, x64, ARM, ARM64), DOS (MZ) und ARM-Linux (ELF).

Understand finished programs, 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 hat eine eigene Seite: dismonite.com

Dismonite has a page of its own: dismonite.com

Von der EXE zurück zum Quelltext

From the EXE back to source

EXEfertiges Programmfinished program

→

Dismoniteanalysieren, kommentierenanalyze, comment

→

.asmmit Labelswith labels

→

asmocAssemblerassembler

→

EXEByte für Byte gleichidentical, byte for byte

Analyse: verfolgt den Code ab Einsprung, Exporten und TLS-Callbacks (PE) bzw. CS:IP (MZ), dazu ab den Relokationszielen
Analysis: follows code from the entry point, exports and TLS callbacks (PE) or CS:IP (MZ), and from the relocation targets
Labels statt Adressen; Strg+Klick springt zum Ziel, Alt+← zurück
Labels instead of addresses; Ctrl+click jumps to the target, Alt+← back
Dateistrukturen (PE-Header, Sections, Importe, Exporte, Ressourcen, ELF-Program-Header und -Symbole) mit Feldnamen als Kommentar
File structures (PE header, sections, imports, exports, resources, ELF program headers and symbols) with field names as comments
Zeichenketten-Ressourcen (RT_STRING): jeder Text einzeln, mit Label str_<Nummer>; im Code zeigt eine Konstante vor einem Aufruf, der eine Meldung lädt, den Text als Hinweis
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
Zeigt Adressen, Bytes, Befehl und Kommentar – auch bei großen Dateien (getestet bis 64 MB)
Shows addresses, bytes, instruction and comment – even for large files (tested up to 64 MB)

Elemente als Code, Byte, Word, Dword, Qword, ASCII oder UTF-16 markieren; Kommentare und Kommentarzeilen
Mark elements as code, byte, word, dword, qword, ASCII or UTF-16; comments and comment lines
Markierungen und Kommentare werden in <programm>.dmon neben dem Programm gespeichert
Marks and comments are saved in <program>.dmon next to the program
Export als .asm mit Labels, den der Asmonite-Assembler wieder zur selben Datei übersetzt
Export as .asm with labels, which the Asmonite assembler turns into the same file again

Dismonite: code at the entry point with labels — Nach der Analyse: der Code am Einsprungpunkt `start`, Sprungziele und Adressen als Labels. After the analysis: the code at the entry point `start`, jump targets and addresses as labels.

Dismonite: the import table with field names — Die Importtabelle: jedes Feld mit Größe und Namen, RVAs als Labels, Füllbytes als eine Zeile `align`. The import table: every field with its size and name, RVAs as labels, padding as one `align` line.

Der Debugger in Dismonite

The debugger in Dismonite

Windows (PE)

Startet das Programm direkt unter Windows. Haltepunkte, Step Over/Into, Run to Cursor, Pause; die Konsole des Programms erscheint in der Ausgabe.

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)

Startet QEMU mit FreeDOS von selbst; 16-Bit-Register, Adressen als Segment:Offset. Ein zweiter Lauf startet im laufenden QEMU.

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

ARM-Linux (ELF)

Lädt das Programm per ssh in den Raspberry-Pi-Gast und debuggt es über gdbserver. Läuft kein Gast, startet Dismonite ihn nach Rückfrage.

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)

Kopiert das 32-Bit-ARM-Programm auf einen echten Windows-on-ARM-Rechner und debuggt es dort über den kleinen Server asmodbg – entweder über ssh oder direkt im Netz mit einem Kopplungscode. „Search LAN“ findet laufende Server im lokalen Netz.

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+)

Startet das 64-Bit-Programm auf diesem Rechner; das kleine Hilfsprogramm asmodbgx64 läuft als Kindprozess. Register rax…r15, Stack und Speicher mit 64-Bit-Adressen.

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)

Debuggt auf einem Windows-on-ARM-Rechner über den Server asmodbg64 – ssh, direkt im Netz oder lokal, wenn Dismonite selbst dort läuft. Register x0…x30, sp, pc, Flags.

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.

Alles auf einen Blick: Register und Stack rechts neben dem Code, Speicher und Ausgabe des Programms darunter – ohne Umschalten; geänderte Werte sind rot
Everything at a glance: registers and stack right of the code, memory and the program's output below it – no switching; changed values are red
Stack mit den Labels, auf die die Werte zeigen (Doppelklick springt hin); Speicher ab einer Adresse, einem Label, einem Register oder unter DOS ab Segment:Offset
Stack with the labels its values point to (double click jumps there); memory from an address, a label, a register or under DOS from segment:offset
Wo das Programm anhält, wird Code – so wächst die Analyse beim Debuggen mit
Where the program stops becomes code – the analysis grows while you debug
Sprunghinweis: Steht das Programm vor einem Sprung, den es gleich nimmt (bei einem bedingten nur, wenn die Bedingung erfüllt ist), sagt die Zeile, ob es nach oben oder nach unten geht, und wohin
Jump note: where the program stands before a jump it is about to take (a conditional one only if the condition holds), the row says whether it goes up or down, and where to
Parameter für das Programm (Debug > Parameters), in der .dmon gespeichert
Command line parameters for the program (Debug > Parameters), saved in the .dmon

Dismonite: debugging demo.exe with registers, stack, memory and output — Windows: `demo.exe` ohne Quelltext im Debugger – angehalten nach dem ersten `printf`: rechts Register und Stack, unten der Speicher der Daten-Section und die Ausgabe „Number 1“. 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: ein Turbo-Pascal-Programm am Haltepunkt in seiner Schleife; QEMU mit FreeDOS, die Zahlen auch in der Ausgabe. 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` im Raspberry-Pi-Gast, nach Step Over über `printf` – ARM-Register, Stack ab `sp` und der Speicher dort. ARM Linux: `hello-arm` in the Raspberry Pi guest, after a step over `printf` – ARM registers, the stack from `sp` and the memory there.

Ein Paket statt einer Werkzeugkette

One package instead of a tool chain

Für jede einzelne Aufgabe gibt es gute Werkzeuge. Asmonite bringt sie für den Alltag mit Assembler zusammen – mit einer Bedienung und ohne Installation.

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

Aufgabe	Asmonite + Dismonite	Übliche Werkzeugkette
Task	Asmonite + Dismonite	Usual tool chain
Quelltext schreiben	✓ Editor mit Hervorhebung	Texteditor
Write source	✓ editor with highlighting	text editor
Übersetzen	✓ eingebaut, dazu `asmoc`	eigenes Programm (z. B. NASM) und Linker
Assemble	✓ built in, plus `asmoc`	separate program (e.g. NASM) and linker
Windows-Programme debuggen	✓ auf Quellzeilen und ohne Quelltext	eigener Debugger (z. B. x64dbg)
Debug Windows programs	✓ on source lines and without source	separate debugger (e.g. x64dbg)
DOS-Programme debuggen	✓ QEMU + FreeDOS, startet von selbst	Emulator mit eigenem Debugger, von Hand eingerichtet
Debug DOS programs	✓ QEMU + FreeDOS, starts by itself	emulator with its own debugger, set up by hand
ARM-Linux-Programme debuggen	✓ Gast wird per Skript eingerichtet	QEMU, gdbserver und gdb von Hand
Debug ARM Linux programs	✓ the guest is set up by a script	QEMU, gdbserver and gdb by hand
Windows-on-ARM-Programme debuggen	✓ Server `asmodbg` auf dem ARM-Rechner, Steuerung aus Dismonite	Remote-Debugger und Entwicklungsumgebung auf dem ARM-Rechner einrichten
Debug Windows on ARM programs	✓ server `asmodbg` on the ARM computer, controlled from Dismonite	set up a remote debugger and a development environment on the ARM computer
x64- und ARM64-Programme	✓ Assembler, Disassembler mit Export und Debugger	getrennte Werkzeuge je Architektur
x64 and ARM64 programs	✓ assembler, disassembler with export and debugger	separate tools per architecture
Befehle nachschlagen	✓ `F1` auf der Zeile: Befehl, Windows-Funktion, Interrupt, Fehlermeldung	Handbuch oder Suchmaschine in einem anderen Fenster
Look instructions up	✓ `F1` on the line: instruction, Windows function, interrupt, error message	manual or search engine in another window
Disassemblieren	✓ Export, der wieder dieselbe Datei ergibt	Disassembler; der Export muss meist nachbearbeitet werden
Disassemble	✓ export that gives the same file again	disassembler; the export usually needs rework
Installation	✓ keine – ein ZIP, unter 2 MB	mehrere Programme
Installation	✓ none – one ZIP, under 2 MB	several programs

Was Asmonite (noch) nicht kann

What Asmonite does not do (yet)

x64: kein AVX (VEX/EVEX) – diese Befehle bleiben Daten; ARM64: kein SVE und SME
x64: no AVX (VEX/EVEX) – those instructions stay data; ARM64: no SVE and SME
Keine x87-Gleitkommabefehle im Assembler; der Disassembler zeigt sie ohne Namen
No x87 floating point instructions in the assembler; the disassembler shows them without names
ARM32: Der Assembler schreibt Thumb-2, noch kein NEON; ARM64 wird mit NEON und Krypto-Befehlen übersetzt
ARM32: the assembler writes Thumb-2, no NEON yet; ARM64 is assembled with NEON and crypto instructions
Beim Debuggen von x64- und ARM64-Programmen kann das Programm noch keine Tastatureingabe lesen
When debugging x64 and ARM64 programs the program cannot read keyboard input yet
Windows on ARM: Das Debuggen braucht einen Rechner, der 32-Bit-ARM-Programme noch ausführt (Windows 10 auf ARM); Windows 11 ab 24H2 tut das nicht mehr
Windows on ARM: debugging needs a computer that still runs 32-bit ARM programs (Windows 10 on ARM); Windows 11 from 24H2 on no longer does
Kein Decompiler – Dismonite zeigt Maschinencode, keinen C-Quelltext
No decompiler – Dismonite shows machine code, not C source
Die Programmoberfläche ist englisch; die Dokumentation gibt es auf Deutsch und Englisch
The user interface is English; the documentation is in German and English

Taste	Asmonite und Dismonite
`F1`	Befehlsinfo: Befehl, Funktion, Interrupt, Direktive, Fehlermeldung	Instruction info: instruction, function, interrupt, directive, error message
`F5`	Haltepunkt umschalten	Toggle breakpoint
`F9`	Starten / Fortsetzen	Start / continue
`F8` / `F7`	Step Over / Step Into	Step over / step into
`F4`	Run to Cursor	Run to cursor
`Strg`+`F2`	Debug-Sitzung beenden	End the debug session
`Strg`+`F9`	Assemblieren (nur Asmonite)	Assemble (Asmonite only)
`Strg`+`F` · `F3`	Suchen · weitersuchen	Find · find next
`Strg`+`H`	Ersetzen (Asmonite)	Replace (Asmonite)
`Strg`+`G`	Gehe zu Zeile (Asmonite) / Adresse (Dismonite)	Go to line (Asmonite) / address (Dismonite)
`Strg`+`Z` / `Strg`+`Y`	Rückgängig / Wiederholen (Asmonite)	Undo / redo (Asmonite)

Taste	Dismonite
`C`	als Code markieren	mark as code
`B` `W` `D` `Q`	Byte, Word, Dword, Qword	byte, word, dword, qword
`A` / `U`	ASCII- / UTF-16-Text	ASCII / UTF-16 text
`;` / `Enter`	Kommentar / Kommentarzeile davor	Comment / comment line before
`N`	Label umbenennen	Rename label
`Strg`+`R`	Verweise auf diese Stelle	References to this place
`Strg`+`F3`	nächster Text	Next string
`Alt`+`←` / `Alt`+`→`	zurück / vor	Back / forward

Download

Ein ZIP-Archiv – entpacken und starten, ohne Installation.

One ZIP archive – unpack and start, no installation.

Testversion – Rückmeldungen willkommen

Test version – feedback welcome

Asmonite 0.5.0

Asmonite (Editor, Assembler, Debugger), Dismonite (Disassembler und Debugger), asmoc (Assembler auf der Kommandozeile), die QEMU-Skripte für FreeDOS und Raspberry Pi OS, die Debug-Server asmodbg, asmodbg64 und asmodbgx64 (Windows on ARM, ARM64, x64), die Befehlsinfo (Deutsch und Englisch) und Beispiele für Windows (x86, x64), DOS und ARM (Thumb-2, ARM64).

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 (ab 1809) / 11 Windows 10 (1809 or later) / 11 Programm: Englisch · Dokumentation: Deutsch / Englisch Program: English · documentation: German / English 2.0 MB Stand: 2026-10-14 Date: 2026-10-14

SHA-256: bda76827994d5d897c1c670ff2e5e7d4df230d724d27d6001fd8ceceba262ec6

Lizenz (Freeware)License (freeware)

⬇ HerunterladenDownload

Was die Programme tun – und was nicht

What the programs do – and what not

Keine Installation, keine Einträge in der Registry: Asmonite merkt sich seine Einstellungen in Asmonite.ini neben der EXE, Dismonite seine Markierungen in <programm>.dmon neben dem untersuchten Programm.
Keine Telemetrie, keine Werbung, kein Kontakt nach Hause.
Ins Netz gehen nur die QEMU-Skripte – und nur nach Rückfrage: QEMU (winget), die FreeDOS-Diskette, Raspberry Pi OS. Dismonite spricht per ssh nur mit dem eigenen Gast auf 127.0.0.1. Zum Debuggen auf Windows on ARM verbindet es sich nur mit dem Rechner, den du angibst; „Search LAN“ fragt dafür einmalig per UDP im lokalen Netz.
Zum Löschen genügt es, den Ordner zu löschen.

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.

Den Download prüfen

Check the download

Die Prüfsumme in der Eingabeaufforderung: certutil -hashfile Asmonite-0.5.0.zip SHA256 – sie muss mit dem Wert oben übereinstimmen.
Die Programme sind nicht signiert. Windows fragt deshalb beim ersten Start evtl. nach („Der Computer wurde durch Windows geschützt“ → „Weitere Informationen“ → „Trotzdem ausführen“).
Fragen, Fehler, Wünsche: mail@asmonite.com

The checksum in a command prompt: certutil -hashfile Asmonite-0.5.0.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”).
Questions, bugs, wishes: mail@asmonite.com

Taste	Asmonite und Dismonite
Key	Asmonite and Dismonite
`F1`	Befehlsinfo: Befehl, Funktion, Interrupt, Direktive, Fehlermeldung	Instruction info: instruction, function, interrupt, directive, error message
`F5`	Haltepunkt umschalten	Toggle breakpoint
`F9`	Starten / Fortsetzen	Start / continue
`F8` / `F7`	Step Over / Step Into	Step over / step into
`F4`	Run to Cursor	Run to cursor
`Strg`+`F2`	Debug-Sitzung beenden	End the debug session
`Strg`+`F9`	Assemblieren (nur Asmonite)	Assemble (Asmonite only)
`Strg`+`F` · `F3`	Suchen · weitersuchen	Find · find next
`Strg`+`H`	Ersetzen (Asmonite)	Replace (Asmonite)
`Strg`+`G`	Gehe zu Zeile (Asmonite) / Adresse (Dismonite)	Go to line (Asmonite) / address (Dismonite)
`Strg`+`Z` / `Strg`+`Y`	Rückgängig / Wiederholen (Asmonite)	Undo / redo (Asmonite)

Asmonite – Assembler, Debugger und Disassembler in einem Paket

Asmonite – assembler, debugger and disassembler in one package

Was drin ist

What's inside

Editor und Assembler

Editor and assembler

PE-Prüfung

PE validation

Debugger auf Quellzeilen

Source-level debugger

DOS-Programme in QEMU

DOS programs in QEMU

Disassembler mit Rückweg

Disassembler with a way back

ARM-Linux-Programme debuggen

Debug ARM Linux programs

Befehlsinfo auf F1

Instruction info on F1

ARM-Assembler (Thumb-2)

ARM assembler (Thumb-2)

Windows on ARM debuggen

Debug Windows on ARM

x64- und ARM64-Assembler

x64 and ARM64 assembler

x64 und ARM64 debuggen

Debug x64 and ARM64

Ressourcen und Meldungstexte

Resources and message texts

Läuft auf – und debuggt

Runs on – and debugs

Für wen ist Asmonite?

Who is Asmonite for?

Assembler lernen

Learning assembly

x86-, x64- und ARM64-Entwicklung

x86, x64 and ARM64 development

Programme untersuchen

Examining programs

Retro und Embedded

Retro and embedded

In 60 Sekunden

In 60 seconds

Asmonite – der EditorAsmonite – the editor

Asmonite – der Debugger

Asmonite – the debugger

Windows-Programme

Windows programs

DOS-Programme in QEMU

DOS programs in QEMU

x64- und ARM64-Programme

x64 and ARM64 programs

Befehlsinfo – F1

Instruction info – F1

Dismonite – Disassembler und DebuggerDismonite – disassembler and debugger

Von der EXE zurück zum Quelltext

From the EXE back to source

Der Debugger in Dismonite

The debugger in Dismonite

Windows (PE)

DOS (MZ)

ARM-Linux (ELF)

Windows on ARM (PE)

x64 (PE32+)

ARM64 (PE)

Ein Paket statt einer Werkzeugkette

One package instead of a tool chain

Was Asmonite (noch) nicht kann

What Asmonite does not do (yet)

Tastenkürzel

Keyboard shortcuts

Download

Download

Asmonite 0.5.0

Was die Programme tun – und was nicht

What the programs do – and what not

Den Download prüfen

Check the download

Befehlsinfo – `F1`

Instruction info – `F1`