Overview
Foundry is the Formula 1 race car of Ethereum development frameworks - built for speed, precision, and performance. While Hardhat is like a comfortable, feature-rich sedan that most developers love, Foundry is the lightweight sports car that serious performance enthusiasts choose when speed and efficiency matter most.
What is Foundry? (The Racing Car Analogy)
Imagine two ways to travel from New York to Los Angeles:
- Hardhat: A comfortable RV with all amenities, JavaScript-based, familiar to web developers
- Foundry: A high-performance sports car, Rust-based, designed for pure speed and efficiency
Both get you there, but the experience and performance are dramatically different.
The Core Philosophy Difference
Hardhat’s Approach: “Comfort and Familiarity”
- Uses JavaScript for tests and scripts
- Extensive plugin ecosystem
- Gradual learning curve
- Rich debugging features
Foundry’s Approach: “Speed and Native Integration”
- Uses Solidity for everything, including tests
- Minimal dependencies
- Steep but rewarding learning curve
- Blazing fast execution
The Four Foundry Tools (Your Complete Toolkit)
1. Forge (The Engine)
Your main development tool that compiles, tests, and manages contracts. Think of it as the engine that powers everything.
2. Cast (The Swiss Army Knife)
Command-line tool for interacting with Ethereum. Like having a direct phone line to any blockchain.
3. Anvil (The Local Network)
Creates a local Ethereum node for testing. Similar to Hardhat Network but faster and more lightweight.
4. Chisel (The Experimentation Lab)
Interactive Solidity shell for quick testing and exploration. Like having a calculator for smart contract logic.
Setting Up Your First Foundry Project
Step 1: Installation
# Install Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup
# Create new project
forge init my-foundry-project
cd my-foundry-project
Step 2: Project Structure
my-foundry-project/
├── src/ # Your contracts
├── test/ # Solidity tests
├── script/ # Deployment scripts
├── lib/ # Dependencies
└── foundry.toml # Configuration
Notice how clean and minimal this is compared to typical JavaScript projects!
Step 3: Your First Contract and Test
Contract (src/Counter.sol):
pragma solidity ^0.8.13;
contract Counter {
uint256 public number;
function setNumber(uint256 newNumber) public {
number = newNumber;
}
function increment() public {
number++;
}
}
Test (test/Counter.t.sol):
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);
}
function testSetNumber(uint256 x) public {
counter.setNumber(x);
assertEq(counter.number(), x);
}
}
Step 4: Run Tests
forge test
The magic: Tests run in milliseconds, not seconds!
Head-to-Head Comparison: Foundry vs Hardhat
Performance Showdown
| Aspect | Foundry | Hardhat |
|---|---|---|
| Test Speed | ⚡ Lightning fast (Rust) | 🐌 Moderate (JavaScript) |
| Compilation | ⚡ Very fast | 🔄 Standard |
| Memory Usage | 📉 Low | 📈 Higher |
| Startup Time | 🚀 Instant | ⏳ Few seconds |
Developer Experience
| Feature | Foundry | Hardhat |
|---|---|---|
| Learning Curve | 📈 Steep (Solidity-first) | 📊 Gentle (JavaScript) |
| Debugging | 🔍 Built-in traces | 🐛 Rich debugging tools |
| Plugin Ecosystem | 🔧 Minimal | 🛠️ Extensive |
| Documentation | 📚 Good | 📖 Excellent |
When to Choose Foundry
✅ Choose Foundry if you:
- Prioritize Performance: Need fastest possible testing and compilation
- Love Solidity: Comfortable writing everything in Solidity
- Want Simplicity: Prefer minimal dependencies and clean architecture
- Are Building Complex Logic: Need advanced testing features like fuzzing
- Value Native Integration: Want everything in the same language
Example: Advanced Testing with Foundry
contract AdvancedTest is Test {
// Fuzz testing - runs with random inputs
function testFuzzWithdraw(uint256 amount) public {
vm.assume(amount > 0 && amount <= 1000 ether);
// Your test logic here
}
// Property-based testing
function invariant_totalSupplyAlwaysPositive() public {
assert(token.totalSupply() >= 0);
}
// Time manipulation
function testTimeBasedLogic() public {
vm.warp(block.timestamp + 30 days);
// Test future state
}
}
When to Choose Hardhat
✅ Choose Hardhat if you:
- Come from Web Development: Comfortable with JavaScript/TypeScript
- Need Rich Tooling: Want extensive plugins and integrations
- Are Learning: Prefer gentler learning curve and better error messages
- Work in Teams: Need robust project management features
- Build Full-Stack Apps: Integrating with frontend frameworks
Example: Hardhat’s JavaScript Flexibility
// Complex deployment logic
async function deployWithProxy() {
const Contract = await ethers.getContractFactory("MyContract");
const proxy = await upgrades.deployProxy(Contract, [initialValue]);
// Integration with external APIs
const gasPrice = await getOptimalGasPrice();
// Complex conditional logic
if (network.name === "mainnet") {
await verifyContract(proxy.address);
}
}
Real-World Performance Comparison
Test Suite Performance
# Foundry (100 tests)
forge test
# ✅ Ran 100 tests in 0.8s
# Hardhat (same 100 tests)
npx hardhat test
# ✅ Ran 100 tests in 12.3s
The difference becomes more dramatic with larger test suites - professional development teams report 10-50x speed improvements when switching to Foundry for testing.
Advanced Foundry Features
1. Built-in Fuzzing
// Automatically tests with random inputs
function testFuzz_deposit(uint256 amount) public {
vm.assume(amount > 0);
vault.deposit(amount);
assertEq(vault.balanceOf(address(this)), amount);
}
2. Gas Profiling
forge test --gas-report
# Shows exact gas consumption for each function
3. Cheat Codes
// Manipulate blockchain state
vm.prank(alice); // Next call from alice
vm.warp(block.timestamp + 1); // Fast forward time
vm.roll(block.number + 1); // Move to next block
vm.deal(alice, 100 ether); // Give alice ETH
4. Symbolic Execution
# Find edge cases automatically
forge test --ffi
Advanced Hardhat Features
1. Rich Plugin Ecosystem
// Gas reporting, coverage, deployment management
require("hardhat-gas-reporter");
require("solidity-coverage");
require("hardhat-deploy");
2. Network Forking
// Test against real protocols
networks: {
hardhat: {
forking: {
url: "https://eth-mainnet.alchemyapi.io/v2/YOUR-KEY"
}
}
}
3. TypeScript Integration
import { ethers } from "hardhat";
import { Contract } from "ethers";
// Full type safety
const contract: Contract = await ethers.getContractAt("MyContract", address);
Migration Stories: Real Developer Experiences
From Hardhat to Foundry
Sarah, DeFi Developer: “Our test suite went from 5 minutes to 30 seconds. The initial learning curve was steep, but the productivity gains were immediate.”
From Foundry to Hardhat
Mike, Full-Stack Dev: “Foundry was too minimalist for our team. We needed the rich tooling and JavaScript integration that Hardhat provides.”
Hybrid Approach: Using Both
Many teams use both frameworks strategically:
# Use Foundry for core contract testing
forge test
# Use Hardhat for deployment and integration
npx hardhat run scripts/deploy.js --network mainnet
This combines Foundry’s speed with Hardhat’s deployment flexibility.
The Economics of Choice
Development Time Impact
- Foundry: Faster feedback loops = faster development
- Hardhat: Richer tooling = fewer bugs in production
Team Productivity
- Small Teams: Foundry’s speed often wins
- Large Teams: Hardhat’s structure and tooling scale better
Learning Investment
- Foundry: High initial cost, high long-term benefit
- Hardhat: Low initial cost, steady ongoing benefit
Future Considerations
Foundry’s Trajectory
- Rapidly growing adoption among performance-focused teams
- Active development with frequent feature additions
- Strong backing from Paradigm (leading crypto VC)
Hardhat’s Trajectory
- Mature ecosystem with extensive plugin support
- Strong integration with existing JavaScript tooling
- Backed by Nomic Foundation with long-term stability
Making Your Decision: A Framework
Ask yourself these questions:
-
What’s your background?
- Solidity-first → Foundry
- JavaScript/Web dev → Hardhat
-
What’s your project size?
- Small, performance-critical → Foundry
- Large, complex deployment → Hardhat
-
What’s your team composition?
- Blockchain specialists → Foundry
- Mixed web2/web3 team → Hardhat
-
What are your priorities?
- Speed and efficiency → Foundry
- Tooling and ecosystem → Hardhat
Key Takeaways
Both Foundry and Hardhat are excellent frameworks that serve different needs and philosophies. The choice isn’t about which is “better” - it’s about which aligns with your project requirements, team skills, and development priorities.
Foundry excels when: You want maximum performance, love working in Solidity, and prefer minimal, fast tooling.
Hardhat excels when: You want rich features, extensive ecosystem, and gentle learning curves with familiar JavaScript patterns.
Many successful projects use elements of both, leveraging each framework’s strengths. The most important decision is to pick one and become proficient with it - both are capable of building world-class smart contracts.
Consider your team’s needs carefully and remember that you can always migrate or use hybrid approaches as your project evolves. The best framework is the one that helps your team ship secure, efficient smart contracts consistently.