Standard Library

1globalSetup {
2  anvil.spawnAnvil()                           # Local node, no fork
3  anvil.spawnAnvil(fork: "https://rpc.url")    # Fork from an RPC endpoint
4}

1after {
2  anvil.stopAnvil()
3}

1use std::anvil
2
3globalSetup {
4  anvil.spawnAnvil(fork: "https://eth.llamarpc.com")
5}
6
7suite evmBench {
8  description: "EVM RPC benchmarks against a forked mainnet node"
9  compare: true
10  baseline: "go"
11  mode: "auto"
12  targetTime: 10000ms
13  cvThreshold: 10
14
15  setup go {
16      import (
17          "context"
18          "github.com/ethereum/go-ethereum/ethclient"
19      )
20
21      declare {
22          var client *ethclient.Client
23          var ctx context.Context
24      }
25
26      init {
27          ctx = context.Background()
28          client, _ = ethclient.Dial(os.Getenv("ANVIL_RPC_URL"))
29      }
30
31      helpers {
32          func getBlockNumber() uint64 {
33              num, _ := client.BlockNumber(ctx)
34              return num
35          }
36      }
37  }
38
39  setup ts {
40      import {
41          import { createPublicClient, http } from 'viem'
42          import { mainnet } from 'viem/chains'
43      }
44
45      declare {
46          let client: any
47      }
48
49      init {
50          client = createPublicClient({
51              chain: mainnet,
52              transport: http(ANVIL_RPC_URL),
53          })
54      }
55
56      helpers {
57          async function getBlockNumber(): Promise<bigint> {
58              return await client.getBlockNumber()
59          }
60      }
61  }
62
63  bench getBlockNumber {
64      description: "Get the current block number via RPC"
65      go: getBlockNumber()
66      ts: await getBlockNumber()
67  }
68}

1use std::charting
2
3suite example {
4  # ... setup, fixtures, benchmarks ...
5
6  after {
7
8      charting.drawTable(title: "Results", output: "results-bar.svg")
9      charting.drawSpeedupChart(
10          title: "Speedup vs baseline",
11          output: "results-speedup.svg",
12          baselineBenchmark: "hashShort"
13      )
14  }
15}

1charting.drawTable(
2
3  title: "Performance Comparison",
4  description: "Go vs TypeScript vs Rust",
5  output: "results-table.svg",
6  sortBy: "speedup",
7  sortOrder: "desc",
8  showStats: true,
9  showGeoMean: true,
10)

1charting.drawSpeedupChart(
2
3  title: "Speedup vs Go baseline",
4  description: "How each benchmark compares to baseline",
5  output: "results-speedup.svg",
6  baselineBenchmark: "hashShort",  # alias: baseline
7  sortBy: "speedup",
8  showGrid: true,
9  gridOpacity: 0.15,
10  legendPosition: "top-right"
11)

1use std::charting
2
3suite comprehensive {
4  # ... benchmarks ...
5
6  after {
7      # Grouped table for overall comparison
8      charting.drawTable(
9          title: "Overall Performance",
10          output: "results-table.svg",
11          sortBy: "speedup",
12          sortOrder: "desc",
13          showStats: true
14      )
15
16      # Speedup chart relative to a baseline benchmark
17      charting.drawSpeedupChart(
18          title: "Speedup vs baseline",
19          output: "results-speedup.svg",
20          baselineBenchmark: "hashShort",
21          showGrid: true
22      )
23  }
24}

1use std::constants
2
3suite mathBenchmarks {
4  setup go {
5      helpers {
6          func circleArea(radius float64) float64 {
7
8              return std_PI * radius * radius
9          }
10      }
11  }
12
13  setup ts {
14      helpers {
15          function circleArea(radius: number): number {
16
17              return std_PI * radius * radius
18          }
19      }
20  }
21
22  setup rust {
23      helpers {
24          fn circle_area(radius: f64) -> f64 {
25
26              STD_PI * radius * radius
27          }
28      }
29  }
30
31  bench area {
32      go: circleArea(10.0)
33      ts: circleArea(10.0)
34      rust: circle_area(10.0)
35  }
36}