mrkeyoor.com_
Sun 27 Sept 03:23 UTC
Dev Toolsevaluationupdated 27 Sept 2026

foundry review

Foundry is a Rust toolchain for building, testing, debugging, and deploying Ethereum smart contracts. Its four main commands cover Solidity projects, chain queries and transactions, a local Ethereum node, and an interactive Solidity shell.

Verdict

Our Foundry source build succeeded in 886 seconds, but the test command was still running when our 900-second cap ended it, so contributors need serious CI time even though release binaries are easy to install. Use Foundry for Solidity work when Forge's testing depth and the Cast, Anvil, and Chisel suite can replace several separate tools. Review deployment-script behavior against your own transaction dependencies before sending valuable operations on-chain.

We ran it

Lab card: what happened when we ran foundryScreenshot of foundry (getfoundry.sh)
Install✓ · 139s1257 packages
Build✓ · 886s
Tests✗ timed out · 900s0 passed · 0 failed of 0 (cargo test)
Repo2035 files~540,056 lines of source · 34.6 MB · 20 CI workflows · Dockerfile

Answers from our run

Does foundry build from source?

Dependencies installed in 139 seconds (1257 packages), and the build succeeded in 886 seconds. We cloned commit 0f73bdb into a clean Debian container with 3 CPUs and no project-specific setup.

Do foundry's tests pass?

Yes: 0 of 0 passed when we ran the project's own test command (cargo test). Some failures need services or credentials a bare container does not have.

Who should not use foundry?

Developers building outside Ethereum and EVM-compatible chains: the README defines Foundry specifically as an Ethereum application toolkit.

What are the alternatives to foundry?

Hardhat, Ape, Remix Project. Our Foundry source build succeeded in 886 seconds, but the test command was still running when our 900-second cap ended it, so contributors need serious CI time even though release binaries are easy to install.

Setup3/5Release install is short; our source build took 886 seconds
Docs5/5Commands, CI, versions, Docker, LSP, and platform limits are covered
Community5/510,626 stars and active issue work through September 2026
Maturity5/5v1.8.3 ships four established tools and patched release binaries

Who it’s for

Solidity teams that want one command-line toolchain for compilation, tests, fuzzing, deployment, and chain inspection.
Developers who need a local Ethereum node that can fork a live network for realistic tests.
Protocol engineers who will use Forge's cheatcodes, invariant tests, gas snapshots, debugger, or integrated Solidity language server.
CI owners willing to install release binaries or budget substantial time for a source build.

Who it’s NOT for

Developers building outside Ethereum and EVM-compatible chains: the README defines Foundry specifically as an Ethereum application toolkit.
Contributors who need a quick source build on a small CI runner: our 3-CPU build took 886 seconds, and the test command exceeded its 900-second limit.
Windows users restricted to PowerShell or Command Prompt: the installation guide says foundryup requires Git Bash or WSL.
Teams that broadcast dependent transactions without reviewing simulation assumptions: open issue 17012 reports that later calls can use values from the initial simulation even with --slow.
Operators expecting every failed deployment to resume cleanly: open issue 16566 documents a narrower estimate-versus-mine case where forge script --resume can misread transaction progress.

Setup reality

Our sandbox installed 1,257 Rust packages in 139 seconds. The source build succeeded in 886 seconds. Tests then timed out at 900 seconds, so Cargo produced no final suite total and our harness recorded 0 passed and 0 failed; the log tail did show multiple Tempo tests finishing with ok.

The normal route is much lighter than our contributor build: foundryup installs Forge, Cast, Anvil, and Chisel as release binaries. Local Anvil work needs no hosted service. Live reads and forks need an RPC URL, while deployments also need properly managed wallet credentials.

Foundryup needs Git Bash or WSL on Windows; PowerShell and Command Prompt are unsupported. Docker and direct release archives are documented alternatives. Building from source requires current stable Rust, and the docs warn that locally building the Docker image can be troublesome on some systems, including Apple Silicon.

Four commands cover the Solidity development loop

Foundry packages 4 tools around the work a Solidity team repeats every day. Forge builds, tests, fuzzes, debugs, and deploys contracts. Cast reads chain data and sends transactions. Anvil supplies a local Ethereum node, including a fork of a live network, while Chisel is an interactive Solidity shell. Keeping these jobs in one release is the main reason to choose Foundry over assembling a compiler, test runner, node, and transaction utility separately.

The suite reaches deeper than a quick forge test demo. Forge has invariant testing, cheatcodes, gas snapshots, scripting, verification, formatting, and linting. The README also documents forge lsp: it can open a bundled VS Code extension host or run as a standard language server over stdio. That breadth pays off when contracts are the product. A small team that only compiles a few examples may use a fraction of it.

The release installer is easier than the 540,056-line source tree

Foundry's documented install is 2 commands: pipe the installer into a shell, then run foundryup. That version manager obtains the current Forge, Cast, Anvil, and Chisel binaries. It can also select a numbered release, a nightly build, or a branch. Release v1.8.3 was published on September 15, 2026, and the installer verifies downloaded binaries against GitHub attestations.

Contributing is a different job. Our checkout contained 2,035 files and roughly 540,056 lines of source before dependencies. The install step brought in 1,257 packages, and the repository carries 20 CI workflow files plus a Dockerfile. That is evidence of substantial release machinery, though it does not make a local source cycle cheap. Teams writing contracts should start with the release binaries unless they need to change Foundry itself.

What happened when we ran it

Our sandbox installed the Rust dependencies in 139 seconds, then completed the build in 886 seconds. The test command ran for another 900 seconds before our limit stopped it. Cargo never printed a final aggregate, so the harness recorded 0 passed and 0 failed out of 0 rather than a completed result. The last log lines showed a run of Tempo and Tempo Canary cases ending in ok.

Our test method used commit 0f73bdb in an unprivileged Debian container with 3 CPUs and 12 GB of RAM. Those results establish that the source compiled under that setup. They do not establish that the full suite passes, because it did not finish. They also say nothing about Forge's contract-test speed or Anvil's RPC performance. The useful planning figure is the wall clock: install, build, and the unfinished test step occupied more than 31 minutes together.

The missing final count matters. A timeout is different from a failing assertion, and the log tail did not show a failed Tempo case. It is still a failed validation step for a contributor who needs a complete green run. If your pull-request gate has a 15-minute ceiling, our 900-second test result says you should split the workspace, reuse caches, or provision a longer job before assuming the default command will fit.

Windows needs WSL or Git Bash for foundryup

The official installation guide says foundryup does not support PowerShell or Command Prompt. Windows users need Git Bash or WSL. Direct release archives and Docker are alternatives, while a Windows source build also needs Visual Studio with the C++ desktop workload. The guide separately warns that locally building the Docker image can have problems on some systems, including Apple Silicon. Those are concrete setup limits, not reasons to avoid the released Linux and macOS binaries.

Local contract work can stay self-contained with Anvil. The README's live-network examples pass an RPC URL to Cast and Anvil, so forks and chain queries depend on an endpoint you trust and can afford. Broadcasting a deployment adds wallet handling. Foundry places the commands in one suite, but your team still owns secret storage, RPC availability, chain selection, and a review process before a script sends transactions.

Open broadcast reports deserve a deployment check

Open issue 17012 describes a specific Forge script risk in version 1.8.1: later transactions may use return values from the initial local simulation even if earlier chain state changes before mining. The report says --slow serializes sending but does not rebuild later transactions from newly mined state. That claim is not a finding from our sandbox, and it remains an open report. It is concrete enough to reproduce against any deployment script whose later calls depend on earlier return values.

Issue 16566 covers a narrower recovery path. Its author reports that forge script --resume can confuse progress when a transaction passes estimation, reverts when mined, and a later transaction still succeeds. The issue explicitly says most ordinary reverts stop earlier during gas estimation, so the trigger is limited. Both reports point to one practical rule: rehearse valuable multi-transaction broadcasts on representative state instead of treating the presence of --slow or --resume as proof of safe recovery.

Current maintenance supports adoption, with upgrade review

GitHub recorded Foundry's last push on September 27, 2026. The repository had 10,626 stars, 210 open issues, and 45 open pull requests when checked. Release v1.8.3 had arrived 12 days earlier with fixes across fork execution, scripting, cheatcodes, formatting, linting, and Chisel sessions. Its notes also say v1.8.2 was left unpublished after a rustls advisory and that v1.8.3 contains patched binaries.

That combination supports using the stable release while still reading its notes. Foundry changes alongside Ethereum hard forks, new transaction types, and multiple EVM networks, so upgrades can alter gas snapshots or script behavior. For a Solidity-heavy team, the 4-tool package is worth standardizing on. For an occasional contract or a TypeScript shop built around npm plugins, Hardhat or a browser-first Remix workflow may impose less change.

Alternatives

ProjectWhat it isPick it when
HardhatA Node.js Ethereum development environment with a large plugin ecosystem.pick this instead when your contract workflow and team conventions are already centered on TypeScript and npm plugins.
ApeA Python framework for compiling, testing, and deploying smart contracts.pick this instead when Python is the team's automation language and its plugin model fits the networks you use.
Remix ProjectA browser and desktop IDE for writing and running Solidity contracts.pick this instead when an interactive graphical workspace matters more than a terminal-first project toolchain.

What people are saying

  1. [github-trending] foundry-rs/foundry
  2. [github-trending] openbkn-ai/bkn-foundry

Sources

  1. Foundry repository and README
  2. Foundry installation guide
  3. Foundry v1.8.3 release
  4. Forge pre-simulation values report
  5. Forge script resume cursor report

More dev tools reviews

fx · qmk_firmware · terminal-browser · fearless_simd · devops-exercises · scriptc · the whole board →