PRICE · TIME · ENGINE

AXIS / Open Charting PWA

OWNTHE AXES.SWAP THE ENGINE.

Name: HOOX
Author: HOOX

Installable AXIS for price and time. Compose sources, streams, engines, and storage — broad Pine-compatible surface via PYNE without a proprietary charting host.

Unofficial · not affiliated with TradingView, Inc. Not a TradingView product.

3×

Engines

500+

Builtins

Lock-in

Open AXIS Docs PYNE runtime Deploy

AXIS charting PWA — candlestick chart, watchlist, and Pine editor on void chrome

Installable PWACompose pluginsPine-compatible via PYNESelf-hostAGPL v3

01 // THESISSEC01

[COORDINATE SYSTEM]

AXIS is an open charting PWA that treats price, time, and calculation as separable axes. Sources load history. Streams advance the present. Engines evaluate Pine Script™. Storage keeps your library. Compose any lawful combination; own AXIS under AGPL v3.

AXIS ≠ engine

The chart shell never embeds a closed interpreter. Evaluation is always a plugin — Flask on the desk, Pyodide offline, or a Cloudflare® Worker proxy at the edge.

Orthogonal plugins

Four kinds share one contract: source, stream, engine, storage. Swap a venue without rewriting the editor; swap an engine without re-plumbing the watchlist.

Research, not wallpaper

Strategy events, equity metrics, drawings, and CSV export ship as first-class panels — AXIS is a laboratory, not a locked display.

What AXIS is not

Not a closed hostNo proprietary charting lock-in around the bar loop.
Not a language rewriteFidelity lives in PYNE; AXIS is the coordinate system.
Not SaaS-onlySelf-host the PWA, the Pro API, or the Worker stack.
Not vapor edge PythonIn-worker Pyodide is planned; shipped path proxies today.

formal · identifiersAXIS.v1

Active set: { source, stream, engine, storage }
Contract: pynescript.axis.plugins.v1
State: pynescript.axis.v1
License: AGPL v3

[Loading section]

02 // SHIPPED SURFACESEC02

[FEATURE ATLAS]

Honest inventory of what ships in the AXIS PWA and its backends — not a roadmap teaser. Tabs map to registry kinds plus AXIS UI chrome, language surface, and Worker API.

registry · catalog12 rows

Id	Name	Tag	Detail
`pwa`	Installable PWAoffline	Shell	manifest.webmanifest · service worker · void chrome (#0a0b10). Cache-first app shell; network-first for /api/*.
`chart`	Multi-pane chart host	Chart	TradingView® Lightweight Charts v5 — price, volume, indicator, and equity panes with resize.
`draw`	Drawing tools	Annotate	Cursor, horizontal line, trend, ray, rectangle, Fibonacci, measure, and text annotations on the chart.
`pine-draw`	Pine Script™ drawings	Runtime	Lines, labels, and boxes from the engine drawings payload render beside interactive tools.
`watchlist`	Watchlist	Market	Detachable side rail — symbol list, quick load, session memory across visits.
`editor`	CodeMirror 6 editor	Edit	Pine language mode, detachable and tabbed layout, void theme tokens.
`indicators`	Indicators panel	Overlay	Multi-indicator cards; visible scripts re-run when live streams advance bars.
`results`	Results panel	Export	Events · Strategy · Plots · Metrics · Raw — copy, JSON, and trades CSV.
`strategy`	Strategy tester	Research	P&L, win rate, max drawdown; jump-to-bar from closed trades on the chart.
`logs`	System logs	Ops	Collapsible ops stream with per-line and bulk copy. Status bar shows engine, source, stream, storage.
`settings`	Schema-driven settings	Config	Plugin configSchema fields become Settings controls — plugins self-describe.
`manager`	Plugin Manager	Ext	Catalog with capability badges · Install from ES-module URL · Script Library tab.

[Loading section]

03 // COMBINATION SPACESEC03

[COMPOSE]

Plugins are orthogonal. Keep AXIS fixed; vary the active set. Default stream pairs follow the selected source — any lawful combination still works.

compose · formula∀ sets

∀Active set = { source, stream, engine, storage }

AXIS fixed · plugins orthogonal · registry contract unified. Default stream pairs follow source (e.g. mock-walk → mock-poll).

01Air-gap

Offline lab

Air-gapped research. Mock data, client-side Python, IndexedDB library — DevTools Offline still runs after first wheel load.

S: mock-walk
T: mock-poll
E: pyodide
St: local

02Dev

Desk research

Full pynescript fidelity on the laptop: Vite AXIS app + Flask Pro API. Live Binance bars, local script library.

S: binance-rest
T: binance-ws
E: server → Flask
St: local

03Swap

Multi-venue

Same AXIS, different venue. Flip source/stream pairs (OKX, Bybit, Coinbase, Kraken) without rewriting the editor or results panel.

S: okx-rest · bybit · …
T: matching WS
E: server | pyodide
St: local

04Own data

CSV backtest

Upload private OHLCV, evaluate with the server engine, export strategy metrics and trades CSV.

S: csv-upload
T: mock-poll
E: server → Flask
St: local

05Cloudflare®

AXIS at the edge

Pages-hosted PWA + Worker proxy. Keys in KV, optional D1 script library, Durable Object stream fan-out.

S: binance-rest
T: binance-ws | DO
E: server → Worker
St: cloud

06Git

Repo-as-library

Any data/engine combo with git storage — Pine scripts as commits on GitHub or GitLab. Drafts stay local until Save.

S: any
T: any
E: any
St: git

07Ext

Plugin lab

Prove the ES-module contract: CoinGecko source + Tiny Pine engine examples via Manager Install URL — no core fork.

S: coingecko (ex.)
T: mock-poll
E: tiny-pine (ex.)
St: local

axis · compose model

CRT · 80×24

REGv1|KINDS4

Browser PWA  →  Sources · Streams · Engines · Storage
       │              (plugin registry)
       │              UDTs · libraries · methods · input.*
       ├─ Flask API (dev)
       ├─ Pyodide (offline)
       └─ Cloudflare® Worker + DO + KV + D1 + R2

Sources · Streams · Engines · StorageUTF-8|LF|AX

[Loading section]

04 // EVALUATION CONTRACTSEC04

[ENGINES]

Three calculation surfaces, one plugin contract. Language fidelity (UDTs, libraries, methods, inputs) travels with the engine, not the host. The server engine points at any compatible /run endpoint — desk Flask or edge Worker.

01Dev

Flask Pro API

Local research backend via make run. Full pynescript fidelity on your machine. Default endpoint http://localhost:5002.

02Offline

Pyodide (browser)

In-browser Python isolate. Installs the vendored pynescript wheel via micropip. Offline when the network is the risk.

03Edge

Cloudflare® Worker

POST /api/run proxies to EXTERNAL_BACKEND today. DO streams, KV keys/usage, optional D1 scripts and R2 bundles.

ops · honestyNOTE

NOTE

In-worker Pyodide evaluation is planned (RUNTIME.md) and feature-gated. Do not assume zero-infra Python on the edge without the external backend until that path ships.

[Loading section]

05 // PERSISTENCESEC05

[SCRIPT LIBRARY]

Script libraries are plugins too. Pick IndexedDB for sovereignty, cloud for multi-device, or git when the repository is the source of truth.

01Default

Local

local

IndexedDB primary store with localStorage fallback. Offline by construction. Migrates SuperChart library keys on first open.

02Worker

Cloud

cloud

Bearer-authenticated /api/scripts. Partitioned by key hash. D1 schema optional; memory store for wrangler dev.

03VCS

Git

git

GitHub or GitLab Contents API. Commit + push on explicit Save. Personal access tokens stay in browser config — never server-side by default.

[Loading section]

06 // DECISION LOGSEC06

[DEV ADRs]

Architecture decisions that shaped AXIS. Short academic form: context, decision, consequences. Numbered for citation in ops notes and PRs.

adr · decision log13 entries

ADR-001

Pluggable four-kind registry

Context: Chart hosts that hard-code a single data feed or interpreter force forks for every venue or calc surface.
Decision: Unify source, stream, engine, and storage under one plugin base (id, kind, configSchema, capabilities) with active selection in the Solid store.
Consequences: Any lawful combination works without UI rewrites. Manager and Settings remain generic.

ADR-002

AXIS ≠ engine

Context: Closed charting products couple the bar loop to a proprietary host — authors cannot audit or relocate evaluation.
Decision: AXIS never embeds a closed interpreter. Evaluation is always an engine plugin; language fidelity is delegated to PYNE.
Consequences: Swap Flask, Pyodide, Worker proxy, or a custom engine without replacing AXIS.

ADR-003

Solid + Vite as product path

Context: The legacy SuperChart vanilla shell mixed concerns and lagged design tokens.
Decision: Ship the Solid/Vite app as the product UI. Retain the legacy shell for smoke tests only (LEGACY.md).
Consequences: One design language (void), typed store, and modern plugin path. Legacy is not marketed.

ADR-004

Dual calculation surfaces

Context: Researchers need offline sovereignty and operators need remote fidelity/ops controls.
Decision: Ship server (POST /run) and pyodide engines as first-class built-ins with identical RunResult contracts.
Consequences: Same results panel, drawings, and strategy export on both paths.

ADR-005

Config via schema

Context: Ad-hoc settings UIs do not scale as plugins accumulate fields (limits, base URLs, modes).
Decision: Each plugin declares configSchema; Settings renders controls from the schema.
Consequences: Plugins self-describe. No per-plugin Settings forks in AXIS.

ADR-006

Dynamic load by URL

Context: Contributors should extend AXIS without publishing to a central store or forking the monorepo.
Decision: Load ES modules via Manager Install URL; persist installed URLs in pynescript.axis.plugins.v1 and re-import on boot.
Consequences: Examples (CoinGecko, Tiny Pine, CF DO stream) live as files under public/plugins/.

ADR-007

Storage as plugin

Context: Script libraries span personal offline, multi-device cloud, and team git workflows.
Decision: Treat storage as a fourth plugin kind with list/read/write/remove (+ optional sync).
Consequences: Script Library tab switches backends without a second library UX.

ADR-008

Cloudflare® project id frozen

Context: Renaming Wrangler/Pages projects severs bindings, custom domains, and CI secrets.
Decision: Keep infrastructure id pynescript-superchart. User-facing brand is AXIS; health JSON may say pynescript-axis-worker.
Consequences: Deploy docs always use the stable project name. Optional axis.* aliases later.

ADR-009

Worker proxies first

Context: In-isolate Pyodide needs wheel packaging, cold-start budgets, and memory headroom.
Decision: Ship /api/run as a proxy to EXTERNAL_BACKEND. Scaffold in-worker Python behind a feature flag (RUNTIME.md).
Consequences: Production edge path works today with a Python host. Full CF-only evaluate remains planned.

ADR-010

Live fan-out via Durable Objects

Context: N browsers opening N upstream exchange sockets wastes quota and complicates reconnect.
Decision: Route /api/stream to a session Durable Object that holds one upstream WebSocket and fans bars to N clients.
Consequences: Hibernation-friendly live sessions; example plugin demonstrates the contract.

ADR-011

State namespace migration

Context: SuperChart → AXIS rename must not wipe user scripts, engines, or plugin installs.
Decision: Persist under pynescript.axis.v1 (and plugins.v1); migrate automatically from pynescript.superchart.* keys.
Consequences: Continuity for early adopters; single namespace going forward.

ADR-012

CORS explicit for Pro API

Context: Browser AXIS calling a separate origin requires controlled Access-Control-Allow-Origin.
Decision: Flask Pro reads ALLOWED_ORIGINS. Demo may use *; production should allowlist AXIS origins and localhost regex.
Consequences: Operators can tighten the VPS unit without code changes.

ADR-013

Results as first-class export

Context: Chart-only tools trap research in screenshots. Strategies need events, metrics, and CSV.
Decision: Five-tab Results panel (Events, Strategy, Plots, Metrics, Raw) with copy/JSON/trades CSV and jump-to-bar.
Consequences: AXIS is a research PWA — exportable, inspectable, host-independent.

[Loading section]

07 // TOPOLOGIESSEC07

[RUN SURFACES]

Where AXIS can run — from air-gapped browser to dual-process desk to Cloudflare® edge. AXIS is constant; the topology is chosen.

axis · topology

CRT · 80×24

PWAALWAYS|BACKENDOPT

┌─ Browser PWA (always) ─────────────────────────────────────┐
│  Sources · Streams · Engines · Storage · SW cache          │
└───────────────┬────────────────────────────┬───────────────┘
                │                            │
     engine=pyodide                    engine=server
     (no backend)                      POST /run
                │                            │
                │              ┌─────────────┴─────────────┐
                │              ▼                           ▼
                │     Local Flask (:5002)        Cloudflare® Worker
                │     make run                   /api/run proxy
                │                                DO /api/stream
                │                                KV · D1 · R2
                ▼
         Fully offline after wheel cache

Browser always · backend optionalUTF-8|LF|AX

01Primary dev

Local dual-process

Day-to-day development with HMR AXIS and full Python fidelity.

Depends · bun · Python · pynescript

make run  # :5002
cd frontend && bun run dev  # :3000

02Prod-like

Static dist + axis_pwa_server

Serve the built PWA without Cloudflare® Pages.

Depends · bun build · Python 3

cd frontend && bun run build
python3 axis_pwa_server.py  # :8081

03Live

Public VPS demo

Shared public AXIS + Pro API for demos and smoke.

Depends · systemd · axis-pwa · pynescript-api

PWA  162.254.38.194:8081
API  162.254.38.194:5002

Demo over HTTP on a raw IP — prefer IP CTAs; hostname may be hosts-file only.

04Edge

Cloudflare® Pages + Worker

Global static AXIS with edge API, keys, streams, optional D1/R2.

Depends · wrangler · KV · (optional D1/R2)

cd frontend/worker && wrangler deploy
cd frontend && wrangler pages deploy dist --project-name=pynescript-superchart

Project id pynescript-superchart is frozen infrastructure — do not rename.

05Air-gap

Offline-only

No network after first load — research on untrusted or denied links.

Depends · Browser only (wheel cached)

Source=mock-walk · Stream=mock-poll · Engine=pyodide · Storage=local

06Mixed

Hybrid venue + remote calc

Public venue data in the browser; evaluate on desk Flask or Worker proxy.

Depends · Any source/stream + server engine endpoint

Set Endpoint → Flask or *.workers.dev · Engine=server

[Loading section]

08 // OPSSEC08

[DEPLOY]

Copyable make targets for the desk and the edge. Demo endpoints remain IP-first on HTTP until TLS lands on the VPS.

Demo PWA · 162.254.38.194:8081API · 162.254.38.194:5002

make · targetscopy

01Dev PWA (Vite)HMR · proxies /run → :5002

02Build PWAVite Solid → dist/

03Serve distStatic AXIS on :8081

04Pro APIFlask pynescript on :5002

05Worker deployEdge proxy · DO · KV

06Pages deployStable CF project id

CORS

Pro API ALLOWED_ORIGINS (comma-separated). Demo may use *; production should list AXIS origins and a localhost regex.

Bindings

Provision KV API_KEYS + USAGE; optional D1 pynescript and R2 indicator-bundles before Worker deploy.

Project id

Wrangler/Pages project remains pynescript-superchart. Brand is AXIS; optional custom domain alias later.

Demo units

VPS systemd: axis-pwa (AXIS) + pynescript-api (Flask). Prefer IP URLs in public CTAs.

[Loading section]

09 // CLOSESEC09

[OWN THE AXES]

Own the axes. Swap the engine. AXIS stays open.

axis · exit vectorsREADY

Open demo PWA Clone AXIS PYNE runtime HOOX mesh

[Loading section]

03 // COMBINATION SPACESEC03

[COMPOSE]

Plugins are orthogonal. Keep AXIS fixed; vary the active set. Default stream pairs follow the selected source — any lawful combination still works.

compose · formula∀ sets

∀Active set = { source, stream, engine, storage }

AXIS fixed · plugins orthogonal · registry contract unified. Default stream pairs follow source (e.g. mock-walk → mock-poll).

01Air-gap

Offline lab

Air-gapped research. Mock data, client-side Python, IndexedDB library — DevTools Offline still runs after first wheel load.

S: mock-walk
T: mock-poll
E: pyodide
St: local

02Dev

Desk research

Full pynescript fidelity on the laptop: Vite AXIS app + Flask Pro API. Live Binance bars, local script library.

S: binance-rest
T: binance-ws
E: server → Flask
St: local

03Swap

Multi-venue

Same AXIS, different venue. Flip source/stream pairs (OKX, Bybit, Coinbase, Kraken) without rewriting the editor or results panel.

S: okx-rest · bybit · …
T: matching WS
E: server | pyodide
St: local

04Own data

CSV backtest

Upload private OHLCV, evaluate with the server engine, export strategy metrics and trades CSV.

S: csv-upload
T: mock-poll
E: server → Flask
St: local

05Cloudflare®

AXIS at the edge

Pages-hosted PWA + Worker proxy. Keys in KV, optional D1 script library, Durable Object stream fan-out.

S: binance-rest
T: binance-ws | DO
E: server → Worker
St: cloud

06Git

Repo-as-library

Any data/engine combo with git storage — Pine scripts as commits on GitHub or GitLab. Drafts stay local until Save.

S: any
T: any
E: any
St: git

07Ext

Plugin lab

Prove the ES-module contract: CoinGecko source + Tiny Pine engine examples via Manager Install URL — no core fork.

S: coingecko (ex.)
T: mock-poll
E: tiny-pine (ex.)
St: local

axis · compose model

CRT · 80×24

REGv1|KINDS4

Browser PWA  →  Sources · Streams · Engines · Storage
       │              (plugin registry)
       │              UDTs · libraries · methods · input.*
       ├─ Flask API (dev)
       ├─ Pyodide (offline)
       └─ Cloudflare® Worker + DO + KV + D1 + R2

Sources · Streams · Engines · StorageUTF-8|LF|AX

06 // DECISION LOGSEC06

[DEV ADRs]

Architecture decisions that shaped AXIS. Short academic form: context, decision, consequences. Numbered for citation in ops notes and PRs.

adr · decision log13 entries

ADR-001

Pluggable four-kind registry

Context: Chart hosts that hard-code a single data feed or interpreter force forks for every venue or calc surface.
Decision: Unify source, stream, engine, and storage under one plugin base (id, kind, configSchema, capabilities) with active selection in the Solid store.
Consequences: Any lawful combination works without UI rewrites. Manager and Settings remain generic.

ADR-002

AXIS ≠ engine

Context: Closed charting products couple the bar loop to a proprietary host — authors cannot audit or relocate evaluation.
Decision: AXIS never embeds a closed interpreter. Evaluation is always an engine plugin; language fidelity is delegated to PYNE.
Consequences: Swap Flask, Pyodide, Worker proxy, or a custom engine without replacing AXIS.

ADR-003

Solid + Vite as product path

Context: The legacy SuperChart vanilla shell mixed concerns and lagged design tokens.
Decision: Ship the Solid/Vite app as the product UI. Retain the legacy shell for smoke tests only (LEGACY.md).
Consequences: One design language (void), typed store, and modern plugin path. Legacy is not marketed.

ADR-004

Dual calculation surfaces

Context: Researchers need offline sovereignty and operators need remote fidelity/ops controls.
Decision: Ship server (POST /run) and pyodide engines as first-class built-ins with identical RunResult contracts.
Consequences: Same results panel, drawings, and strategy export on both paths.

ADR-005

Config via schema

Context: Ad-hoc settings UIs do not scale as plugins accumulate fields (limits, base URLs, modes).
Decision: Each plugin declares configSchema; Settings renders controls from the schema.
Consequences: Plugins self-describe. No per-plugin Settings forks in AXIS.

ADR-006

Dynamic load by URL

Context: Contributors should extend AXIS without publishing to a central store or forking the monorepo.
Decision: Load ES modules via Manager Install URL; persist installed URLs in pynescript.axis.plugins.v1 and re-import on boot.
Consequences: Examples (CoinGecko, Tiny Pine, CF DO stream) live as files under public/plugins/.

ADR-007

Storage as plugin

Context: Script libraries span personal offline, multi-device cloud, and team git workflows.
Decision: Treat storage as a fourth plugin kind with list/read/write/remove (+ optional sync).
Consequences: Script Library tab switches backends without a second library UX.

ADR-008

Cloudflare® project id frozen

Context: Renaming Wrangler/Pages projects severs bindings, custom domains, and CI secrets.
Decision: Keep infrastructure id pynescript-superchart. User-facing brand is AXIS; health JSON may say pynescript-axis-worker.
Consequences: Deploy docs always use the stable project name. Optional axis.* aliases later.

ADR-009

Worker proxies first

Context: In-isolate Pyodide needs wheel packaging, cold-start budgets, and memory headroom.
Decision: Ship /api/run as a proxy to EXTERNAL_BACKEND. Scaffold in-worker Python behind a feature flag (RUNTIME.md).
Consequences: Production edge path works today with a Python host. Full CF-only evaluate remains planned.

ADR-010

Live fan-out via Durable Objects

Context: N browsers opening N upstream exchange sockets wastes quota and complicates reconnect.
Decision: Route /api/stream to a session Durable Object that holds one upstream WebSocket and fans bars to N clients.
Consequences: Hibernation-friendly live sessions; example plugin demonstrates the contract.

ADR-011

State namespace migration

Context: SuperChart → AXIS rename must not wipe user scripts, engines, or plugin installs.
Decision: Persist under pynescript.axis.v1 (and plugins.v1); migrate automatically from pynescript.superchart.* keys.
Consequences: Continuity for early adopters; single namespace going forward.

ADR-012

CORS explicit for Pro API

Context: Browser AXIS calling a separate origin requires controlled Access-Control-Allow-Origin.
Decision: Flask Pro reads ALLOWED_ORIGINS. Demo may use *; production should allowlist AXIS origins and localhost regex.
Consequences: Operators can tighten the VPS unit without code changes.

ADR-013

Results as first-class export

Context: Chart-only tools trap research in screenshots. Strategies need events, metrics, and CSV.
Decision: Five-tab Results panel (Events, Strategy, Plots, Metrics, Raw) with copy/JSON/trades CSV and jump-to-bar.
Consequences: AXIS is a research PWA — exportable, inspectable, host-independent.

07 // TOPOLOGIESSEC07

[RUN SURFACES]

Where AXIS can run — from air-gapped browser to dual-process desk to Cloudflare® edge. AXIS is constant; the topology is chosen.

axis · topology

CRT · 80×24

PWAALWAYS|BACKENDOPT

┌─ Browser PWA (always) ─────────────────────────────────────┐
│  Sources · Streams · Engines · Storage · SW cache          │
└───────────────┬────────────────────────────┬───────────────┘
                │                            │
     engine=pyodide                    engine=server
     (no backend)                      POST /run
                │                            │
                │              ┌─────────────┴─────────────┐
                │              ▼                           ▼
                │     Local Flask (:5002)        Cloudflare® Worker
                │     make run                   /api/run proxy
                │                                DO /api/stream
                │                                KV · D1 · R2
                ▼
         Fully offline after wheel cache

Browser always · backend optionalUTF-8|LF|AX

01Primary dev

Local dual-process

Day-to-day development with HMR AXIS and full Python fidelity.

Depends · bun · Python · pynescript

make run  # :5002
cd frontend && bun run dev  # :3000

02Prod-like

Static dist + axis_pwa_server

Serve the built PWA without Cloudflare® Pages.

Depends · bun build · Python 3

cd frontend && bun run build
python3 axis_pwa_server.py  # :8081

03Live

Public VPS demo

Shared public AXIS + Pro API for demos and smoke.

Depends · systemd · axis-pwa · pynescript-api

PWA  162.254.38.194:8081
API  162.254.38.194:5002

Demo over HTTP on a raw IP — prefer IP CTAs; hostname may be hosts-file only.

04Edge

Cloudflare® Pages + Worker

Global static AXIS with edge API, keys, streams, optional D1/R2.

Depends · wrangler · KV · (optional D1/R2)

cd frontend/worker && wrangler deploy
cd frontend && wrangler pages deploy dist --project-name=pynescript-superchart

Project id pynescript-superchart is frozen infrastructure — do not rename.

05Air-gap

Offline-only

No network after first load — research on untrusted or denied links.

Depends · Browser only (wheel cached)

Source=mock-walk · Stream=mock-poll · Engine=pyodide · Storage=local

06Mixed

Hybrid venue + remote calc

Public venue data in the browser; evaluate on desk Flask or Worker proxy.

Depends · Any source/stream + server engine endpoint

Set Endpoint → Flask or *.workers.dev · Engine=server