LunaLabs

Quantitative finance · 2026

Chronos

A native quant terminal, its strategies, and the returns to show for them.

Chronos is three generations of the same platform pulled into one. A first desktop terminal proved the product and set the pattern — a modular Python backend with local models for private context. A second generation rewrote the shell in Rust with GPU rendering, because an Electron window cannot carry a live chart surface, a terminal, an editor and a 3D globe at once. Underneath both runs the part that has to be right: an event-driven strategy and risk engine whose backtest and live loop are the same code, so a result that reproduces in research reproduces in production.

Status
Active
Domain
Trading systems · Native + local AI
Role
Architecture, strategy design, risk & execution
Year
2026

Stack

  • Rust
  • GPUI
  • Python
  • R
  • C++ · pybind11
  • WGSL
  • Ollama
  • FinBERT
  • FastAPI
  • WebSockets

A GPU-accelerated quantitative trading terminal with its own mechanical strategies and risk engine: a Rust application shell, Python and R sidecars for machine learning and econometrics, locally hosted models so a live portfolio never leaves the machine, and one strategy implementation that runs identically in the backtest and in production.

01

The name

Chronos — KROH-nos, from the Greek khronos (χρόνος), time itself.

A market is a time series before it is anything else, and the edge a trading system has is almost never in what it holds but in when: when a regime turns, when a breakout is real, when to stand down. The terminal is built around that axis, and the name says so. It keeps the same celestial-and-Greek naming as the rest of the work — Luna the fixed reference, Ichne the trace left behind, Aphelion the farthest bound point, Chronos the clock everything is measured against.

02

Three generations, one lineage

The first generation was a shipped desktop terminal that proved the product was real: a modular Python backend covering data, quant, backtesting, portfolio and execution, driven by a packaged interface.

The second rewrote the shell from the metal up for the performance the first could not reach. The strategy and risk engine is the through-line, carried forward and hardened at each step. What is described here is the union of the three, not a fork of any one.

03

One language per job, on purpose

Rust holds the application shell and the core, because the shell must never stutter.

Python runs as a sidecar for machine learning and AI orchestration, because that is where the ecosystem lives. R runs as a service for econometric research, because reimplementing decades of statistical libraries elsewhere is a way to introduce bugs, not to remove dependencies. Shaders are WGSL; the panes inside the embedded webviews are plain JavaScript with no transpilation step.

04

Native rendering, no Electron

The shell renders through DirectX 12 on Windows and Metal on macOS.

That decision buys a chart surface that stays responsive with a live feed, a terminal, an editor and a 3D globe on screen at once — the exact load that made the Electron predecessor stutter. Model inference and econometrics run in separate processes, so a slow model can never drop a frame on the render thread.

05

Local models for private context

Sentiment classification and general reasoning run against locally hosted models rather than a hosted API.

The reason is not cost — it is that a prompt containing a live portfolio is a document you do not want to hand to a third party. Where a frontier model genuinely helps, the interface assembles the context, places it on the clipboard and opens an existing browser session, so the capability is there without the application ever holding a key.

06

The principle behind the returns

The figures in the table are not one clever signal; they are the product of a few principles that hold regardless of the exact rules.

The first is complementarity: strategies run in pairs where one is built to act on precisely the conditions the other stands down in, so the filter that costs one an entry is the signal that hands the trade to the other. The second is selection on correlation rather than on return — the independent-families scenario chooses systems for how little they move together, which is what turns a small give-up in raw return into a large cut in drawdown and the higher Sharpe. The specific entry conditions, thresholds and instruments stay in the repository; the principles are what make the numbers repeatable.

07

Risk as layers, not a stop-loss

Position size is not a fixed fraction; it is a function of how many independent conditions agree, expressed in volatility units so risk per trade stays constant across instruments and regimes, then floored by a drawdown throttle that multiplies rather than subtracts — a tripped breaker takes size to zero, not to something small.

Above the strategies sit per-system cooldowns, a heartbeat watchdog and a crash-safe flatten. Safety is settled before edge is chased.

08

One implementation, live or replay

The identical strategy and risk-manager objects are instantiated by the live loop and by the event-driven backtester, behind an adapter the engine cannot tell is feeding it live ticks or historical bars.

So a result that reproduces in research reproduces in production, or the bug is in the data rather than the code — which is the only footing on which a backtest number is worth reporting at all.

Pipeline

One implementation, live or replay

Stage Can reject

  1. 01

    Market feed

    Normalised ticks

    Live or historical — same adapter

  2. 02

    Signal

    Strategy proposal

  3. 03

    Gates

    Filtered signal

    Regime · volume · spread

  4. 04

    Local AI

    Private context

    Portfolio never leaves the machine

  5. 05

    Conviction

    Position size

  6. 06

    Risk

    Approved order

    Drawdown breaker · cooldown

  7. 07

    Execution

    Fill + state

The mathematics

What makes each
model different.

The distinctive element of each model, with its symbols defined — a bracketed placeholder stands in for the withheld core. The full models, and every fitted parameter, stay in the configuration they belong to.

01

Conviction-scaled position size

Size is a function of how many independent conditions agree, floored at zero and capped by the risk layer above it — never a fixed fraction.

κ = Σg wg · 1[g] Q = κ·R·E λ·ATR · θdd
κ
Conviction score from the weighted gates
1[g]
Indicator that gate g passed
R
Risk fraction per trade
E
Account equity
ATR
Average true range — the volatility unit
λ
Stop distance in ATR units
θdd
Drawdown throttle, 0 when a breaker has tripped

Sizing in volatility units rather than price units is what keeps risk per trade constant across instruments and regimes. The drawdown throttle multiplies rather than subtracts, so a tripped breaker takes size to zero instead of to something small.

The returns

Two scenarios, one sample

Backtest over a foreign-exchange sample. Two selection scenarios of the same engine: S2 chosen for raw return, S3 constrained to independent — mutually uncorrelated — strategy families. Net AUD is shown for two account sizes, B and A. Backtested figures, not a live track record.

  • 17.92 Sharpe ratio peak — independent families
  • 4.38% Return best scenario
  • 0.30% Max drawdown at the higher Sharpe
# Scenario Trades Net AUD (B) Net AUD (A) Return Win rate Max DD PF Sharpe
S2 Max return 131 6,581.73 87.69 4.384% 61.8% 1.61% 2.32 12.67
S3 Independent families 120 6,563.77 86.79 4.340% 59.2% 0.30% 3.45 17.92

The independent-families scenario gives up almost nothing in return — 4.340% against 4.384% — while cutting maximum drawdown from 1.61% to 0.30%, lifting the profit factor from 2.32 to 3.45 and the Sharpe from 12.67 to 17.92. Selecting on how uncorrelated the strategies are, rather than on raw return, buys most of the risk reduction for free.

Skills exercised

What the build
actually demanded.

Against the corpus · 12 systems

  • Stack breadth 10
  • Design decisions 8
  • Pipeline stages 7
  • Decision gates 2

This system Corpus median

Systems

  • GPU-accelerated application shells in Rust
  • WGSL shader authoring for chart and globe surfaces
  • Cross-process IPC between a native shell and language sidecars
  • C++ indicator kernels bound in-process via pybind11

Strategy & quant

  • Complementary strategy design — paired systems that hedge
  • Regime classification and signal gating
  • Selection on cross-strategy correlation, not raw return
  • Econometric research served from a dedicated R process

Applied AI

  • Local LLM serving for private financial context
  • Domain-specific sentiment classification
  • Credential-free frontier-model workflows against existing sessions
  • Model inference isolated from the render loop

Risk & execution

  • Multi-layer conviction scoring driving position size
  • Drawdown circuit breakers and per-strategy cooldowns
  • One strategy implementation shared by live and backtest
  • Kill switch, heartbeat watchdog and crash-safe flatten

What it establishes

  • Three generations, one lineage

    Proven, rewritten, then hardened into one platform

  • GPU-native shell

    DX12 on Windows, Metal on macOS — no Electron

  • Local-first AI

    A live portfolio never leaves the machine

  • One implementation

    The live loop and the backtester run the same code

  • Conviction-scaled sizing

    In volatility units, under drawdown breakers

  • Backtested, not promised

    Returns shown with drawdown and Sharpe beside them