go-mutesting

go-mutesting is a mutation-testing framework for Go developers who want evidence that their tests catch meaningful code changes. It fits projects with Go package tests or a custom test command; its focused language support and acknowledged false-positive risk make it a strengthening check, not a replacement for ordinary testing.

Overview

The tool creates mutations in Go source and runs tests against each one, reporting whether the suite kills, leaves alive, skips, or cannot classify the change. It calculates a mutation score from the proportion of killed mutations and prints a source patch when a mutation survives. That combination turns an abstract test-quality concern into specific code and assertions to inspect.

Targets may be individual Go files, directories, or packages, including recursive ... patterns. Files ending in _test are excluded. By default, go-mutesting replaces the original file with a mutation, runs that package's tests, and reports the result, so it is most natural in repositories already organized around Go package testing.

This is a developer-focused command-line framework rather than a broad, multi-language testing service. It supports Go on Linux and is self-hosted. The project is MIT-licensed, and its README invites feature requests and bug reports.

Key features

Operators and mutation results

Built-in mutators alter branches such as case, if, and else; comparisons; boolean expressions; and statement removal. Projects using the Cosmos SDK also receive arithmetic and comparison operators. The set covers common control-flow and expression weaknesses, while the reported outcomes and surviving patches help reviewers prioritize tests instead of relying on a raw coverage percentage.

Custom test execution

When package tests are not the right harness, the --exec option delegates each mutation to an external command. Environment variables describe the mutation, and exit codes communicate whether it was killed, alive, skipped, or unknown. This makes the framework adaptable to a repository's own validation command, provided that command can interpret the supplied context correctly.

Extensible mutators

Teams can implement the Mutator interface and register custom mutators with the binary. That is useful when domain-specific changes matter more than the built-in operators, but it requires Go development and maintenance rather than configuration alone.

False-positive handling

A checksum blacklist can ignore mutations judged to be false positives. However, the README warns that this feature is poorly implemented because changing source files also changes checksums. Treat blacklist results cautiously and review surviving mutations manually; the project explicitly positions mutation testing as a supplement to an automatic test suite.

Pricing

go-mutesting costs nothing. The single go-mutesting plan is an MIT-licensed open-source framework, with no paid tier, trial period, seat charge, or usage quota stated. That makes it suitable for individual developers and teams that can run and maintain a self-hosted tool. The trade-off is that the plan does not provide a separate hosted service or commercial support tier; execution, integration, and interpretation remain your responsibility.

Platforms

go-mutesting supports Linux and self-hosted deployment. Its supported language is Go, and its default test integration is Go package tests. External commands extend the testing workflow, but they do not broaden the framework beyond a Go mutation-testing setup.

Who it's for

Choose go-mutesting when you maintain a Go codebase with an established package-test suite and want to discover assertions that fail to detect deliberate changes. It is also a good fit for teams comparing automatically generated and manually written tests, or for projects that need custom mutation operators, including Cosmos SDK-specific arithmetic and comparison checks.

Look elsewhere if you need macOS or Windows support, a multi-language mutation platform, or a managed service. The tool's source-replacement workflow and uncertain checksum blacklist also demand disciplined runs and human review, particularly in suites where false positives would be costly.

Pros and cons

Pros

• Concrete diagnostics: Surviving mutations include source patches, giving developers a direct starting point for stronger assertions.
• Flexible scope: Files, directories, packages, and recursive ... targets let teams focus runs without changing project layout.
• Adaptable execution: The --exec command and mutation-specific environment variables support testing workflows beyond the default package tests.
• Extensible and free: Custom Mutator implementations, MIT licensing, and a 0.00 USD plan remove licensing barriers for Go teams.

Cons

• Go and Linux focus: It does not suit teams needing another implementation language or a Windows or macOS runtime.
• False-positive caveat: The checksum blacklist is described as poorly implemented, so results cannot be accepted without review.
• Operational responsibility: Self-hosting means your team handles execution, integration, and maintenance rather than receiving a managed workflow.

Alternatives

ArcMutate is the better choice for teams needing Linux, macOS, Windows, or self-hosted coverage, plus a freemium model with a free open-source plan and an $8.00-per-month Base plan.

MuJava suits Java projects that want a free, Apache-licensed tool across Linux, macOS, and Windows.

Mutant is worth choosing when a commercial option matters: its open-source plan covers public repositories, while Commercial monthly costs $30 per developer.

Mutatest is a free MIT-licensed alternative for teams working across Linux, macOS, and Windows.

LittleDarwin is a Linux-only, donation-supported Java mutation-analysis framework.

MutPy is a free Linux and self-hosted option with no paid plans or usage limits stated.

pymute is a free Linux tool installed with Cargo for teams prepared to use Rust and Cargo.

pytest-gremlins is a free, MIT-licensed Linux package for Python 3.11 and newer.

Browse Mutation Testing Tools for the wider category.

Verdict

go-mutesting is a strong fit for Go teams that want mutation scores and surviving-code patches inside an existing package-test workflow, with custom commands and mutators available when the defaults are not enough. Choose it for its focused diagnostics and zero licensing cost; look elsewhere if you need cross-platform or cross-language support, managed operation, or less manual handling of false positives.