Cómo usamos PyneCore como segundo motor de referencia junto a TradingView, qué mostró el barrido de mayo de 2026 y por qué un segundo motor «amigo» es la herramienta de depuración más útil que tenemos.
Las cifras de este artículo se midieron el 5 de mayo de 2026 y se mantienen tal cual. Para ver los resultados actuales, consulta cómo medimos la paridad.
En mayo de 2026 conocíamos dos motores fuera de TradingView capaces de hacer backtests de estrategias Pine: el nuestro y PyneCore. PyneComp, de PyneSys, transpila Pine a Python; PyneCore es el runtime de Python de código abierto que ejecuta el resultado. Otro lenguaje, otro runtime, el mismo material de partida y las mismas definiciones de API que respetar.
Tratamos PyneCore como nuestro segundo oráculo independiente. En mayo de 2026 ejecutamos el barrido de paridad contra las exportaciones «List of Trades» de TradingView y contra la salida ejecutada de PyneCore. Cuando los tres coinciden en las operaciones de una estrategia, nos creemos el resultado. Cuando dos coinciden y uno diverge, es en el divergente donde miramos primero.
Este artículo muestra las cifras de aquel barrido. La comparación actual, la comparativa del repositorio del motor fechada el 2026-09-29 (medida en el commit 35db01c8, incluido en v1.0.0), está en la página de comparación.
El corpus
El barrido público tenía 50 estrategias de referencia (el corpus más amplio, de 162 estrategias, era privado entonces; este subconjunto es el que publicamos en el informe de comparación de operaciones, benchmarks/results/trade_comparison.md en el commit 7e526c1a del motor). Con cada estrategia hicimos lo siguiente:
- La compilamos a Python con PyneComp y la ejecutamos con PyneCore sobre el OHLCV canónico
- La compilamos a C++ con el codegen de PineForge y la ejecutamos con
pineforge-enginesobre el mismo OHLCV - Comparamos ambas salidas con la exportación CSV de TradingView, recortadas a la ventana
[OHLCV span] ∩ [TV entry span] ∩ [engine entry span] - Le asignamos un grado de coincidencia según la escala de 5 niveles (excellent / strong / moderate / weak / minimal)
El titular
De las 50 estrategias del barrido, 47 obtuvieron el mismo nivel en PineForge y en PyneCore: ambos motores alcanzaron excellent en 45 y strong en 2. En esas 2, 13-parabolic-asr y 17-bos-curv, los dos motores produjeron las mismas operaciones, y los dos recuentos de operaciones se desviaban del de TV entre un 1,8 y un 2,8 %. Con la rúbrica de entonces, excellent exigía una diferencia en el número de operaciones inferior al 1 %, un p90 de entrada y de salida inferior al 0,01 %, un p90 de P&L inferior al 1 % (con límites de salida y de P&L más holgados para las salidas trail_*) y emparejar al menos el 95 % de las operaciones de TV dentro de la ventana.
Las 3 que difieren de nivel son casos interesantes. En las 3, PineForge queda por encima.
| Estrategia | PineForge | PyneCore | Notas |
|---|---|---|---|
49-partial-exit-qty-percent | excellent | weak | PyneCore emite fills de salida de más |
06-liquidity-sweep | excellent | moderate | Deriva en el momento de salida del lado de Pyne |
07-scalping-strategy | excellent | moderate | PnL p90 alto en Pyne; las entradas coinciden |
El caso interesante
49-partial-exit-qty-percent es la mayor diferencia. La estrategia usa strategy.exit(qty_percent=...) para cerrar parte de la posición en la toma de ganancias, y el ciclo se repite: salida total, nueva entrada, nueva salida parcial. En toda la ventana de prueba:
TV trades (raw, in-window): 725
PineForge engine trades: 852 → 725 in-window → 725 matched (100% of TV)
PyneCore engine trades: 3297 → 2805 in-window → 582 matched (80.3% of TV)El delta de recuento de PyneCore en esta estrategia es del 74 %: la herramienta de comparación divide la diferencia entre el recuento mayor, 2.805 operaciones dentro de la ventana frente a las 725 de TV. El de PineForge, del 0 %. Mirando las métricas p90:
PineForge: count_delta 0.0000% · entry p90 0.0000% · exit p90 0.0004% · PnL p90 0.1321%
PyneCore : count_delta 74.1533% · entry p90 0.0000% · exit p90 1.0376% · PnL p90 (high)Traducción: en las operaciones que se emparejan con las de TV, ambos motores entran a los precios de TV (el p90 de entrada es del 0 % en los dos), aunque PyneCore solo empareja 582 de las 725 de TV. La discrepancia está en las salidas. PyneCore genera aproximadamente 4× más operaciones que TradingView para la misma estrategia (2.805 frente a 725 dentro de la ventana); lo más probable es que dispare de más los ciclos de salida parcial, porque la misma cláusula qty_percent se rearma antes de que el procesador de órdenes de TV la dé por completada.
Esto no es un juicio sobre la calidad de PyneCore: es un caso límite de la semántica de strategy.exit() en Pine. La comparación funciona en ambas direcciones: cuando PyneCore coincide con TV y PineForge no, el bug es nuestro.
Las otras dos
06-liquidity-sweep y 07-scalping-strategy son versiones de menor magnitud del mismo patrón. Las dos tienen las entradas alineadas al 100 %; la deriva p90 del precio de salida es del 1,65 % (06) y del 0,48 % (07) en PyneCore, frente al 0,0005 % y el 0,029 % en PineForge. Las salidas de tipo trailing y la semántica de los fills parciales son justo donde la implementación de referencia de Pine está peor documentada; ambos motores tienen que deducirla, por ingeniería inversa, a partir del comportamiento observable de las operaciones.
Llamar a la API de compilación de PyneCore
PyneSys expone el paso de compilación por HTTP en api.pynesys.io. Puedes llamarla directamente con curl:
curl -X POST https://api.pynesys.io/compiler/compile \
-H "Authorization: Bearer $PYNESYS_API_KEY" \
--data-urlencode 'script=//@version=6
strategy("ma cross", overlay=true)
if ta.crossover(close, ta.sma(close, 20))
strategy.entry("L", strategy.long)'La respuesta es un archivo Python pensado para el runtime de código abierto pynecore. Así era en mayo de 2026; las versiones más recientes de PyneComp escriben su propio número de versión en la cabecera y marcan el archivo como @pyne edge:
"""
@pyne
This code was compiled by PyneComp v6.0.31 — the Pine Script to Python compiler.
Run with open-source PyneCore: https://pynecore.org
Compile Pine Scripts online at PyneSys: https://pynesys.io
"""
from pynecore.lib import close, script, strategy, ta
@script.strategy("ma cross", overlay=True)
def main():
if ta.crossover(close, ta.sma(close, 20)):
strategy.entry('L', strategy.long)
if __name__ == "__main__":
from pynecore.standalone import run
run(__file__)Guárdalo en un archivo Python, ejecuta pip install pynesys-pynecore, apúntalo a tu OHLCV y tendrás la salida del segundo motor para compararla con PineForge.
Por qué importa
Un único motor de backtest que informa «tu estrategia rinde un 12,4 % en la ventana de prueba» te dice exactamente una cosa: que ese motor afirma ese resultado. Si no tienes con qué compararlo, tienes que fiarte de su palabra.
Dos motores independientes que dan el mismo resultado con el mismo script son una evidencia mucho más sólida. Cuando discrepan, la propia discrepancia es una hipótesis: uno de los dos tiene un bug, el caso límite de la semántica de Pine es ambiguo o los datos de prueba tienen una condición límite que ninguno de los dos motores contempla. Las tres cosas conviene saberlas.
Así usamos PyneCore: el benchmark del repositorio del motor evalúa ahora PineForge y PyneCore frente a TradingView sobre las mismas 200 estrategias (PineForge ejecuta también una más, cuyo código rechaza el compilador de PyneSys). Si vas a poner en marcha una estrategia en la que arriesgarías dinero real, tú también deberías usar un segundo motor.
Lo que no cubre este artículo
- Deriva a nivel de indicador. Un informe aparte compara los valores de cada indicador entre PineForge, PyneCore y PineTS: motor contra motor, no contra TradingView. Está en
benchmarks/results/indicator_comparison.md, en el repositorio del motor. - Las otras ~110 estrategias del corpus interno de entonces, que no estaban en el barrido público. Ponían a prueba casos límite de Pine (métodos de UDT, consultas multi-timeframe, grupos de salida OCA). Desde entonces, el método se ha publicado en la página de metodología.
Prueba tú mismo la validación cruzada
- Ejecuta PineForge en local o desde un asistente de IA
- Consigue una API key de PyneSys
- Elige una estrategia Pine. Ejecuta ambas cadenas sobre el mismo CSV de OHLCV. Compara las listas de operaciones resultantes.
Dos motores, una fuente, tres salidas que comparar. Si todas coinciden, adelante. Si discrepan, habrás aprendido algo útil antes de poner dinero real en juego.