Online Verilog Compiler

Code-Snippets schreiben, ausführen und teilen — keine Einrichtung nötig.

main.v

Klicken Sie auf Ausführen, um die Ausgabe hier zu sehen.

PlusargsLaufzeitparameter, die an den Simulator übergeben werden — lesen Sie sie in Ihrer Testbench mit $value$plusargs oder $test$plusargs aus.

SchlüsselWert

// 4-bit synchronous counter — DUT plus a small testbench.
// Edit the +PERIOD / +RUNTIME / +VERBOSE plusargs in the panel
// below and press Run. Output appears on the right; the Waveform
// tab plots the signals dumped by $dumpfile/$dumpvars.

module counter(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk or posedge reset) begin
        if (reset)
            count <= 4'b0;
        else
            count <= count + 1'b1;
    end
endmodule

module test;
    reg clk;
    reg reset;
    wire [3:0] count;

    integer period;    // half-period of the clock, in time units
    integer runtime;   // total simulation time
    reg     verbose;

    // Instantiate the device under test.
    counter dut(.clk(clk), .reset(reset), .count(count));

    // Free-running clock — the HDL idiom. Toggles every PERIOD time units.
    always #(period) clk = ~clk;

    // Print on every rising edge so stdout lines up with the waveform.
    always @(posedge clk) begin
        if (verbose)
            $display("t=%0t  count=%0d", $time, count);
    end

    initial begin
        // Make the Waveform tab work — VCD output is written here.
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        // Defaults; override from the plusargs panel below.
        if (!$value$plusargs("PERIOD=%d",  period))  period  = 5;
        if (!$value$plusargs("RUNTIME=%d", runtime)) runtime = 80;
        verbose = $test$plusargs("VERBOSE") != 0;

        clk   = 0;
        reset = 1;
        #(period * 2) reset = 0;
        #(runtime)    $finish;
    end
endmodule

Verilog HDL online schreiben, kompilieren und simulieren

Ein kostenloser Online-Verilog-Compiler und -Simulator. Schreib Verilog- oder SystemVerilog-Module, bau eine Testbench, klick auf Run und sieh dir stdout-Ausgabe plus die gerenderte VCD-Wellenform an. Keine Installation, kein Vivado, kein Quartus, keine Toolchain einzurichten. Der Editor öffnet mit einer getakteten Counter-Testbench, also kannst du in Sekunden bearbeiten und ausführen.

Der Code wird mit Icarus Verilog (iverilog) kompiliert und unter vvp in einem isolierten Container ausgeführt – du bekommst also echte Verilog-HDL-Semantik: getaktete always-Blöcke, nicht-blockierende Zuweisungen, hierarchische Modulinstanziierung, $display, $finish. Setz $dumpfile und $dumpvars in deine Testbench, und der Waveform-Tab rendert Ein-Bit-Signale und Mehrbit-Busse mit verschiebbarem Cursor, Übergängen und Wertangaben pro Signal. Plusargs (+KEY=VALUE / +FLAG) kommen über $value$plusargs und $test$plusargs in deiner Testbench an, sodass du Taktperiode, Laufzeit und Feature-Flags variieren kannst, ohne den Quellcode anzufassen.

Was diesen Verilog Compiler nützlich macht

Sofortiges Kompilieren und Simulieren — schreiben Sie Verilog HDL, klicken Sie auf Ausführen und sehen Sie die Standardausgabe und die VCD-Wellenformen in Sekunden.
Syntax-Hervorhebung für Verilog und SystemVerilog mit demselben Editor-Engine wie VS Code, mit module/endmodule-Scoping und Schlüsselwort-Autovervollständigung.
Eingebauter Wellenform-Viewer: Gib $dumpfile + $dumpvars in deiner Testbench aus, und der Tab Wellenform zeigt Signale, Busse, Übergänge sowie einen verschiebbaren Cursor mit Werten pro Signal.
Plusargs-Panel für Testbench-Parameter: +CYCLES, +PERIOD, +VERBOSE per $value$plusargs / $test$plusargs setzen und neu ausführen, ohne den Quellcode anzufassen.

Was Sie im Verilog-Playground bauen können

Kombinatorische Logik — Addierer, Multiplexer, ALUs — verdrahtet in einer Testbench mit $display-Prüfungen und sofortigem Feedback.
Getaktete sequentielle Designs — Zähler, Schieberegister, endliche Zustandsautomaten, gesteuert über always @(posedge clk), mit VCD-Wellenformen zur Inspektion von Signalübergängen.
Parameter-Sweeps: Plusargs wie +CYCLES, +PERIOD oder +VERBOSE setzen, um das Verhalten zwischen Läufen zu ändern – genauso wie auf der iverilog/vvp-Kommandozeile.

FAQ zum Online Verilog Compiler

Was ist Verilog?

Verilog ist eine Hardware Description Language (HDL), mit der sich digitale Schaltungen modellieren und simulieren lassen, von einfachen Kombinationsgattern bis hin zu vollständigen Prozessoren. Du beschreibst Module, Wires und Register im Code, kompilierst sie mit einem Verilog-Compiler und lässt eine Testbench laufen, um das Verhalten zu prüfen. SystemVerilog ist eine Obermenge von Verilog mit zusätzlichen Verifikationsfunktionen. Der Playground akzeptiert beides.

Ist der Online Verilog Compiler kostenlos?

Ja, der Verilog-Compiler und -Simulator sind kostenlos nutzbar. Keine Anmeldung, keine Vivado- oder Quartus-Lizenz und keine Toolchain zum Installieren – Modul schreiben und auf Run klicken.

Muss ich Icarus Verilog oder ein EDA-Tool installieren?

Nein. Dein Code wird mit iverilog kompiliert und läuft unter vvp in einem isolierten Container auf dem Server. Du schreibst den Verilog-Quellcode und drückst Run; den Rest übernehmen Compiler und Simulator.

Wie sehe ich Wellenformen meines Verilog-Codes?

Ruf in einem initial-Block deiner Testbench $dumpfile("dump.vcd") und $dumpvars(0, dein_modul) auf. Nach dem Run rendert der Waveform-Tab die Signale — klick irgendwo auf eine Spur, um einen Cursor zu setzen und die Werte pro Signal zu diesem Zeitpunkt abzulesen.

Wie schreibe ich eine Verilog-Testbench mit Plusargs?

Füge Zeilen im Plusargs-Panel hinzu (z. B. CYCLES=10, VERBOSE), und sie werden dem Simulator in der Kommandozeile als +CYCLES=10 +VERBOSE übergeben. In deiner Testbench liest du sie mit $value$plusargs("CYCLES=%d", n) für ganzzahlige Werte oder $test$plusargs("VERBOSE") für boolesche Flags. Der Standard-Startercode zeigt beide Muster.