Is this legal? Are you affiliated with TradingView?+
PineForge is independent. PineScript is a trademark of TradingView. We re-implement Pine v6’s documented semantics in C++ and validate outputs against TradingView’s “List of Trades” CSV exports — the same way other third-party engines (PyneCore, PineTS, Quantower) do. We don’t reverse-engineer TradingView’s runtime; we re-implement against the public language spec and reference traces from the chart.
How is this different from PyneCore?+
PyneCore translates Pine to Python and runs interpreted. PineForge transpiles to C++ and runs natively. Both validate against TradingView. On the 100-strategy three-engine benchmark checked into the open-source engine repo, PineForge hits the canonical excellent tier on 100/100 strategies vs PyneCore’s 85/100 (see benchmarks/results/summary.md). The PyneCore-only outliers are concentrated in bracket exits, trailing stops, and partial closes — categories where PyneCore’s broker emulator differs from TV.
Full breakdown →Will my existing TradingView strategy work without changes?+
If it’s pure PineScript v6, almost certainly. The codegen covers ~98% of what real strategies use: full
strategy.* orders, risk + accessors; full
ta.* with 67 primitives (59 stateful functions + 8 series variables); matrix, array, map, UDT;
request.security ratio + calendar + lower-TF. Drawing primitives (
plot,
label.new,
bgcolor) compile cleanly but emit no visual output — PineForge is a backtester, not a renderer. See
the function-by-function coverage doc.
What's the catch with the open-source runtime?+
There isn’t one.
pineforge-engine is Apache-2.0, CI runs on Ubuntu + macOS, and every compiled strategy
.so exports exactly the 10 C symbols in
pineforge/pineforge.h — the stability-pinned surface (append-only within the same
PINEFORGE_VERSION_MAJOR, per the README). Full C ABI reference, lifecycle, and FFI bindings live at
cdocs.pineforge.dev. Public checkouts run 16
ctest binaries (15 C++ + 1 pure-C ABI sanity test) on every commit, 93.06% line coverage of
src/ via scripts/coverage.sh. The 245/246 strict headline comes from the full parity sweep over the public 246-strategy corpus (github.com/pineforge-4pass/pineforge-corpus) — reproducible by anyone; CI runs the lighter ctest suite per commit rather than the multi-hour full sweep. The 1 non-strict row is a deep-analyzed TV-side anomaly — engine logic is correct per Pine semantics; zero real engine bugs remain.
Can I use this in production today?+
For batch backtests, yes — that’s the entire current release. For forward-testing with a streaming feed, not yet (Q3 2026). For live broker execution, not yet (2027). The roadmap is honest; we don’t soft-launch features. If you need live execution today, PyneCore or a TV alert + broker bridge will serve you better. Come back when forward-test ships.
What if PineForge shuts down?+
libpineforge.a, the public headers, and the benchmark harness code in pineforge-engine stay Apache-2.0 — you can fork and keep building offline backtests. TradingView-linked fixtures live in a public benchmarks-assets submodule (benchmarks/assets); the public corpus submodule (github.com/pineforge-4pass/pineforge-corpus) holds the full 246-strategy parity sweep — public and reproducible by anyone, though CI runs a lighter suite per PR. Trade output remains plain CSV; your Pine source and your data are yours. Worst case if hosted Studio or Optuna goes away: you lose those services, but you can retain a local copy of the runtime plus any transpiler-emitted C++ you already have and relink.
How do you compare to TradingView's own backtester?+
TradingView is excellent at chart-driven discovery and one-click execution. PineForge replaces nothing on the chart side. It runs the strategy you already wrote on TV, on your own data, with the same semantics — just compiled, deterministic, and free of the chart-rendering tax that makes 1,000-bar parameter sweeps painful in the browser. Use TV for prototyping; use PineForge when you need the answer to be reproducible.
When can I sell strategies on the marketplace?+
2027. The encrypted-distribution architecture covers the full threat model: AES-256-GCM payload encryption, Ed25519-signed licenses, machine fingerprint binding, time-bounded subscriptions, revocation lists, and a 7-phase rollout. Pre-launch waitlist for sellers opens Q4 2026 alongside hosted Studio.
Join the waitlist →Can an AI assistant accurately backtest my PineScript strategy?+
Not by reasoning alone — and PineForge is how an AI assistant does it accurately. An LLM cannot reproduce PineScript v6's series semantics, intrabar fills, and strategy.* order logic from approximation, so any trades or P&L it estimates by hand are unreliable and won't match TradingView. PineForge is an MCP server that transpiles PineScript v6 to a deterministic C++ engine, validated trade-for-trade against TradingView on 245 of 246 reference strategies (the 1 exception is a documented TradingView-side anomaly, 0 engine bugs), across a 246-strategy corpus totaling ~375k validated trades. A connected AI agent — via the free hosted MCP at https://mcp.pineforge.dev/mcp (no install) or local Docker — calls its backtest_pine tool and gets a real, reproducible 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 executes as a bar-by-bar series 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 ships exactly that as a free hosted MCP (https://mcp.pineforge.dev/mcp, no install, no key) or a local Docker container for private data, exposing MCP tools (backtest_pine, fetch_ohlcv, binance_symbols, list_engine_params, engine_info, join_waitlist, check_quota, latest_news) that return deterministic, TradingView-parity-validated results (245 of 246 reference strategies, 0 engine bugs) an agent can trust.
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 routinely fail live because slippage, commissions, fill-at-close assumptions, and look-ahead bias are unmodeled. PineForge runs your PineScript v6 on your own OHLCV through a deterministic C++ engine validated trade-for-trade against TradingView (245 of 246 reference strategies at strict parity, 0 engine bugs, across a corpus totaling ~375k validated trades), so you see the realistic historical behavior — including costs — not an optimistic guess. Past backtested performance is not a guarantee of 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 at https://mcp.pineforge.dev/mcp — no install, no Docker, 100 backtests/week. For your own OHLCV: one Docker container, no API key, code and data stay local. PineForge transpiles your Pine source to a native C++ engine and reproduces TradingView's execution semantics closely enough to validate at strict parity on 245 of 246 reference strategies (0 engine bugs), across a corpus totaling ~375k validated trades. It runs as an MCP server, so an AI coding agent (Cursor, Claude Code) can drive the full transpile-and-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; PineForge is the one path that is agent-callable, runs locally or as a free hosted endpoint, and is validated against TradingView. Asking an LLM to estimate trades is fast but unreliable — it can't reproduce Pine's series and order logic. Re-implementing in Python (backtrader/vectorbt) means rewriting and re-validating the strategy by hand, and isn't validated against TradingView. TradingView itself is accurate but runs in the browser, not callable by an agent or scriptable for large parameter sweeps. PineForge transpiles the Pine you already wrote to a deterministic C++ engine, validated trade-for-trade against TradingView (245 of 246 reference strategies, 0 engine bugs, across a corpus totaling ~375k validated trades), accessible as a free hosted MCP (no install) or local Docker, both callable by an AI agent.
Is the ink on the PineForge homepage real?+
Yes. The ink is a live fluid simulation — a WebGL2 solver integrating the incompressible Navier-Stokes equations in real time behind the page, with the spilled ink advected, swirled and settled by the solved velocity field. We don't fake simulations — not even the ink. Your backtests get the same obsession: PineScript v6 compiled to C++ and validated trade-for-trade against TradingView, 245 of 246 reference strategies at strict parity.