Charting and indicators
Multi-pane charts drawn on the GPU, over a live feed or your own stored history. 171 indicators ship across 8 categories, 8 of them taking two series rather than one.
Vike · Trader
The code you backtest is the code that trades live.
Vike Trader is a Rust algorithmic trading platform — a desktop charting app, a headless daemon, and an agent-ready CLI/MCP surface — trading 14 venues from crypto perps to FX to prediction markets, with enforced live/backtest parity and a µs-level latency gate run in CI.
Free. Source-available under FSL-1.1; every release becomes Apache-2.0 two years on.
Build. Backtest. Go live. Reconcile.
Four verbs, one engine. The fourth is the one that runs while you are not looking — and the reason a restart, a dropped socket or a fill you never saw does not quietly desynchronise your book.
Write it, and watch it compile
Strategies are Rust, or the embedded script language when you want an edit-and-run loop. The editor tells you it compiles before anything else happens, and the indicator registry the chart draws from is the same one your strategy calls.
Run it over real bars, and read the report
The harness runs the engine itself over your own recorded ticks or the vike data archives — profile a run, sweep a parameter grid, walk it forward. Equity curve, fills and the performance summary come out of the same execution path that will trade the strategy.
Arm it deliberately: paper, then demo, then live
Every venue mounts paper by default, and stays there until credentials exist and a per-venue ceiling in your policy file raises it. That ceiling can only ever refuse — writing live arms nothing on its own — and no environment variable can widen it.
Keep the books honest, continuously
Reconciliation is not a button you press after something has gone wrong. It is a loop that runs the whole time a venue is mounted, and it is what the rest of the pipeline rests on.
- Ask. Each venue is asked what it believes your orders, fills and positions are — over a connection dedicated to reading, never the one your orders go out on.
- Diff. That answer is compared against local state, order by order and position by position.
- Classify. Every disagreement lands in one of 9 divergence kinds. An exhaustive match in the engine means a new kind cannot fall through unclassified.
- Resolve. Your policy decides: fold it into local state, or hold it for an operator to confirm. Fills that came from outside this process can be held for a deliberate claim rather than absorbed silently.
No screenshot on this tab yet — and we would rather say so than stage one. This step runs in the background by design; the capture that shows it honestly is still being built.
What you get, on screen
One desktop application, GPU-rendered, with the research tools and the trading tools in the same window and over the same engine.
Depth-of-market capture pending
real frames or none
real frames or none
Depth of market
A price ladder over the venue's own book, with resting size on both sides and your working orders in line with it. Order flow reads from the same normalised book the strategy engine sees, so the ladder and the backtest do not disagree about what liquidity was there.
Sweeps and walk-forward
Take one strategy, vary its parameters, and read the grid rather than one lucky run. Walk-forward and profiling are in the application, not in a notebook you have to keep in step with it.
Your own historical store
Bars, ticks and books recorded to a local columnar store you own outright, with 13 declared layouts covering the kinds of market data the engine reads. The Data Manager shows what you actually hold — series, row counts, sizes — rather than what you meant to download.
Option chains and greeks
Full chains with strikes, marks and greeks on live positions. Options sit inside the same instrument model as everything else, so one strategy can reach across 11 asset classes without being rewritten.
Your keys, on your machine
One plaintext credential file in your own project folder — no account, no cloud, nothing to sign up for. Absent credentials are the live gate: with no keys, every venue stays on paper, and the connections window shows you which is which.
Tearsheet capture pending
real frames or none
real frames or none
Tearsheets from the journal
Performance is read back out of the command journal rather than accumulated in a counter somewhere. The same 20 event kinds that drove the session produce the report, so the numbers and the history cannot drift apart.
Three surfaces, one engine
Desktop, daemon or agent — pick the artifact that fits how you trade. They share the engine, the credential store and the policy file.
| Surface | Best for | Key capabilities | Runs on |
|---|---|---|---|
| Desktop app | Research & discretionary trading | GPU-rendered charts, live venue feeds, data manager, connections editor, reconciliation controls | Windows · Linux |
| Daemon (vike‑tradehub) | Unattended live trading | Headless venue mounts, journalled events, opt-in Telegram control channel, feed recording | Docker image (Docker Hub · GHCR) · Linux systemd |
| CLI + MCP (vike‑cli) | Agents & automation | Trade REPL with local guardrails, config and secrets inspection, stdio MCP server for Claude or any MCP client | Any terminal · thin observe-only client as a Docker image |
Inside the engine
The parts you do not see on screen, and the reason the parts you do see agree with each other.
Parity gate
- The same engine code live and simulated — there is no second implementation to keep in step
- Frozen fixtures compared bit-for-bit as IEEE-754 patterns
- Profile, run and sweep from one harness
Replay journal
- All 20 engine event kinds durably journalled
- Any session replays deterministically
- Audit and debug on the same execution path that traded
Reconciliation
- Venue truth diffed against local state, continuously
- 9 divergence kinds, four resolution policies
- Per-venue health gating; foreign fills held for a deliberate claim
Order emulator
- Stop, trailing and good-till-date synthesised locally
- For venues that do not offer them natively
- Triggers evaluate in the engine that backtested them
Market making
- A quoting engine with inventory and spread control
- Fills verified by reconciliation, not assumed
- Paper-first, like every venue mount
Strategy library
- 18 templates in the box
- 10 portable: backtest and live, unchanged
- Yours go beside them, in Rust or in script
Agent surface
- A trade REPL with local sanity caps
- An stdio MCP server — Claude or any MCP client
- Guardrails enforced before any venue sees an order
Risk ceilings in a file
- Per-order notional and per-venue arming live in policy
- No environment variable can widen a ceiling
- A removed setting refuses startup rather than being ignored
14 venues, one line of truth each
Every one of them is a native integration — its own signer, its own transport, its own event mapper — written against the venue's own API and checked by the same conformance harnesses. 10 run live execution with continuous reconciliation today; the rest sit behind explicit build gates, and each line below says which and why.
- Binance live exec + recon spot + perps, live exec, reconnect-triggered recon, trade-tape recording
- Bybit live exec + recon perps + spot, live exec, reconnect-triggered recon
- OKX live exec + recon spot + perps, live exec, reconnect-triggered recon
- Hyperliquid live exec + recon on-chain perps, EIP-712 signed exec, reconnect-triggered recon
- Aster live exec + recon on-chain perps, EIP-712 signed exec, interval recon
- Deribit live exec + recon options + futures, live exec with greeks, interval recon over its own order-WS
- Alpaca live exec + recon US equities, live exec, interval recon on a dedicated OAuth2 client
- cTrader live exec + recon FX + CFDs, live protobuf exec, interval recon
- IG live exec + recon FX + CFDs, live exec, interval recon on its own session
- OANDA live exec + recon FX + CFDs, live exec, interval recon on its own client
- Interactive Brokers feature-gated multi-asset via the Client Portal gateway, behind a build feature
- FXCM feature-gated FX via the vendor ForexConnect SDK — the live gate is a property of the binary
- Dukascopy sidecar exec · recon not wired FX exec through a JForex sidecar — recon not yet wired
- Polymarket feature-gated CLOB feeds, EIP-712 signed orders, settlement, full L2 archive on vike data
Tiers are read from the venue capability tables our CI gates, not written down here — this wall cannot claim more than the code does.
Parity is structural, not statistical
Nothing here models the engine — it is the engine. Market data, order events and time go into one deterministic core; fills, positions and signals come out; every event lands in the replay journal, and replays through the same execution path that produced it. There is no second implementation whose agreement with the first has to be measured.
Proof, not adjectives
Every number below is exported from the build that ships and regenerated by CI. None of it is typed into this page, which is the only reason it can still be true next month.
- 14 venue bridges Every one a native integration written against the same execution contract, and checked by the same exec and market-data conformance harnesses.
- 10 µs core-hop p99 ceiling Measured on a CI runner whose cores are reserved for it, on every merge. A regression fails the build rather than appearing in a blog post.
- 171 built-in indicators Counted from the code that computes them. The same registry serves the chart, the strategy builder and the backtest harness.
- 20 engine event kinds Every one durably journalled, and replayable afterwards through the very same execution path that produced it.
- 9 divergence kinds The ways a venue can disagree with you, each classified by an exhaustive match — a new one cannot fall through unhandled.
- 18 strategy templates Shipped in the box, with the portable ones running unchanged from backtest to paper to live.
- 13 historical store layouts One declared schema per kind of market data, gated against every producer and consumer that touches it.
- 11 asset classes One instrument model across every market the venues reach, so a strategy is not rewritten to change what it trades.
The gates that run on every merge
The latency gate
The core hop's tail is measured on a runner whose CPUs are fenced off for the purpose, and gated in CI. Every ceiling in it is a derived constant with its own calibration data attached — not one round number somebody liked.
Venue conformance harnesses
An execution contract (no order silently vanishes; exactly one terminal event) and a market-data contract (the L2 book invariants), both run over every venue's real frame router. A new venue reddens both until it is classified.
Property tests, seeds committed
Randomised suites over the pure cores where fixtures only pin examples — sizing, quantization, the risk-gate against the simulator. Every counterexample CI finds is committed, so it reproduces forever.
One signing binary, audited
The whole workspace links into one binary that signs orders, so a second HTTP, WebSocket, TLS or curve stack is a build failure rather than a preference. Releases carry an embedded SBOM and checksums.
Seed your backtests with vike data
The market-data layer that feeds the engine
Full-depth prediction-market archives, cross-venue funding and perp analytics, on-chain wallet intelligence — the same datasets behind vike.io, reachable over REST and MCP and loadable straight into your local store. →
Questions, answered plainly
Is Vike Trader free?
Yes — all of it. No account, no card, no tier that unlocks the real product. Backtesting, paper trading, demo accounts and live trading all run from the same free download.
Is Vike Trader open source?
Source-available, not OSI open source: releases ship under FSL-1.1, and every release becomes Apache-2.0 two years on. The engineering proof is public either way — the CI latency gate, the venue conformance harnesses and the bit-exact parity fixtures ship with every release.
What venues does Vike Trader support?
14 native venue integrations, every one of them mounting paper by default. Live execution with continuous reconciliation: Binance, Bybit, OKX, Hyperliquid, Aster, Deribit, Alpaca, cTrader, IG and OANDA. Behind explicit opt-in build gates: Interactive Brokers, FXCM and Polymarket. Execution through a sidecar process, reconciliation built but not yet wired: Dukascopy.
What indicators and strategies ship with it?
171 built-in indicators across 8 categories, 8 of which take two series rather than one. 18 strategy templates ship as well, 10 of them portable — the same template backtests and trades live, unchanged. Your own strategies go beside them, written in Rust or in the embedded scripting language.
What does reconciliation actually do?
Each pass asks a venue what it believes your orders and positions are, diffs that against local state, and classifies every disagreement into one of 9 divergence kinds — a missing fill, a position drift, an order the venue has never heard of. What happens next is your policy's call: fold it into local state, or hold it for an operator to confirm. An exhaustive match in the engine means a new kind of divergence cannot fall through unclassified.
Does Vike Trader run in Docker?
Yes. The headless daemon ships as an image on Docker Hub and GHCR, and a thin observe-only client ships as a second image. The desktop app is a native binary for Windows and Linux.
Can my AI agent trade with it?
Yes — the CLI is an MCP server (vike-cli mcp, stdio), so Claude or any MCP client can create strategies, run backtests and place orders. Per-order notional and quantity guardrails are enforced locally, before any venue sees an order.
How are my API keys handled?
One plaintext file in your own project folder — no cloud, no account, nothing leaves your machine. Keys pass to child processes via environment, never argv; they are redacted from logs and debug output; and absent credentials are themselves the live gate: no keys, and every venue stays paper. A per-venue policy ceiling defaults to paper on top of that.
What is live/backtest parity?
The backtest harness runs the same engine code that trades live — not a model of it. Frozen fixtures pin the engine's outputs as IEEE-754 bit patterns and are compared exactly; a tolerance is never widened to make a test pass.
Windows or Linux?
Both, by surface: the desktop app runs on Windows and Linux; the daemon runs on Linux via Docker or systemd; the CLI/MCP surface runs in any terminal. macOS is not a supported artifact today.
The engine is the product. Run it.
Paper-first on every venue, from the first command.
Free. Source-available under FSL-1.1; every release becomes Apache-2.0 two years on.
Trading involves substantial risk of loss and is not suitable for every investor. Nothing on this page is investment, financial or trading advice, and no result shown or described — backtested, simulated, paper or live — is a promise of future performance. Backtested and simulated results in particular have inherent limitations: they are produced with hindsight, do not reflect every real-market condition, and no representation is made that any account will achieve results similar to them. Vike Trader is software; orders sent from your accounts, the credentials that authorize them and the decisions behind them remain yours. Consider your circumstances, and never trade money you cannot afford to lose.