fast-di-compile

A battle-tested, production-ready replacement for Magento's bin/magento setup:di:compile.

4 seconds instead of 50 seconds. 12.5× faster.

What it does

• Provides alternate and faster way to compile the code for Magento/Adobe Commerce
• Generates Magento's DI code and metadata.
• Processes files in parallel.
• Avoids rewriting unchanged files and reuses cached metadata.
• builds with RUST

Get started

You will need a running magento installation:

• Rust and Cargo.
• A Magento project.

1. Installation

git clone https://github.com/speedupmate/di-compiler.git
cd di-compiler
cargo build --release -p fast-di-compile

The executable is created at target/release/fast-di-compile.

Rust and Cargo are needed only when building the compiler. The finished binary can be copied to a matching host and run without installing Rust.

Or build the binary with Docker

Alternatively you can build the binary in Docker and use the built binary on your host. Then you do not need Rust and Cargo on your magento host:

docker run --rm \
  --platform linux/amd64 \
  -v "$PWD:/src" \
  -w /src \
  rust:1.96-bookworm \
  cargo build --release -p fast-di-compile

The binary is written to target/release/fast-di-compile in the repository. Use a Docker platform that matches the host where the binary will run:

• linux/amd64 for Intel and AMD Linux servers. This is the most common option.
• linux/arm64 for ARM64 Linux servers, including AWS Graviton instances and Apple Silicon Mac.

For ARM64, change the platform in the command to --platform linux/arm64. The result is a Linux binary.

A macOS or Windows host needs a native build for that operating system or must run the compiler inside Docker.

2. Compile your Magento project

Set /path/to/magento to your Magento root:

./target/release/fast-di-compile --magento-root /path/to/magento

By default the output goes to generated/code and generated/metadata in your Magento project.

Useful options

How it works under the hood

The compiler is written in Rust. Rust scans Magento PHP files, reads di.xml, resolves dependencies, and writes generated code and metadata.

For Magento compatibility, it starts PHP worker processes when it needs runtime information. These workers load <magento-root>/vendor/autoload.php and use PHP reflection to inspect classes, constructors, constants, and methods. PHP also handles files the Rust parser cannot fully process.

When you run the binary on the host, it uses the host's PHP. Theoretically it is also possible to run it in Docker. But then the container must include a compatible PHP CLI runtime that matches host php setup. If this condition is met then you can mount the Magento directory into the container so the compiler can read the project and write generated files back to the host.

Debugging

If your project has many third-party integrations and you face compilation issues, use the debugging tools below. Start with --verbose for detailed logs and timings.

The main way for debugging is to compare the output with Magento's compiler to investigate compatibility issues. The reports list missing, extra, and changed files.

cd /path/to/magento
bin/magento setup:di:compile
mkdir /tmp/magento-di-baseline
cp -R generated/code /tmp/magento-di-baseline/_code
cp -R generated/metadata /tmp/magento-di-baseline/_metadata

./target/release/fast-di-compile \
  --magento-root /path/to/magento \
  --output /tmp/fast-di-output \
  --compare-archive \
  --archive-root /tmp/magento-di-baseline

Development

Source code is under crates/.

To check changes locally:

cargo fmt --all -- --check
cargo test --workspace
cargo check --workspace

License and copyright

Copyright © 2026 Anton Siniorg.

Fast-Di-Compile is released under the MIT License. Use it, improve it, and share it.