PYNE

Independent open toolchain for the Pine Script™ language — formal grammar, algebraic AST, dual-engine bar-loop runtime, language server, and HTTP evaluation surface. Part of the HOOX open trading stack.

0.3.10 · PyPI hoox-pyne · import pynescript · CLIs pyne · pyne-lsp (aliases: pynescript · pynescript-lsp)

Pine Script™ and TradingView® are trademarks of TradingView, Inc.. Cloudflare® is a trademark of Cloudflare, Inc.
PYNE is an independent, unofficial implementation. It is not affiliated with, authorized by, sponsored by, or endorsed by TradingView, Inc. or Cloudflare, Inc., and is not an official TradingView® product, service, or platform substitute.
Language references are for interoperability and compatibility documentation only. PYNE does not redistribute proprietary TradingView® platform software, charting UI, or closed data services.

Ecosystem

Part of the HOOX open trading stack:

Edge evaluate (one-click, not this repo):

That button deploys pyne-worker — a thin Workers host for POST /run. CLI, LSP, compile, Flask Pro API, and the language source of truth stay here. See pyne-worker limitations.

Abstract

Pine Script™ is commonly executed inside a host charting environment. PYNE models the language as an inspectable pipeline — source text through parse, AST construction, and deterministic bar-loop evaluation — so the same scripts can be analysed and run outside any particular UI.

Source (.pyne / .pine)
  → ANTLR4 lexer / parser
  → ASDL AST
  → bar-loop  (interpret | compile | auto)
  → plots · fills · drawings · strategy events · alerts
  → optional HTTP / edge / editor clients

The same pipeline underlies the desk CLI, the Language Server Protocol (LSP) binary, the Pro API, browser Pyodide evaluation (via AXIS), and Cloudflare® Workers that share one evaluate contract.

Coverage and known gaps are documented under compatibility and implementation status. This repository does not ship third-party script corpora or TradingView® builtin downloads.

Corpus snapshot (set01–04 · local measurement · 2026-08-09)

Open-source Pine regression sets (2477 scripts; not shipped in git) under parse+unparse and Runtime interpret (50 bars, 12s timeout):

Not a claim of TradingView® platform parity. Intentional demos are classified so OK% stays honest.

Capabilities

Language front-end

• Grammar. Approximate Pine Script™ v5–v6 language surface via ANTLR4 resource grammars.
• AST. ASDL-generated nodes with visitor and transformer patterns.
• Round-trip. parse → unparse with preservation of formatting intent.
• Linter. Static checks for common structural and style issues.

Runtime

• Bar-loop evaluation. Deterministic indicator and strategy execution on OHLCV.
• Dual engine. Interpret (AST walk) and compile (Numba nopython kernels with object-mode fallback); mode ∈ {auto, compile, interpret}.
• Warm compile. Disk IR cache, process prewarm, and recovery from corrupt cache state.
• Plot parity. Interpret ↔ compile series alignment verified by harness and tests (internal engine consistency, not platform certification).
• Alerts. alert() / alertcondition() with documented frequency semantics (once_per_bar, once_per_bar_close, all); structured export on Pro /run and optional L2 webhooks.
• Strategy surface. Entries, exits, events, commission/slippage paths, pending-fill behaviour under pyramiding constraints.
• Drawing GC. Honour of max_lines_count, max_labels_count, max_boxes_count, max_polylines_count.
• UDT collections. array.sort / array.sort_indices / matrix.sort and array.binary_search* take sort_field (const int index, default 0, or const string name) on arrays of user-defined types.
• Security policy. Same-symbol simple OHLCV for request.security; foreign or complex security resolves to na (no invented foreign closes).

Surfaces

Installation

pip install hoox-pyne                 # core library + CLI
pip install "hoox-pyne[lsp]"          # language server
pip install "hoox-pyne[compile]"      # Numba compile path
pip install "hoox-pyne[data]"         # market data providers
pip install "hoox-pyne[pro]"          # Flask Pro API stack

# Development install from a clone
git clone --recurse-submodules https://github.com/hoox-sh/pyne.git
cd pyne
pip install -e ".[lsp,pro]"

Container images (GHCR)

Multi-arch (linux/amd64, linux/arm64) images publish to GitHub Container Registry on v* tags (and via Actions → GHCR → Run workflow):

# CLI
docker pull ghcr.io/hoox-sh/pyne/cli:0.3.10
docker run --rm -v "$PWD:/work" -w /work ghcr.io/hoox-sh/pyne/cli:0.3.10 check script.pine

# Language server (stdio; -i required)
docker pull ghcr.io/hoox-sh/pyne/lsp:0.3.10
docker run --rm -i -v "$PWD:/work" -w /work ghcr.io/hoox-sh/pyne/lsp:0.3.10

# Pro API
docker pull ghcr.io/hoox-sh/pyne/api:0.3.10
docker run --rm -p 5002:8080 -e ADMIN_TOKEN=… ghcr.io/hoox-sh/pyne/api:0.3.10

Packages: ghcr.io/hoox-sh/pyne. Local: make docker-build-lsp.

Quickstart

Parse and unparse

from pynescript.ast.helper import parse, unparse

source = """
//@version=6
indicator("My RSI")
plot(ta.rsi(close, 14))
"""

tree = parse(source)
print(unparse(tree))

Evaluate an expression

from pynescript.ast.helper import literal_eval

literal_eval("1 + 2 * 3")  # 7
literal_eval("ta.rsi([100, 102, 101, 103, 105], 9)")

CLI

pyne check script.pine
pyne format script.pine -w
pyne lint script.pine
pyne run script.pine --bars 100
pyne compile script.pine --emit
pyne data AAPL --provider yahoo --period 6mo
pyne info
# aliases still work: pynescript check …

Language server

pip install "hoox-pyne[lsp]"
pyne-lsp
# alias: pynescript-lsp

Editor integration: PYNE for VS Code; Neovim, Zed, and Emacs configs under clients/.

Pro API

Self-hosted (or managed) HTTP surface for script evaluation and previews:

/run accepts mode ∈ {auto, compile, interpret}, returns structured errors (error_kind, error_type, error_bar), and can forward last-bar alert firings to an optional webhook (webhook_url or server ALERT_WEBHOOK_URL).

make run   # :5002

curl -s http://127.0.0.1:5002/run \
  -H 'Content-Type: application/json' \
  -d '{
    "script": "//@version=6\nindicator(\"demo\")\nplot(close)\nalert(close > open, alert.freq_once_per_bar)",
    "data": [{"open":1,"high":2,"low":0.5,"close":1.5,"time":1,"volume":1}],
    "mode": "auto"
  }'

Documentation: POST /run · Alerts · API hub

Library API (sketch)

from pynescript.ast.helper import parse, unparse, literal_eval
from pynescript.ast.linter import lint_script
from pynescript.ast.transformer import NodeTransformer

tree = parse(source_code)
warnings = lint_script(source_code)
value = literal_eval("ta.sma([100, 102, 101], 3)")

class Renamer(NodeTransformer):
    def visit_Name(self, node):
        if node.id == "close":
            node.id = "price"
        return node

CLI reference

Language server entry point: pyne-lsp (alias pynescript-lsp; separate console script).

Documentation

Canonical product documentation: hoox.sh/pyne/docs

In-repository notes: Roadmap · Missing features · Changelog

Compatibility

PYNE targets practical runtime fidelity verified with first-party fixtures, unit tests, and (when present locally) open-source corpus sets. Latest local corpus snapshot (set01–04, 2026-08-09): parse 99.96%, Runtime interpret 100% excl. intentional demos — see the table under Abstract. It does not claim:

• official TradingView® certification or endorsement
• complete platform parity (chart host, data model, every edge-case builtin, or closed UI behaviour)
• that results will match the TradingView® platform on every script or bar

Prefer the published compatibility and implementation status pages for current surface coverage.

Results obtained with PYNE are for research, development, and self-hosted evaluation. They are not financial advice and are not provided by TradingView, Inc.

Contributing

See CONTRIBUTING.md. Code of conduct: CODE_OF_CONDUCT.md. Security reports: SECURITY.md.

make install   # editable install with LSP
make test      # pytest
make lint      # ruff

HOOX Open Trading Stack

PYNE is part of the HOOX Open Trading Stack — three complementary open projects under one product site:

                    https://hoox.sh
           ┌──────────────┼──────────────┐
           ▼              ▼              ▼
         HOOX            PYNE           AXIS
    (edge execution)  (Pine engine)  (charting UI)
           │              │              │
           └──────────────┴──────────────┘
                    trade signals / eval API

How they relate

• PYNE owns language semantics: parse, evaluate/compile, alerts, strategy events, and the HTTP evaluate surface (/run, batch, previews).
• AXIS is an optional chart host. It can call PYNE’s Pro API (or edge workers) to plot series, fills, and drawings — evaluation does not require AXIS.
• HOOX is an optional execution mesh. Strategy events and alert webhooks from PYNE can feed edge trade paths; HOOX does not replace the PYNE runtime.

Evaluation never depends on a proprietary chart host. AXIS and HOOX are optional clients of the same open evaluate contract. None of these projects is affiliated with or endorsed by TradingView, Inc.

Side projects

This repository plus satellites that share the evaluate contract. Python pynescript.runtime remains the language SoT.

HOOX also publishes execution-plane workers (hoox-worker, trade-worker, telegram-worker, d1-worker, …) under github.com/hoox-sh. Those are execution and ops, not the Pine language toolchain.

git clone --recurse-submodules https://github.com/hoox-sh/pyne.git   # PYNE + pynets/ + pyne-lsp
pip install -e ".[lsp,pro]"                                          # CLI + LSP + Pro API
git clone https://github.com/hoox-sh/pynets.git
git clone https://github.com/hoox-sh/pyne-worker.git
git clone https://github.com/hoox-sh/axis.git

License

SPDX: AGPL-3.0-or-later · Copyright (C) 2024–2026 jango_blockchained

GNU Affero General Public License v3.0 or later — see LICENSE.

🔋 Batteries included.