Skip to content
Install

Performance

Three measured workloads, the configuration behind them, the commands that reproduce them, and where the remaining time goes.

Volant is measured on three real workloads, each run by a recipe in the repository. Every figure on this page comes from those recipes.

On four Ansible Galaxy roles (geerlingguy.security, nginx, git and pip) applied to two Ubuntu 24.04 hosts that had already converged, Volant finishes in 0.529 s where ansible-core 2.19.12 with pipelining = True takes 26.435 s, a ratio of 49.97. On the official k3s-ansible site.yml, against an installed cluster, Volant takes 23.477 s and the reference 50.519 s, a ratio of 2.15. Measured on 2026-09-27 with just bench and just bench-k3s, which reproduce these figures. They have not been measured again since. The third workload, a full molecule test of a Galaxy role, is described under Molecule.

Two workloads, two converged hostsMedian of three timed passes, 2026-09-27. Reference: ansible-core 2.19.12, pipelining = True. Shorter is faster.
  • ansible-core 2.19.12
  • Volant
  • Four Galaxy roles26.435 s0.529 sFour Galaxy rolesansible-core 2.19.12: 26.435 sVolant: 0.529 s
  • k3s-ansible site.yml50.519 s23.477 sk3s-ansible site.ymlansible-core 2.19.12: 50.519 sVolant: 23.477 s
Show as a table
ansible-core 2.19.12Volant
Four Galaxy roles26.435 s0.529 s
k3s-ansible site.yml50.519 s23.477 s

The two ratios are far apart because the roles change nothing on a converged host, so most of the reference’s time there goes to the machinery around each module, and Volant removes most of that. The k3s playbook restarts services and runs install scripts on every pass, and that work takes as long under either engine. What is left breaks it down.

Managed hosts two Ubuntu 24.04 hosts, 4 cores each, on an overlay network
Controller Ubuntu 26.04, 8 cores
Volant release build of e57fbe5 (v0.1.0-alpha.7-74-ge57fbe5), default settings: native modules on, one ssh connection per host, --facts auto, batching off
Reference ansible-core 2.19.12, pipelining = True, forks left at its default of 5, every other setting at its default
Roles workload geerlingguy.security 3.0.2, geerlingguy.nginx 3.3.1, geerlingguy.git 3.0.1 and geerlingguy.pip 3.1.2 in one play, become: true, facts gathered, 56 tasks per host
k3s workload the k3s-ansible playbooks at a pinned commit, k3s v1.31.12+k3s1, one server and one agent, the cluster installed first by a pass of the reference
Passes one untimed warm-up pass per engine, then three timed passes of each, median reported

Every timed pass has its PLAY RECAP compared with the first one, across both engines. A difference would mean the engines did different work, and the recipe would fail. On the roles every pass ended on ok=28 changed=0 skipped=28 per host. On k3s every pass ended on ok=34 changed=2 skipped=69 for the server and ok=19 changed=3 skipped=54 for the agent. The changed tasks are the real work described under What is left.

The individual passes:

Workload Volant (s) ansible-core (s)
Four Galaxy roles 0.530, 0.529, 0.524 26.408, 26.438, 26.435
k3s-ansible 24.150, 23.448, 23.477 51.121, 50.519, 50.505

Both recipes build Volant in release mode, run against the hosts you name, and print the medians and the ratio. The controller needs ansible-core 2.19.12 installed with uv tool install, and the account on the hosts needs sudo without a password.

Terminal window
VOLANT_TARGET_HOST=host1 VOLANT_SECOND_HOST=host2 just bench 3
VOLANT_TARGET_HOST=host1 VOLANT_SECOND_HOST=host2 just bench-k3s 3

Every timed Volant pass also writes its profile through VOLANT_PROFILE_JSON, under target/bench/, so a surprising number can be traced to the task that caused it. The tables below come from those files.

Times are per host, from the median pass of 2026-09-27. The same workloads measured on 2026-09-24, before the native modules, took 12.66 s for the roles (reference 26.23 s) and 37.53 s for k3s (reference 50.19 s). Decision record 0008 has the profile of that day.

Step Time
Building the Python module union on the controller 15.3 ms, read from the cache
apt, 8 tasks, packages installed, cache fresh 38.4 ms, native
setup, gathering facts 47.6 ms, native
systemd, 3 tasks 52.4 ms, native
file ×8, lineinfile ×8, stat ×5 52.8 ms, native
Opening the connections 172.6 ms
Preparing tasks on the controller 25.0 ms
Frames and blobs on the wire 27.1 ms
Waiting for the other host at each task 10.6 ms
Wall clock, two hosts 0.529 s (reference 26.435 s)

All 66 module tasks of the median pass, 33 per host, were answered by a native module. None was handed back, so no Python server started on either host.

Where the two hosts differ, the figures are the server’s.

Step Time
Building the Python module union, collections included 30.6 ms, read from the cache
Restarting the k3s service, server and agent 8,269 + 4,763 ms, native systemd
service_facts 2,485 ms, native
package_facts 168 ms, native
apt: name=policycoreutils update_cache=true 2,205 ms, handed back to Python
Gathering facts 55 ms, native
Preparing tasks on the controller 185 ms
Opening the connections 350 ms
Waiting for the other host at each task (agent) 253 ms
Wall clock, two hosts 23.477 s (reference 50.519 s)

In the median pass, 28 tasks ran natively, 11 were handed back to the Python module, and 5 ran a module with no native version (ansible.posix.sysctl and wait_for).

On k3s most of Volant’s 23.5 seconds is work the playbook asks for:

  • the restarts of the k3s service, about 8.3 seconds on the server and 4.8 on the agent, spent in systemctl and k3s itself;
  • the k3s install script, about 1.4 to 1.5 seconds per host;
  • 13 command tasks, such as k3s --version, about 3.1 seconds across both hosts.

Both engines pay for these the same way, because they are processes running on the host.

Two steps are held back by what the reference itself does:

  • service_facts runs the commands ansible-core runs (systemctl list-unit-files, service --status-all and one systemctl show per unit) so that its answer is the same. The native module runs them side by side where the reference runs them one after the other, and they still make up most of its 2.4 seconds. It cannot go below them while it reads the same sources.
  • The playbook’s apt task sets update_cache without cache_valid_time, so the reference runs apt-get update on every pass. When this was measured, the native apt only answered a task with nothing to do, so this one went to the Python module, and the cache refresh is most of its 2.2 seconds. Since 2026-10-25 the native apt runs the update itself (#879).

Those two steps together cost 4.5 to 4.7 seconds per host. Making them faster would mean reading other sources than the reference reads, and that decision is left to a later release.

molecule test runs the whole test sequence of a role. It removes any container left from an earlier run, checks the syntax, creates a container, applies the role (converge), applies it a second time to check that nothing changes (idempotence), and removes the container. Molecule starts ansible-playbook for each of these playbooks, so with Volant’s ansible-playbook first on PATH the whole sequence runs under Volant, with no change to the role or to Molecule.

On geerlingguy.nginx with the docker driver, a full molecule test takes 60.349 s under Volant and 96.102 s under ansible-core 2.19.12, a ratio of 1.59. Both engines report the same PLAY RECAP lines on every pass. Measured on 2026-11-08 with just bench-molecule 5.

molecule test on geerlingguy.nginx, docker driverMedian of five timed passes per engine, 2026-11-08. Reference: ansible-core 2.19.12 with the configuration Molecule writes. Shorter is faster.
  • ansible-core 2.19.12
  • Volant
  • Create9.750 s5.931 sCreateansible-core 2.19.12: 9.750 sVolant: 5.931 s
  • Converge51.650 s38.133 sConvergeansible-core 2.19.12: 51.650 sVolant: 38.133 s
  • Idempotence13.133 s3.320 sIdempotenceansible-core 2.19.12: 13.133 sVolant: 3.320 s
  • Destroy, twice15.801 s11.288 sDestroy, twiceansible-core 2.19.12: 15.801 sVolant: 11.288 s
  • Whole test96.102 s60.349 sWhole testansible-core 2.19.12: 96.102 sVolant: 60.349 s
Show as a table
ansible-core 2.19.12Volant
Create9.750 s5.931 s
Converge51.650 s38.133 s
Idempotence13.133 s3.320 s
Destroy, twice15.801 s11.288 s
Whole test96.102 s60.349 s
Role geerlingguy.nginx at commit 5ff0b23, its default scenario: one Rocky Linux 9 container, 22 tasks
Image geerlingguy/docker-rockylinux9-ansible, pinned by digest, pulled before the passes
Molecule Molecule 26.11.0, molecule-plugins 26.11.0 and ansible-compat 26.11.0 in a Python 3.12 virtual environment, with community.docker 4.8.5 and ansible.posix 2.2.2
Reference ansible-core 2.19.12 from the same virtual environment, with the ansible.cfg Molecule writes (forks = 50) and every other setting at its default
Volant release build of da423e7 (v0.1.0-alpha.13-265-gda423e78), run through its ansible-playbook link, with VOLANT_RUNTIME=system
Machine the controller of the other workloads (Ubuntu 26.04, 8 cores), which also runs Docker 29.1.3 and the container
Load one-minute load average between 0.84 and 2.30 before and after every timed pass, in the same range for both engines
Passes one untimed warm-up pass per engine, then five timed passes of each, alternating, median reported

Every pass starts with no container and must end with none. On every pass converge ended on ok=14 changed=8 skipped=8 and idempotence on ok=12 changed=0 skipped=8, under both engines.

A small ansible-playbook placed first on PATH times each playbook Molecule starts, the same way for both engines, which gives the split by step:

Step ansible-core (s) Volant (s)
Create the container 9.750 5.931
Converge 51.650 38.133
Idempotence 13.133 3.320
Destroy, at the start and at the end 15.801 11.288
Syntax check 0.749 0.027
Molecule’s own work 5.167 1.650
Whole test 96.102 60.349

Each row is a median on its own, so the rows do not add up to the last one. Molecule’s own work is what is left of the whole test once the playbooks are taken out. It includes the ansible-playbook --version calls Molecule makes, which run under the engine being measured.

The whole test, pass by pass:

Engine Passes (s)
ansible-core 100.599, 95.499, 96.675, 96.102, 95.646
Volant 61.769, 60.048, 60.349, 60.095, 60.794

Most of the time left under Volant is spent outside the engine:

  • Converge installs nginx with dnf, which downloads packages from the Rocky Linux and EPEL mirrors. Idempotence runs the same tasks with nothing to install and takes 3.320 s, so most of converge’s 38.133 s is the package installation. That time depends on the mirrors: one untimed warm-up of the reference failed when an EPEL mirror did not answer.
  • Docker starts the container during create and stops and removes it during destroy. The engine only waits for it.
  • A first molecule test on a new machine also pulls the image, 268,904,562 bytes. The recipe pulls it before the timed passes, so the figures above leave that download out. Its length depends on your network.

Two differences show in the logs and not in the recaps. Volant polls async_status sooner than ansible-core, so destroy can print one more FAILED - RETRYING line while it waits for docker. And the Volant passes set VOLANT_RUNTIME=system: without it, the implicit localhost runs the docker driver’s modules under Volant’s managed Python, which does not have the docker library, where ansible-core uses the Python of the virtual environment (#1422).

The recipe needs Docker and uv on the machine that runs it, and no other host. It builds Volant in release mode, installs the pinned versions under target/molecule/, fetches the role at its commit and pulls the image by digest:

Terminal window
just bench-molecule 5

The first argument is the number of timed passes per engine. Before each pass the recipe waits until no build or other ansible-playbook runs and the one-minute load average is under the second argument, 1.5 by default. It writes the medians and the load range to target/molecule/logs/, and fails if two passes report different PLAY RECAP lines or if a container named instance exists before or after a pass.

Decision record 0008 explains the choices behind these numbers and the options that were measured and dropped.