Skip to content
PineForge

Questions

  • What is PineForge?
    PineForge is a deterministic C++ backtesting engine with its own kernel; it runs PineScript v6 strategies through a transpiler and a Pine adapter, offline, in CI or from an AI agent. In its parity baseline of 2026‑10‑13, 100.00 % of 7,989 backtests graded excellent or strong against the trade lists TradingView itself exported; the main baseline ran on engine 2608ebdd. Release v1.4.0 (2026‑10‑08) grades 7,983 excellent and 6 strong on its own immutable baseline. The same script, data and PineForge version (engine and transpiler) give the same trades, so you can commit a report to a repository and have CI rerun the backtest and compare. Use it from an AI assistant through the free hosted MCP server, or run the pineforge-release Docker image on your own data; the engine is Apache-2.0 on GitHub.
  • Is PineForge only for Pine Script?
    No. PineForge is an engine of its own, built on a Pine-agnostic C++ kernel. PineScript v6 is the language it adopted: the transpiler compiles a Pine strategy to C++, and a Pine adapter on top of the kernel reproduces TradingView’s execution semantics. You can also write a strategy in C++ or C straight against the kernel, as the engine’s README shows. The pineforge-release Docker image takes Pine or a pre-transpiled C++ translation unit, the transpiler’s output (at /in/strategy.cpp, used when no Pine file is given); the MCP servers take Pine only. MQL5 is planned as a second adopted language, with no date; it does not run today.
  • How accurate is PineForge compared with TradingView?
    In PineForge’s parity baseline of 2026‑10‑13, 100.00 % of 7,989 backtests graded excellent or strong, the top two of five grades, against the trade lists TradingView itself exported: 7,983 excellent (99.92 %) and 6 strong (0.08 %). Over the window both trade lists cover, excellent means the same number of trades, and entry and exit prices within 0.01 % and P&L within 1 % at the 90th percentile (strategies with trail_* exits: exits within 0.05 %, P&L within 100 %); it also needs at least 99 % of TradingView’s closed trades matched, or at most one unmatched. Strong allows a trade-count difference under 6 %, entries within 0.1 %, exits within 0.5 % and P&L within 100 %, with at least 95 % matched, or at most one unmatched. The backtests come from 309 open reference strategies (one backtest each), 680 community-shared scripts and 61 probe scripts the maintainers wrote, on 9 markets across crypto, US stocks, CME index futures, FX, gold and India’s NIFTY index, across 2 timeframes. 17 backtests whose TradingView export shows a TradingView-side defect are excluded (8,006 in the population). The main baseline ran on engine 2608ebdd. Release v1.4.0 grades 7,983 excellent and 6 strong on its own immutable baseline. 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). How each grade is computed
  • How do I install PineForge?
    Use the free hosted MCP server, which needs no install, or pull the pineforge-release Docker image to backtest on your own data. Give any MCP client the URL https://mcp.pineforge.dev/mcp, or add the server to Claude Code with one command: 
    claude mcp add --transport http pineforge https://mcp.pineforge.dev/mcp
    For your own data you need Docker. Pull the release image (engine 1.4.0, codegen 1.4.0): 
    docker pull ghcr.io/pineforge-4pass/pineforge-release:1.4.0
    Then, in the folder that holds strategy.pine and ohlcv.csv (header timestamp,open,high,low,close,volume, timestamps in UNIX milliseconds), run the backtest; the JSON report lands in report.json: 
    docker run --rm --network=none \
  -v "$PWD/strategy.pine:/in/strategy.pine:ro" \
  -v "$PWD/ohlcv.csv:/in/ohlcv.csv:ro" \
  ghcr.io/pineforge-4pass/pineforge-release:1.4.0 > report.json
    To work on your own data from an AI assistant, run the local MCP server instead: see its setup.
  • How is PineForge different from PyneCore?
    PyneCore runs Pine-style Python: Pine is converted to Python by the PyneSys compiler and runs in the Python interpreter. PineForge transpiles Pine to C++ and runs it natively. Both are checked against TradingView. In the 201-strategy bake-off in the engine repo (2026‑09‑29, engine 35db01c8), graded against TradingView’s own trade lists, PineForge grades all 201 excellent and PyneCore 6.10.3 137 excellent and 46 strong; most of PyneCore’s gap comes from its runner’s trading window, and some from multi-timeframe request.security and grid bots. Full breakdown
  • Will my existing TradingView strategy work without changes?
    Often, but check first. PineForge covers strategy.* orders, risk gates and accessors, 59 official ta.* functions plus the 8 ta.* series variables, arrays, maps, matrices, user-defined types, and request.security. On another symbol, it reads that symbol’s own bars, which you install through the engine’s C API before the run or give the pineforge-release image as feeds (PINEFORGE_SYMBOL_FEEDS); the MCP servers install none. Without those bars, a request whose value can affect a trade stops the run instead of using the chart’s bars. Drawing objects (line, box, label, linefill, chart.point) are kept as data the strategy can read back, their history included as of codegen 1.0.1. Plots, tables, visual setters and alerts are accepted and have no effect: nothing is drawn. Scripts declared with indicator() are rejected. Look up any identifier in the coverage doc, or ask the MCP server’s check_pine_feature tool.
  • Does PineForge run Pine Script v5 or older scripts?
    PineForge accepts Pine Script v6 strategies. A v6 strategy can import v5 libraries; a few v5 behaviors that PineForge does not reproduce are refused with an error naming the library, for example a v5 library function called inside request.security() or another request.*() call. Scripts written in v5 or earlier must be migrated to v6 first (TradingView’s editor can convert them).
  • What are PineForge’s limitations?
    PineForge places no orders and draws no charts. Drawing objects (line, box, label, linefill, chart.point) are kept as data the strategy can read back, their history included as of codegen 1.0.1; plots, tables, visual setters and alerts are accepted and have no effect. Scripts declared with indicator() are rejected. It does not execute every Pine v6 identifier, so before you rely on a script, look up the identifiers it uses in the coverage doc or with the MCP server’s check_pine_feature tool. The free hosted server allows 100 shared backtest_pine and check_tradingview_parity calls a week per IP, on the last 365 days of crypto data only, and a monthly compute budget shared by all free users can pause backtests and parity checks until the next UTC month. The release image includes no market data: you supply the OHLCV CSV (the local MCP server can download Binance candles for you). The hosted server has no sweep tool: sweep parameters with the local MCP server’s backtest_pine_grid or a script around the release image; hosted optimization is planned, with no date. A backtest reports what a strategy did on the data you gave it; it is not a forecast or trading advice.
  • Is PineForge free? Which parts are open source?
    Yes, for personal trading: the hosted MCP server (no key, 100 metered calls a week per IP), both local Docker images (unmetered) and the transpiler cost nothing today. Hosted paid plans are planned, with no dates. The engine, pineforge-engine, is Apache-2.0: a C++17 runtime with a stable, append-only C ABI, documented at cdocs.pineforge.dev, with CI on Ubuntu and macOS. The transpiler, pineforge-codegen, is source-available under the PineForge Source License 1.2 from codegen 1.3.0, not open source. Personal trading (one person, their own account, their own capital) is free, and so is noncommercial use, including use by schools, charities, public research bodies and government institutions for teaching, research and their own operations. Use by or for a company or fund, in a product or a hosted service, and investment management other than personal trading (endowments, pension funds and public funds included) need a commercial license: write to [email protected]. An account a proprietary-trading firm or funded-trader program provides or allocates, including a challenge, evaluation or simulated account, is not the trader’s own: its capital, real or simulated, is investment capital, so trading it or backtesting strategies for it is Commercial Use. Earlier releases keep the license they shipped with. The parity evidence is public too: the 312-strategy pineforge-corpus ships TradingView’s trade list and the engine’s for every strategy, and the corpus check on engine main pins 311 excellent plus 1 declared anomaly.
  • Can I use this in production today?
    For backtests, yes: that is what the released engine (v1.4.0) does. It can also warm up on OHLCV history and then run in real time on ordered trades you feed it (released since v0.11.0). Engine v1.4.0 also ships an optional native runner, pineforge-live, off by default: it warms a compiled strategy on confirmed historical bars, runs it on normalized ticks or confirmed bars, sends simulated fill actions to a broker-neutral webhook and journals to SQLite (the runner’s guide). The parity scoreboard does not certify its live behavior or real broker fills, and PineForge does not place orders. If you need live execution today, use a broker bridge, for example TradingView alerts to your broker.
  • Can PineForge trade live or connect to my broker?
    No: PineForge does not place orders and has no broker connection. Engine v1.4.0 includes an optional native runner, pineforge-live, behind a build option that is off by default; it runs a compiled strategy on normalized ticks or confirmed bars and sends simulated fill actions to a broker-neutral webhook (the runner’s guide), and the parity scoreboard does not certify its live behavior or real broker fills. To trade a strategy live, use a broker bridge, for example TradingView alerts to your broker.
  • What if PineForge shuts down?
    The engine (libpineforge.a, its headers and the benchmark harness) is Apache-2.0: you can fork it and keep building. The pineforge-release image you pulled keeps working offline, the C++ the transpiler generated for your strategies stays on your disk, and the transpiler’s code is on GitHub. The open corpus and the public benchmark assets are public repositories. Reports are plain JSON; your Pine source and your data are yours. If the hosted MCP server went away, you would lose that endpoint and its hosted data; the local Docker server keeps running on your own CSVs.
  • How do you compare to TradingView’s own backtester?
    TradingView is where you discover and chart strategies, and it can route orders to brokers. PineForge replaces nothing on the chart side. It runs the strategy you already wrote on your own data or from an AI agent, compiled and deterministic: the same inputs give the same trades, so a parameter sweep or a CI check is a script. Use TradingView to prototype; use PineForge when the answer has to be reproducible.
  • When can I sell strategies on a marketplace?
    There is no date. The marketplace, where compiled strategies are sold with seller-set licenses, is planned and not built: no license server, seller tools or payments exist today. The seller waitlist is open. Join the waitlist
  • Can an AI assistant accurately backtest my PineScript strategy?
    Not by reasoning alone. An LLM cannot reproduce PineScript v6’s series semantics, intrabar fills and strategy.* order logic from approximation, so trades or P&L it estimates by hand are unreliable and will not match TradingView. PineForge is a deterministic C++ engine, callable through an MCP server, that runs PineScript v6 by transpiling it to C++: in the 2026‑10‑13 parity baseline (main engine 2608ebdd; release v1.4.0: 7,983 excellent, 6 strong), 100.00 % of 7,989 backtests graded excellent or strong against TradingView’s own trades (309 open reference strategies, 680 community-shared scripts and 61 probe scripts the maintainers wrote, on 9 markets and 2 timeframes). A connected agent calls backtest_pine, on the free hosted MCP at https://mcp.pineforge.dev/mcp (no install) or on a local Docker server, and gets a real backtest instead of a guess. Connect in one line: claude mcp add --transport http pineforge https://mcp.pineforge.dev/mcp.
  • Why can’t ChatGPT or Claude just backtest my Pine script directly?
    Because a backtest is a deterministic computation over your price data, not a fact a model can recall. PineScript v6 runs bar by bar with look-ahead rules, intrabar fill order and strategy.* broker logic (slippage, commission, OCA, pyramiding); approximating that in prose drops or invents trades, so the P&L won’t reconcile with TradingView. The reliable path is to run a real engine. PineForge offers one as a free hosted MCP server (https://mcp.pineforge.dev/mcp, no install, no key) or as a local Docker server for private data, with tools such as backtest_pine, fetch_ohlcv and check_pine_feature. The engine is deterministic, and in the 2026‑10‑13 parity baseline (main engine 2608ebdd; release v1.4.0: 7,983 excellent, 6 strong), 100.00 % of 7,989 backtests graded excellent or strong against TradingView’s own trades.
  • Can a PineScript strategy actually make money? Is mine profitable?
    No tool can promise that, and no AI can tell you by reasoning. What you can do is measure honestly before risking capital, which is what PineForge is for. Strategies that look profitable in a naive or AI-estimated backtest often fail live because slippage, commissions, fill assumptions and look-ahead bias are not modeled. PineForge runs your PineScript v6 over real OHLCV on its own deterministic C++ engine, costs included; in the 2026‑10‑13 parity baseline (main engine 2608ebdd; release v1.4.0: 7,983 excellent, 6 strong), 100.00 % of 7,989 backtests graded excellent or strong against TradingView’s own trades. Past backtested performance does not guarantee future results; treat the output as validation, not a profit forecast.
  • How do I backtest PineScript without TradingView?
    Run it through PineForge. Fastest start: connect the free hosted MCP server at https://mcp.pineforge.dev/mcp: no install, no key, 100 shared backtest_pine and check_tradingview_parity calls a week per IP, on the last 365 days of crypto OHLCV. For your own OHLCV, run the pineforge-release Docker image or the local MCP server: no API key, and the code and data stay on your machine. PineForge transpiles your Pine to C++, runs it on its own engine and reproduces TradingView’s execution semantics: in the 2026‑10‑13 parity baseline (main engine 2608ebdd; release v1.4.0: 7,983 excellent, 6 strong), 100.00 % of 7,989 backtests graded excellent or strong against TradingView’s own trades. Over MCP, it lets an AI coding agent (Claude Code, Cursor) run the transpile and the backtest from a prompt.
  • What’s the best way to backtest a PineScript strategy accurately: AI estimate, re-coding in Python, or TradingView itself?
    Each option trades off accuracy, determinism and where your data lives. Asking an LLM to estimate trades is fast but unreliable: it cannot reproduce Pine’s series and order logic. Rewriting the strategy in Python (backtrader, vectorbt) means re-implementing and re-validating it by hand, with no check against TradingView. TradingView itself is accurate but runs in the browser: not callable by an agent or scriptable for large sweeps. PineForge transpiles the Pine you already wrote to C++ and runs it on its own deterministic engine, locally or on a free hosted MCP endpoint, both callable by an AI agent; in the 2026‑10‑13 parity baseline (main engine 2608ebdd; release v1.4.0: 7,983 excellent, 6 strong), 100.00 % of 7,989 backtests graded excellent or strong against TradingView’s own trades.

If your question isn’t here, ask in GitHub Discussions on the engine repo. We read every thread.