Ubuntu Architecture Overview

Ubuntu Architecture Overview

Ubuntu is a Linux distribution — a curated collection of software built around the Linux kernel. Understanding how the different layers relate to each other helps you diagnose problems, make better package decisions, and understand why certain changes require a reboot while others do not. This article walks through the Ubuntu software stack from hardware to the applications you run.

The layered architecture

Ubuntu is built in layers. Each layer depends on the one below it and provides an interface for the one above it. Problems at a lower layer affect every layer above it.

The Linux kernel

The Linux kernel is the core of Ubuntu. It manages hardware access (drivers), memory allocation, CPU scheduling, networking, and the filesystem. Every system call your programs make — opening a file, accepting a network connection, forking a process — goes through the kernel.

# Check the running kernel version
uname -r

# Check kernel architecture
uname -m

# List all installed kernel packages
dpkg -l | grep linux-image

# See kernel messages from the current boot
dmesg | tail -20

Example output

6.8.0-57-generic
x86_64

Ubuntu ships multiple kernel flavours. The generic kernel is the standard choice. The HWE (Hardware Enablement) kernel on LTS releases tracks newer hardware support from subsequent Ubuntu releases. The lowlatency kernel is used for real-time audio.

A kernel update requires a reboot to take effect. All other software updates can be applied without a reboot (though services often need a restart).

The init system: systemd

After the kernel starts, it hands control to the init system. On Ubuntu, this is systemd, which runs as PID 1. systemd is responsible for:

• Starting all system services in the correct order
• Managing service dependencies (e.g., the database starts before the web app)
• Mounting filesystems (via systemd-fstab-generator)
• Managing the journal (logs via journald)
• Managing login sessions (via systemd-logind)
• Network time sync (via systemd-timesyncd)

# Check systemd version
systemctl --version

# List all running services
systemctl list-units --type=service --state=running

# Show the dependency tree for a service
systemctl list-dependencies nginx

# See how long the boot took
systemd-analyze

# Show the slowest services at boot
systemd-analyze blame | head -10

The C library: glibc

Almost every program on Ubuntu is compiled against glibc (the GNU C Library). It provides the standard C library functions (malloc, printf, open, etc.) and is the bridge between application code and the Linux kernel’s system calls. Most applications dynamically link to glibc, which is why upgrading glibc can break programs compiled against older versions. On Ubuntu, glibc is updated carefully during point releases.

# Check glibc version
ldd --version | head -1

# See which libraries a binary links to
ldd /usr/bin/bash | head -5

Package management: apt and dpkg

Ubuntu uses two related tools for package management. dpkg is the low-level package installer that handles individual .deb files. apt is the high-level tool that resolves dependencies, downloads packages from repositories, and calls dpkg to install them.

# Show where a package's files were installed
dpkg -L nginx

# Find which package owns a specific file
dpkg -S /usr/sbin/nginx

# Show all installed packages
dpkg -l | grep -v "^rc"

# Show the apt repository list
cat /etc/apt/sources.list

The snap layer

Ubuntu also ships snapd, which runs as a system service and manages snap packages. Snaps are self-contained application bundles that include their own dependencies. They are isolated from the base system using Linux namespaces and AppArmor. Snaps update automatically in the background.

# List installed snaps
snap list

# Show snap services (daemons)
snap services

# See snapd service status
systemctl status snapd

# Check which snaps have pending updates
snap refresh --list

Snaps and apt packages coexist on the same system. Some software (Firefox, Thunderbird, LXD) is distributed primarily as snaps on Ubuntu Desktop.

The Ubuntu base system

The Ubuntu base system includes the packages from the ubuntu-minimal and ubuntu-standard metapackages. These provide the shell, coreutils, compression tools, networking utilities, and enough to run a functional system. Ubuntu Server adds ubuntu-server on top of this, which includes tools like landscape-common, lvm2, and the cloud-init framework.

# See what ubuntu-minimal pulls in
apt-cache depends ubuntu-minimal

# See what ubuntu-server pulls in
apt-cache depends ubuntu-server

# Check cloud-init status (present on cloud VMs)
cloud-init status

How these layers interact

When you run sudo apt install nginx, apt downloads the package, dpkg installs the files, and then a systemd unit file is registered so nginx starts at boot. When nginx runs, it makes system calls to the kernel (to bind a port, read files, accept connections). All of this flows through the layers described above.

Conclusion

Ubuntu is a layered system: hardware, kernel, init system, C library, package management, and applications. Understanding which layer a problem lives in narrows down diagnostics quickly. A service that won’t start is a systemd problem. A package that won’t install is an apt/dpkg problem. A driver issue is a kernel problem. Use uname -r, systemctl, dpkg, and dmesg to inspect each layer.