What AFL++ is
AFL++ is a coverage-guided fuzzer that alters inputs to a target program and checks whether they reach previously unseen execution paths. Its afl-cc compiler supports LTO, LLVM, and GCC_PLUGIN instrumentation modes. Other listed capabilities include collision-free coverage, AFLfast++ power schedules, MOpt mutators, laf-intel, and redqueen. Documentation covers fuzzing programs with available source, binary-only targets, network services, and GUI programs; builds can target source-only fuzzing, binary-only fuzzing, or both. A Docker image is provided for x86_64 and arm64, with an example that mounts target source at /src. On Linux, installation guidance recommends LLVM 18 or newer and identifies LLVM 14 as the minimum. macOS build guidance covers x86_64 and arm64, but notes that afl-clang-lto, afl-gcc-fast, and qemu_mode do not work there. The project warns that fuzzing can strain hardware, use substantial memory or disk, and generate heavy filesystem activity. AFL++ is free under AGPL-3.0-or-later; modified versions offered as network services must offer users the corresponding source. A commercial license is listed at €20,000 a year.
Who it suits
AFL++ suits developers and security practitioners fuzzing source-available programs, binary-only targets, network services, or GUI programs. Users should be prepared to manage its resource demands and comply with its license terms.
Good to know, and what to watch
- Supports LTO, LLVM, and GCC_PLUGIN instrumentation.
- Documentation covers source, binary, network, and GUI targets.
- Docker image supports x86_64 and arm64.
- Free use is available under AGPL-3.0-or-later.
- GitHub issues, FAQ, and Fuzzing Zulip are listed support channels.
- Fuzzing can consume substantial memory or disk.
- Fuzzing can generate heavy filesystem activity.
- Several named modes do not work on macOS.
- Modified network services must offer corresponding source under AGPL terms.
Plans
Every plan and priceAGPL-3.0-or-later
Commercial license
Free plan
Getting started
- Open the AFL++ GitHub website
- Choose a supported platform or self-hosted environment
- Install LLVM 18 or newer on Linux, or use LLVM 14 minimum
- Select source-only, binary-only, or combined build mode
- Use the Docker image for x86_64 or arm64 and mount target source at /src
- Choose the stable branch or the bleeding-edge dev branch
Limits to check
The free AGPL plan permits use, study, modification, and distribution under AGPL terms. Modified versions offered as network services must provide users the corresponding source; the commercial alternative is €20,000 a year for a one-year license.
The Club's review
Overview
AFL++ is a free, coverage-guided fuzzer that mutates inputs to uncover new execution paths in target software. It is best suited to developers and security teams who can build or run programs locally and want flexibility across source code and binary targets. Its broad instrumentation choices are compelling, but hardware demands and AGPL terms deserve close attention before adoption.
Key features
Instrumentation and mutation
The central afl-cc compiler supports LTO, LLVM, and GCC_PLUGIN instrumentation. AFL++ also offers collision-free coverage, AFLfast++ power schedules, MOpt mutators, laf-intel, and redqueen. That range gives teams choices in how targets are instrumented and how mutation is guided, rather than locking them into one approach. Coverage guidance and crash triage are supported, as is CI/CD integration.
Target flexibility
The documentation covers source-available programs, binary-only targets, network services, and GUI programs. Build modes can target source-only fuzzing, binary-only fuzzing, or a distribution build containing both. This makes AFL++ a strong fit for teams testing a varied target estate; its local execution model is less suited to organizations seeking a managed fuzzing service.
Containers and resource demands
A Docker image supports x86_64 and arm64, and its example command mounts target source at /src. Linux installation guidance recommends LLVM 18 or newer, with LLVM 14 as the minimum. The project also warns that fuzzing can strain hardware, consume substantial memory or disk, and generate heavy filesystem I/O. Teams should plan for those costs rather than assume fuzzing is a lightweight background task.
Release choices and support
The stable branch is the default for users prioritizing stability. The dev branch is bleeding edge and may fail to compile or contain bugs, making it a riskier choice for dependable workflows. For help, maintainers direct users to GitHub issues for defects, the FAQ and best practices, and the Fuzzing Zulip server.
Pricing
AFL++ has a free plan at free. The AGPL-3.0-or-later plan permits use, study, modification, and distribution under AGPL terms. The key tradeoff is that modified versions offered as network services must provide users with the corresponding source. Individual files marked Apache-2.0 may be reused under that license, while bundled third-party components keep their own licenses.
The commercial license costs €20,000 a year, billed as a donation to EFF or CCC. It lasts one year and can be renewed by donating again; proof of donation must be emailed. This option is intended for organizations that cannot or do not want to comply with AGPL, but its annual cost makes the free AGPL route the practical choice for teams able to meet those obligations.
Platforms
AFL++ supports Android, Linux, macOS, self-hosted, and Windows environments. The macOS guide documents builds on x86_64 and arm64, but afl-clang-lto, afl-gcc-fast, and qemu_mode do not work there. Those exclusions matter for teams whose workflow depends on one of those modes. The Docker image supports x86_64 and arm64.
Who it's for
AFL++ suits developers and security teams working with C, C++, Python, or Rust who want local, coverage-guided fuzzing and can manage target builds or binaries. It is especially attractive when different projects need different instrumentation or target modes. Teams should account for its resource footprint and decide whether AGPL obligations fit their deployment, particularly if offering modified versions as network services.
Pros and cons
- Pro: Multiple instrumentation modes and mutation approaches give teams flexibility across targets and fuzzing strategies.
- Pro: Documentation covers source-based, binary-only, network-service, and GUI targets, with build modes for source, binary, or both.
- Pro: Free use is available under AGPL terms, with a paid commercial-license route for organizations that cannot comply.
- Con: Fuzzing can consume substantial memory and disk, strain hardware, and create heavy filesystem I/O.
- Con: macOS does not support afl-clang-lto, afl-gcc-fast, or qemu_mode.
- Con: Modified network-service versions must offer users corresponding source under the AGPL plan.
Alternatives
For API scanning with a free allowance and paid plans, consider Mayhem: its free plan includes up to 50 scans per month, and paid plans start at $236 a month.
For Rust projects seeking a free fuzzing tool, cargo-fuzz is another option, with Linux, macOS, and Windows support.
ClusterFuzz is a free, Apache-2.0-licensed option for teams whose production deployment can depend on Google Cloud services.
For coverage-guided, in-process JVM fuzzing, choose Jazzer, which supports Linux, macOS, and Windows.
Accessibility Test Framework for Android is another free option for Android accessibility testing.
Teams building protocol fuzzers as Python scripts may prefer boofuzz, a free GPL-2.0 Python library.
For JavaScript engine fuzzing, Fuzzilli is a free Apache-2.0 option that requires building the fuzzer and a supported, instrumented JavaScript engine.
EvoMaster is another free fuzz-testing tool to consider.
Browse Fuzz Testing Software for more options. Readers looking for other software categories can also explore Stream Processing Software and Game Mod Managers.
Verdict
Choose AFL++ if you need a flexible local fuzzer with multiple instrumentation and target options, and can budget for its hardware demands and comply with AGPL terms. Its breadth is the main reason to adopt it; macOS mode exclusions and the resource and licensing obligations are strong reasons to look elsewhere when they conflict with your workflow.
The verdict
AFL++ offers multiple instrumentation and target options for coverage-guided fuzzing. Review the platform caveats, expected resource use, and AGPL obligations before adopting it.
Questions people ask
Is AFL++ free?
Yes. The AGPL-3.0-or-later plan is free.
Which platforms does AFL++ support?
Listed platforms are Android, Linux, macOS, self-hosted, and Windows.
What does AFL++ fuzz?
Documentation covers source-available programs, binary-only targets, network services, and GUI programs.
What license options are available?
AFL++ offers AGPL-3.0-or-later and a commercial license priced at €20,000 a year.
Which languages are supported?
Supported languages are C, C++, Python, and Rust.
Where can users get support?
Maintainers direct users to GitHub issues, the FAQ and best practices, and the Fuzzing Zulip server.
What the maker publishes
- Build modes
- Build targets include source-only fuzzing, binary-only fuzzing, or a distribution build with both. source
- Compiler instrumentation
- Its central afl-cc compiler supports LTO, LLVM, and GCC_PLUGIN instrumentation modes. source
- Container image
- The project provides a Docker image for x86_64 and arm64, with the target source mounted at /src in its example command. source
- Founded
- 2019 source
- Free plan
- Yes source
- Hardware and storage limits
- The project warns that fuzzing can strain hardware, consume large amounts of memory or disk, and generate heavy filesystem I/O. source
- License exceptions
- Individual source files marked Apache-2.0 may be reused under that license, while bundled third-party components retain their own licenses. source
- License obligations
- The combined afl-fuzz program is AGPL as a whole, and modified versions offered as network services must offer users the corresponding source. source
- Linux requirements
- The installation guide recommends LLVM 18 or newer and gives LLVM 14 as the minimum. source
- macOS support
- The guide documents building on macOS x86_64 and arm64, but says afl-clang-lto, afl-gcc-fast, and qemu_mode do not work there. source
- Mutation and coverage
- The project lists collision-free coverage, AFLfast++ power schedules, MOpt mutators, laf-intel, and redqueen among its features. source
- Purpose
- AFL++ is a coverage-guided fuzzer that mutates input and checks whether it reaches a new path in the target binary. source
- Release channels
- The stable branch is described as the stability-focused default, while dev is bleeding edge and may fail to compile or contain bugs. source
- Support
- The maintainers direct users to GitHub issues for AFL++ defects, the FAQ and best practices, and the Fuzzing Zulip server. source
- Target types
- The documentation covers fuzzing source-available programs, binary-only targets, network services, and GUI programs. source
Checked against the maker's pages on 28 Sept 2026.