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.

Algorithmic Trading on Polymarket in Go

Wisp is the only Go framework with native Polymarket support. Build prediction market trading bots in minutes. Trade election outcomes, sports events, geopolitical scenarios—all with sub-millisecond execution and a unified API. No other language has this.

Start Building Learn Polymarket Basics

Why Polymarket Matters

What is Polymarket?

Polymarket is a decentralized prediction market platform where traders buy and sell binary YES/NO contracts on real-world events. Markets cover:

• Election outcomes
• Sports game results
• Geopolitical developments
• Tech industry milestones
• Economic indicators

Contracts are priced between $0–$1 based on the implied probability of the event occurring. If you buy YES at $0.45 and the event happens, you collect $1.

Why Trade Prediction Markets?

Orthogonal to crypto: Prediction market prices aren't correlated with BTC/ETH
Information-driven: Market sentiment shifts before major events
Lower leverage risk: Binary outcomes mean no liquidation surprises
Diverse alpha: Arbitrage vs traditional prediction markets, market-making, event signals

Why Wisp for Polymarket

Native Connector (Not API Wrapper)

Most trading bots treat Polymarket as a simple REST API. Wisp treats it as a first-class market type—alongside spot and perpetual futures—with the same event-driven architecture.

// Same pattern as any other market type
strategy.On(polymarket.OrderbookUpdate, func(market Market) {
    if isPriceArbitrageOpportunity(market) {
        strategy.PlaceOrder(market.Yes, quantity)
    }
})

Unified API Across All Market Types

Trade Polymarket AND Binance simultaneously without context switching:

// One strategy, multiple markets
strategy.On(binance.Price.Update, handleSpotSignal)
strategy.On(polymarket.Orderbook.Update, handlePredictionSignal)
strategy.On(deribit.Greeks.Update, handleOptionsHedge)

Sub-Millisecond Execution

Go's concurrency model means you process market data and place orders in parallel without thread-safety overhead. Binary outcomes mean no slippage surprises mid-execution.

Deterministic Backtesting

Test your prediction market strategies against historical resolution data with the exact same code path as live trading.

Zero Python Overhead

Deploy as a single binary. No runtime dependencies, no GIL bottleneck, no waiting for Python startup.

How It Works

1. Connect to Polymarket

pm := connectors.NewPolymarketConnector(config)
orderbook := pm.GetOrderbook("Will Biden win 2024?")

2. Monitor Prices & Liquidity

pm.On(polymarket.OrderbookUpdate, func(event OrderbookEvent) {
    bid := event.Orderbook.BestBid  // Highest price someone will pay for YES
    ask := event.Orderbook.BestAsk  // Lowest price someone will sell YES at
    spread := ask - bid
})

3. Place Orders

pm.PlaceOrder(polymarket.Order{
    Market: "Will the Fed raise rates in 2024?",
    Side:   polymarket.Buy,
    Price:  0.65,  // Buy YES at $0.65
    Size:   100,
})

4. Track & Settle

pm.On(polymarket.MarketResolution, func(resolution *polymarket.Resolution) {
    if resolution.Outcome == YES {
        pnl := holdingSize * (1.00 - entryPrice)
    }
})

Real Use Cases

Market-Making

Provide two-way liquidity on low-volume markets, capture the spread. Wisp's event-driven loop handles rapid order updates without blocking.

Arbitrage

Monitor price divergence between Polymarket and other prediction platforms (e.g., Manifold Markets, Kalshi). Execute hedges instantly.

Event Signals

Use prediction market prices as a leading indicator. When a market reprices sharply (e.g., Fed decision expectations), trigger hedges in spot or perpetual.

Portfolio Hedging

If your primary trading strategy is exposed to geopolitical risk, hedge with Polymarket contracts. Uncorrelated to crypto prices.

Comparison: Wisp vs Alternatives

	Wisp (Go)	Hummingbot	Manual Trading
Polymarket Support	✓ Native	✗ No	Manual
Execution Speed	Sub-millisecond	100–500ms	N/A
Setup Time	5 minutes	1–2 hours	N/A
Deployment	Single binary	Docker + Python	N/A
Cost	Free (MIT)	Free	High fees

FAQ

Is Polymarket legal?

Yes, but it's restricted in the US to a whitelist of approved states. Check your jurisdiction before trading.

Can I trade Polymarket 24/7?

Markets close after resolution (usually within a day of the event). New markets open continuously, so there's always something to trade.

How much can I profit?

Returns depend on your edge. Binary outcomes eliminate liquidation risk but cap upside at 100% profit per trade.

Do I need capital on multiple exchanges?

Only if you want to arbitrage across markets. For directional trading, you just need USDC on Polygon.

Can I backtest Polymarket strategies?

Yes. Wisp supports deterministic backtesting against historical resolution data, using the exact same code path as live trading.

Ready to Build?

5-Minute Tutorial Explore All Features