Automated integer factorization.

YAFU (with assistance from other free software) uses the most powerful modern algorithms (and implementations of them) to factor input integers in a completely automated way.

YAFU has been referenced several times in the academic literature. If you have academic work that requires integer factorization, YAFU might be able to help.

For factorization help, support, and discussion, see the community at https://www.mersenneforum.org/node/58.

Detailed documentation lives in the project wiki. The wiki covers every option, every callable function, and a fuller version of the build instructions below.

Download from the latest release. All Windows builds are fully static — no extra DLLs required, runs in cmd.exe and PowerShell.

Not sure which to pick? Run wmic cpu get name in a Windows command prompt and look up your CPU generation, or just start with avx2 — it works on nearly every CPU sold since 2015.

yafu "factor(rsa(200))"

Or launch the interactive prompt:

yafu
>> factor(2056802480868100646375721251575555494408897387375737955882170045672576386016591560879707933101909539325829251496440620798637813)

Files YAFU writes (logs, savefiles, yafu.ini) go next to the executable. No installation step is needed.

Pre-built Windows binaries are provided, but building yourself, tuned to your CPU, will very likely be faster. The whole build is driven by Makefile.new, configured per-machine through config.mk.

As of YAFU 3.0, ytools, ysieve, and msieve are bundled in this repository and built as part of the YAFU build.

cp config.mk.example config.mk          # first time only — edit paths as needed
make -f Makefile.new yafu                # builds with sensible defaults (gcc)

Pass feature/ISA flags either on the command line or by uncommenting them in config.mk. The most useful ones are listed below. For the complete set, see the Building YAFU wiki page or run make -f Makefile.new help.

# Inspect the resolved configuration before/during a build
make -f Makefile.new info
make -f Makefile.new help

# Using config.mk for configuration of ISA and features
make -f Makefile.new yafu

or

make -f Makefile.new all

# ISA selection — overriding config.mk with specified ISA
make -f Makefile.new yafu USE_AVX2=1
make -f Makefile.new yafu USE_AVX512=1          # Skylake-X, Cascade Lake, Zen 4, etc.
make -f Makefile.new yafu USE_AVX512IFMA=1      # Ice Lake and newer

# ISA selection — overriding config.mk with feature flags or compiler options
make -f Makefile.new yafu ECM=1 OMP=1           # link GMP-ECM, enable OpenMP
make -f Makefile.new yafu CC=clang              # use clang
make -f Makefile.new yafu DEBUG=1               # debug build

The first time you set up, copy config.mk.example to config.mk and edit any paths that differ from your system. config.mk is gitignored — only config.mk.example is tracked.

Build files live under build.vc22/. To configure your build:

1. Open build.vc22/yafu.sln in Visual Studio 2022 (the free Community edition is fine).
2. Edit the property sheets in build.vc22/ for your environment:
   • Directory.Build.props — global build settings inherited by every project.
   • build_config.props — toolset selection (e.g. v143, Intel oneAPI) and global build configuration.
   • libs_and_extensions.props — paths to the dependency libraries and the ISA extensions to enable for this build.
3. Build the yafu project under x64 / Release.

Dependencies for the MSVC build:

These ship with their own MSVC build files. Build them first; then point YAFU at them via the paths in libs_and_extensions.props.

The free Intel compiler also works inside Visual Studio 2022.

YAFU's release artifacts (the matrix of Windows .exe files shown above) are produced by an automated GitHub Actions pipeline that exercises:

• Linux / gcc, via Makefile.new
• Windows / MSYS2 / MinGW-w64 gcc, via Makefile.new with STATIC_WIN=1 for the fully-static binaries
• Windows / MSVC, via the build.vc22/ solution and property sheets (this leg is being expanded for CI)

For every push, the CI builds the full matrix of ISA targets (generic, sse41, avx2, avx512, avx512ifma) on each platform. On tagged releases (e.g. v3.1.2), the resulting binaries are attached to the release page.

See the Continuous Integration wiki page for details on the matrix, the artifacts, and how the same Makefile.new flags drive both CI and local builds.

For NFS factorizations, YAFU needs external GGNFS lattice sieve binaries (ggnfs-lasieve4I*). Linux and MinGW binaries are bundled under factor/lasieve5_64/bin/. Point YAFU at them with ggnfs_dir= in yafu.ini, or -ggnfs_dir <path> on the command line. Without these, NFS will not run.

If you have AVX-512 on your CPU, YAFU will also use AVX-ECM as the default ECM backend (built in). A standalone version lives at https://github.com/bbuhrow/avx-ecm.

# Exercises many of yafu's algorithms
yafu "factor(2056802480868100646375721251575555494408897387375737955882170045672576386016591560879707933101909539325829251496440620798637813)"

# Neat ECM example
yafu "ecm(140870298550359924914704160737419905257747544866892632000062896476968602578482966342704)"

If you build YAFU on a new platform or with a new compiler — or build a binary that beats one of the pre-compiled releases for a specific CPU — the maintainer would like to hear about it.