> ## Content Index
> Fetch the complete content index at: https://blog.borodutch.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# plain 0.5.0 against forge 1.9.0 on PRBMath, Solady and Morpho Blue: what ran and how long it took
- URL: https://blog.borodutch.com/plain-vs-forge-prbmath-solady-morpho-blue/
- Published: 2026-11-17T16:00:00.000Z
- Updated: 2026-11-17T17:03:49.000Z
- Description: On PRBMath plain passes all 408 tests and reruns in 0.2 s against forge's 3.2 s. Solady needs one config line, and Morpho Blue stops plain with a clear message. Timings and test counts from my own runs on 2026-11-17.
- Author: Nikita Kolmogorov
- Tags: plain, Solidity, Foundry, #radiant

I ran [plain](https://getplain.org/?ref=blog.borodutch.com) 0.5.0 and Foundry's forge 1.9.0 on three Solidity projects I hadn't tried before, on 2026-11-17: PRBMath, Solady and Morpho Blue. PRBMath passes all 408 of its tests under plain with the same compile time as forge, and an unchanged rerun takes 0.2 seconds where forge needs 3.2\. Solady runs once `foundry.toml` gets one line changed, and then reruns in 0.29 seconds where forge needs 47\. Morpho Blue is turned away at the door in 0.0 seconds with a message that names the setting plain doesn't read yet.

plain is the single binary I made to compile, test, deploy and verify Solidity contracts; it reads Foundry projects as they are. I had already published runs on [Uniswap v4-core](https://getplain.org/docs/ci/?ref=blog.borodutch.com), [OpenZeppelin Contracts and solmate](https://getplain.org/docs/foundry-projects/?ref=blog.borodutch.com), so this post adds three different codebases and a newer forge. Every number below comes from my own runs today, single runs rather than averages, and the commands are at the end if you want to repeat them.

## How I ran it

I installed plain with `curl -fsSL https://getplain.org/install | sh` (0.5.0) and forge with `foundryup -i v1.9.0` (commit 6056c5845d, built 2026-11-02, the newest release that day). Each project was a fresh `git clone --recurse-submodules --depth 1`, and every command ran under `taskset -c` pinned to two CPUs of a 12-core machine, which is roughly what a small CI runner gives you. Both tools had their solc versions downloaded before the timed runs, so downloads are not in any number. For each project I ran `forge test` cold, `forge test` again unchanged, then deleted `out` and `cache` and did the same with `plain test`.

## The results at a glance

| Project             | forge cold  | plain cold                  | Unchanged rerun            |
| ------------------- | ----------- | --------------------------- | -------------------------- |
| PRBMath 3fbfb3e     | 43.3 s      | 40.8 s                      | plain 0.2 s, forge 3.2 s   |
| Solady 258f67c      | 151.3 s     | 97.6 s with one config line | plain 0.29 s, forge 47.2 s |
| Morpho Blue 339a885 | 14 min 47 s | stops in 0.0 s              | forge 138.3 s              |

## PRBMath: every test passes, and the rerun is instant

PRBMath is a fixed-point math library with 408 tests in 63 suites, and its dependencies come from npm (`npm install` fetches forge-std into `node_modules`). forge 1.9.0 compiled 118 files with solc 0.8.30 in 38.5 seconds and ran the suites in 2.2 seconds, 43.3 seconds in all. plain compiled 108 files in 39.1 seconds and finished the run with `408 passed, 0 failed, 0 skipped (63 suites, 1.70s)`, 40.8 seconds in all. Both are limited by solc here, so a cold run is a draw.

The difference shows on the second run. Nothing had changed, so plain reused the results it had stored and took 0.2 seconds; forge compiled nothing but ran every test again and took 3.2 seconds. That is the loop I care about when I edit one file and want to know whether anything else moved: plain keeps the results of suites that haven't changed.

## Solady: plain stops until one config line changes

Solady is a library of gas-optimised contracts, a repository where forge compiles 208 files with solc 0.8.36\. Its `foundry.toml` pins `evm_version = "paris"` and uses `skip` to leave out the files that need newer opcodes (the transient storage ones, EIP-7702, the `clz` instruction and the zkSync copies). forge ran 1,599 tests in 80 suites, all passing, in 151.3 seconds cold (45.8 seconds of that is the test run), and 47.2 seconds again unchanged.

plain 0.5.0 reads `evm_version` but not `skip`, so it tried to compile the skipped files for Paris and failed after 95.5 seconds with `The "tload" instruction is only available for Cancun-compatible VMs`. Raising `evm_version` to `cancun` moved the failure to the `clz` files, and `osaka` let everything compile. On a copy of the repository with that one line changed, plain compiled 251 files in 64.5 seconds and ran 97 suites against forge's 80: 2,081 tests passed and 13 failed, 97.6 seconds from a clean checkout. Rerun unchanged, it answered in 0.29 seconds with `2094 results cached`.

The 13 failures are specific. Four are in `test/ext/zksync/ERC1155.t.sol` and two in `test/BlockHashLib.t.sol`, both of which forge's own skip list excludes. Three more are P256 tests that call cheatcodes plain 0.5.0 doesn't implement (`vm.publicKeyP256`, `vm.signP256` and `vm.readLine`), and the last four, in `test/ERC1155.t.sol`, report a different revert payload than the one the test expects. So on the files forge also runs, plain passes everything except those seven tests, and the other six come from plain running files the project had asked to leave out.

## Morpho Blue: a clear message in no time

Morpho Blue is a lending protocol compiled with `via_ir` and an `optimizer_runs` of 999,999, and it limits its core contract to the Paris EVM with `compilation_restrictions`. forge took 14 minutes 47 seconds from a clean checkout on two CPUs, of which the test run was 173.5 seconds (194 tests in 29 suites, all passing, including a 121-second invariant). An unchanged forge run took 138.3 seconds, because forge runs the tests again, invariants included.

plain exits immediately with a message that says exactly what to change or wait for: `error: compilation_restrictions: plain doesn't support "evm_version" yet`. It didn't compile anything or guess, and I didn't try to work around it, so there is no plain number for this project.

## What I'd take from it

On a project plain reads fully, the cold run costs what solc costs, and every run after it costs almost nothing: 0.2 seconds against forge's 3.2 on PRBMath, 0.29 against 47.2 on Solady. For the projects it can't read yet, it stops with the setting's name instead of running something different from what your `foundry.toml` says, which is the behaviour I want from a tool that is supposed to be a drop-in.

Both gaps found today are specific: plain doesn't read `skip` from `foundry.toml` yet, and it doesn't accept `compilation_restrictions` that set an `evm_version`. The [Foundry projects page](https://getplain.org/docs/foundry-projects/?ref=blog.borodutch.com) on getplain.org lists what ran on OpenZeppelin Contracts and solmate, if you want the same kind of result for those.

## Repeat it yourself

```
curl -fsSL https://getplain.org/install | sh
foundryup -i v1.9.0
git clone --recurse-submodules --depth 1 https://github.com/PaulRBerg/prb-math
cd prb-math && npm install --ignore-scripts
forge test            # cold, then again unchanged
rm -rf out cache
plain test            # cold, then again unchanged
```

Tested 2026-11-17 with plain 0.5.0, forge 1.9.0 (6056c5845d), solc 0.8.30 for PRBMath and 0.8.36 for Solady, on Linux x86\_64 with two pinned CPUs. Timings are single runs and will vary with your machine; plain is MIT licensed and its source and releases are on [GitHub](https://github.com/backmeupplz/plain?ref=blog.borodutch.com).