Skip to content

Performance ​

These benchmarks compare Fatou's formatting speed with Runic and JuliaFormatter, and its language-server speed and memory use with LanguageServer.jl and JETLS. Fatou runs as a compiled Rust program; the comparison tools run in Julia.

Formatter ​

We compare Fatou with Runic and JuliaFormatter on source files from JuliaSyntax.jl and DataFrames.jl. Each tool uses its default formatting style.

The single-file and project benchmarks keep each tool loaded between runs, so Julia startup and compilation do not count. The cold-start benchmark below includes those costs.

  • Corpora: JuliaSyntax.jl v0.4.10 (09576ca), DataFrames.jl v1.8.2 (946c72a)
  • Versions: Fatou 0.20.0, Runic 1.9.0, JuliaFormatter 2.12.6, Julia 1.13.0
  • Host: AMD Ryzen 9 7900 12-Core Processor (Linux x86_64)
  • Machine: terra
  • Warm-loop iterations: 50 single, 20 project; 3 warmup
  • Cold-start iterations: 5 fresh-process runs (single file)

Single files ​

The three files cover parser internals (parse_stream.jl), a large data table (kinds.jl), and docstring- and macro-heavy library code (abstractdataframe.jl).

The charts show time relative to Fatou: 1 is the Fatou baseline, and 10 means ten times as long. Lower is faster. Each step on the logarithmic axis is a tenfold increase. Tooltips and expandable tables show the measured times and throughput.

Median formatting time relative to Fatou (lower is faster). Each color is one file; the dashed line at 1 is Fatou.
Data table

parse_stream.jl (JuliaSyntax/src/parse_stream.jl)

ToolFilesBytesMedian (ms)Throughput (MB/s)Relative
Fatou141,9374.110.26baseline
Runic141,93715.82.653.88x
JuliaFormatter141,9377.85.351.92x

kinds.jl (JuliaSyntax/src/kinds.jl)

ToolFilesBytesMedian (ms)Throughput (MB/s)Relative
Fatou124,4421.515.79baseline
Runic124,44212.61.948.13x
JuliaFormatter124,4424.15.972.64x

abstractdataframe.jl (DataFrames/src/abstractdataframe/abstractdataframe.jl)

ToolFilesBytesMedian (ms)Throughput (MB/s)Relative
Fatou1100,3885.618.04baseline
Runic1100,38831.53.195.66x
JuliaFormatter1100,38813.77.352.46x

Whole projects ​

This comparison checks formatting across each project's src/ tree, including file discovery, reading files, and parallel processing. Runic is omitted because it has no in-process directory API. The tables list any files a tool skipped.

Median formatting time relative to Fatou (lower is faster). Each color is one project; the dashed line at 1 is Fatou.
Data table

JuliaSyntax (JuliaSyntax/src)

ToolFilesBytesMedian (ms)Throughput (MB/s)Relative
Fatou15332,78310.631.37baseline
JuliaFormatter15332,78327.312.202.57x

DataFrames (DataFrames/src)

ToolFilesBytesMedian (ms)Throughput (MB/s)Relative
Fatou36870,5819.987.52baseline
JuliaFormatter36870,58134.025.593.42x

Cold start ​

Each run starts a fresh process, formats parse_stream.jl once, and exits. This is the cost of a command-line invocation, including Julia startup, package loading, and compilation for Runic and JuliaFormatter.

Median cold-start time relative to Fatou (lower is faster). The dashed line at 1 is Fatou. Each run starts a fresh process and formats one file.
Data table
Cold start: parse_stream.jl, one fresh process per run
ToolMedian timeThroughput (MB/s)vs Fatou
Fatou5.9 ms7.10baseline
Runic189.1 ms0.2232.01x
JuliaFormatter287.1 ms0.1548.60x

Language servers ​

We compare Fatou with LanguageServer.jl and JETLS in the same DataFrames.jl workspace. The benchmark opens the same files, collects diagnostics, and sends editor requests to each server.

The servers provide different analyses: Fatou analyzes source statically, LanguageServer.jl indexes the Julia environment, and JETLS performs type inference through JET. These results show the time and memory each editor session uses.

  • Workspace: DataFrames.jl v1.8.2 (946c72a), instantiated
  • Session: 5 files opened (343 KiB of source), diagnostics, symbols, and hovers
  • Navigation target: _names in src/abstractdataframe/selection.jl at line 383
  • Versions: Fatou 0.18.0, LanguageServer.jl 5.0.0, JETLS 7e01ca58 (2026-08-08), Julia 1.12.6
  • Host: AMD Ryzen 9 7900 12-Core Processor (Linux x86_64, 61 GB RAM)
  • Machine: terra

Speed ​

The startup measurements cover three stages:

  • Initialize measures the server's response to the editor's initialization request.
  • Workspace ready measures the time from process start until background indexing settles.
  • Open files ready measures the time from opening the files until diagnostics arrive and background work settles.

After startup, we time requests for document symbols, hover information, definitions, references, and renaming. The chart shows median response times. Tooltips and expandable tables include the 95th percentile (p95) and the number of results returned, which can differ between servers. The p95 is the time within which 95% of requests finish. Lower is faster.

Readiness ​

Readiness time in seconds on a log scale (lower is faster). Each color is one startup phase. The phases have different starting points and are not additive.
Readiness data
ServerInitializeWorkspace readyOpen files ready
Fatou1 ms152 ms54 ms
LanguageServer.jl4.14 s27.70 s3.30 s
JETLS5.88 s9.88 s13.54 s

Warm requests ​

Median request latency in milliseconds on a log scale (lower is faster). Each color is one request. Tooltips and the table include p95 and the number of results returned.
Request timings and returned work
ServerRequestMedianp95Returned work
FatouDocument symbols1.29 ms1.68 ms54–123 symbols (median 70), 24 KiB
FatouHover0.06 ms0.13 ms1 result, 162 B
FatouGo to definition0.28 ms0.40 ms5 locations in 4 files, 879 B
FatouFind references0.54 ms0.68 ms135 locations in 17 files, 23 KiB
FatouRename0.61 ms0.69 ms135 edits in 17 files, 17 KiB
LanguageServer.jlDocument symbols5.42 ms7.96 ms372–626 symbols (median 519), 117 KiB
LanguageServer.jlHover0.09 ms0.35 ms1 result, 709 B
LanguageServer.jlGo to definition1.30 ms1.38 ms5 locations in 4 files, 884 B
LanguageServer.jlFind references54.30 ms84.15 ms135 locations in 17 files, 23 KiB
LanguageServer.jlRename54.57 ms59.51 ms135 edits in 17 files, 18 KiB
JETLSDocument symbols2.08 ms5.84 ms348–578 symbols (median 477), 131 KiB
JETLSHover1.28 ms4.23 ms1 result, 1 KiB
JETLSGo to definition0.62 ms0.87 ms2 locations in 1 file, 761 B
JETLSFind references1.07 ms4.38 ms135 locations in 17 files, 23 KiB
JETLSRename22.36 ms41.46 ms135 edits in 17 files, 18 KiB

Warm requests show median / p95. Each target ran 20 measured rounds after 2 warmup rounds; symbols and hover span 3 files, while definition, references, and rename use _names in src/abstractdataframe/selection.jl.

Memory ​

The chart shows resident memory (RSS) for each server and its child processes. Baseline is after initialization, Settled is after the open files have been analyzed, and Peak is the highest sample during the session. Each server is measured in one session.

Resident memory across each server's process tree, in MB (lower uses less memory). Each bar shows one server at one milestone.
Memory data
ServerBaselineSettledPeakvs FatouSettled afterDoing
Fatou79 MB84 MB93 MBbaseline9 sstatic analysis, no Julia runtime
LanguageServer.jl965 MB1104 MB1567 MB13.1x41 sJulia runtime plus a SymbolServer pass over the environment
JETLS792 MB1998 MB2111 MB23.7x33 sJulia runtime plus type inference through JET

Command-line memory use ​

For a CI job or pre-commit hook, Fatou runs once and exits. This table shows peak memory use for format, lint, and parse on individual files and whole source trees. Whole-tree runs process files in parallel, so several syntax trees can be in memory at once.

CommandOverInputPeak RSSWall
fatou format --checksrc tree850 KiB39.2 MB20 ms
fatou lintsrc tree850 KiB26.6 MB30 ms
fatou format --checkone file98 KiB10.3 MB10 ms
fatou lintone file98 KiB9.3 MB10 ms
fatou parseone file98 KiB7.7 MB10 ms
fatou --versionprocess floor-4.6 MB0 ms
trueharness floor-2.2 MB0 ms

The src tree is 36 files, 850 KiB. Lowest of 5 runs each, measured with GNU time.

Reproduce the results ​

Run these commands from the repository root in the devenv shell:

sh
task bench-corpus  # Fetch the pinned Julia projects.
task bench        # Measure formatter speed.
task bench-lsenv   # Set up LanguageServer.jl and JETLS.
task bench-lsp     # Measure language-server speed and memory.

The commands write bench/results.json and bench/memory.json. These committed files supply the charts, machine details, and tool versions shown above. Building the documentation reads them without running the benchmarks.

Released under the MIT License.