Incus is an open-source system container and virtual machine manager for Linux that runs both LXC containers and QEMU/KVM virtual machines behind a single REST API and command-line client. In Linux virtualization, it occupies the layer above low-level runtimes: it handles images, storage, networking, clustering and access control so that administrators manage instances rather than individual processes or disk files.
Incus began in 2023 as a community fork of LXD, after Canonical moved LXD out of the Linux Containers project. It is maintained by the Linux Containers community, keeps a familiar command structure and has since diverged in features, licensing and release cadence, with long-term support releases intended for production use.
How Incus manages containers and virtual machines
Incus works as a long-running daemon that exposes a REST API over a local Unix socket and, optionally, over HTTPS for remote clients. The incus command-line tool, web interfaces and automation tools such as Terraform providers or Ansible modules all talk to the same API, which keeps behavior consistent regardless of the client.
Every workload is an instance of one of two types. A system container shares the host kernel and uses namespaces, cgroups, AppArmor or seccomp profiles and LXC underneath; a virtual machine runs its own kernel under QEMU with KVM acceleration and paravirtualized Virtio devices. Both types use the same images, profiles, storage pools and networks, so moving a workload from a container to a VM usually means changing one flag at creation time.
Containers run unprivileged by default: root inside the container is mapped to an unprivileged UID range on the host, which greatly limits the damage of a container escape.
Core building blocks of an Incus deployment
An Incus host is configured through a small set of first-class objects, each with its own API endpoint. The table below lists the objects administrators work with most often.
| Object | Purpose | Example use |
|---|---|---|
| Instance | A container or virtual machine | A Debian web server or a Windows test VM |
| Image | Template used to create instances | Ubuntu, Alpine or an OCI application image |
| Profile | Reusable set of configuration and devices | Shared CPU limits and a network interface |
| Storage pool | Backend that holds instance volumes | A ZFS pool on local NVMe disks |
| Network | Managed bridge or overlay network | An OVN network spanning a cluster |
| Project | Isolated namespace for objects and quotas | Separate environments for two teams |
The choice of storage driver has the largest effect on performance and features, because snapshots, copies and migration depend on it.
| Driver | Strength | Main limitation |
|---|---|---|
| dir | Simplest setup, no extra tools | No efficient snapshots or quotas |
| ZFS | Fast clones, compression, reliable snapshots | Needs ZFS kernel modules and memory |
| Btrfs | Copy-on-write clones in the mainline kernel | Quota handling is less predictable |
| LVM | Thin provisioning on block devices | Fewer data management features |
| Ceph RBD | Shared storage for clusters and live migration | Requires a separate Ceph cluster |
Incus compared with related virtualization tools
Incus overlaps with several tools in the Linux virtualization stack, but it sits at a different level of abstraction. LXC and QEMU are runtimes, libvirt is a management library mostly centered on virtual machines, and Proxmox VE is a complete distribution with a web interface.
| Tool | Scope | Key difference from Incus |
|---|---|---|
| LXC | Low-level container runtime | No image server, clustering or REST API |
| LXD | Container and VM manager | Canonical project from which Incus was forked |
| libvirt | Virtualization API, mainly for VMs | Weaker system container workflow |
| Proxmox VE | Full virtualization distribution | Installs as an operating system with its own stack |
| Docker or Podman | Application containers | One process per container instead of a full init system |
The most important conceptual distinction is between system containers and application containers. An Incus container boots a full init system, runs SSH, cron and multiple services, and behaves like a lightweight virtual machine, whereas an application container usually packages a single service. Recent Incus releases can also run OCI images, but that capability does not turn Incus into a replacement for container orchestration platforms.
Clustering, migration and day-to-day operations
Incus supports clustering, in which several hosts share one distributed database and appear to clients as a single API endpoint. Instances can be placed on specific members, evacuated during maintenance and moved between hosts; live migration works best for virtual machines on shared storage such as Ceph.
Routine operations follow a short and predictable command pattern. incus launch images:debian/12 web01 creates and starts a container, adding --vm creates a virtual machine, incus snapshot create captures state, and incus export writes a portable backup tarball. Limits such as limits.cpu and limits.memory apply through profiles or per instance.
For teams leaving LXD, the lxd-to-incus migration tool converts an existing installation in place, including instances, storage and networks. Testing the conversion on a non-production host first is still advisable, because storage driver and kernel differences can surface during the move.
Limitations and common mistakes
Incus is a capable platform, but several pitfalls recur in practice. The following table maps typical symptoms to their causes and fixes.
| Symptom | Likely cause | Recommended fix |
|---|---|---|
| Nested Docker fails inside a container | Nesting not allowed | Set security.nesting=true on that instance |
| Slow instance creation | dir storage driver copies full images | Use ZFS, Btrfs or LVM thin pools |
| Files owned by odd UIDs on the host | Unprivileged ID mapping | Use shifted disk devices or adjust idmaps |
| VM fails to start | KVM unavailable or nested virtualization off | Enable hardware virtualization in firmware |
The most consequential mistake is treating privileged containers as a convenient shortcut. Setting security.privileged=true removes the UID mapping that protects the host, so it should be reserved for trusted workloads that genuinely need it, and untrusted tenants belong in virtual machines.
The short version
Incus is a tool that lets one Linux computer host many separate mini computers. Some of them are lightweight containers that share the main system’s core, and others are full virtual machines with their own operating system.
Think of an apartment building manager: one person handles the keys, the utilities and the floor plans for every apartment. Incus is that manager, so you create, copy, back up and remove these mini computers with a few short commands.
Where it makes a difference
A university computer science department needs isolated Linux environments for about 120 students each semester. Instead of buying separate servers, the administrators build a three-node Incus cluster with Ceph storage. Each student receives a system container created from a Debian image and a profile that limits it to 2 CPU cores and 4 GiB of memory.
Courses on kernel development use virtual machines instead, because students must boot and crash their own kernels. At the end of the semester, a short script deletes every project and recreates fresh instances in minutes. The department reports far less administrative work than with its previous manually maintained virtual machines, and hardware maintenance no longer interrupts classes because instances are evacuated to other cluster members.