Skip to content
PineForge

All 201 excellent on PineForge, 137 on PyneCore

36× faster than PyneCore, at the median

ExcellentStrongModerateWeakMinimalNo trade list
Open corpusOpen corpus, 100 strategiesClosed scriptsClosed community scripts, 101, names withheld

Tap or drag the chart to read any point.

Source: summary.md, pineforge-engine 6b45f510, bake-off of 2026-09-29.

The chart as a table

One step per strategy, in the same order on every line: a dip is a strategy graded below excellent, and the deeper the dip, the lower the grade.

GradePineForgePyneCore
Excellent201137
Strong046
Moderate012
Weak04
Minimal01
No trade list01
How this is measured

Source: benchmarks/results/summary.md in pineforge-engine at commit 6b45f510: the bake-off of 2026-09-29 at engine 35db01c8, with PyneCore 6.10.3. Engine v1.4.0 was released after it, and the tiers were not re-measured on the release.

Every number on this page comes from the bake-off in the open-source pineforge-engine repository: 201 strategies on the same 53,929-bar ETHUSDT 15-minute feed, each engine’s trades graded against the trade list TradingView exported. The 100 open-corpus strategies reproduce from a clean clone with bash benchmarks/run_all.sh and no API keys.

Tiers follow the engine’s canonical rubric in scripts/verify_corpus.py. Excellent means the same number of trades, entry and exit prices within 0.01 % and P&L within 1 % at the 90th percentile, and at least 99 % of TradingView’s trades matched. Strong allows a trade-count difference under 6 %, entries within 0.1 %, exits within 0.5 %, P&L within 100 %, and at least 95 % matched. Strategies with trail_* exits use the production profile: exits within 0.05 % and P&L within 100 %. Moderate, weak and minimal step down from there. For excellent, where TradingView shows two or more distinct entry Signals at one exact time, price and direction, the engine shows as many distinct entries there (distinct-entry identity).

vectorbt: The 13 strategies with a hand-written vectorbt port. Excellent 4Strong 6Moderate 2Weak 1

Each mark is one of the 200 strategies timed on both engines, at its exact speed-up on a log scale. How we timed it: PineForge in-process with Google Benchmark, bar magnifier on; PyneCore 6.10.3 as a subprocess, so its wall time includes interpreter start-up. An AWS c7a.8xlarge (AMD EPYC 9R14, 32 cores, SMT off) running Ubuntu 24.04, each timing process pinned to fixed cores; engine 35db01c8, 2026-09-29, one 53,929-bar ETHUSDT 15-minute feed. Engine v1.4.0 was released after it, and the timings were not re-measured on the release. Read the full benchmark.

Where the grades differ

  1. analyzer-parity-percent-of-equity-sizing-01

    percent-of-equity sizing

    PineForge
    excellent (57 / 57)
    PyneCore
    strong (57 / 57)

  2. mtf-triple-tf-macd-hist-confluence-01

    multi-timeframe (request.security)

    PineForge
    excellent (24 / 24)
    PyneCore
    moderate (22 / 22)

  3. ta-str-match-regex-filter-01

    str.match regex filter

    PineForge
    excellent (1,916 / 1,916)
    PyneCore
    weak (1,514 / 1,917)
How this is measured

PyneCore 6.10.3 grades 63 of the 201 strategies below excellent and produces no trade list for 1, whose source the PyneSys compiler rejects. The benchmark report traces them. 32 fail only on P&L (16) or only on the trade count (16), and their fills match TradingView’s: PyneCore’s broker trades from the feed’s first bar, five months before TradingView’s range opens, so percent-of-equity sizing compounds P&L that TradingView never had, and a position already open when the range opens adds one trade at its edge. Of the 9 multi-timeframe scripts an earlier PyneCore release reproduced only in part, fixes to request.security lift 4 to excellent; 4 others still reproduce 41.6 to 91.7 % of TradingView’s history. 3 grid bots drift on FIFO drains, a str.match regex filter grades weak, and the rest fail other gates. Three open-corpus examples:

analyzer-parity-percent-of-equity-sizing-01: PyneCore’s fills match TradingView’s: its entry and exit prices agree at the 90th percentile. Its P&L differs by 2.05 % at the 90th percentile because its broker started trading five months before TradingView’s range, so percent-of-equity sizing had already compounded P&L that TradingView never had.

mtf-triple-tf-macd-hist-confluence-01: TradingView exported 24 trades. PyneCore emits 39, and in the window both lists cover, 22 of TradingView’s trades, it matches all 22: it reproduces 91.7 % of TradingView’s history. PineForge’s 24 trades grade excellent.

ta-str-match-regex-filter-01: The strategy filters entries with str.match. PyneCore emits 1,514 trades against TradingView’s 1,917 in the window, a 21 % count difference, and matches 51.2 % of TradingView’s trades; PineForge matches all 1,916 in its window.

Where each engine fits

All three runtimes are open source. PineForge and PyneCore run strategies with strategy.* orders, and PineTS has shipped a strategy.* namespace since 0.9.17, but the bake-off runs PineTS on indicators only: its harness has no PineTS strategy runner. Only PineForge compiles a strategy to native code. PineForge and PineTS convert Pine on your own machine; PyneCore converts it through the PyneSys compiler, a hosted service.

PineForge

  • You need the trades TradingView would give you: PineForge grades all 201 bake-off strategies excellent.
  • You run many backtests: a median 36× faster than PyneCore per strategy (PineForge timed in-process, PyneCore as a subprocess including interpreter start-up).
  • You want to embed the engine: an Apache-2.0 C++17 runtime with a stable, append-only C ABI.
  • You backtest from an AI agent: a free hosted MCP endpoint, or a local Docker MCP server for your own data.

PyneCore

  • You want to write strategies in Python: PyneCore runs Pine-style Python bar by bar, with the Python data and machine-learning libraries in the same code.
  • You need indicators and plotted values: PyneCore computes them. PineForge rejects indicator() scripts and draws nothing: plots, tables, visual setters and alerts have no effect, and line, box, label, linefill and chart.point objects are kept as data the strategy can read back.
  • You want an Apache-2.0 runtime and are fine converting Pine through the PyneSys compiler, a hosted service. PineForge’s engine is Apache-2.0, but its transpiler is source-available (the PineForge Source License 1.2 from codegen 1.3.0), not OSI open source.

Reproduce the bake-off

The public half of the bake-off, the 100 open-corpus strategies, reproduces from a clean clone: every input is committed to the benchmark assets, and no API key is needed. The 101 closed community scripts are not redistributed (TradingView’s terms), so that half cannot be rerun outside PineForge.

# 1. Clone the engine and the public benchmark assets
git clone https://github.com/pineforge-4pass/pineforge-engine.git
cd pineforge-engine
git submodule update --init benchmarks/assets

# 2. Install the Python and Node tools for the other engines, then build
(cd benchmarks && uv sync --python 3.12 && npm install)
cmake -B build -S . -DPINEFORGE_BUILD_TESTS=ON -DPINEFORGE_BUILD_BENCH_STRATEGIES=ON -DPINEFORGE_BUILD_SPEED_BENCH=ON
cmake --build build --target pineforge bench_strategies pineforge_bench -j

# 3. Grade every engine against TradingView
SKIP_BUILD=1 SKIP_SPEED=1 JOBS=8 bash benchmarks/run_all.sh

# 4. Read the results: the 100 open-corpus rows behind the tallies on this page
cat benchmarks/results/summary.md
Benchmarks in the engine repoMethodology