兄弟们，有个东西我实在忍不住要跟你们念叨一下。

一个开源AI量化交易平台，悄悄就上线了，本地自部署，全链路打通，加密货币、美股、外汇全覆盖，从分析到实盘一条龙——你说气不气，这种东西两年前要么收费贵到离谱，要么根本找不到，现在直接开源扔GitHub上，大多数人却还不知道。

我看完有几个地方直接眼睛放光：

AI分析模块直接接OpenRouter、OpenAI、Gemini、DeepSeek，一键跨市场研究，省掉你东拼西凑的时间

策略生成傻瓜化，不会写代码没关系，让AI帮你生成Python策略，零基础也能上手

回测系统是专业级的，完整记录、可复现、可回放，不是那种跑完就忘的玩具

实盘对接支持多家加密交易所，自动半自动随便切，不用你手动盯盘

还能连IBKR做美股、MT5做外汇、Polymarket玩预测市场，一套系统全搞定

底层是Docker + PostgreSQL + Redis，生产级部署，稳得一批，不是那种跑个demo就出来骗星的项目。

说真的，量化这条路的门槛正在快速往下掉，工具越来越强，普通人能用上的东西越来越多。你现在不入场，等的那个“完美时机”永远不会来。

https://github.com/brokermr810/QuantDinger…

brokermr810/QuantDinger

Source: https://github.com/brokermr810/QuantDinger

QuantDinger

The open-source AI infrastructure layer for quant trading

Turn trading ideas into Python strategies, backtests, paper trading, and live execution — all in one self-hosted stack.

AI research → Strategy code → Backtest → Paper/Live execution → Monitoring

English · 简体中文 · 日本語 · 한국어 · ไทย · Tiếng Việt · العربية

SaaS  ·  API Docs  ·  Video Demo  ·  Website  ·  AWS Marketplace

     

Contents

Try in 2 minutes · Why QuantDinger · Safety model · Technical highlights · Repositories · AI agents & MCP · Overview · Features · Visual tour · Architecture · Install · Docs · FAQ · License

Try in 2 minutes

Fastest path: one command. No git clone, no npm, no Vue source tree. Prebuilt images from GHCR; SECRET_KEY auto-generated on first backend start.

Prerequisites: Docker with Compose v2 (Docker Desktop on Windows/macOS). Node.js is not required.

curl -fsSL https://raw.githubusercontent.com/brokermr810/QuantDinger/main/install.sh | bash

Installs to ~/quantdinger by default (override: … | bash -s -- /opt/quantdinger). Re-run the same command to pull latest images and restart.

Then open http://localhost:8888, sign in with quantdinger / 123456, and change the default admin password.

git clone https://github.com/brokermr810/QuantDinger.git
Set-Location QuantDinger
Copy-Item backend_api_python\env.example -Destination backend_api_python\.env
$key = & python -c "import secrets; print(secrets.token_hex(32))" 2>$null
if (-not $key) { $key = & py -c "import secrets; print(secrets.token_hex(32))" 2>$null }
(Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding utf8
docker compose pull
docker compose up -d

git clone https://github.com/brokermr810/QuantDinger.git && cd QuantDinger && cp backend_api_python/env.example backend_api_python/.env && chmod +x scripts/generate-secret-key.sh && ./scripts/generate-secret-key.sh && docker compose pull && docker compose up -d

For step-by-step detail and troubleshooting, see Installation & first-time setup.

Why QuantDinger

QuantDinger is a self-hosted, local-first quantitative infrastructure layer — not a chatbot with a buy button. It unifies multi-LLM research, Python-native strategy engines, server-side backtesting, and multi-broker live execution (10+ crypto venues, IBKR, MT5, Alpaca) in one production-grade stack you fully control.

Safety model

• Agent tokens are paper-only by default — live trading requires explicit server-side unlock.
• Live execution requires explicit permission — token scope + AGENT_LIVE_TRADING_ENABLED on self-hosted stacks.
• Exchange keys stay inside the user’s own deployment — not held by QuantDinger SaaS operators on self-hosted installs.
• Every agent call is audit-logged — append-only audit trail for automation and compliance review.
• QuantDinger does not provide investment advice — software for lawful research and execution only; you are responsible for compliance and risk.

API documentation

_{From zero to running stack — charting, AI research, and strategy workflow in minutes.}

_{Closed loop: AI research → Strategy code → Backtest → Paper/Live execution → Monitoring — market data in, audited orders out.}

Technical highlights

curl -O https://raw.githubusercontent.com/brokermr810/QuantDinger/main/docker-compose.ghcr.yml
curl -o backend.env https://raw.githubusercontent.com/brokermr810/QuantDinger/main/backend_api_python/env.example
docker compose -f docker-compose.ghcr.yml pull
docker compose -f docker-compose.ghcr.yml up -d

Related repositories

This repo ships the backend, Docker Compose stack, and documentation. The web UI image is published independently to GHCR by the sibling Vue repo. Use the sibling repos when you need source-level UI changes or the mobile app:

Note: Node.js is only required if you build the web UI from QuantDinger-Vue; the default Docker quick start pulls the published image and does not need it.

Use it from an AI agent (Cursor / Claude Code / Codex / MCP)

QuantDinger ships an Agent Gateway at /api/agent/v1 plus a small MCP server (quantdinger-mcp on PyPI) that wraps it as Model Context Protocol tools. Issue a token once and your AI client can read markets, manage strategies, run backtests, and (paper-only by default) place trades — without ever seeing your exchange keys or your admin JWT.

Every agent call is audit-logged, and trading-class tokens are paper-only by default. Live execution requires both paper_only=false on the token AND AGENT_LIVE_TRADING_ENABLED=true on the server.

Two backends, same client config — only QUANTDINGER_BASE_URL differs:

• Hosted (30 s try-out) — sign up at ai.quantdinger.com → Profile → My Agent Token → Issue Token. T (Trading) scope is available; paper-only by default. Live execution still requires paper_only=false on the token, explicit risk acknowledgment at issuance, and AGENT_LIVE_TRADING_ENABLED=true on the server. On multi-tenant SaaS, opening T scope increases shared infrastructure load and platform operational risk — see the in-app risk disclosure.
• Self-hosted (this repo) — after the Try in 2 minutes Docker bring-up, open Profile → My Agent Token (or the admin-only /agent-tokens page for cross-tenant audit). You control scopes, allowlists, rate limits, and the live-trading flag.

Then point Cursor / Claude Code / Codex at the MCP server (.cursor/mcp.json template: docs/agent/cursor-mcp.example.json):

{ "mcpServers": { "quantdinger": {
  "command": "uvx", "args": ["quantdinger-mcp"],
  "env": { "QUANTDINGER_BASE_URL": "http://localhost:8888",
           "QUANTDINGER_AGENT_TOKEN": "qd_agent_xxxxxxxx" }
} } }

Full setup recipe — local stdio config, remote HTTP transport, Claude Code CLI helper, example agent prompts, audit-log walkthrough: docs/agent/MCP_SETUP.md.

Deeper references: AI Integration design · Quickstart with curl · OpenAPI 3.0 spec · MCP server README

Product overview

Audience: independent quants, Python strategy authors, prop/small teams, and operators building white-label quant products on private infrastructure — without handing API keys to a black-box SaaS.

Visual Tour

▶ Watch Product Demo on YouTube Click the preview card above to open the full video walkthrough.
Indicator IDE, charting, backtest, and quick trade	AI asset analysis and opportunity radar
Trading bot workspace and automation templates	Strategy live operations, performance, and monitoring

Features at a glance

• Research & AI — Multi-LLM ensemble analysis, watchlists, opportunity radar, NL→indicator/strategy, post-backtest AI hints; optional confidence calibration. Agent Gateway + MCP for Cursor / Claude Code / Codex with scoped tokens and SSE job streaming.
• Build — Professional KLine chart UI; IndicatorStrategy (dataframe buy/sell signals) and ScriptStrategy (on_bar, ctx.buy() / ctx.sell()); AI code generation as a starting point, Python as source of truth.
• Validate — Server-side backtests with equity curves, drawdown metrics, trade logs, and strategy snapshots — no client-side-only backtest theater.
• Operate — Live strategy bots, quick trade, 10+ crypto exchanges via CCXT, IBKR / MT5 / Alpaca (US stocks, ETFs, crypto); unified Broker Accounts page; notifications (Telegram, email, SMS, Discord, webhooks).
• Platform — Docker Compose + GHCR images, PostgreSQL 16, Redis 7, OAuth, multi-user RBAC, credits / membership / USDT billing toggles, AWS Marketplace AMI, 7-language documentation.

Architecture

Design principle: separate market data ingestion, strategy/backtest compute, and order execution so research never shares a code path with live capital unless you explicitly promote a strategy.

Stack: Nginx serves the prebuilt Vue SPA (ghcr.io/brokermr810/quantdinger-frontend); Flask + Gunicorn API hosts strategy, AI, billing, and agent services; PostgreSQL 16 is the system of record; Redis 7 backs cache and worker coordination. Exchanges, brokers, LLMs, and payment rails plug in through env-driven adapters — swap providers without forking core code.

Runtime flow: market feeds → indicator/signal layer → strategy engine → backtest or live runtime → venue-specific execution adapters; pending orders dispatched by background workers with health checks and retry semantics.

Deploy surfaces: one-line install.sh, zero-repo GHCR Compose, full-repo Compose (local backend build), AWS Marketplace AMI, and SaaS at ai.quantdinger.com for trials.

System diagram

flowchart LR
    U[Trader / Operator / Researcher]

    subgraph FE[Frontend Layer]
        WEB[Vue Web App]
        NG[Nginx Delivery]
    end

    subgraph BE[Application Layer]
        API[Flask API Gateway]
        AI[AI Analysis Services]
        STRAT[Strategy and Backtest Engine]
        EXEC[Execution and Quick Trade]
        BILL[Billing and Membership]
    end

    subgraph DATA[State Layer]
        PG[(PostgreSQL 16)]
        REDIS[(Redis 7)]
        FILES[Logs and Runtime Data]
    end

    subgraph EXT[External Integrations]
        LLM[LLM Providers]
        EXCH[Crypto Exchanges]
        BROKER[IBKR / MT5 / Alpaca]
        MARKET[Market Data / News]
        PAY[TronGrid / USDT Payment]
        NOTIFY[Telegram / Email / SMS / Webhook]
    end

    U --> WEB
    WEB --> NG --> API
    API --> AI
    API --> STRAT
    API --> EXEC
    API --> BILL

    AI --> PG
    STRAT --> PG
    EXEC --> PG
    BILL --> PG
    API --> REDIS
    API --> FILES

    AI --> LLM
    AI --> MARKET
    EXEC --> EXCH
    EXEC --> BROKER
    BILL --> PAY
    API --> NOTIFY

Installation & first-time setup (Docker Compose)

Already ran Try in 2 minutes? Skip this section — it’s the same outcome, just expanded into a step-by-step checklist for first-time deployers and operations folks who want to understand every knob.

This section mirrors a typical “local deploy” path: prepare the host → obtain the code → configure secrets → start the stack → verify → harden → optionally wire AI. Node.js is not required: the frontend service pulls ghcr.io/brokermr810/quantdinger-frontend directly, so Nginx serves the SPA without any local build step.

Prerequisites

1) Clone the repository

git clone https://github.com/brokermr810/QuantDinger.git
cd QuantDinger

2) Create backend configuration (mandatory)

cp backend_api_python/env.example backend_api_python/.env

Almost all runtime behavior is driven by backend_api_python/.env (database URL, admin user, LLM keys, workers, billing toggles, etc.). The optional repository root .env only adjusts Compose-level concerns such as ports and image mirrors (IMAGE_PREFIX).

3) Set SECRET_KEY before the first boot (mandatory)

The API refuses to start if SECRET_KEY is still the placeholder from env.example. This blocks accidental insecure deployments.

Linux / macOS (recommended):

./scripts/generate-secret-key.sh

The script overwrites the SECRET_KEY= line in backend_api_python/.env using Python’s secrets module.

Manual (any OS): generate a long random string (for example 64 hex chars) and set SECRET_KEY=... in backend_api_python/.env.

4) Start the stack

docker compose pull
docker compose up -d

• frontend — pulls ghcr.io/brokermr810/quantdinger-frontend:latest (no local Vue tree required).
• backend — built from ./backend_api_python on first start if no local image exists yet.
• For UI development from Vue source, clone QuantDinger-Vue into ./QuantDinger-Vue/ and add -f docker-compose.build.yml to the command (see Build the frontend from Vue source below).

Services: postgres, redis, backend, frontend (see docker-compose.yml).

Alternative: zero-repo install from GHCR (lightest)

Prebuilt multi-arch (amd64/arm64) images for both backend and frontend — no git clone:

curl -O https://raw.githubusercontent.com/brokermr810/QuantDinger/main/docker-compose.ghcr.yml
curl -o backend.env https://raw.githubusercontent.com/brokermr810/QuantDinger/main/backend_api_python/env.example
docker compose -f docker-compose.ghcr.yml pull
docker compose -f docker-compose.ghcr.yml up -d

The backend entrypoint auto-generates a random SECRET_KEY on first start and applies the schema (migrations/init.sql) idempotently. Edit backend.env for persistent overrides (API keys, OAuth, broker credentials). Compose orchestration knobs go in a separate .env (optional) — e.g. pin a version:

# Common case: lockstep both sides to one tag
IMAGE_TAG=3.0.22

# Advanced (opt-in): decouple sides. Either var alone overrides only
# that side; the other still follows IMAGE_TAG.
# BACKEND_TAG=v3.0.9
# FRONTEND_TAG=v3.1.0-rc1

# BACKEND_IMAGE=ghcr.io/<your-fork>/quantdinger-backend     # optional, for forks
# FRONTEND_IMAGE=ghcr.io/<your-fork>/quantdinger-frontend

Tag resolution: BACKEND_TAG / FRONTEND_TAG → IMAGE_TAG → compose default (latest). Without a root .env, both compose files pull ghcr.io/brokermr810/quantdinger-{backend,frontend}:latest. Pin a specific release by setting IMAGE_TAG (lockstep) or BACKEND_TAG / FRONTEND_TAG (per-side) — see GitHub Releases for available tags.

Version stamping

Published backend images are stamped from the Git release tag automatically. A v3.0.23 tag becomes APP_VERSION=3.0.23, which is what OpenAPI metadata and the UI brand config expose. Local source runs fall back to git describe and then the repo-root VERSION file; local Docker builds can override explicitly:

APP_VERSION=$(git describe --tags --abbrev=0 | sed 's/^v//') docker compose up -d --build backend

Alternative: build the frontend from Vue source

If you have access to the QuantDinger-Vue repo and want to iterate on UI source (theme tweaks, forks, debugging) instead of pulling the published image, clone it into the ./QuantDinger-Vue/ slot at the repo root (gitignored) and let Compose build from there:

git clone https://github.com/brokermr810/QuantDinger-Vue.git QuantDinger-Vue
docker compose -f docker-compose.yml -f docker-compose.build.yml up -d --build

The main docker-compose.yml only pulls the GHCR image; the override file docker-compose.build.yml adds the local build: block. Without the override, ./QuantDinger-Vue/ does not need to exist. Point FRONTEND_SRC_PATH=/abs/path/to/QuantDinger-Vue if you’d rather keep the source somewhere else, or set COMPOSE_FILE=docker-compose.yml:docker-compose.build.yml in a root .env to skip the long -f -f invocation. The locally built image is tagged the same way as the published one (FRONTEND_TAG / IMAGE_TAG rules apply), so it slots into the rest of the stack with no further changes.

5) Verify and sign in

Default admin (change immediately in production):

• User: quantdinger
• Password: 123456 (from env.example; override with ADMIN_USER / ADMIN_PASSWORD in .env before first use if you prefer).

If ADMIN_PASSWORD is set to any value other than 123456, the bootstrap admin is treated as safely initialized and the first-login password reminder is not shown. If an existing database still stores the old default, startup syncs the first admin password to the non-default env value.

Also set FRONTEND_URL in backend_api_python/.env to the URL users actually use (including https:// behind a reverse proxy); it affects redirects, CORS-related settings, and some generated links.

6) Optional: enable AI features

AI analysis, NL→code, and related flows need at least one LLM provider configured. Open backend_api_python/env.example, find the AI / LLM block, copy the relevant keys into your .env (for example LLM_PROVIDER + OPENROUTER_API_KEY, or another supported provider). Restart the backend after edits.

AtlasCloud is also supported as an OpenAI-compatible provider. Use the official AtlasCloud LLM API docs and API key guide, then configure:

LLM_PROVIDER=atlascloud
ATLASCLOUD_API_KEY=your_api_key
ATLASCLOUD_MODEL=deepseek-v3
ATLASCLOUD_BASE_URL=https://api.atlascloud.ai/v1

7) Windows notes

Use Docker Desktop (WSL2 backend recommended). From PowerShell in the repo root:

git clone https://github.com/brokermr810/QuantDinger.git
Set-Location QuantDinger
Copy-Item backend_api_python\env.example -Destination backend_api_python\.env
$key = py -c "import secrets; print(secrets.token_hex(32))"
(Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding UTF8
docker compose pull
docker compose up -d

If py is not on PATH, use python or python3 in the one-liner that generates $key. Line endings should remain UTF-8; avoid editors that strip newlines from .env.

Troubleshooting (first boot)

Common Docker commands

docker compose ps
docker compose logs -f backend
docker compose restart backend
docker compose pull
docker compose up -d
docker compose up -d --build backend   # backend code changes only
docker compose down

Optional root .env (Compose only)

For custom ports or mirror/prefix for base images (slow Docker Hub pulls), create a file named .env in the repository root (same directory as docker-compose.yml):

FRONTEND_PORT=3000
BACKEND_PORT=127.0.0.1:5001
IMAGE_PREFIX=docker.m.daocloud.io/library/

Production-style TLS, domain, and reverse-proxy placement are covered in Cloud deployment.

Suggested first session (product walkthrough)

After the stack is healthy: (1) run an AI asset / market analysis so LLM and data paths are verified; (2) open the Indicator IDE, load a symbol, and run a signal backtest on a small date range; (3) optionally use AI code generation to draft an indicator, then edit the Python; (4) when ready, attach exchange API keys (profile / credentials), use test connection, then explore live strategy or quick trade with execution mode you intend. This order surfaces configuration issues early before real capital.

Minimal Example: Python Indicator Strategy

This is the kind of Python-native strategy logic QuantDinger is designed for:

# @param sma_short int 14 Short moving average
# @param sma_long int 28 Long moving average

sma_short_period = params.get('sma_short', 14)
sma_long_period = params.get('sma_long', 28)

my_indicator_name = "Dual Moving Average Strategy"
my_indicator_description = f"SMA {sma_short_period}/{sma_long_period} crossover"

df = df.copy()
sma_short = df["close"].rolling(sma_short_period).mean()
sma_long = df["close"].rolling(sma_long_period).mean()

def edge(signal):
    signal = signal.fillna(False).astype(bool)
    return signal & ~signal.shift(1).fillna(False)

open_long = (sma_short > sma_long) & (sma_short.shift(1) <= sma_long.shift(1))
open_short = (sma_short < sma_long) & (sma_short.shift(1) >= sma_long.shift(1))

df["open_long"] = edge(open_long)
df["close_long"] = edge(open_short)
df["open_short"] = edge(open_short)
df["close_short"] = edge(open_long)

output = {
    "name": my_indicator_name,
    "plots": [
        {"name": "SMA Short", "data": sma_short.fillna(0).tolist(), "color": "#FF9800", "overlay": True},
        {"name": "SMA Long", "data": sma_long.fillna(0).tolist(), "color": "#3F51B5", "overlay": True},
    ],
    "signals": [],
}

See full examples:

• docs/examples/dual_ma_with_params.py
• docs/examples/multi_indicator_composite.py
• docs/examples/cross_sectional_momentum_rsi.py

Supported Markets, Brokers, and Exchanges

Crypto Exchanges

Traditional Markets

Broker Accounts page (/broker-accounts, v3.0.5+) — IBKR, MT5 and Alpaca share a single unified management page: per-broker connect form, account KPIs, positions table and open-order management with one-click cancel. Multi-tenant safe: each user’s session is isolated via BrokerSessionRegistry, so one user reconnecting doesn’t kick everyone else off.

Strategy Development Modes

QuantDinger supports two main strategy authoring models:

IndicatorStrategy

• dataframe-based Python scripts
• buy / sell signal generation
• chart rendering and signal-style backtests
• best for research, indicator logic, and visual strategy prototyping

ScriptStrategy

• event-driven on_init(ctx) / on_bar(ctx, bar) scripts
• explicit runtime control with ctx.buy(), ctx.sell(), ctx.close_position()
• best for stateful strategies, execution-oriented logic, and live alignment

For the full developer workflow, see:

• Strategy Development Guide
• Cross-Sectional Strategy Guide
• Strategy Examples

The example scripts live in docs/examples/ and are kept aligned with the current strategy development guides.

Repository Layout

QuantDinger/
├── backend_api_python/      # Open backend source code
│   ├── app/routes/          # REST endpoints
│   ├── app/services/        # AI, trading, billing, backtest, integrations
│   ├── migrations/init.sql  # Database initialization
│   ├── env.example          # Main environment template
│   └── Dockerfile
├── docs/                    # Product, strategy, and deployment documentation
├── install.sh               # One-line GHCR install (curl | bash)
├── docker-compose.yml       # Web UI via GHCR; optional ./QuantDinger-Vue/ for local UI builds
├── docker-compose.ghcr.yml  # Zero-repo deploy — both images from GHCR
├── LICENSE
└── TRADEMARKS.md

Configuration Areas

Use backend_api_python/env.example as the primary template. Key areas include:

Documentation

Strategy: EN · CN · TW · JA · KO · Cross-sectional EN / CN · Examples

Integrations & alerts: IBKR · MT5 EN / CN · OAuth EN / CN · Telegram / Email / SMS configs under docs/ (NOTIFICATION_*).

FAQ

Is QuantDinger really self-hosted?

Yes. The default deployment model is your own Docker Compose stack with your own database, Redis instance, credentials, and environment configuration.

Is QuantDinger only for crypto trading?

No. Crypto is a major focus, but the platform also includes IBKR and Alpaca workflows for US stocks / ETFs (Alpaca additionally covers crypto) and MT5 workflows for forex.

Can I write strategies directly in Python?

Yes. QuantDinger supports both dataframe-style IndicatorStrategy development and event-driven ScriptStrategy development. You can also use AI to generate a starting point and then edit it yourself.

Is this a research tool or a live trading platform?

It is both. QuantDinger is built to connect AI research, charting, strategy development, backtesting, quick trade flows, and live execution operations in one system.

Can I use QuantDinger commercially?

The backend is licensed under Apache 2.0. The web frontend source (QuantDinger-Vue) uses a separate source-available license—review both and contact the project for commercial frontend authorization if needed. The mobile app repo is open source under its own license (see that repository).

Is there a mobile app?

Yes—see QuantDinger-Mobile (open source). It connects to the same backend you self-host or to SaaS.

Exchange Partner Links

The following links are available in-app under Profile → Open account or Broker Accounts → Open account, and may qualify users for trading-fee rebates depending on venue policies.

Crypto exchanges (API keys)

Forex / CFD — TMGM (MetaTrader 5)

After opening a TMGM account, install MetaTrader 5 and bind your server/login under Profile → Exchange or Broker Accounts.

License and Commercial Terms

• Backend source code is licensed under Apache License 2.0. See LICENSE.
• This repository distributes the frontend UI here as prebuilt files for integrated deployment.
• The frontend source code is available separately at QuantDinger Frontend under the QuantDinger Frontend Source-Available License v1.0.
• Under that frontend license, non-commercial use and eligible qualified non-profit use are permitted free of charge, while commercial use requires a separate commercial license from the copyright holder.
• Trademark, branding, attribution, and watermark usage are governed separately and may not be removed or altered without permission. See TRADEMARKS.md.

For commercial licensing, frontend source access, branding authorization, or deployment support:

• Website: quantdinger.com
• Telegram: t.me/worldinbroker
• Email: [email protected]

Legal Notice and Compliance

QuantDinger is intended for lawful research, education, and compliant trading only—not for fraud, market manipulation, sanctions evasion, money laundering, or other illegal activity. Operators must follow applicable laws, licensing, and exchange rules in every jurisdiction where they deploy. This project does not provide legal, tax, investment, or regulatory advice. You use the software at your own risk; to the extent permitted by law, contributors disclaim liability for trading losses, service interruption, or regulatory enforcement arising from use or misuse.

Community and Support

• Contributing Guide
• Contributors
• Report Bugs / Request Features
• Email: [email protected]

Support the Project

Crypto donations:

0x96fa4962181bea077f8c7240efe46afbe73641a7

Star History

Acknowledgements

QuantDinger stands on top of a strong open-source ecosystem. Special thanks to projects such as:

• Flask
• Pandas
• CCXT
• yfinance
• Vue.js
• Ant Design Vue
• KLineCharts
• ECharts
• Capacitor
• bip-utils

P.S. — A Note on the Name

QuantDinger is a small tribute to Erwin Schrödinger — the “-dinger” in our name is the tail of “Schrödinger”. The cat in the box was a thought experiment; every un-fired strategy is its own little version of it — simultaneously winning and losing until the order actually fills. Backtests open the box. Live trading collapses the wavefunction. Trade carefully.

_{If QuantDinger is useful to you, a GitHub star helps the project a lot.}