svling 0.7.0

SystemVerilog simulator: pyslang frontend + Rust runtime + time-travel + RTL-as-Python-callable + compiled-Python monitors + semantic waveform search + cocotb adapter

svling

SystemVerilog compiler + runtime + time-travel debugger + RTL-as-Python-callable — in one package.

svling bundles:

• sling — a SystemVerilog → VVP compiler frontend built on pyslang (full IEEE 1800-2023 LRM coverage).
• evvp — a Rust reimplementation of Icarus Verilog's vvp runtime, exposed to Python via pyo3 and invoked in-process.
• sling.Simulator — time-travel-capable Python wrapper: .checkpoint() / .restore() / .fork() for parallel-universe debugging.
• sling.Design — pyslang AST access, .compile_as_function() to turn combinational modules into Python callables, .compile_as_object() for stateful ones, auto-generated Python IntEnum / dataclass from RTL typedefs.
• sling.features — protocol detection (AXI4-Lite, APB, etc.), FSM identification, auto-assertion synthesis, mutation testing, coverage, recorder→pandas/numpy, counterfactual sim, invariant discovery, differential testing, git-bisect-RTL, design space sweep, and more.

The whole stack ships as a single wheel containing the Python compiler sources and one sling/_native.abi3.so carrying the entire runtime.

Highlights

Time-travel debugging

import sling

sim = sling.Simulator.from_sv("counter.sv")
sim.step_cycles(50)
cp = sim.checkpoint()             # O(N) deep clone

sim.step_cycles(50)
print(sim.read_int("tb.count"))   # value at t=100

sim.restore(cp)                   # rewind
print(sim.read_int("tb.count"))   # value at t=50

fork = sim.fork(cp)               # independent timeline

RTL module as a Python callable

d = sling.Design.from_sv("alu.sv")
alu = d.compile_as_function("alu")
print(alu(a=42, b=17, op=0))      # → {'result': 59}

counter = d.compile_as_object("counter", clock="clk", reset="rst_n")
counter.reset()
print(counter.cycle(en=1))        # → {'count': 1}

Auto-generated Python types from RTL

d = sling.Design.from_string("""
    typedef enum logic [1:0] {IDLE, RUN, DONE} state_t;
    typedef struct packed { logic [7:0] addr; logic [3:0] cmd; } pkt_t;
    module top (output state_t s, output pkt_t p);  ...  endmodule
""")
State = d.py_enums()["state_t"]
Pkt   = d.py_structs()["pkt_t"]
print(State.RUN.value)            # → 1
print(Pkt(addr=0xAB, cmd=0x3).to_bits())

Verification features

f = sling.features
f.find_state_machines(d)          # AST-detected FSMs
f.detect_protocols(d, "axi_dut")  # AXI4-Lite/APB/SPI/I2C/UART/...
f.synthesize_assertions(d)        # enum-legality SVA strings
f.counterfactual(sim, until=100, overrides={"signal": 0xFF})
f.discover_invariants(recorder)
f.bisect_regression("rtl/alu.sv", test_fn, ...)
f.mutate(sv_source, test_fn)      # mutation testing

Compiled Python monitors (spec §53)

Write monitors as Python lambdas; sling compiles them to a typed IR and runs them at every sim time-step. Python is only called when the predicate transitions.

import sling
from sling.monitors import compiled_trigger, compiled_monitor, until, capture

sim = sling.Simulator.from_sv("design.sv")

# Single-cycle predicate. The decorator returns the Monitor itself.
@compiled_trigger(sim, dut="top", edge="rising")
def overflow(dut):
    return (dut.cnt > 250) & (dut.enable == 1)

# Multi-cycle sequence monitor.
@compiled_monitor(sim, dut="top")
def axi_write(dut):
    yield until(lambda d: d.awvalid == 1)
    yield capture(lambda d: d.awaddr)
    yield until(lambda d: d.awready == 1)

sim.run_until(10_000)

print(f"overflow fired {overflow.fire_count}x, last at t={overflow.last_fire_time}")
for h in axi_write.history[:5]:
    print(f"  AXI write at t={h.time} addr={h.captures['awaddr']:#x}")

Supported Python subset in predicates: comparisons (==, !=, <, <=, >, >=), bitwise (&, |, ^, ~, <<, >>), arithmetic (+, -, *), boolean (and, or, not), ternary (X if C else Y), attribute chains rooted at the DUT parameter, integer/boolean literals. Function calls are rejected with a helpful diagnostic.

Time-travel workflows (built on Simulator.checkpoint/fork)

Higher-level helpers in sling.timetravel:

from sling.timetravel import run_universes, diff_timelines, AutoCheckpointer

sim.run_until(1000)
cp = sim.checkpoint()

results = run_universes(
    cp, sim_template=sim, until_time=2000,
    sample_signals=["top.result", "top.error"], sample_period=50,
    stimulus_callbacks={
        "normal": lambda u: u.write("top.in", 0x42),
        "fuzzed": lambda u: u.write("top.in", 0xFF),
    },
)
for d in diff_timelines(results["normal"], results["fuzzed"])[:5]:
    print(f"t={d.time}: {d.signal} normal={d.value_a} fuzzed={d.value_b}")

# Ring-buffer of periodic checkpoints — rewind past an unknown failure.
with AutoCheckpointer(sim, period=100, keep=20) as auto:
    for cycle in range(5000):
        sim.run_until((cycle + 1) * 10)
        auto.tick()
        if sim.read_int("top.error_flag"):
            sim.restore(auto.rewind(steps_back=5))
            break

Semantic waveform search (spec §44)

Beyond name-grep — search by structure (AST), behavior (recorded samples), or both:

from sling import features as f
from sling.wavesearch import WaveformSearch, Pattern

rec = f.Recorder(sim, ["top.valid", "top.ready", "top.state"])
for _ in range(2000):
    sim.run_until(sim.now + 5)
    rec.sample()

ws = WaveformSearch(sim, design=design, recorder=rec)

# Behavior: handshakes on a valid/ready pair.
hs = ws.find_handshake("top.valid", "top.ready")

# Structure × behavior: state-machine transitions by enum name.
errs = ws.find_transition("top.state", from_val="IDLE", to_val="ERROR")

# Custom temporal pattern.
pulses = ws.find_pattern("top.req", Pattern.pulse(min_width=3))

Install

pip install svling
# or
uv tool install svling

Use

# Compile and run in one go:
svling design.sv tb.sv

# Compile only (write a .vvp file):
sling -o design.vvp design.sv

# Run a pre-compiled .vvp through the Rust runtime in-process:
python -c "from sling._native import run_cli; run_cli(['evvp', '-N', 'design.vvp'])"

Anything that starts with + on the svling command line is forwarded to the runtime as a Verilog plusarg (e.g. +verbose, +seed=42). Use -- to forward arbitrary extra flags to the runtime.

Layout

svling/
├── sling/          Python frontend (pyslang → VVP)
├── evvp/           Rust crate: VVP runtime; produces both a standalone
│                   `evvp` binary and a pyo3 cdylib for the wheel
├── tests/          Sample SystemVerilog used by the docs
└── pyproject.toml  maturin build, project metadata, console scripts

License

GPL-2.0-or-later. evvp is a clean-room reimplementation of Icarus Verilog's vvp, which is GPL-2.0; this package keeps the same license.