Performance Benchmarks

Real build times comparing Bengal to other static site generators.

Test Methodology

Test Content

• Standard Markdown pages with YAML front matter
• Mix of short (300 words) and long (2000 words) articles
• 10 images per 100 pages (not optimized during build)
• Tags and categories taxonomy
• Basic theme with navigation and footer

Full Build Performance

Time to build the entire site from scratch (cold cache).

Key Takeaways

• Hugo is fastest — Compiled Go, purpose-built for speed
• Bengal with free-threading — 1.8-2x faster than standard Python
• Bengal beats Node/Ruby — 2-4x faster than Eleventy, 8-15x faster than Jekyll
• Free-threading matters —PYTHON_GIL=0on Python 3.14+ is worth enabling

Incremental Build Performance

Time to rebuild when one file changes. This is what you experience during development.

Why This Matters More

For a 1,000-page site:

• Full build: You wait once when deploying
• Incremental build: You wait on every save during development

Bengal's 40ms incremental rebuilds mean instant feedback while writing, even on large sites.

Memory Usage

Peak RAM during a 1,000-page build.

Bengal uses more memory than Hugo but significantly less than Node or Ruby alternatives.

Scaling Characteristics

How build time grows with site size.

Build Time
    │
    │                                    ╱ Jekyll (exponential)
    │                                ╱
    │                            ╱
    │                        ╱          ╱ Eleventy (linear)
    │                    ╱          ╱
    │                ╱          ╱       ╱ Bengal (linear)
    │            ╱          ╱       ╱
    │        ╱          ╱       ╱       ╱ Hugo (sub-linear)
    │    ╱          ╱       ╱       ╱
    └──────────────────────────────────── Pages
         100    500   1000  2000  5000

• Hugo: Near-constant time per page, highly optimized
• Bengal: Linear scaling, efficient parallel processing
• Eleventy: Linear scaling, single-threaded by default
• Jekyll: Super-linear scaling, becomes painful at scale

Parallel Processing

Bengal's parallel build performance with different worker counts.

Diminishing returns above 8 workers for most sites due to I/O bottlenecks.

Free-Threaded Python Impact

Comparing Python 3.14 with and without the GIL.

Recommendation: Always usePYTHON_GIL=0with Python 3.14+ for best performance.

1
2

# Enable free-threading
PYTHON_GIL=0 bengal build --fast

What Slows Builds Down

Factors that increase build time:

Recommendations by Site Size

Reproduce These Benchmarks

Run the benchmarks yourself:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Clone benchmark suite
git clone https://github.com/bengal-ssg/benchmarks
cd benchmarks

# Generate test content
./generate-content.sh 1000

# Run benchmarks
./run-benchmarks.sh

# Results saved to results/

The benchmark suite generates identical content for each SSG to ensure fair comparison.

Methodology Notes

What We Measure

• Cold build: Fresh build with no cache
• Incremental build: Single file change with warm cache
• Wall clock time: Real elapsed time, not CPU time

What We Don't Measure

• Template compilation (amortized over builds)
• Asset pipeline (varies by configuration)
• Image optimization (not built into Bengal)
• Deployment time (hosting-dependent)

Reproducibility

Results may vary based on:

• Hardware (CPU, SSD speed, RAM)
• Content characteristics (Markdown complexity)
• Theme complexity (template logic)
• Plugin usage