pymute

pymute is a free mutation-testing utility for Python projects built around pytest or tox. It best suits developers comfortable installing Rust tooling and arranging tests to run against temporary project copies. Its focused reports and run controls are useful, but packaging and disk-space constraints make it a poor fit for some test layouts.

Overview

Mutation testing deliberately changes source code and checks whether a test suite detects the change. pymute creates a separate temporary directory for each mutant and edits Python file text to insert mutations instead of working on the abstract syntax tree. That approach keeps the tool centered on source-level changes, while making its project-copy workflow an important part of adoption.

The default report shows mutants that survived because tests passed. Those survivors are the most actionable signal for finding weak assertions or untested behavior. Higher output levels can also show caught mutants and the underlying process output when a run needs more diagnostic context.

Key features

Mutation operators and scope

Supported operators cover mathematical operators, conjunctions, booleans, control flow, comparison operators, and numbers. The --modules option filters files with a glob, and files named test_* or ending in *_test.py are excluded automatically. You can choose mutation types to keep a run relevant to the code under review.

Targeted and parallel runs

The --tests option selects tests, which is practical when iterating on a particular module instead of running an entire suite. --max-mutants limits work to a randomly sampled subset, trading complete coverage of possible mutations for shorter feedback cycles. --num-threads controls parallel execution, so larger machines can process mutants concurrently.

Parallelism has a concrete cost: every thread needs temporary disk space. Runs can fail when /tmp is exhausted, making storage capacity part of planning rather than an incidental operational detail.

Test runners

Pytest is the default runner, with tox available as an alternative. With pytest, tests must run from the project root in independent copies and test the local copy rather than an installed package. Projects whose tests assume an installed distribution or a different working-directory model will need restructuring.

Tox provides a more installation-like environment, but it creates a separate virtual environment and installs the package for every mutant. The resulting setup work is considerably slower, so tox is better reserved for projects that need that isolation and can accept long mutation runs.

Pricing

There are no paid tiers, seat charges, quotas, trial periods, or renewal terms. The tradeoff is operational rather than financial: users supply the Rust and Cargo toolchain and accommodate temporary-copy execution themselves.

Platforms

pymute supports Linux and targets Python projects using pytest or tox. Distribution is through Cargo from crates.io or directly from GitHub, and installation therefore requires Rust and Cargo. The repository identifies version 0.2.1 and the author as Leonard Sasse, and uses the Unlicense.

Who it's for

Choose pymute if you maintain Python tests, want a no-cost way to measure whether they catch common code changes, and can run a Rust-installed command against disposable project directories. Its module and test selection, random mutant cap, and parallel threads suit focused development runs as well as broader checks.

Look elsewhere if your pytest suite only works against an installed package, cannot run from the project root, or lacks temporary disk headroom for concurrent copies. Tox users should also budget for substantially slower execution caused by per-mutant environment creation.

Pros and cons

Pros

• Free distribution: There is a single 0.00 USD plan with no paid-tier restrictions.
• Actionable default report: Surviving mutants put test-suite gaps first, while extra output levels provide caught-mutant and process detail when needed.
• Useful run controls: Module globs, test selection, operator selection, random sampling, and configurable parallelism help contain large jobs.
• Broad core operators: Mathematical, boolean, conjunction, control-flow, comparison, and numeric mutations cover several common defect patterns.

Cons

• Rust prerequisite: Installation through Cargo requires Rust and Cargo, adding a toolchain dependency to a Python workflow.
• Pytest layout restriction: Tests must run from the root in independent copies and exercise the local copy, excluding some packaging arrangements.
• Tox performance cost: A fresh environment and package installation for each mutant makes tox considerably slower.
• Temporary-storage risk: Parallel threads consume disk space and can fail when /tmp fills.
• Text-based mutation: Editing source text rather than an AST can be less accommodating of source-structure edge cases.

Alternatives

Mutation Testing Tools is the broader category starting point when you want to compare mutation-testing options.

• ArcMutate is the better choice when you need macOS or Windows support, self-hosting, or a freemium model with an $8.00-per-month Base plan; its Open Source plan is free for open-source projects.
• MuJava suits Java users who want a free Apache-licensed option across Linux, macOS, and Windows.
• Mutant is worth choosing for public repositories on its free full-feature plan, or for commercial teams needing any number of repositories at $30.00 per developer per month.
• Mutatest is a free, MIT-licensed alternative for users who prefer a cross-platform Python option.
• go-mutesting is for Go projects needing a free MIT-licensed framework on Linux or self-hosted systems.
• LittleDarwin is a free Linux Java mutation-analysis framework supported through donations.
• MutPy is a free Linux or self-hosted option with no paid plans or usage limits stated.
• pytest-gremlins is a free MIT-licensed Python package for Linux that requires Python 3.11 or newer.

Verdict

pymute is a strong fit for Linux-based Python teams that can install Rust, keep tests local to temporary project copies, and value configurable pytest mutation runs at no cost. Choose it for survivor-focused feedback and practical scoping controls; look elsewhere when your packaging model conflicts with pytest’s layout rules, tox’s per-mutant setup is too slow, or your environment cannot spare temporary disk space.