Virt-manager

virt-manager, also known as Virtual Machine Manager, is a free and open-source desktop application that serves as a graphical user interface (GUI) for managing virtual machines (VMs) through the libvirt virtualization API.^[1] It allows users to create, edit, start, stop, pause, and delete VMs, as well as monitor their performance and resource usage in real-time.^[1] Primarily designed for KVM (Kernel-based Virtual Machine) hypervisors on Linux systems, virt-manager also supports other technologies including Xen and libvirt-managed LXC containers.^[2] Key features include an overview dashboard for connected hypervisors and running guests, wizards for VM creation and hardware configuration, embedded VNC and SPICE clients for console access, and integration with libvirt-based command-line tools such as virt-install for automated VM provisioning.^[1] The application is built using Python and GTK, making it lightweight and suitable for integration into various Linux desktop environments like GNOME and KDE.^[3] As part of the broader open-source virtualization ecosystem, virt-manager is distributed via package managers in major Linux distributions, including Fedora, Ubuntu, and Red Hat Enterprise Linux, where it provides a user-friendly alternative to command-line interfaces like virsh.^[4] Originally initiated in 2006 by Dan Berrangé as a GNOME-based tool for libvirt management, it has evolved into a mature project hosted on GitHub, with ongoing development focused on enhancing usability and compatibility with modern hardware and storage options.^[5]

Overview

Description

virt-manager is an open-source desktop graphical user interface (GUI) application for managing virtual machines (VMs) and containers through the libvirt virtualization API.^[1][2] It provides a user-friendly way to oversee virtualization environments, displaying running domains and enabling their creation, configuration, and monitoring via a visual interface.^[1] Primarily designed for Linux environments, virt-manager focuses on simplifying the VM lifecycle management process, allowing users to perform tasks such as starting, stopping, and modifying virtual resources without relying on command-line tools.^[6] This approach makes it accessible for users seeking an intuitive alternative to direct interaction with underlying virtualization technologies like KVM, Xen, or LXC containers supported by libvirt.^[7] Architecturally, virt-manager is built using Python and the GTK toolkit, serving as a frontend to libvirt's backend services for handling domain operations across local or remote hosts.^[8] This design leverages libvirt's toolkit capabilities to abstract complex virtualization management into a cohesive desktop experience.^[7]

Purpose

virt-manager serves as a graphical desktop application designed to offer an intuitive, point-and-click interface for managing virtual machines through the libvirt API, serving as a user-friendly alternative to command-line tools such as virsh.^[7][9] By abstracting the underlying XML-based configurations required by libvirt, it simplifies the process of defining and modifying virtual machine settings, making virtualization tasks more accessible without necessitating direct editing of configuration files. This approach is particularly valuable for users who prefer visual workflows over terminal-based operations. The tool primarily targets system administrators, developers, and hobbyists who need to oversee local or remote virtual machines, enabling efficient handling of multiple domains across hypervisors with minimal technical overhead.^[1] It supports primary use with KVM as the hypervisor, alongside others like Xen and LXC containers, to facilitate seamless virtualization in diverse environments.^[1] Key benefits include enhanced accessibility for non-expert users through guided wizards for VM creation and configuration, real-time monitoring of performance metrics and resource utilization, and smooth integration with desktop environments such as GNOME via components like gnome-keyring for secure authentication.^[1][10] These features collectively reduce the learning curve associated with libvirt management, promoting broader adoption among varied user groups.^[7]

History and Development

Origins

Development of virt-manager began in March 2006, initiated by Dan Berrangé as an integral component of the libvirt project to provide graphical management capabilities for virtualization on Linux systems.^[5] The tool was initially named gnome-vm-manager, reflecting its early ties to the GNOME desktop environment, but was quickly renamed to gnome-virt-manager and eventually to virt-manager to emphasize its independence from specific desktop environments and broader compatibility across Linux distributions.^[5] This inception was driven by the need for an intuitive graphical user interface to simplify the creation, installation, and management of virtual machines on emerging hypervisors like Xen and KVM, which at the time lacked accessible tools beyond command-line interfaces in the Linux ecosystem. By August 2006, progress included integration with libvirt for backend operations, a wizard-based installation process for Xen guests on Fedora hosts, and support for embedded VNC or serial console access to improve user experience during provisioning.^[11]

Major Releases

The first stable release of virt-manager emerged around 2007, coinciding with libvirt's expansion and inclusion in Fedora 7, providing initial graphical management for KVM and Xen-based virtual machines.^[12] Major version milestones followed, with 1.0 released in February 2014, introducing enhanced Xen support alongside snapshot management, improved default configurations like qcow2 disk formats and USB2 passthrough, and UI refinements for remote connections and device editing.^[13] Version 2.0.0 arrived on October 5, 2017, featuring a complete port to Python 3 for long-term maintainability and bolstered LXC container integration through refined libvirt bindings.^[14][15] More recent updates have emphasized modern virtualization workflows. Version 4.0, launched in March 2022, advanced SPICE display capabilities with better USB redirection and added UI support for virtiofs shared filesystems, default TPM emulation for UEFI guests, and CPU host-passthrough options for QEMU on x86 architectures. Version 5.0 followed on November 26, 2024, incorporating UI modernizations such as streamlined domain creation interfaces and new support for LoongArch architectures, HVF hypervisors, and passt network backends. The subsequent 5.1.0 release on August 26, 2025, addressed bug fixes and performance optimizations, including CLI options for CPU maximum limits, TPM backend selections, and TDX secure VMs, while enhancing RISC-V64 and Windows ARM guest handling.^[16] The project migrated its source repository from Fedora Hosted to Pagure.io in 2018. Development is hosted on Pagure.io, with an unofficial mirror on GitHub, fostering contributions from Red Hat developers like Cole Robinson and Pavel Hrdina, as well as the broader community; all releases are GPG-signed by maintainer Pavel Hrdina for integrity verification.^[17][16] These evolutions align with libvirt's versioning, ensuring seamless integration for VM lifecycle management.^[18]

Features

Core Features

virt-manager provides guided wizards for creating new virtual machines, allowing users to select operating system installation methods such as ISO media, network installation, or import from existing disk images, while allocating hardware resources including CPU cores, RAM, and storage devices.^[1][19] These wizards integrate with libvirt to define domain configurations, supporting hardware emulation for devices like virtual CPUs, memory ballooning for dynamic allocation, and block or file-based storage volumes. For cloning, virt-manager utilizes the virt-clone tool to duplicate inactive guest domains, automatically copying disk images and generating new unique identifiers such as UUIDs and MAC addresses to ensure compatibility across hosts.^[1][20] The application enables real-time performance monitoring of running virtual machines, displaying resource utilization statistics including CPU usage percentages, memory consumption in gigabytes, and disk I/O throughput rates.^[1][21] These metrics are collected via libvirt APIs, providing insights into host and guest resource demands to aid in optimization and troubleshooting without requiring command-line intervention. Additionally, virt-manager offers brief graphical console access to guests using embedded VNC or SPICE protocols for direct interaction.^[1] virt-manager supports comprehensive snapshot management for virtual machines, capturing states of disk, memory, and devices to enable quick reversion or branching for testing.^[22] Snapshots are created and managed through libvirt, with support for internal snapshots on qcow2 formats, allowing offline or live captures depending on the guest's runtime state. For migration, it facilitates live transfers of running domains between hosts sharing storage like NFS, minimizing downtime by progressively copying memory pages and finalizing with a brief pause.^[23] Storage pool configuration is handled via libvirt backends, enabling the creation and management of pools from local directories, LVM, or network shares, with volumes allocated as guest block devices.^[24]

User Interface

The main window of virt-manager serves as the central hub for managing virtual machines, presenting a list view of domains grouped by connection, with each entry displaying key details such as the domain name, state, and maximum virtual CPUs. Status icons visually indicate the operational state of each domain, including running (green play icon), paused (yellow pause icon), and shut off (gray power icon), allowing users to quickly assess system status at a glance. Additionally, the interface includes configurable summary graphs embedded in the list view, which plot real-time metrics like CPU utilization, memory usage, disk I/O, and network throughput over selectable time intervals, enhancing usability by providing immediate visual feedback on performance without navigating to separate views.^[25][26] For direct interaction with guest operating systems, virt-manager integrates embedded VNC and SPICE clients directly into the virtual machine details window, enabling console access without requiring external applications. These clients support graphical display protocols for remote viewing and control, with options for scaling, fullscreen mode, and sending special keys (e.g., Ctrl+Alt+Del) via menu or toolbar buttons, which streamlines troubleshooting and administration tasks. The console view maintains a persistent connection during sessions, displaying the guest's framebuffer output and accepting input through the host's input devices, thus promoting an intuitive, seamless user experience for console-based operations.^[25][26][2] Configuration changes are facilitated through dialog-based wizards accessible from the virtual machine details window, which guide users step-by-step in modifying settings such as adding virtual hardware. For instance, the "Add Hardware" dialog presents categorized options like network interfaces (NICs), where users select source models, target devices, and VLAN tagging, including selection of networking modes such as NAT, bridged, host-only, or VLAN configurations (see [[#Networking Modes]] for details on each mode), with live previews of the resulting XML configuration; similarly, USB device addition allows browsing host devices, specifying redirection types (e.g., passthrough or redirect), and applying changes immediately or on next boot. These wizards incorporate validation checks, tooltips for options, and preview panes to illustrate impact, reducing errors and improving accessibility for users managing complex hardware setups.^[25][26]

Installation

Prerequisites and Dependencies

To run virt-manager, a desktop GUI for managing virtual machines via libvirt, several core software dependencies must be installed. The primary backend is libvirt version 5.0 or later (as of 2025 for compatibility with virt-manager 5.1.0), accessed through its Python bindings (libvirt-python >= 5.0.0), which provide the API for hypervisor interactions.^[27] Additionally, Python 3 (version 3.5 or higher) is required, along with GTK bindings via pygobject3 (>= 3.31.3) and GTK3 (>= 3.22) for the graphical interface.^[27] QEMU/KVM serves as the main hypervisor support, necessitating the QEMU package and KVM kernel modules for hardware-accelerated virtualization.^[27] Hardware prerequisites include a compatible CPU with virtualization extensions enabled in the BIOS/UEFI: Intel VT-x (with EPT for nested paging) or AMD-V (with RVI).^[28] These extensions are essential for efficient full virtualization with KVM, as software emulation without them results in significant performance degradation.^[29] Additional packages enhance functionality: virt-install for scripted virtual machine creation, and libvirt-daemon-system (or equivalent) to manage the libvirt daemon service.^[30] For non-root access, users must be added to the libvirt group (e.g., via usermod -a -G libvirt username on most distributions) to connect to the libvirtd socket without elevated privileges.^[31] This setup ensures secure, permissioned operation of virt-manager on supported Linux distributions.

Distribution-Specific Installation

virt-manager is available through the package repositories of major Linux distributions and some BSD variants, allowing straightforward installation via their respective package managers. Users must ensure that the libvirt daemon is properly configured and running, as detailed in the prerequisites section. On Fedora, installation is performed using the DNF package manager with the command sudo dnf install virt-manager.^[32] After installation, enable and start the libvirtd service using sudo systemctl enable --now libvirtd to allow virt-manager to connect to the hypervisor.^[33] For Ubuntu and Debian-based systems, use the APT package manager: sudo apt install virt-manager.^[34] To grant the user access to libvirt resources, add the user to the libvirt group with sudo adduser $USER libvirt, followed by restarting the libvirtd service via sudo systemctl restart libvirtd.^[34] On Arch Linux, virt-manager and required components for KVM/QEMU can be installed using Pacman: sudo pacman -S libvirt qemu virt-manager dnsmasq.^[6][35] A minimal post-install setup for virt-manager with KVM/QEMU includes the following steps:

1. Verify hardware virtualization support: Run lscpu | grep Virtualization (should show VT-x for Intel or AMD-V for AMD). Enable virtualization in the BIOS/UEFI settings if disabled.^[36]
2. Enable and start the libvirt daemon: sudo systemctl enable --now libvirtd.
3. Add the user to the libvirt group for non-root access: sudo usermod -aG libvirt $USER. Log out and log back in for the change to take effect.
4. (Optional but recommended) Activate the default NAT network: virsh net-start default and virsh net-autostart default.
5. Launch virt-manager: Run virt-manager from the terminal or application menu. Connect to the default QEMU/KVM hypervisor and create a new virtual machine using the wizard (select an ISO, allocate CPU/RAM/storage, etc.).

This provides a basic graphical interface for creating and managing KVM virtual machines with NAT networking. For bridged networking or advanced configurations, consult the Arch Linux Wiki.^[6] Gentoo users install it via Portage with emerge --ask app-emulation/virt-manager.^[10] In FreeBSD, virt-manager is available through the ports collection or as a binary package; install it with pkg install virt-manager or by building from the deskutils/virt-manager port.^[37] virt-manager lacks native support on Windows or macOS, though it can be run in these environments using compatibility layers such as Cygwin on Windows or MacPorts on macOS, or via containerized Linux environments.^[38][39]

Usage

Creating Virtual Machines

To create a new virtual machine in virt-manager, users launch the application via the virt-manager command or desktop shortcut, then click the "Create a new virtual machine" icon in the main window to initiate the New VM wizard. This guided process spans several steps, beginning with naming the virtual machine—using alphanumeric characters, underscores, hyphens, or periods—and selecting the installation method. Supported methods include local installation from an ISO or CD-ROM image, network-based installation via HTTP, FTP, NFS, or PXE boot, and importing an existing disk image for pre-installed operating systems.^[40][41] In the installation media configuration step, users specify the OS type and version to automatically tune hypervisor settings, such as architecture and emulator. For local media, the ISO file is browsed and attached, often stored in /var/lib/libvirt/images/ for accessibility. Network installs require entering a URL to the installation tree, with optional kernel boot parameters like ks= for kickstart files to enable automated provisioning. PXE setups leverage DHCP and TFTP servers for network booting, integrating virt-manager's capabilities with libvirt's virt-install backend for streamlined OS deployment without manual intervention. Following this, resources are allocated: RAM (minimum 512 MB, typically 1-2 GB per vCPU recommended), vCPUs (up to the host's physical cores or threads), and storage, where a new virtual disk is created (e.g., qcow2 format, with a recommended size of at least 5 GB) or an existing volume is selected from a storage pool.^[41][40] Networking is configured next, defaulting to NAT via the "Default" virtual network for shared host access and internet connectivity, though users can select bridged, host-only, or isolated modes and optionally set a custom MAC address. Hardware options, such as adding USB devices or adjusting firmware (e.g., UEFI vs. BIOS), can be referenced briefly for compatibility. The wizard concludes with a summary screen reviewing all settings, including a preview of the underlying libvirt XML configuration for verification or manual tweaks via advanced options. Upon clicking Finish, the VM starts automatically, booting into the installer or imported OS for initial setup.^[40][41]

Networking Modes

In virt-manager (based on libvirt and primarily KVM), common VM networking modes include:

• NAT (also known as shared): The default mode uses libvirt's virtual network (typically named "default"). Virtual machines receive private IP addresses from a virtual subnet, access the internet through the host's NAT, and can communicate with other VMs on the same virtual network. External hosts cannot initiate connections to the VMs. This mode requires no additional host configuration and is ideal for simple internet access scenarios.
• Bridged: Connects the VM directly to a host network bridge (e.g., br0 attached to a physical NIC). The VM obtains an IP address from the physical LAN's DHCP server, behaving like a separate physical machine with full bidirectional connectivity to the local network and internet. This mode provides the best performance and network integration but requires setting up a bridge interface on the host.
• Host-only (isolated): Creates an isolated virtual network where VMs can communicate with each other and the host but have no external network access. Useful for private testing environments or VM-to-host communication without internet exposure.
• VLAN configurations: Supports VLAN tagging (802.1Q) via macvtap interfaces in bridge or VEPA mode, or bridge devices with VLAN filtering. This allows VMs to join specific VLANs on the physical network or maintain internal network segmentation. It is more advanced and typically used in complex enterprise environments.

Bridged networking generally offers the highest performance and most transparent integration, while NAT is the simplest for basic internet access. Host-only suits isolated setups, and VLAN modes enable advanced segmentation. These options are selected in the VM creation wizard or added/modified via the "Add Hardware" dialog for network interfaces, where source, model, and VLAN tags can be configured.^[42][43][44]

Managing and Monitoring VMs

virt-manager provides a graphical interface for performing runtime control operations on established virtual machines (VMs), including starting, stopping, pausing, and rebooting them through dedicated toolbar actions. To start a VM, users select the "Run" option from the toolbar, which initiates the boot process using the configured hypervisor. Pausing a running VM suspends its execution temporarily via the "Pause" button, preserving the current state in memory for quick resumption. For shutdown, the "Shut Down" action sends an ACPI signal to gracefully halt the guest OS, while "Force Off" abruptly terminates the VM, potentially risking data loss. Rebooting follows a similar pattern, with "Reboot" performing a clean restart and "Force Reset" enforcing an immediate power cycle.^[25][45] In networked libvirt environments, virt-manager supports live migration of running VMs between host machines to enable load balancing or maintenance without downtime. Users initiate migration by right-clicking the VM in the main window, selecting "Migrate," and choosing the destination host from a drop-down list of connected systems; the process requires shared storage such as NFS and an SSH connection for secure transfer, with progress displayed in a dedicated dialog. Upon completion, the VM continues executing on the target host seamlessly.^[23] For monitoring, virt-manager offers a real-time performance dashboard accessible via the "Performance" view in the VM details window, featuring interactive graphs that track key metrics such as CPU utilization (both guest and host), memory allocation and usage in MB, and network throughput including input/output rates. These graphs are enabled through the Preferences dialog under the Polling tab, allowing customization of update intervals for disk I/O and other resources as well; the main window also displays summary resource usage bars for all VMs. Event logs, integrated from libvirt, capture VM lifecycle events, errors, and alerts such as resource thresholds or connection issues, viewable in the ~/.cache/virt-manager/virt-manager.log file or via the application's status indicators for proactive troubleshooting.^{[21][46][47][48]} Device hotplug functionality in virt-manager allows dynamic addition or removal of virtual hardware to a running VM, enhancing flexibility without requiring shutdowns. To add devices like disks or GPUs, users open the VM hardware details, click "Add Hardware," select the device type (e.g., storage for disks or PCI Host Device for GPUs), configure parameters such as bus type or capacity, and apply the changes, which triggers libvirt to attach the device immediately with a confirmation prompt to avoid conflicts. Removal follows a similar workflow: select the device in the hardware list and click "Remove," detaching it from the VM after verification that it is not in active use by the guest OS. This feature relies on hypervisor support, such as QEMU's capabilities for PCI and USB hotplug, and may involve loading kernel modules like acpiphp for certain operations.^[49][48] Console access for direct VM interaction and troubleshooting is available through an embedded VNC or SPICE viewer in the UI, as detailed in the User Interface section.^[25]

Technical Integration

With libvirt

virt-manager integrates with libvirt through its Python bindings, provided by the libvirt-python package, which allows the application to access libvirt's C API in a Pythonic manner.^[50] This binding enables virt-manager to query and modify virtual machine (VM) definitions by calling functions such as virDomainDefineXML and virDomainGetXMLDesc, where graphical user interface (GUI) inputs from the user—such as CPU allocation, memory settings, or disk configurations—are translated into libvirt's domain XML format for storage and execution.^[51] The translation process ensures that VM configurations remain hypervisor-agnostic at the libvirt level, abstracting underlying details like QEMU command-line arguments.^[52] For connectivity, virt-manager establishes connections to libvirt daemons using URIs like qemu:///system for local system-wide access or qemu+ssh://user@host/system for remote management, facilitating multi-host environments where a single interface can oversee VMs across networked servers.^[53] Authentication for these connections supports mechanisms such as SASL for username/password-based security or TLS for encrypted, certificate-based verification, configurable via libvirt's daemon settings to ensure secure remote operations.^[54] To provide real-time feedback in the GUI, virt-manager registers callbacks with libvirt's event system through the Python bindings, monitoring domain lifecycle events like startup, shutdown, or migration without requiring direct interaction with the hypervisor backend. This event-driven approach allows the application to update displays dynamically—for instance, reflecting a VM's transition from "running" to "paused"—while maintaining separation from low-level hypervisor calls.^[51]

Supported Hypervisors

virt-manager interfaces with various hypervisors through the libvirt virtualization API, enabling management of diverse virtualization technologies on Linux hosts.^[1] The primary supported hypervisors include KVM/QEMU for hardware-assisted virtualization, Xen for both paravirtualized and fully virtualized domains, and LXC for lightweight container-based isolation.^[55] KVM/QEMU serves as the core hypervisor in virt-manager, providing full hardware virtualization capabilities via the Kernel-based Virtual Machine (KVM) module and QEMU emulator. It supports multiple architectures, including x86 (both 32-bit and 64-bit), ARM (aarch64), and PowerPC (PPC64), allowing virt-manager to create and manage virtual machines across these platforms.^[56] Key features include nested virtualization, where a guest VM can itself act as a hypervisor to run additional nested guests, enhancing flexibility for development and testing environments.^[56] This driver leverages hardware accelerators like KVM on Linux for efficient performance, with support for QEMU versions 6.2.0 and later.^[56] Xen integration in virt-manager allows management of domains using the Xen hypervisor, which supports both paravirtualization—where guests are aware of the hypervisor and optimized for performance—and Hardware Virtual Machine (HVM) modes for full emulation of legacy hardware.^[57] In paravirtualized mode, guests boot via a bootloader like pygrub or direct kernel loading, while HVM guests use a loader such as hvmloader for BIOS-based initialization.^[57] Domain management is handled through libvirt's libxl driver for Xen 4.6.0 and newer, supporting local and remote connections via URIs like xen:///system.^[57] For containerization, virt-manager supports LXC through libvirt's container driver, treating Linux Containers as lightweight domains with kernel-level isolation using namespaces (for mount, IPC, PID, UTS, and optionally network and user) and control groups (cgroups).^[58] This enables virt-manager to impose resource limits, such as memory allocation (e.g., 500 MB) and CPU counts (e.g., 1 vCPU), via domain XML configuration.^[58] Networking is configurable with separate interfaces, often bridged to host networks, and security is enhanced by sVirt for mandatory access control.^[58] Unlike full VMs, LXC domains share the host kernel, making them suitable for efficient, application-focused isolation without the overhead of emulation.^[58]