ltsp.org

What is Linux Terminal Server Project?

The Linux Terminal Server Project (LTSP) is free software for running diskless computers on a local network. Each client boots over the network from a single template installation kept on an LTSP server—either a virtual machine image, a chroot, or the server's own root filesystem. Because every client gets the same image, updating one template updates all of them; maintaining tens or hundreds of clients becomes about as much work as maintaining one PC. The project was redesigned and rewritten from scratch in 2019 to support systemd, modern desktop environments, Wayland and UEFI; only that version is actively developed, while the older code is now called LTSP5 and receives minimal maintenance.

What LTSP actually does

LTSP is less a single program than an integration layer that configures and drives existing network-boot tools:

• iPXE — shows the client boot menu and loads the kernel and initrd.
• dnsmasq or isc-dhcp-server — assigns IP addresses, or acts as a ProxyDHCP server when a router already handles DHCP.
• dnsmasq or tftpd-hpa — serves the boot files to clients over TFTP.
• dnsmasq — optional DNS caching or blacklisting.
• mksquashfs — compresses the template into the image clients use as their root filesystem.
• NFS or NBD — delivers that image across the network.
• tmpfs and overlayfs — make the shared, read-only image temporarily writable per client, much like a live CD.
• NFS or SSHFS — mounts the user's home directory from the server.
• SSH, SSHFS or LDAP — authenticates users against the server.

Who it suits, and the trade-offs

It fits schools, offices, labs and public-access rooms that already have a wired LAN and want central control, cheap client hardware, and consistent software versions. The main costs are operational: clients depend on the network and server being up, so a server outage takes down every seat; boot traffic and image serving put real load on the LAN and server; and you need to understand DHCP, TFTP and NFS well enough to debug them when a client fails to boot. Users also lose local persistence by default, since changes live in a per-client overlay—good for resetting shared machines, inconvenient if people expect to keep local files.

A practical next step is to check the official documentation and installation guidance at Linux Terminal Server Project, then decide based on your environment: if you have wired clients, a spare server and a need for centralized updates, LTSP is a strong fit; if clients are mostly laptops on Wi-Fi or need offline autonomy, it is usually the wrong tool.

How do I install LTSP on my server?

Installing LTSP means preparing one server so that many diskless clients can network-boot from a single template. The current LTSP (rewritten in 2019) is the version to use; LTSP5 is in minimal maintenance.

What the install actually does

LTSP configures and coordinates several existing tools rather than replacing them:

• iPXE — client boot menu, loads kernel and initrd over the network.
• dnsmasq or isc-dhcp-server — assigns client IPs, or acts as ProxyDHCP alongside your existing router/DHCP.
• dnsmasq or tftpd-hpa — TFTP delivery of iPXE, kernel and initrd.
• mksquashfs + NFS or NBD — compresses the template (VM image, chroot, or server root) and serves it as each client's /.
• tmpfs + overlayfs — makes that read-only image temporarily writable per client, like a live CD.
• NFS or SSHFS, plus SSH/SSHFS/LDAP — mounts /home from the server and authenticates users.

Practical path

1. Start from the official installation documentation at Linux Terminal Server Project, and check the preparation page first — it covers the decisions that trip people up (network layout, whether another DHCP server already exists, and which template location you'll use).
2. Choose your template form: a VM image, a chroot on the server, or the server root itself (chrootless). The chrootless option is the simplest for a first test; a separate chroot or VM keeps experiments away from the server's own OS.
3. Decide on DHCP handling. If your LAN already has a router handing out addresses, configure LTSP as ProxyDHCP so it only supplies boot information.
4. Build the client image, then boot one client before rolling out more.

Choosing between the main options

A concrete scenario: a school lab with 30 identical desktops and an existing router. You'd keep the router as DHCP, run LTSP as ProxyDHCP, put the desktop environment in a chroot, serve it over NFS, and authenticate with SSH — then a software update means rebuilding one image, not patching 30 machines.

The trade-off is upfront complexity: you are running DHCP, TFTP, NFS and image tooling together, so a misconfigured network or a client that ignores PXE will look like an LTSP failure when it isn't. Test with a single client and a wired connection first, and consult the man pages listed on the site (ltsp, ltsp.conf, ltsp-image, ltsp-dnsmasq) when a step behaves unexpectedly.

Can LTSP boot Raspberry Pi clients?

Yes. LTSP's own documentation lists Raspberry Pi OS among its supported client setups, and the project's netboot workflow is designed to hand a kernel, initrd and a shared root filesystem to LAN clients — including ARM boards — from one template installation.

How it works in practice

An LTSP server keeps a single template image (a VM image, a chroot, or the server root itself). Clients fetch a bootloader over the network, load the kernel and initrd, then mount a compressed squashfs image as their root filesystem, made writable per client with tmpfs and overlayfs. Home directories and authentication come back from the server over NFS, SSHFS or LDAP. For a Raspberry Pi, that means the SD card no longer holds the operating system — it holds firmware/bootloader files and points the board at the server.

What you need to sort out first

• Boot method. Classic Pis boot from the SD card or USB, so you typically need the firmware partition plus a network boot configuration; newer Pi models with Pi 4 and later firmware can be configured for network boot, but this is a firmware-level step separate from LTSP itself.
• Architecture match. The template must match the client's CPU architecture. A single server serving both x86 thin clients and ARM Pis generally needs separate images, since the kernel and userland differ.
• DHCP/TFTP ownership. LTSP configures iPXE, a DHCP or ProxyDHCP service (dnsmasq or isc-dhcp-server), and a TFTP server. If your router already hands out DHCP, plan on ProxyDHCP rather than fighting it.
• Version. Only the post-2019 rewrite is actively developed; the older code is now LTSP5 in minimal maintenance. Raspberry Pi OS support belongs to the current line, so check that your distribution packages the new version.

A concrete scenario

A school lab with 20 Raspberry Pis and one modest server: you build and update one Raspberry Pi OS template, and every board picks up the change on next boot. The trade-off is that a network or server outage takes the whole lab down, and graphics-heavy or video workloads depend on the server's CPU and the LAN bandwidth rather than the Pi's local storage.

Next step: check whether your distribution ships the current LTSP release and whether it documents a Raspberry Pi OS image, then read the project's installation and netboot client pages at Linux Terminal Server Project.

What is the difference between LTSP and LTSP5?

LTSP5 is the older generation of the Linux Terminal Server Project, now in minimal maintenance mode. "LTSP" as used today means the version redesigned and rewritten from scratch in 2019, which is the only branch under active development. The practical difference is therefore less about two competing products than about an actively maintained codebase versus a legacy one kept alive for existing deployments.

What changed in the redesign

The rewrite was aimed at modern Linux infrastructure and desktops. According to the project, it added support for systemd, updated desktop environments, Wayland and UEFI. Those are the areas where LTSP5 tends to show its age: newer boot firmware, display servers and service management are exactly the moving parts that a diskless-client system depends on.

How the pieces fit together

The current LTSP does not replace the underlying network services; it configures and coordinates them. A typical setup uses:

• iPXE as the network boot loader that presents the client boot menu and loads the kernel and initrd.
• dnsmasq or isc-dhcp-server for DHCP, or as a ProxyDHCP server when another DHCP server such as a router already exists on the LAN.
• dnsmasq or tftpd-hpa as the TFTP server delivering iPXE, kernel and initrd.
• mksquashfs to compress the template image, chroot or VM that becomes each client's root filesystem.
• NFS or NBD to serve that squashfs image, with tmpfs and overlayfs making it temporarily writable per client, much like a live CD.
• NFS or SSHFS for home directories, and SSH, SSHFS or LDAP for authentication.

Choosing between them

If you are starting a new deployment, the decision is straightforward: use the current LTSP, because that is where development happens. LTSP5 only makes sense if you already run it and the cost of migrating outweighs the benefit of newer hardware and desktop support. The maintenance model is also a factor: with a single template installation, whether in a VM image, a chroot, or the server root itself, updating tens or hundreds of diskless clients is roughly as much work as updating one PC, so the effort of moving to the maintained branch is usually paid back quickly.

A sensible next step is to read the project's installation and preparation documentation at Linux Terminal Server Project before committing to a topology, since the choice between a VM image, a chroot and a chrootless server root shapes everything that follows.

How does LTSP handle user authentication and home directories?

LTSP keeps authentication and home directories on the server rather than on each client. The client machine boots a read‑only template image over the network, but the user's files and login credentials are served from the LTSP server, so a diskless workstation behaves like a thin client rather than a standalone PC.

Authentication

According to the project's own documentation, LTSP supports SSH, SSHFS or LDAP for authenticating users against the server. In practice this means the login prompt on a client is checked by the server, and the same account works on any client on the LAN. LDAP is the option to consider when you already run a directory service for many users; SSH‑based authentication is simpler for small labs.

Home directories

The user's /home directory resides on the server and is accessed over NFS or SSHFS. Because the client's root filesystem is a compressed template image made writable per client with tmpfs and overlayfs, only the home directory and similar server‑side storage persist between sessions. A student can log in at any seat and find the same files.

Practical trade‑offs

• Central control: adding or removing a user, or resetting a password, happens once on the server instead of on every machine.
• Single point of failure: if the server or its network storage is down, clients cannot log in and cannot reach home directories.
• Network dependency: NFS or SSHFS traffic means home directory performance depends on LAN quality; large files or many simultaneous users put load on the server.
• Storage sizing: since homes live on the server, plan disk capacity and backups there, not on individual clients.

For a concrete scenario, a school computer lab with 30 identical seats can keep one template and one set of accounts; a technician updates the template, and every client picks it up at next boot. If the lab instead needs offline use or per‑machine local storage, LTSP's server‑centric model is the wrong fit.

A useful next step is to read the installation and man pages on Linux Terminal Server Project and decide whether your existing directory service (for example LDAP) should handle authentication, or whether SSH/SSHFS is enough for your user count.

What network services does LTSP configure automatically?

LTSP automatically configures the network services needed to boot and run diskless clients from one server image. According to the project's own documentation, these are:

• iPXE — the network boot loader that presents the client boot menu and loads the kernel and initrd.
• DHCP — either dnsmasq or isc-dhcp-server, assigning client IPs; it can also act as a ProxyDHCP server when an existing router already handles DHCP.
• TFTP — dnsmasq or tftpd-hpa, transferring the iPXE binary, kernel and initrd to clients.
• DNS — dnsmasq, optionally, for caching or blacklisting.
• NFS or NBD — serving the compressed squashfs image that becomes each client's root filesystem.
• NFS or SSHFS — mounting the user's /home directory from the server.
• SSH, SSHFS or LDAP — authenticating users against the server.

The practical division is worth noting: boot-time services (DHCP, TFTP, iPXE) get a machine to a login prompt, while storage and identity services (NFS/NBD, SSHFS, LDAP) determine whether it behaves like a normal desktop. A school lab or office with dozens of identical workstations benefits most, because a single template change propagates to every client. The trade-off is that the server becomes a single point of failure, and network throughput matters more than local disk speed.

As a next step, check whether your LAN already has a DHCP server — a router, for instance. If it does, LTSP's ProxyDHCP mode lets you add netbooting without disturbing existing leases, which is usually the deciding factor in mixed networks. The project's installation documentation covers that setup; see Linux Terminal Server Project.