Skip to content
| Marketplace
Sign in
Visual Studio Code>Programming Languages>Struktograf – Nassi-Shneiderman DiagramsNew to Visual Studio Code? Get it now.
Struktograf – Nassi-Shneiderman Diagrams

Struktograf – Nassi-Shneiderman Diagrams

Preview

Uranolith

|
5 installs
| (0) | Free
Draw Nassi-Shneiderman diagrams (structograms), run them step by step and turn them into code – and back: Python, Java, C, C++, C#, JavaScript/TypeScript, Pascal, Kotlin and Rust. Structorizer compatible (.nsd, full command set incl. Turtleizer), optionally with the original Structorizer (18 target
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

Struktograf – Nassi-Shneiderman-Struktogramme für VS Code

Struktogramm-Editor im Stil von Structorizer, direkt in VS Code.

Preview. Die Extension ist im VS Code Marketplace veröffentlicht, befindet sich aber noch in aktiver Entwicklung.

Installation

Voraussetzung: VS Code 1.80 oder neuer. Java 11+ wird nur für die optionalen Original-Structorizer-Funktionen gebraucht.

  • In VS Code die Ansicht Erweiterungen öffnen (Strg+Umschalt+X), nach Struktograf suchen und Installieren klicken.
  • Oder im Terminal:
    code --install-extension Uranolith.struktogramm
    
  • Oder über die Marketplace-Seite.

Updates installiert VS Code automatisch. Deinstallieren geht über Erweiterungen → Struktograf → Deinstallieren oder mit code --uninstall-extension Uranolith.struktogramm.

Funktionen

  • Neues Struktogramm: Datei → Neue Datei... → Neues Struktogramm..., Rechtsklick auf einen Ordner im Explorer, das Symbol oben in der Explorer-Leiste oder Neues Struktogramm... in der Werkzeug-Ansicht Struktograf. Nach Eingabe des Namens öffnet sich die neue .nsd-Datei mit einem leeren Hauptprogramm.
  • Sprache: Oberfläche auf Englisch oder Deutsch, je nach Anzeigesprache von VS Code (Configure Display Language).
  • Arbeitsbereich: Die Werkzeuge stehen in der Ansicht Struktograf (Symbol links in der Aktivitätsleiste), die Ausführung (Konsole, Eingabe, Turtleizer, Variablen) im Panel Struktograf unten neben Probleme und Ausgabe. Wer beides lieber direkt im Editor hat, stellt struktogramm.toolbarLocation bzw. struktogramm.executionPanelLocation auf editor – oder schaltet live über die Knöpfe in den Titelleisten um. Die Kategorien der Werkzeug-Ansicht lassen sich ein- und ausklappen und per Drag & Drop (oder Alt+↑/↓) umsortieren.
  • Code → Struktogramm: Python, Java, C, C++, C#, JavaScript, TypeScript, Kotlin, Rust (Rechtsklick im Editor → Struktogramm aus Code erzeugen; mit Markierung nur der markierte Teil). Jede Funktion wird ein eigenes Diagramm, main bzw. Code auf oberster Ebene wird das Hauptprogramm.
  • Live-Vorschau: Symbol oben rechts im Code-Editor – das Struktogramm aktualisiert sich beim Tippen.
  • Grafischer Editor für .nsd-Dateien: Elemente einfügen, bearbeiten (Doppelklick), ziehen, kopieren/einfügen, Kontextmenü, Farben, Kommentare, Rückgängig.
  • Struktogramm → Code: Python, Java, C, C++, C#, JavaScript (Node.js), Pascal, Kotlin, Rust.
    • Live-Code: Der erzeugte Code öffnet sich als ungespeichertes Dokument und folgt jeder Änderung am Struktogramm. In der Statusleiste steht dann Live: datei.nsd. Die Verbindung endet, sobald du den Code speicherst, selbst bearbeitest oder schließt; ein Klick auf die Statusanzeige beendet sie sofort. Das gilt für die eigene Übersetzung, nicht für die Structorizer-Generatoren.
    • Kotlin: readln() für Eingaben, String-Templates für Ausgaben, IntArray/intArrayOf, when, downTo/step.
    • Rust: println!, eine kleine read_line()-Hilfsfunktion für Eingaben, Vec, match, loop; ganze Zahlen werden in Rechnungen mit Kommazahlen automatisch als 2.0 geschrieben.
  • Ausführen (wie der Structorizer-Executor): Ausführen, Einzelschritt, Anhalten, Beenden; Tempo langsam (400 ms), mittel (200 ms), schnell (50 ms) oder sofort; Haltepunkte (F9 oder Rechtsklick). Das gerade ausgeführte Element ist markiert und bleibt im Bild, Fehler werden am Element rot markiert. Unterprogramme und Rekursion werden unterstützt; funktioniert auch in der Live-Vorschau von Quelltext.
    • Konsole mit Ein- und Ausgabe (bei INPUT steht der Cursor direkt im Eingabefeld), daneben die Turtleizer-Zeichnung.
    • Reiter Variablen: laufende Aufrufe und darunter alle abgeschlossenen Aufrufe mit Endzustand und Rückgabewert; mehrfache Aufrufe sind nummeriert (summe [#1](https://github.com/Uranolith/struktogramm-vscode/issues/1), summe [#2](https://github.com/Uranolith/struktogramm-vscode/issues/2) …).
    • Reiter Aufrufe: Aufrufstapel und Aufrufverlauf als Baum mit Argumenten und Rückgabewerten; ein Klick springt zu den Variablen des Aufrufs.
  • Original-Structorizer (optional, benötigt Java 11+): wird beim ersten Gebrauch von GitHub heruntergeladen (Befehl Structorizer herunterladen oder einrichten...).
    • Code aus Struktogramm erzeugen... bietet zusätzlich alle 18 Structorizer-Generatoren an (u.a. PHP, Perl, BASIC, Bash, Oberon, Delphi, LaTeX/StrucTeX).
    • Pascal/Delphi-, COBOL- und Processing-Dateien werden mit dem Structorizer-Parser eingelesen; für C/Java gibt es Struktogramm aus Code erzeugen (Structorizer-Parser).
    • Im Structorizer öffnen startet die Structorizer-Oberfläche mit dem Diagramm.
  • Export als SVG, PNG, JSON, XML, KI-kompakter Pseudocode und einzelne Structorizer-Dateien (siehe Export).
  • Structorizer-kompatibel: liest und schreibt .nsd (XML) in Structorizer-Schreibweise. Eine Datei mit einem Diagramm öffnet der Structorizer direkt. Dateien mit mehreren Diagrammen (z.B. nach einem Code-Import mit Funktionen) kann der Structorizer nicht lesen. Teile sie mit Diagramme einzeln als Structorizer-Dateien speichern auf.

Schreibweise im Struktogramm

Die Diagramme verwenden die Schreibweise des Original-Structorizers: Zuweisung :=, Vergleich = und <>. Eine .nsd-Datei mit einem Diagramm lässt sich daher unverändert im Structorizer öffnen.

Andere Schreibweisen werden beim Speichern automatisch umgestellt: x = 5 und x <- 5 werden zu x := 5, == wird zu =, != zu <>. Das gilt für Eingaben im Editor, für Code-Importe und für Dateien älterer Versionen dieser Extension.

Geteilt wird immer mit /. Zwischen zwei ganzen Zahlen rechnet / ganzzahlig (7 / 2 ergibt 3). Ein div aus importiertem Code wird zu /.

Element Beispiel
Zuweisung x := 5
Deklaration var x: int · var x: int := 0 · const MAX := 10
Eingabe / Ausgabe INPUT "Zahl: ", x · OUTPUT "Summe: ", s
Bedingung x > 3 and y <> 0 · Vergleich x = 0
Zählschleife for i := 1 to 10 by 2 · foreach x in liste
Kopf-/Fußschleife while x > 0 · until x = 0
Fallauswahl 1. Zeile Ausdruck, dann je Fall eine Zeile, letzte Zeile default (oder %)
Sprung leave · leave 2 (zwei Schleifen) · return x · exit 0 · throw "Fehler"
Try Element Try: Text = Name der Fehlervariable; Blöcke try, catch fehler, finally
Typdefinition type Punkt = record{x: int; y: int} · type Farbe = enum{ROT, GRUEN = 5, BLAU}
Record p := Punkt{x: 3, y: 4} · var q: Punkt · q.x := 7
Prozeduren inc(x) · dec(x, 2) · insert("ab", s, 3) · delete(s, 1, 2) · randomize()

Befehlssatz des Structorizers

Ausführung, Hervorhebung und Autovervollständigung kennen den Befehlssatz des Original-Structorizers (Executor und Turtleizer):

Bereich Befehle
Mathematik abs min max round ceil floor sgn signum sqr sqrt exp log pow sin cos tan asin acos atan toRadians toDegrees random(n) randomize()
Zeichenketten length pos copy insert delete lowercase uppercase trim split strcmp ord chr
Prüfen / Kopieren isArray isString isChar isBool isNumber copyArray copyRecord
Prozeduren inc(x) inc(x, d) dec(x) dec(x, d) insert(w, s, i) delete(s, i, n)
Dateien fileOpen fileCreate fileAppend fileClose fileEOF fileRead fileReadChar fileReadInt fileReadDouble fileReadLine fileWrite fileWriteLine – relative Pfade gelten ab dem Ordner der .nsd-Datei
Turtleizer forward backward left right gotoXY gotoX gotoY penUp penDown hideTurtle showTurtle setPenColor(r, g, b) setBackground(r, g, b) clear getX getY getOrientation – die Zeichnung erscheint neben der Konsole
Elemente Anweisung, Verzweigung, Fallauswahl, Zähl-/Kopf-/Fuß-/Endlosschleife, Aufruf, Sprung, Try, Parallel; eingebundene Diagramme (includeList von Includable-Diagrammen)

Beim Erzeugen von Code werden diese Befehle in die Zielsprache übersetzt, z.B. uppercase(s) → s.upper() (Python) / s.toUpperCase() (Java), try → try/catch/finally (in C mit setjmp, in Rust mit catch_unwind), Records → Klassen/Structs, leave 2 → break L1 bzw. goto. Turtle-Befehle werden für Python in das Modul turtle übersetzt; die Datei-API wird nur ausgeführt, nicht übersetzt.

Parallelverarbeitung wird zu echten Threads: Python threading, Java je Zweig eine Thread-Klasse, C# Parallel.Invoke, C++ std::thread, C OpenMP (#pragma omp parallel sections, mit -fopenmp übersetzen), Kotlin thread { }, Rust std::thread::scope, Pascal BeginThread. Das Programm wartet, bis alle Zweige fertig sind. In Java arbeitet jeder Zweig mit Kopien der Variablen, geänderte Werte werden danach übernommen. Beim Ausführen im Editor laufen die Zweige dagegen nacheinander. Ein Beispiel mit allen Elementen, Rekursion und Parallelverarbeitung ist test/samples/gesamttest.nsd.

Schlüsselwörter (blau, fett), Funktionsaufrufe (dunkelgelb, fett), Datentypen (petrol), Zeichenketten (rot), Operatoren (lila, fett: Zuweisung :=, Vergleiche = <> < > ≤ ≥, Rechnen + - * / % mod) werden im Diagramm farbig dargestellt; abschalten mit der Einstellung struktogramm.highlightKeywords.

Hell / Dunkel

Das Struktogramm passt sich dem VS-Code-Farbschema an: bei einem dunklen Theme wird es dunkel dargestellt, sonst hell (Einstellung struktogramm.theme: auto, light, dark). Elementfarben werden im dunklen Schema als dunkle Variante desselben Farbtons gezeigt. Beim Export als SVG oder PNG wird gefragt, ob das Bild hell oder dunkel werden soll (struktogramm.exportTheme: ask, editor, light, dark).

Export

Exportieren... (Werkzeug-Ansicht, Titelleiste des Editors, Explorer-Kontextmenü) bietet:

Format Zweck
SVG / PNG Bild, hell oder dunkel
JSON vollständige Struktur (diagrams[].body[] mit type, text, condition, then/else, body, branches …)
XML dieselbe Struktur als einfaches XML (<if><condition/><then/><else/></if> …)
KI-kompakt token-sparender Pseudocode für KI-Agents – in die Zwischenablage oder als .ki.txt (Menü Exportieren... oder Befehl KI-Pseudocode in die Zwischenablage kopieren)
Structorizer-Dateien je Diagramm eine .nsd für den Original-Structorizer

KI-kompakt nutzt Einrückung mit einem Leerzeichen statt Klammern/Tags und ist etwa 6–8× kürzer als JSON:

PROGRAM rechner
INPUT "Zahl: ", zahl
for i := 1 to zahl
 s := s + i
if ist_prim(zahl)
 OUTPUT zahl, " ist prim"
else
 OUTPUT "nein"
FUNCTION summe(a: int; b: int): int # Addiert zwei Zahlen.
return a + b

Tastatur im Editor

F5 ausführen / fortsetzen · F10 (oder F11) Einzelschritt · F6 anhalten · Umschalt+F5 beenden · F9 Haltepunkt. Im Explorer: Rechtsklick auf eine .nsd → Ausführen oder fortsetzen. Läuft oder pausiert eine Ausführung, wirken diese Tasten überall in VS Code. Hat die aktive Datei keinen eigenen Debugger, startet F5 das geöffnete Struktogramm; in der Debugger-Auswahl von VS Code steht ▶ Struktogramm ausführen (Struktograf) ganz oben.

Der Editor ist vollständig per Tastatur bedienbar; ? zeigt alle Tastenkürzel.

Taste Wirkung
↑ / ↓ vorheriges / nächstes Element (am Blockende weiter hinter dem umgebenden Element)
→ / ← in den ersten Block hinein / zum umgebenden Element
Strg + → / ← nächster / vorheriger Zweig: Ja/Nein, Fälle, try/catch/finally, parallele Zweige
Pos1 / Ende · Bild ↑ / ↓ erstes / letztes Element im Block · vorheriges / nächstes Diagramm
Enter / F2 bearbeiten (im leeren Block: Anweisung einfügen)
Strg+Enter / Einfg Einfügen mit Vorschau: An der Einfügestelle öffnet sich eine Auswahl; Tippen filtert nach Name, Kürzel oder Stichwort (I Anweisung, V Verzweigung, F Fallauswahl, Z Zählschleife, K Kopfschleife, U Fußschleife, E Endlosschleife, A Aufruf, S Sprung, T Try, P Parallel – oder if, while, try …). Das gewählte Element erscheint gestrichelt als Vorschau im Diagramm. ↑/↓ wählt, Enter fügt ein, ein weiteres Enter öffnet die Detailbearbeitung, Esc bricht ab. Strg+Umschalt+Enter bzw. Umschalt+Einfg fügt davor ein.
Umschalt+F10 / Menütaste Kontextmenü (Umschließen, Deaktivieren …) – Menüs mit ↑/↓, Enter, →/←, Esc
Leertaste Element aktivieren / deaktivieren
Entf · Strg+↑/↓ · Strg+C/X/V löschen · verschieben · kopieren/ausschneiden/einfügen
Strg + + / − / 0 · Strg+Mausrad Zoom
Tab Werkzeugleiste und Ausführungsbereich erreichen, sofern sie im Editor angezeigt werden; Esc in der Konsoleneingabe springt zurück ins Diagramm

Die Statusleiste nennt das ausgewählte Element samt Zweig (z.B. „Anweisung: y := 1 · Nein-Zweig“) und wird von Screenreadern vorgelesen. Nach dem Einfügen öffnet sich der Bearbeiten-Dialog; nach dem Schließen ist der Fokus wieder im Diagramm. Mit der Maus: Shift+Klick auf einen Einfüge-Knopf der Editor-Werkzeugleiste fügt davor ein; in der Werkzeug-Ansicht legen die Knöpfe Danach / Davor einfügen die Position fest.

Im Bearbeiten-Dialog lässt sich der Elementtyp wechseln (z.B. Kopfschleife → Fußschleife, Verzweigung → Fallauswahl, Anweisung → Aufruf). Enthaltene Elemente bleiben erhalten: Sie wandern in den ersten Block des neuen Elements oder stehen – bei einer einfachen Anweisung – direkt dahinter. Bedingungen werden passend umgeformt (while x > 0 → until x <= 0).

Im Bearbeiten-Dialog schlägt die Autovervollständigung passend zur Stelle vor (↑/↓ auswählen, Tab/Enter übernehmen, Esc schließt, Strg+Leertaste öffnet von Hand):

Stelle Vorschläge
Zeilenanfang einer Anweisung INPUT, OUTPUT, var, const, type, dann Variablen, Unterprogramme und Prozeduren (inc, forward …)
nach var name: nur Datentypen (int, double, string …) – Liste öffnet sich von selbst
nach var nichts (neuer Name)
nach INPUT nur Variablen
in Ausdrücken (x := …, OUTPUT …, Bedingungen) Variablen, Unterprogramme, Funktionen wie int(), sqrt(), true/false/not
nach einem Wert + Leerzeichen and, or, mod – in Zählschleifen to/by, bei foreach in
Sprung / Zählschleife / Fußschleife leave, return, exit … / for, foreach / until

Grenzen

Es ist kein vollständiger Compiler: Klassen, Zeiger und Bibliotheksaufrufe werden vereinfacht oder unverändert übernommen; von mehreren catch-Zweigen wird nur der erste übernommen. Variablentypen werden – wo nötig – geschätzt. String-Verkettung mit + lässt sich nicht nach C übersetzen. Bei Kotlin und Rust werden Klassen, impl-Blöcke, Lambdas/Closures und Ownership vereinfacht; im erzeugten Rust-Code werden Zeichenketten und Arrays bei Funktionsaufrufen mit .clone() übergeben.

Parallelverarbeitung im erzeugten Code:

  • Rust lässt nicht zu, dass ein Zweig eine Variable ändert, die ein anderer Zweig verwendet – der Compiler meldet dann einen Fehler (das wäre ein Datenwettlauf).
  • Pascal erzeugt Threads nur im Hauptprogramm; in Unterprogrammen laufen die Zweige nacheinander, weil Thread-Funktionen nur globale Variablen sehen. Felder brauchen Free Pascal ab 3.2.
  • JavaScript kennt keine Threads mit gemeinsamen Variablen, die Zweige laufen nacheinander. Für INPUT braucht der erzeugte Code das Paket prompt-sync (npm install prompt-sync), das in einem Terminal laufen muss.
  • C braucht -fopenmp, sonst laufen die Zweige nacheinander.

Entwicklung

node test/sprachtest.js führt test/samples/gesamttest.nsd mit dem eingebauten Interpreter aus, erzeugt Code für alle Zielsprachen, übersetzt und startet ihn und vergleicht die Ausgaben. Sprachen ohne installierten Compiler werden übersprungen; ein anderes Struktogramm und die Eingabe lassen sich angeben (node test/sprachtest.js datei.nsd --input 3 python rust).

Lizenz

Diese Extension steht unter der MIT-Lizenz. Structorizer (© Bob Fisch, Kay Gürtzig u.a.) ist ein eigenständiges Programm unter GPL-3.0 (https://github.com/fesch/Structorizer.Desktop); es wird nicht mitgeliefert, sondern nur auf Wunsch heruntergeladen und als separates Programm aufgerufen. Das Symbol „Neues Struktogramm“ (media/struktograf-icons.woff) übernimmt den Kreis mit Plus aus den Codicons von Microsoft (CC BY 4.0); erzeugt mit docs/build-icon-font.py.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft