foundry

Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.

8,736

1,892

8,736

510

View on GitHub

Top Related Projects

truffle

14,015

:warning: The Truffle Suite is being sunset. For information on ongoing support, migration options and FAQs, visit the Consensys blog. Thank you for all the support over the years.

hardhat

7,600

Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software.

openzeppelin-contracts

25,227

OpenZeppelin Contracts is a library for secure smart contract development.

mythril

3,924

Mythril is a symbolic-execution-based securty analysis tool for EVM bytecode. It detects security vulnerabilities in smart contracts built for Ethereum and other EVM-compatible blockchains.

slither

5,447

Static Analyzer for Solidity and Vyper

Quick Overview

Foundry is a blazing fast, portable, and modular toolkit for Ethereum application development written in Rust. It provides a comprehensive suite of tools for smart contract development, testing, and deployment, offering a more efficient and developer-friendly alternative to traditional Ethereum development environments.

Pros

Extremely fast compilation and testing speeds due to its Rust implementation
Highly customizable and extensible with a modular architecture
Native support for Solidity and Vyper languages
Robust testing framework with built-in fuzzing capabilities

Cons

Steeper learning curve for developers not familiar with Rust or command-line tools
Less extensive documentation compared to more established tools like Truffle
Smaller ecosystem and community support compared to older alternatives
May require additional setup for integration with certain IDEs or development workflows

Code Examples

Writing a simple test in Foundry:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import "../src/Counter.sol";

contract CounterTest is Test {
    Counter public counter;

    function setUp() public {
        counter = new Counter();
    }

    function testIncrement() public {
        counter.increment();
        assertEq(counter.number(), 1);
    }
}

Using Foundry's cheatcodes in tests:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import "forge-std/Test.sol";

contract CheatcodeTest is Test {
    function testPrank() public {
        address alice = address(0x1);
        vm.prank(alice);
        // The next call will be made with alice's address
        assertEq(msg.sender, alice);
    }
}

Fuzzing example in Foundry:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import "forge-std/Test.sol";

contract FuzzTest is Test {
    function testFuzz_AdditionIsCommutative(uint256 x, uint256 y) public {
        // This test will run multiple times with different random inputs
        assertEq(x + y, y + x);
    }
}

Getting Started

To get started with Foundry:

Install Foundry:

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

Create a new project:
```
forge init my_project
cd my_project
```
Compile the project:
```
forge build
```
Run tests:
```
forge test
```

For more detailed instructions and advanced usage, refer to the official Foundry documentation.

Competitor Comparisons

dapptools

2,106

Dapp, Seth, Hevm, and more

Pros of Dapptools

Mature ecosystem with a comprehensive suite of tools (seth, dapp, hevm)
Strong support for formal verification and property-based testing
Extensive documentation and established community resources

Cons of Dapptools

Steeper learning curve, especially for developers new to Ethereum
Slower development cycle and less frequent updates
Limited cross-platform support (primarily focused on Unix-like systems)

Code Comparison

Dapptools (using dapp):

dapp test
dapp build
dapp deploy

Foundry:

forge test
forge build
forge create

Key Differences

Foundry is written in Rust, while Dapptools is primarily written in Nix and Haskell
Foundry offers faster compilation and testing times compared to Dapptools
Foundry provides better Windows support and easier installation process
Dapptools has a more extensive set of integrated tools, while Foundry focuses on core development features

Both projects aim to improve Ethereum development workflows, but Foundry emphasizes speed and ease of use, while Dapptools offers a more comprehensive toolkit with advanced features for formal verification and property-based testing.

truffle

14,015

:warning: The Truffle Suite is being sunset. For information on ongoing support, migration options and FAQs, visit the Consensys blog. Thank you for all the support over the years.

Pros of Truffle

Mature ecosystem with extensive documentation and community support
Integrated with other tools like Ganache for local blockchain development
Supports multiple programming languages (Solidity, Vyper)

Cons of Truffle

Slower compilation and testing compared to Foundry
JavaScript-based, which can be less performant for large projects
Configuration can be complex for advanced use cases

Code Comparison

Truffle contract deployment:

const MyContract = artifacts.require("MyContract");

module.exports = function(deployer) {
  deployer.deploy(MyContract);
};

Foundry contract deployment:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Script.sol";

contract MyScript is Script {
    function run() external {
        vm.startBroadcast();
        // Deploy contract here
        vm.stopBroadcast();
    }
}

Foundry offers a more Solidity-centric approach, while Truffle uses JavaScript for deployment scripts. Foundry's syntax is more concise and closely aligned with Solidity development, potentially reducing context switching for developers. However, Truffle's JavaScript-based approach may be more familiar to web developers transitioning into blockchain development.

hardhat

7,600

Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software.

Pros of Hardhat

Extensive JavaScript ecosystem integration
Well-established with a large community and plugin ecosystem
Flexible configuration options for diverse project needs

Cons of Hardhat

Slower test execution compared to Foundry
JavaScript-based, which may be less efficient for some operations
Steeper learning curve for developers new to JavaScript/TypeScript

Code Comparison

Hardhat (JavaScript):

const { expect } = require("chai");

describe("Token", function() {
  it("Should return the new token name", async function() {
    const Token = await ethers.getContractFactory("Token");
    const token = await Token.deploy();
    expect(await token.name()).to.equal("MyToken");
  });
});

Foundry (Solidity):

pragma solidity ^0.8.13;
import "forge-std/Test.sol";
import "../src/Token.sol";

contract TokenTest is Test {
    function testName() public {
        Token token = new Token();
        assertEq(token.name(), "MyToken");
    }
}

The code comparison showcases the different approaches: Hardhat uses JavaScript with Chai assertions, while Foundry employs Solidity with built-in assertions. Foundry's tests are more concise and closer to the contract language, potentially offering a more intuitive experience for Solidity developers.

openzeppelin-contracts

25,227

OpenZeppelin Contracts is a library for secure smart contract development.

Pros of OpenZeppelin Contracts

Comprehensive library of secure, audited smart contract components
Widely adopted and battle-tested in production environments
Extensive documentation and community support

Cons of OpenZeppelin Contracts

Limited to contract development, not a full development environment
May require additional tools for testing and deployment

Code Comparison

OpenZeppelin Contracts:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
}

Foundry:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Test.sol";

contract CounterTest is Test {
    function setUp() public {}

    function testIncrement() public {}
}

Key Differences

OpenZeppelin Contracts focuses on providing reusable smart contract components
Foundry is a complete Ethereum development environment with testing, deployment, and debugging tools
OpenZeppelin Contracts is primarily used for contract development, while Foundry covers the entire development lifecycle
Foundry includes a powerful testing framework, whereas OpenZeppelin Contracts requires external testing tools

mythril

3,924

Mythril is a symbolic-execution-based securty analysis tool for EVM bytecode. It detects security vulnerabilities in smart contracts built for Ethereum and other EVM-compatible blockchains.

Pros of Mythril

Specialized in security analysis and vulnerability detection for smart contracts
Supports multiple blockchain platforms beyond Ethereum
Utilizes symbolic execution and SMT solving for in-depth analysis

Cons of Mythril

Steeper learning curve for non-security experts
May produce false positives in some cases
Less frequent updates compared to Foundry

Code Comparison

Mythril (vulnerability detection):

from mythril.mythril import MythrilDisassembler
from mythril.analysis.security import fire_lasers

disassembler = MythrilDisassembler()
contract = disassembler.load_from_solidity("contract.sol")
issues = fire_lasers(contract)

Foundry (testing and development):

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "forge-std/Test.sol";

contract ContractTest is Test {
    function testExample() public {
        assertTrue(true);
    }
}

Mythril focuses on security analysis, while Foundry provides a comprehensive development environment. Mythril's code demonstrates vulnerability scanning, whereas Foundry's code shows a basic test setup. Foundry offers a more user-friendly approach for general smart contract development, while Mythril excels in specialized security auditing.

slither

5,447

Static Analyzer for Solidity and Vyper

Pros of Slither

Specialized in static analysis and vulnerability detection
Supports multiple smart contract languages (Solidity, Vyper)
Extensive set of built-in detectors for common vulnerabilities

Cons of Slither

Limited testing capabilities compared to Foundry
Steeper learning curve for configuring and customizing detectors
Less focus on development workflow integration

Code Comparison

Slither (running a security analysis):

slither contracts/

Foundry (running tests):

forge test

Slither focuses on static analysis and vulnerability detection, while Foundry is a comprehensive development toolkit. Slither excels in identifying potential security issues across multiple smart contract languages, but has limited testing capabilities. Foundry, on the other hand, offers a more integrated development experience with powerful testing features, but may not provide as extensive security analysis out of the box.

Slither's strength lies in its specialized detectors and ability to analyze contracts written in different languages. Foundry shines in its testing framework, fast compilation, and overall development workflow. While both tools are valuable for smart contract developers, they serve different primary purposes and can be complementary in a comprehensive development and security pipeline.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Install | User Book | Developer Docs | Contributing

Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.

Foundry consists of:

Forge: Build, test, fuzz, debug and deploy Solidity contracts, like Hardhat, Brownie, Ape.
Cast: A Swiss Army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
Anvil: Fast local Ethereum development node, akin to Hardhat Network, Tenderly.
Chisel: Fast, utilitarian, and verbose Solidity REPL.

Need help getting started with Foundry? Read the ð Foundry Book!

Demo

Features

High-Performance Compilation
- Fast and Flexible: Automatically detects and installs the required Solidity compiler version.
- Solidity and Vyper Support: Fully supports both Solidity and Vyper out-of-the-box.
- Incremental Compilation: Re-compiles only changed files, saving time.
- Parallelized Pipeline: Leverages multi-core systems for ultra-fast builds.
- Broad Compatibility: Supports non-standard directory structures, including Hardhat repos.
Advanced Testing
- No Context Switching: Write tests directly in Solidity.
- Fuzz Testing: Quickly identify edge cases with input shrinking and counter-example generation.
- Invariant Testing: Ensure complex system properties hold across a wide range of inputs.
- Debugging Made Easy: Use forge-std's console.sol for flexible debug logging.
- Interactive Debugger: Step through your Solidity code with Foundry's interactive debugger, making it easy to pinpoint issues.
Powerful Runtime Features
- RPC Forking: Fast and efficient remote RPC forking backed by Alloy.
- Lightweight & Portable: No dependency on Nix or other package managers for installation.
Streamlined CI/CD
- Optimized CI: Accelerate builds, run tests and execute scripts using Foundry's GitHub action.

Installation

Getting started is very easy:

Install foundryup:

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

Next, run foundryup.

It will automatically install the latest version of the precompiled binaries: forge, cast, anvil, and chisel.

foundryup

Done!

For additional details see the installation guide in the Foundry Book.

If you're experiencing any issues while installing, check out Getting Help and the FAQ.

How Fast?

Forge is quite fast at both compiling (leveraging solc with foundry-compilers) and testing.

See the benchmarks below. Older benchmarks against DappTools can be found in the v0.2.0 announcement post and in the Convex Shutdown Simulation repository.

Testing Benchmarks

Project	Type	Forge 1.0	Forge 0.2	DappTools	Speedup
vectorized/solady	Unit / Fuzz	0.9s	2.3s	-	2.6x
morpho-org/morpho-blue	Invariant	0.7s	1m43s	-	147.1x
morpho-org/morpho-blue-oracles	Integration (Cold)	6.1s	6.3s	-	1.04x
morpho-org/morpho-blue-oracles	Integration (Cached)	0.6s	0.9s	-	1.50x
transmissions11/solmate	Unit / Fuzz	2.7s	2.8s	6m34s	1.03x / 140.0x
reflexer-labs/geb	Unit / Fuzz	0.2s	0.4s	23s	2.0x / 57.5x

In the above benchmarks, compilation was always skipped

Takeaway: Forge dramatically outperforms the competition, delivering blazing-fast execution speeds while continuously expanding its robust feature set.

Compilation Benchmarks

Takeaway: Forge compilation is consistently faster than Hardhat by a factor of 2.1x to 5.2x, depending on the amount of caching involved.

Forge

Forge helps you build, test, fuzz, debug and deploy Solidity contracts.

The best way to understand Forge is to simply try it (in less than 30 seconds!).

First, let's initialize a new counter example repository:

forge init counter

Next cd into counter and build :

forge build

[â ] Compiling...
[â ] Compiling 27 files with Solc 0.8.28
[â ] Solc 0.8.28 finished in 452.13ms
Compiler run successful!

Let's test our contracts:

forge test

[â ] Compiling...
No files changed, compilation skipped

Ran 2 tests for test/Counter.t.sol:CounterTest
[PASS] testFuzz_SetNumber(uint256) (runs: 256, Î¼: 31121, ~: 31277)
[PASS] test_Increment() (gas: 31293)
Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 5.35ms (4.86ms CPU time)

Ran 1 test suite in 5.91ms (5.35ms CPU time): 2 tests passed, 0 failed, 0 skipped (2 total tests)

Finally, let's run our deployment script:

forge script script/Counter.s.sol

[â ] Compiling...
No files changed, compilation skipped
Script ran successfully.
Gas used: 109037

If you wish to simulate on-chain transactions pass a RPC URL.

Run forge --help to explore the full list of available subcommands and their usage.

More documentation can be found in the forge section of the Foundry Book.

Cast

Cast is a Swiss Army knife for interacting with Ethereum applications from the command line.

Here are a few examples of what you can do:

Check the latest block on Ethereum Mainnet:

cast block-number --rpc-url https://eth.merkle.io

Check the Ether balance of vitalik.eth

cast balance vitalik.eth --ether --rpc-url https://eth.merkle.io

Replay and trace a transaction

cast run 0x9c32042f5e997e27e67f82583839548eb19dc78c4769ad6218657c17f2a5ed31 --rpc-url https://eth.merkle.io

Optionally, pass --etherscan-api-key <API_KEY> to decode transaction traces using verified source maps, providing more detailed and human-readable information.

Run cast --help to explore the full list of available subcommands and their usage.

More documentation can be found in the cast section of the Foundry Book.

Anvil

Anvil is a fast local Ethereum development node.

Let's fork Ethereum mainnet at the latest block:

anvil --fork-url https://eth.merkle.io

You can use those same cast subcommands against your anvil instance:

cast block-number

Run anvil --help to explore the full list of available features and their usage.

More documentation can be found in the anvil section of the Foundry Book.

Chisel

Chisel is a fast, utilitarian, and verbose Solidity REPL.

To use Chisel, simply type chisel.

chisel

From here, start writing Solidity code! Chisel will offer verbose feedback on each input.

Create a variable a and query it:

â uint256 a = 123;
â a
Type: uint256
â Hex: 0x7b
â Hex (full word): 0x000000000000000000000000000000000000000000000000000000000000007b
â Decimal: 123

Finally, run !source to see a was applied:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

import {Vm} from "forge-std/Vm.sol";

contract REPL {
    Vm internal constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

    /// @notice REPL contract entry point
    function run() public {
        uint256 a = 123;
    }
}

Run chisel --help to explore the full list of available features and their usage.

More documentation can be found in the chisel section of the Foundry Book.

Configuration

Foundry is highly configurable, allowing you to tailor it to your needs. Configuration is managed via a file called foundry.toml located in the root of your project or any parent directory. For a full list of configuration options, refer to the config package documentation.

Profiles and Namespaces

Configuration can be organized into profiles, which are arbitrarily namespaced for flexibility.
The default profile is named default. Learn more in the Default Profile section.
To select a different profile, set the FOUNDRY_PROFILE environment variable.
Override specific settings using environment variables prefixed with FOUNDRY_ (e.g., FOUNDRY_SRC).

You can find additional setup and configurations guides in the Foundry Book and in the config crate:

Contributing

See our contributing guidelines.

Getting Help

First, see if the answer to your question can be found in the Foundy Book, or in the relevant crate.

If the answer is not there:

Join the support Telegram to get help, or
Open a discussion with your question, or
Open an issue with the bug

If you want to contribute, or follow along with contributor discussion, you can use our main telegram to chat with us about the development of Foundry!

License

Licensed under either of Apache License, Version 2.0 or MIT License at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in these crates by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Acknowledgements

Foundry is a clean-room rewrite of the testing framework DappTools. None of this would have been possible without the DappHub team's work over the years.
Matthias Seitz: Created ethers-solc (now foundry-compilers) which is the backbone of our compilation pipeline, as well as countless contributions to ethers, in particular the abigen macros.
Rohit Narurkar: Created the Rust Solidity version manager svm-rs which we use to auto-detect and manage multiple Solidity versions.
Brock Elmore: For extending the VM's cheatcodes and implementing structured call tracing, a critical feature for debugging smart contract calls.
All the other contributors to the ethers-rs, alloy & foundry repositories and chatrooms.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot