Foundry - Fast Ethereum Dev Tools That Don't Suck

Foundry is a set of command-line tools for Ethereum development built in Rust. It started as a Paradigm project in late 2021 when they got tired of Hardhat being slow and wanted to write tests in Solidity instead of JavaScript.

The core pitch is simple: why learn JavaScript testing libraries when you already know Solidity? Instead of wrestling with Mocha, Chai, and ethers.js, you write your tests in the same language as your contracts. No more expect(await contract.getValue()).to.equal(42) bullshit - just assertEq(contract.getValue(), 42).

It's grown to 8.6k+ GitHub stars with hundreds of active contributors, which is pretty good for a tool that makes you throw out your existing JavaScript test suite.

The Four Tools

Forge is the main compiler and test runner. It's fast because it's written in Rust and can compile multiple contracts in parallel. Unlike Hardhat, it doesn't recompile everything when you change one file - it actually does incremental compilation properly.

Cast is for interacting with deployed contracts from the command line. Think of it as a command-line wallet that can call contract functions, decode transaction data, and query blockchain state. Way more powerful than web3 scripts for debugging production issues.

Anvil is the local development node. It starts instantly (unlike Ganache) and can fork mainnet state without eating all your RAM. You can impersonate accounts, manipulate block timestamps, and generally mess with the blockchain in ways that help with testing.

Chisel is a Solidity REPL where you can test code snippets interactively. It's actually useful for figuring out how Solidity works without deploying contracts just to test simple expressions.

Installation Actually Works

Installation is refreshingly simple - no Node.js, no Python, no virtual environments:

curl -L https://foundry.paradigm.xyz | bash
foundryup

That's it. It downloads precompiled binaries for all four tools. The whole thing is under 100MB and doesn't conflict with anything else on your system. foundryup manages versions automatically, so you can switch between releases without breaking your projects.

Who Actually Uses This?

Major projects like OpenZeppelin, Uniswap, and Solmate have migrated from Hardhat. The migration isn't trivial - you have to rewrite all your tests from JavaScript to Solidity - but teams do it anyway because the speed gains are worth the long-term productivity improvements.

Documentation is solid in the Foundry Book, and there's active community support on Telegram and GitHub discussions. The project maintains regular releases with bug fixes and new features, including improved EIP support and enhanced debugging tools.

Foundry feels fast because it is fast, but the real win is that you can stop context-switching between languages. Here's what actually matters in day-to-day development:

Builds That Don't Waste Your Time

The compilation is legitimately faster than Hardhat - noticeable on any decent-sized codebase. More importantly, it only recompiles what changed, which Hardhat claimed to do but never really worked properly.

It automatically downloads and manages Solidity compiler versions, so you don't have to manually install solc or worry about version mismatches between your local machine and CI.

On larger projects (think OpenZeppelin Contracts size), you're looking at seconds instead of minutes for full rebuilds. Incremental builds are actually incremental.

Testing That Actually Catches Bugs

Fuzzing: Foundry can generate thousands of random inputs to test your contracts. This actually finds bugs that you missed in your manual test cases. It's fast enough to run in CI without making everyone hate you.

Invariant Testing: You can define properties that should always be true (like "total supply equals sum of all balances") and Foundry will try to break them by calling random functions in random orders. This catches the subtle bugs that come from weird interaction patterns in DeFi protocols.

Coverage-Guided Fuzzing: Introduced in v1.3.0 and refined in subsequent releases, this prioritizes inputs that exercise new code paths. It's like fuzzing but smarter about finding the weird edge cases in your contract logic - basically teaching the fuzzer to be more efficient at breaking your code.

Debugging When Things Go Wrong

Call Traces: When a transaction fails, Foundry shows you the exact call stack, including internal function calls and state changes. Way better than trying to decode revert messages from Etherscan.

Gas Profiling: Built-in gas reports show you exactly where your gas is going. You can see per-function gas usage and identify the expensive operations without installing additional tools like hardhat-gas-reporter.

Interactive Debugger: You can step through failed transactions line by line, inspect variable values, and see exactly where things went wrong. It actually works, unlike most smart contract debuggers.

The Pain Points

Git Submodules: Dependency management uses git submodules instead of npm packages. This is annoying if you're used to npm install, but it's deterministic and doesn't break when someone unpublishes a package.

Learning Curve: If you're coming from JavaScript testing, you need to learn Solidity testing patterns. The forge-std library helps, but it's still a mental shift from async/await patterns.

Migration Cost: Moving from Hardhat means rewriting all your tests. Depending on your test suite size, this could take days or weeks. Teams do it anyway because the long-term productivity gains are worth it, as shown by major projects migrating.

Current Status

Version v1.3.2 was released in August 2025. The project is actively maintained with regular bug fixes and new features. The community is growing fast, and major protocols are adopting it despite the migration costs.