Register-transfer level design is the way almost every modern digital chip is written: you describe a circuit as a set of registers that update on a clock edge, plus the logic that computes what goes into them next. If you have ever wondered how a CPU, a GPU or a homebrew FPGA game console goes from an idea to working silicon, this is the layer where the real design work happens. This guide explains the concept in plain terms, walks through a working Verilog example built around a game, and shows where the abstraction fits, where beginners trip up, and how to prototype a hardware game before you write a line of RTL.
What is register-transfer level design?
A synchronous digital circuit is made of two kinds of parts. Registers are storage elements, usually D flip-flops, that capture a value on each clock edge and hold it until the next one. Combinational logic is everything else: gates, adders, comparators and multiplexers whose outputs depend only on their current inputs, with no memory. As the Wikipedia article on register-transfer level puts it, RTL models a circuit as the flow of data between hardware registers and the logical operations performed on that data.
So register-transfer level design means writing down, for every register in your circuit, what value it should load on the next clock edge. You do not draw transistors or individual gates. You write code in a hardware description language (HDL), a language for describing circuits rather than programs, such as Verilog or VHDL. A synthesis tool then works out which gates implement your description.
The name is literal. Data is “transferred” from register to register each clock cycle, transformed by logic on the way. If your design says “on every rising clock edge, the score register gets the score plus one when the ball crosses the goal line”, you have written a register transfer.
Why designers work at this level
Lower levels are too detailed to manage. A modern chip has billions of transistors, and nobody places them by hand. Higher levels, like pure algorithm descriptions, do not say enough about timing for a tool to build reliable hardware. RTL is the sweet spot: abstract enough for a person to reason about, precise enough that tools can turn it into a physical circuit. That is why it remains the normal input that chip designers work on, rather than an intermediate step hidden inside a compiler.
Registers, combinational logic and the clock
The core mental model of register-transfer level design fits in one loop. Registers output the current state. Combinational logic reads that state (and any inputs) and computes the next state. On the clock edge, the registers capture that next state. Repeat forever.
Registers hold state
Think of a register as a variable that can only change at one instant: the clock edge. Between edges it is frozen. This is what makes synchronous design predictable. As long as the logic finishes computing before the next edge arrives, the circuit behaves the same way every time.
Combinational logic computes
Every if, case, comparison and addition you write becomes physical logic. An if/else turns into a multiplexer, a component that picks one of two inputs. An addition becomes an adder circuit. All of it exists at once and computes continuously, which is the biggest difference from software.
Feedback and pipelines
Two circuit shapes appear constantly. When a register’s output feeds back into its own input through logic, you have a finite-state machine (FSM), a circuit that steps through defined states such as IDLE, SERVE, PLAY and GAME_OVER. When data flows forward through a chain of registers with no feedback, you have a pipeline, which splits a long computation into stages so each one fits inside a clock cycle.
If you make games, this loop will feel familiar. A game loop reads the current state, computes the next frame, and commits it. RTL does the same thing, except the “frame” might be a few nanoseconds long and every piece of logic runs in parallel.

A register-transfer level design example in Verilog
The classic first project for hardware hobbyists is Pong on an FPGA, popularised by books such as Pong P. Chu’s FPGA prototyping series. Here is a small, complete Verilog module that moves a Pong ball horizontally and bounces it off two walls. It uses one register for position and one for direction.
module ball_x (
input wire clk, // system clock
input wire rst, // synchronous reset
input wire tick, // one-cycle pulse, once per video frame
output reg [9:0] x // ball x position in pixels
);
reg dir; // 0 = moving right, 1 = moving left
localparam LEFT_WALL = 10'd8;
localparam RIGHT_WALL = 10'd624;
localparam SPEED = 10'd2;
always @(posedge clk) begin
if (rst) begin
x <= 10'd320;
dir <= 1'b0;
end else if (tick) begin
if (dir == 1'b0) begin
if (x >= RIGHT_WALL) dir <= 1'b1;
else x <= x + SPEED;
end else begin
if (x <= LEFT_WALL) dir <= 1'b0;
else x <= x - SPEED;
end
end
end
endmodule
Read it as register transfers. On each rising edge of clk, if a frame tick is active, x loads either x + 2 or x - 2, and dir flips when the ball reaches a wall. The <= operator is a non-blocking assignment: every register samples its new value at the same instant, which is exactly how real flip-flops behave.
Notice what a synthesis tool will build from this: a 10-bit register for x, a 1-bit register for dir, an adder, a subtractor, two comparators and some multiplexers to choose between them. You never drew any of those. That is the whole value of register-transfer level design.
The same logic as a software reference model
Hardware engineers usually write a software model of the expected behaviour first, then check the RTL against it in simulation. Here is the equivalent in JavaScript, one call per frame:
const LEFT_WALL = 8;
const RIGHT_WALL = 624;
const SPEED = 2;
let ball = { x: 320, dir: 0 }; // 0 = right, 1 = left
function onFrameTick(b) {
// Compute the next state from the current state, like the RTL does
const next = { ...b };
if (b.dir === 0) {
if (b.x >= RIGHT_WALL) next.dir = 1;
else next.x = b.x + SPEED;
} else {
if (b.x <= LEFT_WALL) next.dir = 0;
else next.x = b.x - SPEED;
}
return next; // "clock edge": commit the whole next state at once
}
for (let frame = 0; frame < 5; frame++) {
ball = onFrameTick(ball);
console.log(frame, ball.x, ball.dir);
}
Building the next state as a fresh object, then committing it, mirrors non-blocking assignment. If your simulator’s waveform for x matches this model frame by frame, your RTL is very likely correct.
Where RTL sits in the chip design flow
Register-transfer level design is one stage in a longer pipeline. Above it is system-level work: architecture, specifications and models that describe what the chip does without committing to clock-by-clock detail. Electronic system-level design covers that higher layer, including transaction-level modelling. Below RTL, tools take over and turn your code into gates, then into physical layout.
| Level | What you describe | Who or what produces it |
|---|---|---|
| System / transaction level | Functions, data transfers between blocks, rough timing | Architects, often in C++ or SystemC |
| Register-transfer level | Registers, clock-by-clock behaviour, logic between registers | RTL designers, in Verilog, SystemVerilog or VHDL |
| Gate level (netlist) | Specific logic cells and flip-flops and their connections | Logic synthesis tool |
| Physical layout | Placement and wiring on the chip or FPGA fabric | Place-and-route tools |
Simulation tools run your RTL directly to verify it, which is far faster than simulating gates. Synthesis converts it into a netlist and performs logic optimisation along the way. Placement and routing then produce the layout for an ASIC (a custom chip) or a configuration file for an FPGA. Designers also estimate power and area at RTL, because changes made early, at the architecture and RTL stage, tend to matter far more than tweaks made late at the gate level.





