Transport delay passes every input change to the output after the delay, however short the pulse. Inertial delay also delays the signal, but it filters out pulses shorter than the delay (or a set reject limit), as a real gate does. Delta delay is the zero-time step a VHDL simulator uses to order events that happen at the same simulation time; Verilog orders them through its event scheduling regions instead.
Key takeaways
- Transport delay models a wire or ideal delay line: every pulse comes through, just later.
- Inertial delay models a gate: pulses shorter than the delay are swallowed. It is the default in VHDL (
afteron its own) and for Verilog continuous assignments and gate delays. - Delta delay is an infinitely small step at the same simulation time. It is not written with any keyword; every signal assignment without an
afterclause takes effect one delta later. - In Verilog, transport behaviour comes from an intra-assignment delay on a non-blocking assignment:
y <= #5 a;. - Synthesis ignores all of these delays. They matter for simulation, testbenches and gate-level models.
In Verilog and VHDL, three types of delay are commonly discussed in digital logic simulation: delta delay, transport delay and inertial delay. Here are the differences between the three types of delays, along with code examples in both Verilog and VHDL.
Corrected November 2026: earlier versions of this post contained syntax errors and some inaccurate statements about delay keywords. The explanations and code below have been checked and corrected.
The three delays at a glance
| Delay | What it models | VHDL | Verilog | Pulse shorter than the delay |
|---|---|---|---|---|
| Delta | Ordering of zero-time events | y <= a; (no after) | No formal delta; same-time events are ordered by scheduling regions | Not applicable (zero delay) |
| Transport | Wire or ideal delay line | y <= transport a after 5 ns; | y <= #5 a; (non-blocking, intra-assignment) | Passed to the output |
| Inertial | Logic gate with switching inertia | y <= a after 5 ns; or y <= reject 2 ns inertial a after 5 ns; | assign #5 y = a; or a gate delay such as and #5 g1(y, a, b); | Filtered out (rejected) |
Delta delay
Delta delay is a zero-time delay used to order events that occur at the current simulation time. It is also referred to as delta cycle delay or zero-time delay.
In VHDL, delta delay is implicit: any signal assignment without an after clause, such as y <= a;, takes effect one delta cycle later, at the same simulation time. There is no "delta" keyword; delta delay needs no special syntax. (VHDL does have an attribute 'delayed, but it is a separate feature.)
In Verilog, delta delay is also implicit and does not require any special syntax. Strictly, the Verilog standard does not use the term "delta"; it orders events at the same time step through scheduling regions: active events (blocking assignments, continuous assignments), inactive events (#0) and then non-blocking assignment updates. The effect is similar: values settle through several zero-time steps before simulation time advances.
How a delta cycle works in VHDL
At each simulation time, the VHDL simulator repeats a cycle: update all signals that have pending changes, then run every process that is sensitive to a changed signal. Those processes schedule new changes, and the next delta cycle applies them. Time only advances when no more changes are pending at the current time.
signal a : std_logic := '0';
signal b : std_logic := '1';
signal c : std_logic := '1';
...
b <= not a; -- b changes one delta after a
c <= b; -- c changes one delta after b
If a rises at 10 ns, b falls one delta later and c falls one delta after that, all still at 10 ns on the waveform. The deltas guarantee a deterministic order without inventing a real delay.
The classic delta-cycle trap: assigning a clock
clk_b <= clk; -- clk_b lags clk by one delta
process (clk) begin
if rising_edge(clk) then q1 <= d; end if;
end process;
process (clk_b) begin
if rising_edge(clk_b) then q2 <= q1; end if;
end process;
On the clock edge, q1 and clk_b both update in the same delta cycle, so the second process sees the new q1 and q2 captures it in the same cycle. The intended two-stage shift collapses into one. Avoid deriving clocks with plain signal assignments in RTL, or make sure every flip-flop uses the same clock signal.
Zero-delay (delta) register examples
Here is an example of a zero-delay register assignment in Verilog. The non-blocking update of data_out happens in the same time step as the clock edge:
always @(posedge clk) begin
if (enable) begin
data_out <= data_in;
end
end
Here is the same register in VHDL. data_out changes one delta cycle after the rising edge of clk:
process(clk)
begin
if rising_edge(clk) then
if enable = '1' then
data_out <= data_in;
end if;
end if;
end process;
Transport delay
Transport delay is a delay model that represents the time it takes for a signal to propagate through a wire or an ideal delay line. Every change on the input appears on the output after the delay, including pulses shorter than the delay. Transport delay is not the same as unit delay, which is a simulation mode in which every gate is given a delay of one time unit (see the related reading below).
In VHDL, transport delay needs the keyword transport together with after; after on its own gives inertial delay.
y <= transport a after 5 ns;
In Verilog, the # symbol specifies a delay, but where you place it decides the behaviour. Transport delay is modelled with an intra-assignment delay on a non-blocking assignment:
always @(a)
y <= #5 a; // every change on a reaches y 5 time units later
A register with a 1-unit clock-to-output delay
In Verilog, put the delay inside the non-blocking assignment. The input is sampled at the clock edge and the output updates 1 time unit later:
always @(posedge clk) begin
if (enable) begin
data_out <= #1 data_in;
end
end
Watch where the # goes. Writing #1 data_out <= data_in; is an inter-assignment delay: the block waits 1 time unit and only then reads data_in, so it samples the data after the edge instead of at it, and the block cannot respond to anything else while it waits.
In VHDL, the same register with transport delay is:
process(clk)
begin
if rising_edge(clk) then
if enable = '1' then
data_out <= transport data_in after 1 ns;
end if;
end if;
end process;
Without transport, data_out <= data_in after 1 ns; uses the default inertial delay. For a register that changes at most once per clock, the two give the same result.
Inertial delay
Inertial delay is a delay model that represents the time it takes for a signal to propagate through a gate, with the added rule that an input pulse must last at least a minimum duration to be propagated. Pulses shorter than that are filtered out, as a real gate with input capacitance does not respond to a very short glitch. Inertial delay is often described as the more realistic gate model. By default the minimum pulse width (the reject limit) equals the delay itself.
In VHDL, inertial delay is the default for after; the keyword inertial can be written explicitly, and since VHDL-93 a separate reject limit can be given with reject:
y1 <= a after 5 ns; -- inertial, rejects pulses shorter than 5 ns
y2 <= inertial a after 5 ns; -- the same, written explicitly
y3 <= reject 2 ns inertial a after 5 ns; -- rejects only pulses shorter than 2 ns
In Verilog, continuous assignments and gate primitives with a delay use inertial delay:
assign #5 y = a; // inertial: pulses shorter than 5 units are filtered
and #5 g1 (y, a, b); // gate primitive with inertial delay
Note that ## is not a Verilog delay operator. It is SystemVerilog's cycle delay, used in sequences, assertions and clocking blocks, and it counts clock cycles rather than modelling gate inertia.
Inertial delay on a data path
Inertial delay is most useful on combinational or wire-like paths, written as a concurrent assignment. In Verilog:
assign #1 data_out = data_in; // pulses on data_in shorter than 1 unit never reach data_out
In VHDL, as a concurrent signal assignment outside any process:
data_out <= inertial data_in after 1 ns; -- pulses shorter than 1 ns are rejected
Inside a clocked process, an inertial delay has little visible effect, because the flip-flop already ignores changes on its input between clock edges. Delay expressions also cannot be used inside an if condition in either language; the delay belongs on the assignment.
Worked example: one short pulse, three models
Input a rises at 10 ns and falls at 12 ns, a 2 ns pulse. Each output uses a 5 ns delay.
| Assignment | Output behaviour |
|---|---|
y <= transport a after 5 ns; | Rises at 15 ns, falls at 17 ns: the pulse passes. |
y <= a after 5 ns; (inertial) | Stays at 0: the 2 ns pulse is shorter than 5 ns and is rejected. |
y <= reject 1 ns inertial a after 5 ns; | Rises at 15 ns, falls at 17 ns: the pulse is longer than the 1 ns reject limit. |
y <= a; (delta only) | Rises at 10 ns and falls at 12 ns, each one delta after a. |
The Verilog equivalents behave the same way: always @(a) y <= #5 a; passes the pulse, while assign #5 y = a; filters it.
Delays in simulation and synthesis
- Synthesis tools ignore
afterclauses and#delays; real timing comes from the cell library and is checked with static timing analysis. - In RTL, add delays only where they help simulation, for example a small clock-to-output delay to make waveforms easier to read. Many teams avoid them altogether.
- In gate-level simulation, cell delays are back-annotated from an SDF file, and simulators provide options to control pulse filtering on module paths.
- Testbenches use transport-style delays to model board traces and cable delays, where short pulses should not be lost.
Common mistakes in real projects
- Delay before the assignment instead of inside it.
always @(a) #5 y = a;looks like a 5-unit delay, but the block is blind toawhile it waits, so changes are missed. Question 2 below shows the effect. - Expecting
afterto pass glitches. In VHDL, a plainafteris inertial, so a short glitch you wanted to see in a testbench model vanishes. Usetransportfor delay lines and board models. - Clock assignments that add a delta. Renaming or buffering a clock in RTL with
clk_b <= clk;causes the race shown above. Gate-level netlists avoid it because every flop sees a real delayed clock, which is one reason RTL and gate-level results can differ. - Delays that hide bugs. Small
#1delays sprinkled through RTL can mask race conditions that later appear in gate-level simulation or on silicon. Fix the race with correct blocking and non-blocking use instead.
Test yourself
Question 1
Input a is high from 10 ns to 16 ns, a 6 ns pulse. What does y <= a after 5 ns; produce in VHDL?
Answer: the pulse is longer than the 5 ns inertial delay, so it passes: y is high from 15 ns to 21 ns. Shorten the pulse to 4 ns and y stays low.
Question 2
Input a rises at 10 and falls at 12. What does always @(a) #5 y = a; do in Verilog?
Answer: the rise at 10 starts the block, which waits until 15 and then copies a, which is already 0 again. The fall at 12 arrived while the block was waiting and is missed. So y stays 0: the pulse is lost, but not for the reason inertial delay would give. With y <= #5 a; instead, y is high from 15 to 17.
Question 3
Three concurrent VHDL assignments form a chain: b <= a; c <= b; d <= c;. If a changes at 20 ns, at what time does d change?
Answer: still at 20 ns on the waveform, three delta cycles after a. Simulation time does not advance, only the delta count.
Summary
The main differences between delta delay, transport delay and inertial delay are the way they model delay in digital logic simulation:
- Delta delay is a zero-delay model used to order events at the same simulation time.
- Transport delay represents the delay through a wire or an ideal delay line, and passes every pulse.
- Inertial delay represents realistic gate delay, with a minimum pulse duration that must be met for a change to reach the output.
Related reading
- Event driven simulation and simulators
- Unit delay simulation, an intermediate step in gate-level simulation
- Delay modelling and coding guidelines
- Verilog blocking vs non-blocking, myths and facts
- The Semiconductor Hub glossary entries on VHDL and Verilog
Frequently asked questions
What is the difference between transport and inertial delay?
Both delay a signal by the same amount, but inertial delay rejects pulses shorter than the delay (or the reject limit), while transport delay passes every pulse. Use transport for wires and delay lines, inertial for gates.
What is the default delay model in VHDL?
Inertial. A signal assignment with after and no keyword, such as y <= a after 5 ns;, uses inertial delay with a reject limit equal to the delay. An assignment with no after clause takes effect after one delta cycle.
What is a delta cycle in VHDL?
A delta cycle is one round of signal updates and process execution at the same simulation time. Several delta cycles can run at one time point before time advances, which gives zero-delay assignments a well-defined order.
How do you model transport delay in Verilog?
With an intra-assignment delay on a non-blocking assignment, for example always @(a) y <= #5 a;. Continuous assignments such as assign #5 y = a; are inertial and filter short pulses.
Are delays synthesisable?
No. Synthesis ignores after and # delays. Timing in the real circuit comes from the technology library and is verified with static timing analysis and, where needed, gate-level simulation with SDF.



The definition for Inertial delay given here is actually the rejection limit time. Once that is crossed a signal takes (inertial delay rejection limit time) to appear at the output.
ReplyDelete