Why is Go better for trading bots?

Go provides sub-millisecond execution latency, true concurrency via goroutines, and a tiny memory footprint — all critical for production trading systems. Unlike Python, there are no GIL bottlenecks, no runtime interpreter overhead, and no surprise GC pauses mid-execution. Go's static typing catches bugs at compile time, and binaries compile to a single self-contained executable. For a system that needs to be on 24/7 and react to market events in microseconds, Go is the right tool.

What's the difference between backtesting and paper trading?

Backtesting replays your strategy against historical market data to measure how it would have performed in the past. Paper trading runs your live strategy against real-time market data with simulated order fills — no real capital at risk. It validates that your bot handles live market conditions before you risk real money. Wisp supports both modes from the same strategy code — just change a single flag.

Can I use Wisp with ChatGPT, Claude, or other AI models?

Yes. Wisp has a first-class agentic interface designed for LLMs. Market state, positions, and portfolio data are exposed as structured context that any LLM can consume. Claude, GPT-4, Gemini, or any model with tool-calling support can analyse conditions and emit trading signals that Wisp executes. You can also run Wisp as an MCP server so AI assistants like Claude Desktop can control your bot directly.

Which exchanges does Wisp support?

Wisp currently supports Hyperliquid, Binance, Polymarket, and Paradex, with more connectors in active development. All exchanges share the same unified connector interface, so strategies are portable across venues with zero code changes.

How do I backtest a trading strategy with Wisp?

Write your strategy using Wisp's Strategy interface, then run: wisp backtest --from 2024-01-01 --to 2024-12-31 --exchange hyperliquid --pair BTC-USD. Wisp replays historical candle data through your strategy, simulates fills at realistic prices, and produces a full performance report: P&L, max drawdown, Sharpe ratio, win rate, and a trade log.

Is Wisp free and open source?

Yes. Wisp is MIT-licensed and completely free — no paid tiers, no subscription fees. The full source is on GitHub. You can use it commercially, fork it, modify it, and self-host it.

How does Wisp compare to Python trading bot frameworks?

Python frameworks like Backtrader or Freqtrade have large communities but trade performance for convenience. Wisp's Go runtime is typically 10–50× faster for strategy execution, uses a fraction of the memory, and handles concurrent streams from multiple exchanges without thread-safety complexity. If you need a low-latency strategy or a single binary deployable anywhere without a Python environment, Wisp is the better choice.

Can Wisp trade multiple exchanges simultaneously?

Yes. Wisp's architecture is built around concurrent exchange connectors — each exchange runs in its own goroutine, feeding a unified event stream. A single strategy instance can receive data from and place orders on multiple exchanges simultaneously, making cross-exchange arbitrage and multi-market signal aggregation straightforward.

v0.0.8-alpha

In Development

THE TRADING
BOT
FRAMEWORK

Open-source Go framework for algorithmic & agentic trading. Backtest, paper trade, then go live - on Hyperliquid, Binance, Polymarket & more.

GET STARTED

01 - RELIABILITY

BUILT IN GO
FOR PRODUCTION

Scroll

Already using AI? Let it help you get started

Ask Claude→Ask ChatGPT→Ask Perplexity→Ask Gemini→

Wisp is a batteries-included trading bot framework written in pure Go. Build algorithmic trading strategies yourself, or let AI agents trade autonomously with Claude, GPT-4, or any LLM. Backtest against historical data, paper trade with zero capital at risk, then deploy live to Hyperliquid, Binance, Polymarket, Paradex, and more - all from a single codebase.

Why Go?

Go delivers sub-millisecond execution, a tiny memory footprint, and rock-solid concurrency - exactly what a production trading bot demands. Unlike Python-based frameworks, Wisp runs 24/7 without GC pauses, unexpected latency spikes, or runtime surprises.

Who It's For

Wisp is built for developers, quant traders, and AI engineers who need a reliable, open-source foundation for automated trading. Whether you're writing deterministic strategies or wiring up an LLM agent, Wisp stays out of your way.

Open Source

Wisp is MIT-licensed and free forever. No vendor lock-in, no closed strategy vaults, no hidden fees. Inspect every line, fork the repo, and run your own instance - full ownership from day one.

SUPPORTED EXCHANGES & MARKETS

HyperliquidPerps & Spot PolymarketPrediction Markets ParadexDerivatives BinanceSpot & Futures More comingOpen an issue

02 - BATTERIES INCLUDED

EVERYTHING
YOU NEED
OUT OF THE BOX

⚡

Multi-exchange

Polymarket, Hyperliquid, Paradex, Binance and more - one connector interface for all of them.

🤖

Agentic interface

First-class support for LLM-driven trading. Expose market state as context, receive signals, execute autonomously.

📈

Backtesting

Replay any strategy against historical data before risking capital. Validate your edge.

📋

Paper trading

Run live with real market data, zero capital at risk. The fastest path from idea to confidence.

🔢

Built-in indicators

RSI, MACD, EMA, Bollinger Bands and more - composable, chainable, and ready to use.

🖥

CLI + TUI

A beautiful terminal interface for monitoring positions, reviewing signals, and controlling your bots.

🔋

Batteries included

Sensible defaults out of the box. No boilerplate, no config sprawl - override only what you need.

🦾

Production-grade Go

Statically typed, sub-millisecond execution, designed to run 24/7 without babysitting.

03 - TWO WAYS TO TRADE

HUMAN
OR
AGENTIC

For traders

Write your strategy

Define your logic in Go using Wisp's composable API. Backtest against historical data, validate with paper trading, then deploy to live markets with a single command.

-Full control over entry and exit logic
-Access to 20+ built-in indicators
-Multi-exchange execution from one strategy
-Real-time monitoring via the TUI

For AI agents

Let an LLM trade

Wisp exposes a structured agentic interface - market state, positions, and available actions - as context any LLM can reason over. The model generates signals; Wisp executes them.

-Works with Claude, GPT-4, Gemini, and any model
-Structured market context fed directly to the model
-Full audit trail of every agent decision
-Human oversight controls - pause, override, stop

04 - INTUITIVE

MADE
FOR
TRADERS
& AGENTS

wisp - terminal

05 - COMPOSABLE

WRITTEN
IN PURE
GO

Build trading bots with simple, chainable functions. Go gives you speed, reliability, and static types - so your bot runs 24/7 without surprises.

View Docs→

func (s *Strategy) GetSignals() ([]*strategy.Signal, error) {
    btc := s.k.Asset("BTC")
    rsi := s.k.Indicators().RSI(btc, 14)
    
    if rsi.LessThan(decimal.NewFromInt(30)) {
        return []*strategy.Signal{
            s.k.Signal(s.GetName()).
                Buy(btc, connector.Binance, 0.1).
                Build(),
        }, nil
    }
    
    return nil, nil
}

05 - COMMON QUESTIONS

THE TRADINGBOTFRAMEWORK

BUILT IN GOFOR PRODUCTION