# Building a 4-Bit ALU from Scratch: A Digital Logic Design Walkthrough

## Overview
An Arithmetic Logic Unit, commonly known as an ALU, is one of the most critical blocks inside a processor. It is the part of the system that actually performs calculations and logical decisions. In this article, we walk through the design and verification of a 4-bit ALU, focusing on how fundamental digital logic concepts come together to form a working computational unit.

This project was developed as part of a Digital Logic Design course and demonstrates how arithmetic, logic, comparison, and control selection can be implemented using combinational circuits.

## What This ALU Does
The designed ALU operates on two 4-bit binary inputs and supports eight different operations. A 3-bit control signal determines which operation is executed. Internally, all operations are computed in parallel, and a multiplexer selects the final output.

The ALU supports:
- Addition with carry input and carry output
- Subtraction using two’s complement
- Bitwise AND, OR, and XOR
- Bitwise NOT on either input
- Equality comparison between operands

The entire design is combinational, meaning the output depends only on the current inputs.

## Inputs and Outputs
The system accepts the following inputs:
- A: 4-bit operand
- B: 4-bit operand
- Control signal: 3 bits to select the operation
- Cin: carry input for addition
- C: selector used in the NOT operation to choose between A and B

The outputs are:
- A 4-bit result corresponding to the selected operation
- A single carry-out flag used mainly during addition

In total, the ALU processes 13 input bits and produces 5 output bits.

## Control Signal Mapping
Each value of the 3-bit control signal corresponds to a specific operation:

- 000: Addition
- 001: Subtraction
- 010: Bitwise AND
- 011: Bitwise OR
- 100: Bitwise XOR
- 101: Equality check
- 110: Bitwise NOT
- 111: Reserved

This mapping allows the ALU to be easily extended in future designs.

## Internal Architecture
The ALU is built using a modular approach. Each function is implemented as a separate sub-circuit, which improves clarity and reusability.

### Arithmetic Unit
Addition is implemented using a ripple-carry adder composed of four 1-bit full adders. Each full adder computes a sum bit and propagates a carry to the next stage.

Subtraction is implemented using the two’s complement method. The second operand is inverted, and a carry-in of 1 is applied. This allows subtraction to reuse the same adder hardware with minimal additional logic.

### Logic Unit
The logic operations are implemented bitwise:
- AND, OR, and XOR use one gate per bit
- NOT uses four inverters and a small multiplexer to select whether A or B is inverted

### Equality Comparator
Equality is checked by comparing each bit of A and B using XNOR gates. If all bits match, the output is asserted. The result is encoded as a 4-bit value where only the least significant bit indicates equality.

### Multiplexing
An 8-to-1 multiplexer selects one of the operation results based on the control signal. This ensures that only the desired computation appears at the output.

## Boolean Logic Foundation
At the core of the ALU is the 1-bit full adder. Its behavior is defined by the following expressions:

- Sum = A ⊕ B ⊕ Cin  
- Cout = AB + (A ⊕ B)Cin  

These expressions are already in simplified form and are directly implemented using XOR, AND, and OR gates.

The same principles apply to the 4-bit adder, where carry signals ripple from the least significant bit to the most significant bit.

Logical operations such as AND, OR, XOR, and NOT are inherently simple and require no further simplification beyond their standard gate-level implementations.

## Verification and Simulation
<iframe src="https://circuitverse.org/simulator/embed/4-bit-alu-8b187e86-4cbd-4640-b897-e421dc031991?theme=night-sky&display_title=true&clock_time=true&fullscreen=true&zoom_in_out=true" style="border-width:; border-style: dashed; border-color:;" name="myiframe" id="projectPreview" scrolling="no" frameborder="1" marginheight="0px" marginwidth="0px" height="500" width="500" allowFullScreen></iframe>

The tests covered:
- Normal arithmetic cases
- Carry generation and overflow scenarios
- Negative results in subtraction using two’s complement
- All logical operations with varied input patterns
- Equality and inequality detection
- Correct operand selection in the NOT operation

All test cases produced the expected outputs, confirming the correctness of the design.

## Why This Design Matters
This 4-bit ALU may seem small, but it captures the essential ideas behind real-world processors. Modern CPUs use the same principles, just scaled up with wider data paths and more complex control logic.

The project highlights:
- How modular design simplifies complex systems
- Why two’s complement is preferred for subtraction
- How multiplexers enable flexible control
- How Boolean algebra translates directly into hardware

## Final Thoughts
Designing a 4-bit ALU is an excellent exercise for understanding how software-level operations are executed at the hardware level. Every arithmetic instruction, comparison, or logical check in a processor ultimately maps back to circuits like these.

This project successfully demonstrates the practical application of digital logic concepts and provides a strong foundation for more advanced topics such as CPU architecture, pipelining, and hardware description languages.


Design and Implementation of a 4-Bit Arithmetic Logic Unit (ALU)

Third Post after deployment 69

# Designing a Retro CPU from First Principles

I’ve been reading about retro computers recently and began wondering how feasible it would be to design and build one from scratch. To explore this idea, I decided to simulate a computer using one of the many online logic simulation tools available.

My tool of choice is **CircuitVerse**. It provides a clean, functional interface along with a number of sophisticated features that make it well suited to this kind of experimentation.

To guide the project, I’ve set myself a small number of rules.

---

## Design Rules

**Rule 1:**  
Everything must initially be built from a universal logic gate — either **NOR** or **NAND**.

**Rule 2:**  
Once I have constructed a module, I will allow myself to use the equivalent built-in CircuitVerse module in other designs.  
For example, after building an AND gate from first principles, I may then use the CircuitVerse AND gate module elsewhere.

---

## Project Scope

While there are already several CPU designs available on CircuitVerse, my interest here is in **documenting the construction process**, starting from basic logic gates and progressing incrementally toward a working CPU.

I won’t go into extensive detail on the underlying theory. There are many excellent resources available online for readers who want a deeper theoretical background.

---

## Design Parameters

- The design will begin with a **NOR gate**. Most designs I’ve seen tend to use NAND gates, so I’ve chosen NOR simply to be different. In practice, this choice mainly affects the earliest stages.
- The CPU will be **4-bit** rather than 8-bit. An 8-bit design felt too complex to be practical for constructing every component by hand.
- What can ultimately be achieved with a 4-bit CPU remains to be seen.
- The final design aims to include:
  - An **Arithmetic Logic Unit (ALU)**
  - Separate **RAM** and **ROM**
  - **Memory registers**
  - **Control logic**

---

## Notation

The following conventions will be used when labelling designs:

- **I** — Single-bit inputs  
- **Q** — Outputs  
- **A, B** — 4-bit inputs  
- **D** — Data lines  
- **E** — Enable lines (to activate or deactivate modules)  
- **S** — Select lines  
- **CLK** — Clock signal  

Multiple signals are indicated using subscripts.

A prime (`'`) denotes logical NOT. For example, `Q'` means **NOT(Q)**.

---

## Fundamental Logic Gates

To begin, the following fundamental logic gates are required:

- AND  
- OR  
- NAND  
- NOT  
- XOR  
- XNOR  

The first gate I constructed was the **NOT gate**, as it is particularly useful when creating AND and OR gates. These, in turn, are used to build more complex gates such as NAND and NOR.

All fundamental gates can be seen in the interactive window below. You can modify the inputs and observe the resulting outputs.

---

## Multiple-Input Logic Gates

Several multiple-input gates are also required, such as a **4-input AND gate**. Although CircuitVerse provides built-in modules for these, they must first be constructed from simpler gates to comply with the design rules.

For example, chaining two 2-input AND gates makes it straightforward to build a 3-input AND gate. Below are the constructions for the multiple-input gates used in this project.

Once the 4-input AND gate was completed, the built-in CircuitVerse version was used to construct a 5-input AND gate, in accordance with Rule 2.

---

## Interactive Circuit

<iframe src="https://circuitverse.org/simulator/embed/4-bit-alu-7457aee0-7e4f-4eed-a64c-21187b472ffc?theme=&display_title=false&clock_time=true&fullscreen=true&zoom_in_out=true"
        style="border-width:; border-style: dashed; border-color:;"
        name="myiframe"
        id="projectPreview"
        scrolling="no"
        frameborder="1"
        marginheight="0px"
        marginwidth="0px"
        height="500"
        width="500"
        allowfullscreen>
</iframe>


this is second post

Cache Components are a new set of features designed to make caching in Next.js both more explicit, and more flexible. They center around the new 

 directive, which can be used to cache pages, components, and functions, and which leverages the compiler to automatically generate cache keys wherever it’s used. #new

Unlike the implicit caching found in previous versions of the App Router, caching with Cache Components is entirely opt-in. All dynamic code in any page, layout, or API route is executed at request time by default, giving Next.js an out-of-the-box experience that’s better aligned with what developers expect from a full-stack application framework.

Cache Components also complete the story of Partial Prerendering (PPR), which was first introduced in 2023. Prior to PPR, Next.js had to choose whether to render each URL statically or dynamically; there was no middle ground. PPR eliminated this dichotomy, and let developers opt portions of their static pages into dynamic rendering (via Suspense) without sacrificing the fast initial load of fully static pages.

Blog. waqas

Design and Implementation of a 4-Bit Arithmetic Logic Unit (ALU)

More Stories

Third Post after deployment 69

this is second post

this is a test post