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.
pipelining = True. Shorter is faster.- ansible-core 2.19.12
- Volant
- Four Galaxy roles
- k3s-ansible site.yml
Show as a table
| ansible-core 2.19.12 | Volant | |
|---|---|---|
| Four Galaxy roles | 26.435 s | 0.529 s |
| k3s-ansible site.yml | 50.519 s | 23.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.
Configuration
Section titled “Configuration”| 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 |
Reproducing the figures
Section titled “Reproducing the figures”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.
VOLANT_TARGET_HOST=host1 VOLANT_SECOND_HOST=host2 just bench 3VOLANT_TARGET_HOST=host1 VOLANT_SECOND_HOST=host2 just bench-k3s 3Every 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.
Where the time went
Section titled “Where the time went”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.
Four Galaxy roles
Section titled “Four Galaxy roles”| 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.
k3s-ansible
Section titled “k3s-ansible”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).
What is left
Section titled “What is left”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
systemctland k3s itself; - the k3s install script, about 1.4 to 1.5 seconds per host;
- 13
commandtasks, such ask3s --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_factsruns the commands ansible-core runs (systemctl list-unit-files,service --status-alland onesystemctl showper 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
apttask setsupdate_cachewithoutcache_valid_time, so the reference runsapt-get updateon every pass. When this was measured, the nativeaptonly 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 nativeaptruns 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
Section titled “Molecule”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.
- ansible-core 2.19.12
- Volant
- Create
- Converge
- Idempotence
- Destroy, twice
- Whole test
Show as a table
| ansible-core 2.19.12 | Volant | |
|---|---|---|
| Create | 9.750 s | 5.931 s |
| Converge | 51.650 s | 38.133 s |
| Idempotence | 13.133 s | 3.320 s |
| Destroy, twice | 15.801 s | 11.288 s |
| Whole test | 96.102 s | 60.349 s |
Configuration of the Molecule workload
Section titled “Configuration of the Molecule workload”| 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 |
What Volant does not change
Section titled “What Volant does not change”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 teston 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).
Reproducing the Molecule figures
Section titled “Reproducing the Molecule figures”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:
just bench-molecule 5The 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.