Für Windows · Ziele: Windows (x86, x64, ARM, ARM64), DOS, ARM-Linux

Asmonite – Assembler, Debugger und Disassembler in einem Paket

Schreiben. Assemblieren. Debuggen. Disassemblieren.

Zwei kleine, portable Programme statt einer Werkzeugkette: Asmonite zum Schreiben, Übersetzen und Debuggen von Assembler (x86, x64, ARM32/Thumb-2 und ARM64/AArch64), Dismonite zum Untersuchen und Debuggen ausführbarer Dateien – Windows (PE für x86, x64, ARM32 und ARM64/AArch64), DOS (MZ) und ARM-Linux (ELF). Mit eingebauter Befehlsinfo auf F1. Entpacken, starten, fertig.

⬇ Herunterladen In 60 Sekunden ausprobieren

Version 0.7.6 (Testversion) · Windows 10/11 · 2.1 MB · keine Installation · kostenlos · kein Tracking

Asmonite: the debugger stopped at a breakpoint, registers, stack and memory on the right, the output below the code
Asmonite: Quelltext und Haltepunkt, rechts Register, Stack und Speicher, darunter die Programmausgabe – alles in einem Fenster, debuggen, wo der Code geschrieben wird.

Was drin ist

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

📝

Editor und Assembler

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

Asmonite
🛡️

PE-Prüfung

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

Asmonite
🐞

Debugger auf Quellzeilen

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

Asmonite
💾

DOS-Programme in QEMU

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

Asmonite · Dismonite
🔍

Disassembler mit Rückweg

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

Dismonite
🍓

ARM-Linux-Programme debuggen

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.

Dismonite
💡

Befehlsinfo auf F1

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

Asmonite · Dismonite
🧩

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.

Asmonite · Dismonite
🖥️

Windows on ARM debuggen

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
🧮

x64- und 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.

Asmonite
🚀

x64 und ARM64 debuggen

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.

Asmonite · Dismonite
🗂️

Ressourcen und Meldungstexte

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

Läuft auf – und debuggt

Läuft auf (Host)Programme, die man damit baut oder untersucht (Ziel)
AsmoniteWindows 10/11, 32 oder 64 BitWindows (PE, PE32+) aus i386-, x64- und ARM64-Assembler; DOS-Programme in QEMU; ARM-Thumb-2-Code schreiben
DismoniteWindows 10/11, 32 oder 64 BitWindows PE (x86, x64, ARM, ARM64), DOS MZ (16 Bit), ARM-Linux ELF (32 Bit)
asmodbgWindows 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
asmodbg64Windows on ARM64 (läuft dort, wo das ARM64-Programm läuft)ARM64-Programme (PE), von Asmonite und Dismonite über ssh oder im Netz gesteuert
asmodbgx6464-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
QEMU64-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)

Für wen ist Asmonite?

Für alle, die verstehen wollen, was der Prozessor wirklich tut – vom ersten mov bis zur fremden EXE.

🎓

Assembler lernen

  • Programm schreiben, F9, fertig
  • Schritt für Schritt durch den Code
  • Register und Flags ändern sich sichtbar
  • Stack und Speicher verstehen
  • F1 erklärt jede Zeile
⚙️

x86-, x64- und ARM64-Entwicklung

  • Assembler mit PE-Ausgabe (auch PE32+), Importtabelle inklusive
  • PE-Prüfung vor jedem Start
  • schneller Kreislauf: ändern, übersetzen, debuggen
  • asmoc für die Kommandozeile
🔬

Programme untersuchen

  • PE-, MZ- und ELF-Strukturen mit Feldnamen
  • Code ab Einsprung und Exporten verfolgen
  • markieren, kommentieren, umbenennen
  • Export als übersetzbares .asm
🕹️

Retro und Embedded

  • DOS-Programme in FreeDOS debuggen
  • 16-Bit-Register, Segment:Offset
  • ARM-Programme im Raspberry-Pi-Gast oder auf Windows on ARM
  • DOS und ARM lokal in QEMU

In 60 Sekunden

Vom ZIP zum ersten Haltepunkt – mit dem mitgelieferten Beispiel.

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

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

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

Asmonite – der Editor

Übersichtlich, schnell und auf Assembler zugeschnitten.

  • Syntax-Hervorhebung für x86-Assembler (Intel-Syntax), C und Pascal
  • Gutter mit Zeilennummern, Haltepunkten und Ausführungszeile
  • Rückgängig/Wiederholen – zusammenhängendes Tippen zählt als ein Schritt
  • x86 und ARM in einer Datei: nach .arch thumb färbt der Editor die Zeilen als ARM
  • Suchen und Ersetzen – vorwärts, rückwärts, ganzes Wort, „Alle ersetzen“ als ein Rückgängig-Schritt
  • Assembler: .format pe erzeugt Header und Importtabelle, oder jedes Byte selbst im Quelltext
  • Eigene Editor-Komponente, keine Fremdbibliotheken
  • Befehlsinfo auf F1 in der Spalte rechts – siehe unten
Asmonite: editor with an assembler program
Der Editor mit einem kleinen Programm: Schleife, Aufruf von printf über die Importtabelle.

Asmonite – der Debugger

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

Windows-Programme

  • Haltepunkte (auch während das Programm läuft), Step Over/Into, Run to Cursor, Pause, Stop
  • Register mit Flags; geänderte Werte sind rot
  • Stack: 32 Doppelwörter ab ESP, mit Hinweisen auf Label und Codezeile
  • Speicher: Hexdump ab Adresse, Label oder esp/ebp/eip
  • Programmausgabe live im Ausgabefenster; Ladefehler als verständliche Meldung

DOS-Programme in QEMU

  • Start in QEMU mit FreeDOS – QEMU startet von selbst
  • Haltepunkte, Step Over/Into, Run to Cursor und Pause auf Quellzeilen
  • Register, Stack (SS:SP) und Speicher (Segment:Offset) in 16 Bit
  • Bildschirmausgabe bei jedem Halt und am Ende im Output
  • Erneuter Start im laufenden QEMU, ohne neues Booten
  • Beispiele: hello.com.asm und hello_exe.asm – Hello World als .COM und als .EXE, mit Erklärung des Unterschieds

x64- und ARM64-Programme

  • Ein Programm mit .arch x64 startet mit F9 auf diesem Rechner, mit .arch arm64 auf einem Windows-on-ARM-Rechner
  • ARM64: ssh, direkt im Netz oder lokal; das Ziel unter Debug > Debug target Windows on ARM
  • Haltepunkte, Step Over/Into, Run to Cursor und Pause auf Quellzeilen
  • Register rax…r15 bzw. x0…x30 mit Flags, Stack als 64-Bit-Werte, Speicher mit 64-Bit-Adressen
  • Noch nicht: Tastatureingabe für das Programm

Befehlsinfo – F1

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

  • Befehle (x86 und ARM Thumb-2): Syntax, erlaubte Operanden, Flags und ein Beispiel
  • 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 …)
  • DOS- und BIOS-Interrupts: bei int 21h die Funktion, deren Nummer die Info in den Zeilen davor findet, mit Ein- und Ausgaberegistern
  • Direktiven: .arch, .format, .import, section und die anderen Besonderheiten des Assemblers
  • 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
  • Deutsch und Englisch, umschaltbar im Menü Help; ohne Auswahl richtet sich die Sprache nach Windows
  • In Dismonite stehen dieselben Texte im Reiter Info; sie folgen dem Cursor, wenn man es nicht abschaltet
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.
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.

Dismonite – Disassembler und Debugger

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

Dismonite hat eine eigene Seite: dismonite.com

Von der EXE zurück zum Quelltext

EXEausführbare Datei
→
Dismoniteanalysieren, kommentieren
→
.asmmit Labels
→
asmocAssembler
→
EXEByte für Byte gleich
  • Analyse: verfolgt den Code ab Einsprung, Exporten und TLS-Callbacks (PE) bzw. CS:IP (MZ), dazu ab den Relokationszielen
  • Labels statt Adressen; Strg+Klick springt zum Ziel, Alt+← zurück
  • Dateistrukturen (PE-Header, Sections, Importe, Exporte, Ressourcen, ELF-Program-Header und -Symbole) mit Feldnamen als Kommentar
  • 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
  • Zeigt Adressen, Bytes, Befehl und Kommentar – auch bei großen Dateien (getestet bis 64 MB)
  • Elemente als Code, Byte, Word, Dword, Qword, ASCII oder UTF-16 markieren; Kommentare und Kommentarzeilen
  • Markierungen und Kommentare werden in <programm>.dmon neben dem Programm gespeichert
  • Export als .asm mit Labels, den der Asmonite-Assembler wieder zur selben Datei übersetzt
Dismonite: code at the entry point with labels
Nach der Analyse: der Code am Einsprungpunkt start, Sprungziele und Adressen als 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.

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

DOS (MZ)

Startet QEMU mit FreeDOS von selbst; 16-Bit-Register, Adressen als Segment:Offset. Ein zweiter Lauf startet im laufenden 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.

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.

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.

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.

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

Ein Paket statt einer Werkzeugkette

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.

AufgabeAsmonite + DismoniteÜbliche Werkzeugkette
Quelltext schreiben✓ Editor mit HervorhebungTexteditor
Übersetzen✓ eingebaut, dazu asmoceigenes Programm (z. B. NASM) und Linker
Windows-Programme debuggen✓ auf Quellzeilen und ohne Quelltexteigener Debugger (z. B. x64dbg)
DOS-Programme debuggen✓ QEMU + FreeDOS, startet von selbstEmulator mit eigenem Debugger, von Hand eingerichtet
ARM-Linux-Programme debuggen✓ Gast wird per Skript eingerichtetQEMU, gdbserver und gdb von Hand
Windows-on-ARM-Programme debuggen✓ Server asmodbg auf dem ARM-Rechner, Steuerung aus DismoniteRemote-Debugger und Entwicklungsumgebung auf dem ARM-Rechner einrichten
x64- und ARM64-Programme✓ Assembler, Disassembler mit Export und Debuggergetrennte Werkzeuge je Architektur
Befehle nachschlagen✓ F1 auf der Zeile: Befehl, Windows-Funktion, Interrupt, FehlermeldungHandbuch oder Suchmaschine in einem anderen Fenster
Disassemblieren✓ Export, der wieder dieselbe Datei ergibtDisassembler; der Export muss meist nachbearbeitet werden
Installation✓ keine – ein ZIP, unter 2 MBmehrere Programme

Was Asmonite (noch) nicht kann

Tastenkürzel

Die wichtigsten Befehle auf einen Blick. Die Debug-Tasten sind in beiden Programmen gleich.

TasteAsmonite und Dismonite
F1Befehlsinfo: Befehl, Funktion, Interrupt, Direktive, Fehlermeldung
F5Haltepunkt umschalten
F9Starten / Fortsetzen
F8 / F7Step Over / Step Into
F4Run to Cursor
Strg+F2Debug-Sitzung beenden
Strg+F9Assemblieren (nur Asmonite)
Strg+F · F3Suchen · weitersuchen
Strg+HErsetzen (Asmonite)
Strg+GGehe zu Zeile (Asmonite) / Adresse (Dismonite)
Strg+Z / Strg+YRückgängig / Wiederholen (Asmonite)
TasteDismonite
Cals Code markieren
B W D QByte, Word, Dword, Qword
A / UASCII- / UTF-16-Text
; / EnterKommentar / Kommentarzeile davor
NLabel umbenennen
Strg+RVerweise auf diese Stelle
Strg+F3nächster Text
Alt+← / Alt+→zurück / vor

Download

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

Testversion – Rückmeldungen willkommen

Asmonite 0.7.6

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

Windows 10 (ab 1809) / 11 Programm: Englisch · Dokumentation: Deutsch / Englisch 2.1 MB Stand: 2026-10-31
SHA-256: 2484d078507abefc2c0b2cd27c8bddaeb464dd6b329ee617369b41c22c10ef90
Lizenz (Freeware) Prüfung bei VirusTotal ↗
⬇ Herunterladen

Was die Programme tun – und was nicht

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

Den Download prüfen

  • Die Prüfsumme in der Eingabeaufforderung: certutil -hashfile Asmonite-0.7.6.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“).
  • Doku, Beispiele und alle Versionen auch auf GitHub.
  • Fragen, Fehler, Wünsche: mail@asmonite.com