Skip to the content
Know your tech before you buy it. Makers: get listed from $49/mo

AFL++

By AFL++ · github.com

  • Free plan
  • Windows
  • macOS
  • Linux
  • Android
  • Self-hosted
7.9 Club score Visit github.com

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.

AGPL-3.0-or-later

Free

Commercial license

€20,000/yr

Free plan

Getting started

  1. Open the AFL++ GitHub website
  2. Choose a supported platform or self-hosted environment
  3. Install LLVM 18 or newer on Linux, or use LLVM 14 minimum
  4. Select source-only, binary-only, or combined build mode
  5. Use the Docker image for x86_64 or arm64 and mount target source at /src
  6. 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.