New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Vibe-Trading to vnpy Exporter

by HKUDS in HKUDS/Vibe-Trading

Translates a Vibe-Trading backtest strategy into a runnable vnpy CtaTemplate Python class for A-share stocks, futures or crypto.

MITAuto-check passedBusiness, Finance & HR

Install Vibe-Trading to vnpy Exporter

skills CLI
$ npx skills add HKUDS/Vibe-Trading --skill vnpy-export -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install HKUDS/Vibe-Trading vnpy-export --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .claude/skills && cp -r skills-src/agent/src/skills/vnpy-export .claude/skills/vnpy-export && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
vnpy-export
GitHub stars
35k
Token cost
~2.9k tokens
SKILL.md length
793 words
Files
2 (incl. scripts)
Skills in repo
89
Repo updated
First seen
Licence
MIT

At a glance

Translates a Vibe-Trading backtest strategy into a runnable vnpy CtaTemplate Python class for A-share stocks, futures or crypto.

  • Works in 7 steps: load_skill("vnpy-export") — read this… → read_file("config.json") — extract… → read_file("code/signal_engine.py") —… → …
  • Exporting a Vibe-Trading strategy to run in vnpy
  • SKILL.md covers Overview, Workflow: Export from Backtest…, Workflow: Generate from… and Asset Class Conventions, plus 8 more sections
  • Runs Python scripts from its folder

What it does

It reads the backtest run's config for the instrument, dates, parameters and interval, and the signal engine's own logic, then determines the asset class to pick the right symbol convention: an A-share ticker trading in whole lots of shares, a futures contract trading in lots, or a crypto pair trading in coin units, and whether short selling applies, since stocks default to buy and sell only.

The translated class subclasses vnpy's CtaTemplate and implements its lifecycle methods, such as warming up indicators on init, using a bar generator and an array manager to handle bars and indicator arrays. The output is saved as a single Python file under an artifacts folder named after the strategy and returned to the user with setup instructions, ready to load into vnpy's CTA Strategy App for backtesting or live trading.

When your agent uses it

  • Exporting a Vibe-Trading strategy to run in vnpy
  • Converting a backtested signal into a vnpy CtaTemplate class
  • Choosing the right symbol format for stocks, futures or crypto

Example prompts

  • “Export my mean-reversion backtest strategy to a vnpy CtaTemplate.”
  • “Generate a vnpy strategy class for trading IF2406 futures from this description.”
  • “Convert this crypto signal engine into a runnable vnpy strategy file.”

Requirements

  • vnpy with the CTA Strategy App
  • A Vibe-Trading backtest run's config and signal engine

Workflow steps

7 steps, taken from the first numbered list in SKILL.md.

  1. load_skill("vnpy-export") — read this guide
  2. read_file("config.json") — extract instrument, dates, parameters, interval
  3. read_file("code/signal_engine.py") — understand the Python signal logic
  4. Determine asset class from config.json → choose correct CtaTemplate convention (see below)
  5. Translate signal logic to CtaTemplate using the reference tables
  6. write_file("artifacts/vnpy_strategy/Strategy.py") — save the output
  7. Return the class in a code block with setup instructions

What it can do on your machine

Read from SKILL.md and the folder at commit 14cabaf. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • vnpy.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Vibe-Trading to vnpy Exporter loads about 2.9k tokens when it runs. Until then it costs about 44 tokens; SKILL.md has 793 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~44
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from HKUDS/Vibe-Trading at commit 14cabaf, republished under its MIT licence (© HKUDS). 793 words, ~2,872 tokens.

Download SKILL.mdSave it as .claude/skills/vnpy-export/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
vnpy-export
description
Export a Vibe-Trading backtest strategy to a runnable vnpy CtaTemplate Python class — supports A-share equities, futures, and crypto via BarGenerator + ArrayManager.
category
tool

Overview

This skill translates a Vibe-Trading strategy into a vnpy CtaTemplate subclass .py file that can be loaded directly into the vnpy CTA Strategy App for live trading or vnpy backtesting.

Output file: artifacts/vnpy_strategy/<StrategyName>Strategy.py (inside the run directory).

vnpy is the most widely-used open-source quant framework in mainland China (39k+ GitHub stars). Use this skill when the user asks to export to vnpy, requests a /vnpy command, or wants to run a Vibe-Trading strategy inside vnpy's CTA backtester or live trading engine.

Workflow: Export from Backtest Run

  1. load_skill("vnpy-export") — read this guide
  2. read_file("config.json") — extract instrument, dates, parameters, interval
  3. read_file("code/signal_engine.py") — understand the Python signal logic
  4. Determine asset class from config.json → choose correct CtaTemplate convention (see below)
  5. Translate signal logic to CtaTemplate using the reference tables
  6. write_file("artifacts/vnpy_strategy/<StrategyName>Strategy.py") — save the output
  7. Return the class in a code block with setup instructions

Workflow: Generate from Description

  1. load_skill("vnpy-export") — read this guide
  2. Write a CtaTemplate class from the user's strategy description
  3. write_file("artifacts/vnpy_strategy/<StrategyName>Strategy.py") — save the output
  4. Return the class with setup and usage instructions

Asset Class Conventions

vnpy uses the same CtaTemplate base class for all asset types, but parameter conventions differ:

Asset ClassInstrument Examplevt_symbol FormatPosition Unit
A-share stockPing An Bank000001.SZSEshares (整手, min 100)
FuturesIF2406IF2406.CFFEXlots
CryptoBTC/USDTBTC/USDT.BINANCEcoin units

For stocks: use buy / sell only (no short selling unless margin account). For futures / crypto: use all four directions — buy, sell, short, cover.

CtaTemplate Structure

Every strategy must subclass CtaTemplate and implement these methods:

MethodPurpose
__init__Declare parameters, variables, BarGenerator, ArrayManager
on_initCalled once at startup; call load_bar(n) to warm up indicators
on_startCalled when strategy is started by user
on_stopCalled when strategy is stopped
on_tickReceives live tick data; forward to BarGenerator
on_barMain logic — called once per bar by BarGenerator
on_orderOrder status updates
on_tradeFill notifications
on_stop_orderStop-order status (if using stop orders)

Always call self.cancel_all() at the start of on_bar to avoid stale orders. Always call self.put_event() at the end of on_bar to refresh the UI.

Full Template

See scripts/cta_template.py for a complete, runnable example (MA crossover). The template below is the canonical skeleton — replace the # SIGNAL LOGIC section:

python
from vnpy_ctastrategy import (
    CtaTemplate,
    StopOrder,
    TickData,
    BarData,
    TradeData,
    OrderData,
    BarGenerator,
    ArrayManager,
)


class {{StrategyName}}Strategy(CtaTemplate):
    """
    Vibe-Trading export — {{StrategyName}}
    Generated from run: {{run_id}}
    Instrument: {{vt_symbol}}
    """

    author = "Vibe-Trading"

    # ── Parameters (editable in vnpy UI) ──────────────────────────────────
    {{param_name}} = {{param_default}}   # add one line per parameter

    parameters = [{{param_list_as_strings}}]

    # ── Variables (displayed in vnpy UI, reset on strategy restart) ────────
    {{var_name}} = 0.0   # add one line per runtime variable

    variables = [{{var_list_as_strings}}]

    def __init__(self, cta_engine, strategy_name, vt_symbol, setting):
        super().__init__(cta_engine, strategy_name, vt_symbol, setting)
        self.bg = BarGenerator(self.on_bar)
        self.am = ArrayManager()

        # initialise variable attributes to match class-level defaults
        # (vnpy requires instance attributes for variables declared above)

    def on_init(self):
        self.write_log("Strategy initialised")
        self.load_bar({{warmup_bars}})   # load enough bars to warm up all indicators

    def on_start(self):
        self.write_log("Strategy started")
        self.put_event()

    def on_stop(self):
        self.write_log("Strategy stopped")

    def on_tick(self, tick: TickData):
        self.bg.update_tick(tick)

    def on_bar(self, bar: BarData):
        self.cancel_all()

        am = self.am
        am.update_bar(bar)
        if not am.inited:
            return

        # ── INDICATOR CALCULATIONS ──────────────────────────────────────────
        # translate indicators from signal_engine.py using the mapping table

        # ── SIGNAL LOGIC ───────────────────────────────────────────────────
        # set cross_over / cross_under (or long_signal / short_signal) here

        # ── ORDER EXECUTION ────────────────────────────────────────────────
        if cross_over:
            if self.pos == 0:
                self.buy(bar.close_price, 1)
            elif self.pos < 0:
                self.cover(bar.close_price, 1)
                self.buy(bar.close_price, 1)
        elif cross_under:
            if self.pos == 0:
                self.short(bar.close_price, 1)
            elif self.pos > 0:
                self.sell(bar.close_price, 1)
                self.short(bar.close_price, 1)

        self.put_event()

    def on_order(self, order: OrderData):
        pass

    def on_trade(self, trade: TradeData):
        self.put_event()

    def on_stop_order(self, stop_order: StopOrder):
        pass

Python → ArrayManager Indicator Mapping

ArrayManager is vnpy's built-in vectorised indicator library. Always prefer it over pandas when the equivalent method exists — it is faster and avoids look-ahead bias.

Python (Vibe-Trading / pandas / ta-lib)vnpy ArrayManager
df['close'].rolling(n).mean()am.sma(n)
df['close'].ewm(span=n).mean()am.ema(n)
ta.RSI(close, n)am.rsi(n)
ta.MACD(close, 12, 26, 9)am.macd(12, 26, 9) → (macd, signal, hist)
Bollinger Bandsam.boll(n, dev) → (mid, upper, lower)
ATRam.atr(n)
ADXam.adx(n)
df['close'].rolling(n).std()am.std(n)
Stochastic K, Dam.kd(n, m) → (k, d)
df['high'].rolling(n).max()am.high_array[-n:].max()
df['low'].rolling(n).min()am.low_array[-n:].min()
Donchian channelam.donchian(n) → (upper, lower)
df['close'].shift(1) (previous bar)am.close_array[-2]
Last N bars as arrayam.sma(n, array=True) (returns full array)

Using arrays: pass array=True to get the full history array (e.g. for crossover detection):

python
fast_ma = am.sma(self.fast_window, array=True)
cross_over = fast_ma[-1] > slow_ma[-1] and fast_ma[-2] <= slow_ma[-2]
Show full SKILL.md (318 more words)Show less

Signal → Order Mapping

Vibe-Trading signalPosition checkvnpy call
Long entryself.pos == 0self.buy(price, volume)
Long entry (reverse from short)self.pos < 0self.cover(price, vol); self.buy(price, vol)
Long exitself.pos > 0self.sell(price, volume)
Short entryself.pos == 0self.short(price, volume)
Short entry (reverse from long)self.pos > 0self.sell(price, vol); self.short(price, vol)
Short exitself.pos < 0self.cover(price, volume)
Close all (stop signal)anyself.cancel_all() then sell / cover as needed

Price conventions:

  • For backtesting: use bar.close_price (market order equivalent)
  • For live trading with limit orders: use bar.close_price ± a small offset (e.g. * 1.001)
  • For stop orders: use self.buy_stop(trigger, volume) / self.short_stop(trigger, volume)

Volume conventions:

  • Stocks: volume in shares; must be a multiple of 100 (round lots)
  • Futures: volume in lots (usually 1 for CtaTemplate strategies)
  • Crypto: volume in base-currency units (e.g., BTC)

Multi-Timeframe Strategies

When the Vibe-Trading strategy uses multiple timeframes (e.g., daily signal, hourly entry):

python
def __init__(self, ...):
    super().__init__(...)
    self.bg = BarGenerator(self.on_bar, 5, self.on_5min_bar)   # 5-min bars
    self.bg_d = BarGenerator(self.on_bar, window=1, on_window_bar=self.on_daily_bar,
                              interval=Interval.DAILY)          # daily bars
    self.am = ArrayManager()
    self.am_d = ArrayManager(size=100)                          # daily ArrayManager

def on_bar(self, bar: BarData):
    self.bg.update_bar(bar)    # feeds 5-min generator

def on_5min_bar(self, bar: BarData):
    self.bg_d.update_bar(bar)  # feeds daily generator
    # put intraday entry logic here

def on_daily_bar(self, bar: BarData):
    self.am_d.update_bar(bar)
    # put daily trend-filter logic here

Output File Instructions

Save the generated file to: artifacts/vnpy_strategy/<StrategyName>Strategy.py

To load in vnpy:

  1. Copy the file to your vnpy project's strategies/ folder (or any folder on sys.path)
  2. Open the vnpy Trader → CTA Strategy App
  3. Click Add Strategy → select <StrategyName>Strategy from the dropdown
  4. Set vt_symbol (e.g. IF2406.CFFEX) and adjust parameters
  5. Click Init → Start to begin

To run the vnpy backtester:

python
from vnpy_ctastrategy.backtesting import BacktestingEngine
from vnpy.trader.constant import Interval

engine = BacktestingEngine()
engine.set_parameters(
    vt_symbol="000001.SZSE",
    interval=Interval.DAILY,
    start=datetime(2020, 1, 1),
    end=datetime(2024, 1, 1),
    rate=0.0003,
    slippage=0.02,
    size=1,
    pricetick=0.01,
    capital=1_000_000,
)
engine.add_strategy({{StrategyName}}Strategy, {})
engine.load_data()
engine.run_backtesting()
df = engine.calculate_result()
engine.calculate_statistics()
engine.show_chart()

Quality Checklist

Before saving the output file:

  • Class name ends with Strategy and matches the filename
  • All parameters entries have matching class-level defaults and __init__ instance attributes
  • All variables entries have matching instance attributes initialised in __init__
  • on_bar calls self.cancel_all() at the start
  • on_bar calls self.put_event() at the end
  • on_bar returns early if not am.inited
  • Position direction checked with self.pos before every order call
  • Stocks: no short / cover calls unless margin trading is explicitly requested
  • load_bar(n) warmup in on_init is at least max(all indicator windows) + 2
  • Comment block at top of file notes the original Vibe-Trading run_id and instrument

References

  • vnpy CtaTemplate source: vnpy/app/cta_strategy/template.py
  • ArrayManager source: vnpy/app/cta_strategy/base.py
  • Official docs: https://www.vnpy.com/docs/cn/cta_strategy.html
  • Example strategies (official): vnpy/app/cta_strategy/strategies/

© HKUDS, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (scripts) in agent/src/skills/vnpy-export of HKUDS/Vibe-Trading.

  • SKILL.md
  • scripts/cta_template.py

Open the folder on GitHubat commit 14cabaf

Compare with similar skills

Vibe-Trading to vnpy Exporter next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Vibe-Trading to vnpy Exporter compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Vibe-Trading to vnpy Exporter this skillHKUDS/Vibe-Trading35k—~2.9kAutomated safety check: PassMIT
Tushare Datazillionare/zillionare3192 repos~2.3kAutomated safety check: PassNone
Kalshi Traderyanfrigo/kalshi-ai-trading-bot612—~3.4kAutomated safety check: PassMIT
Polymarket Tennislivetennisapi/livetennisapi-mcp152—~3kAutomated safety check: PassMIT
Quant Backtestjoemccann/market-data-warehouse183—~2.1kAutomated safety check: PassNone
Openscriptmarketcalls/openalgo2.8k—~2.3kAutomated safety check: NotesAGPL-3.0

Similar skills

  • Tushare Data

    zillionare/zillionare

    面向中文自然语言的 Tushare 数据研究技能。用于把“看看这只股票最近怎么样”“帮我查财报趋势”“最近哪个板块最强”“北向资金在买什么”“给我导出一份行情数据”这类请求，转成可执行的数据获取、清洗、对比、筛选、导出与简要分析流程。适用于 A 股、指数、ETF/基金、财务、估值、资金流、公告新闻、板块概念与宏观数据等研究场景。

    319 GitHub starsUsed in 2 repos~2.3k tokens
    Business, Finance & HRAuto-check passed

  • Kalshi Trade

    ryanfrigo/kalshi-ai-trading-bot

    The disciplined process for autonomously and profitably trading the live Kalshi account on each /loop tick, with Claude as the decision-maker.

    612 GitHub stars~3.4k tokensUpdated yesterday
    Business, Finance & HRAuto-check passed

  • Polymarket Tennis

    livetennisapi/livetennisapi-mcp

    Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier.

    152 GitHub stars~3k tokensUpdated yesterday
    Business, Finance & HRAuto-check passed

  • Quant Backtest

    joemccann/market-data-warehouse

    Institutional-grade Python backtesting framework builder for Codex.

    183 GitHub stars~2.1k tokensUpdated 6 mo ago
    Business, Finance & HRAuto-check passed

  • Openscript

    marketcalls/openalgo

    Write an OpenScript study or strategy for OpenAlgo, and install it into strategies/openscript/ only after it compiles.

    2.8k GitHub stars~2.3k tokensUpdated today
    Business, Finance & HRAuto-check: notes

  • Qmt Inner Backtest

    dfkai/xtquantai

    根据策略描述、研报 PDF 或截图，解读因子/选股逻辑，基于 scripts/daily-factors-backtest.py 框架生成 QMT 内置日频因子回测脚本。用户提到 QMT 内置回测、因子选股回测、截面因子、 研报复现、handlebar 回测、afterinit 预计算信号时使用。

    164 GitHub stars~1.8k tokensUpdated 3 mo ago
    Business, Finance & HRAuto-check passed

More from HKUDS/Vibe-Trading

All 89 skills in this repo

  • Eastmoney Market Data

    HKUDS/Vibe-Trading

    Index of Eastmoney's free, no-token market data interfaces for China A-shares and Hong Kong stocks: fund flows, dragon-tiger lists, margin trading, reports and news.

    35k GitHub stars~1k tokensUpdated today
    Auto-check passed

  • OKX Market Data

    HKUDS/Vibe-Trading

    Retrieves public OKX cryptocurrency market data such as spot prices, candlesticks, funding rates and open interest through the OKX V5 REST API, with no authentication.

    35k GitHub stars~1.3k tokensUpdated today
    Auto-check passed

  • SEC EDGAR Filings Fetcher

    HKUDS/Vibe-Trading

    Fetches U.S. SEC EDGAR data: resolves tickers to CIK numbers, lists recent 10-K, 10-Q and 8-K filings with document URLs, and pulls XBRL financial series.

    35k GitHub stars~1.4k tokensUpdated today
    Auto-check passed

  • A-Share ST Risk Screener

    HKUDS/Vibe-Trading

    Predicts whether a mainland China A-share company risks an ST or *ST warning after its next annual report, using financial thresholds and Sina penalty records.

    35k GitHub stars~4.9k tokensUpdated today
    Auto-check passed

  • Supply-Chain Bottleneck Hunter

    HKUDS/Vibe-Trading

    Breaks a structural trend such as AI infrastructure into its physical supply chain and ranks lesser-known listed companies sitting on each bottleneck.

    35k GitHub stars~2.7k tokensUpdated today
    Auto-check passed

  • Eight-Part Company Deep Dive

    HKUDS/Vibe-Trading

    Plans and drafts an eight-part, roughly 120k-word investigative series on one company, built around a strict fact-check pass rather than fast drafting.

    35k GitHub stars~2.4k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Vibe-Trading to vnpy Exporter

What does Vibe-Trading to vnpy Exporter do?

Translates a Vibe-Trading backtest strategy into a runnable vnpy CtaTemplate Python class for A-share stocks, futures or crypto. It reads the backtest run's config for the instrument, dates, parameters and interval, and the signal engine's own logic, then determines the asset class to pick the right symbol convention: an A-share ticker trading in whole lots of shares, a futures contract trading in lots, or a crypto pair trading in coin units, and whether short selling applies, since stocks default to buy and sell only.

When should I use Vibe-Trading to vnpy Exporter?

Vibe-Trading to vnpy Exporter fits situations like: exporting a Vibe-Trading strategy to run in vnpy; converting a backtested signal into a vnpy CtaTemplate class; choosing the right symbol format for stocks, futures or crypto.

How do I install Vibe-Trading to vnpy Exporter in Claude Code?

Run `npx skills add HKUDS/Vibe-Trading --skill vnpy-export -a claude-code`. Or copy the skill folder (agent/src/skills/vnpy-export in HKUDS/Vibe-Trading) into .claude/skills/vnpy-export in your project. Claude Code loads it when a task matches its description.

How do I install Vibe-Trading to vnpy Exporter in Codex?

Run `npx skills add HKUDS/Vibe-Trading --skill vnpy-export -a codex`. Or copy the skill folder (agent/src/skills/vnpy-export in HKUDS/Vibe-Trading) into .agents/skills/vnpy-export in your project. Codex loads it when a task matches its description.

Can I use Vibe-Trading to vnpy Exporter in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add HKUDS/Vibe-Trading --skill vnpy-export -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/vnpy-export, .gemini/skills/vnpy-export, .github/skills/vnpy-export and .opencode/skills/vnpy-export in your project.

What does Vibe-Trading to vnpy Exporter need to run?

Going by SKILL.md and its folder, Vibe-Trading to vnpy Exporter needs Python for the scripts in its folder. Our summary lists: vnpy with the CTA Strategy App; A Vibe-Trading backtest run's config and signal engine.

Does Vibe-Trading to vnpy Exporter access the network?

SKILL.md names 1 domain. As links in the text: vnpy.com. This is read from the text; nothing was executed.

Is Vibe-Trading to vnpy Exporter safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Vibe-Trading to vnpy Exporter use?

Vibe-Trading to vnpy Exporter is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Vibe-Trading to vnpy Exporter use?

About 2.9k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Vibe-Trading to vnpy Exporter?

Skills that share tags, products or a category with Vibe-Trading to vnpy Exporter: Tushare Data (zillionare/zillionare, 319 stars), Kalshi Trade (ryanfrigo/kalshi-ai-trading-bot, 612 stars), Polymarket Tennis (livetennisapi/livetennisapi-mcp, 152 stars) and Quant Backtest (joemccann/market-data-warehouse, 183 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Vibe-Trading to vnpy Exporter?

HKUDS (a GitHub organization) maintains it in HKUDS/Vibe-Trading, which has 34,949 GitHub stars. The repository holds 89 skills in this directory. The repository was last updated on October 8, 2026.

Source: HKUDS/Vibe-Trading on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.