Backtest.Net 4.2.2

High-Performance Backtest.Net

A high-performance backtesting engine for algorithmic trading strategies in .NET.

Introduction

High-Performance Backtest.Net is a specialized backtesting library designed for quantitative trading applications. It processes multi-timeframe candlestick data across multiple symbols, simulating tick-by-tick strategy execution with proper warmup periods and OHLC handling.

Key Characteristics

• Multi-Symbol Support: Process multiple trading symbols in parallel
• Multi-Timeframe: Handle multiple timeframes per symbol with automatic synchronization
• Performance Optimized: 11 iteratively optimized engine versions, including an opt-in reusable-buffer engine for allocation-sensitive workloads
• Data Splitting: Intelligent data partitioning for memory-efficient large-scale backtests
• Cancellation Support: Graceful async cancellation with progress tracking

Features

Performance Optimizations

The library implements focused performance techniques:

• Allocation-Aware Hot Paths: EngineV11 reuses feed buffers instead of cloning the strategy feed graph on every tick
• Span-Based Iteration: Uses Span<T> and CollectionsMarshal.AsSpan in tight loops where it is safe
• Parallel Processing: EngineV9 and EngineV10 use Parallel.ForEach for symbol-level work
• Binary Search: O(log n) candlestick lookups
• Aggressive Inlining: [MethodImpl(MethodImplOptions.AggressiveInlining)]
• Sealed Classes: JIT optimization hints

Installation

Package Manager

dotnet add package Backtest.Net

PackageReference

<PackageReference Include="Backtest.Net" Version="4.2.0" />

Quickstart

Basic Engine Usage

using Backtest.Net.Engines;
using Backtest.Net.SymbolsData;
using Backtest.Net.SymbolDataSplitters;
using Backtest.Net.Timeframes;
using Backtest.Net.Enums;

// 1. Prepare your symbol data (candlesticks per timeframe)
// Candlestick properties: OpenTime, Open, High, Low, Close, CloseTime, Volume
var symbolsData = new List<SymbolDataV2>
{
    new SymbolDataV2
    {
        Symbol = "BTCUSDT",
        Timeframes = new List<TimeframeV2>
        {
            new TimeframeV2
            {
                Timeframe = CandlestickInterval.M1,
                Candlesticks = yourOneMinuteCandles
            },
            new TimeframeV2
            {
                Timeframe = CandlestickInterval.H1,
                Candlesticks = yourOneHourCandles
            }
        }
    }
};

// 2. Split data for efficient processing
var splitter = new SymbolDataSplitterV2(
    daysPerSplit: 30,
    warmupCandlesCount: 100,
    backtestingStartDateTime: new DateTime(2024, 1, 1)
);

var splitData = await splitter.SplitAsyncV2(symbolsData);

// 3. Create and configure the engine
var engine = new EngineV10(
    warmupCandlesCount: 100,
    sortCandlesInDescOrder: false,
    useFullCandleForCurrent: false
);

// 4. Set up your strategy callback
engine.OnTick = async (symbolData) =>
{
    foreach (var symbol in symbolData)
    {
        var latestCandle = symbol.Timeframes[0].Candlesticks[^1];
        // Your strategy logic here
        Console.WriteLine($"{symbol.Symbol}: Close = {latestCandle.Close}");
    }
};

// 5. Run the backtest
await engine.RunAsync(splitData);

Console.WriteLine($"Progress: {engine.GetProgress()}%");

With Cancellation Support

using var cts = new CancellationTokenSource();

engine.OnCancellationFinishedDelegate = () =>
{
    Console.WriteLine("Backtest cancelled gracefully");
};

// Cancel after 30 seconds
cts.CancelAfter(TimeSpan.FromSeconds(30));

await engine.RunAsync(splitData, cts.Token);

Engine Versions

Integration with History-Vault.Net

This library works seamlessly with History-Vault.Net - a high-performance historical market data storage solution. Both libraries use identical data structures (SymbolDataV2, TimeframeV2, CandlestickV2) with the same properties, differing only in namespaces:

Converting Between Types

The easiest way to convert between the two libraries' types is using JSON serialization:

using System.Text.Json;
using Backtest.Net.SymbolsData;

// Convert from History-Vault.Net to Backtest.Net
public static List<SymbolDataV2> ConvertFromHistoryVault(List<HistoryVault.Models.SymbolDataV2> historyVaultData)
{
    var json = JsonSerializer.Serialize(historyVaultData);
    return JsonSerializer.Deserialize<List<SymbolDataV2>>(json)!;
}

// Convert from Backtest.Net to History-Vault.Net
public static List<HistoryVault.Models.SymbolDataV2> ConvertToHistoryVault(List<SymbolDataV2> backtestData)
{
    var json = JsonSerializer.Serialize(backtestData);
    return JsonSerializer.Deserialize<List<HistoryVault.Models.SymbolDataV2>>(json)!;
}

Complete Workflow Example

using Backtest.Net.Engines;
using Backtest.Net.SymbolsData;
using Backtest.Net.SymbolDataSplitters;
using System.Text.Json;
using HistoryVault;
using HistoryVault.Configuration;
using HistoryVault.Models;
using HistoryVault.Storage;

// Configure the vault (paths are auto-detected based on OS and scope)
var options = new HistoryVaultOptions
{
    DefaultScope = StorageScope.Local
};

await using var vault = new HistoryVaultStorage(options);

// Save candlestick data
var symbolData = new SymbolDataV2
{
    Symbol = "BTCUSDT",
    Timeframes = new List<TimeframeV2>
    {
        new TimeframeV2
        {
            Timeframe = CandlestickInterval.M1,
            Candlesticks = candlesticks // Your candlestick list
        }
    }
};

// Load candlestick data
var loadOptions = LoadOptions.ForSymbol(
    "BTCUSDT",
    new DateTime(2025, 1, 1),
    new DateTime(2025, 1, 31),
    CandlestickInterval.M1
);

var historyData = await vault.LoadAsync(loadOptions);

// 2. Convert to Backtest.Net types via JSON
var json = JsonSerializer.Serialize(historyData);
var backtestData = JsonSerializer.Deserialize<List<SymbolDataV2>>(json)!;

// 3. Run backtest
var splitter = new SymbolDataSplitterV2(daysPerSplit: 30, warmupCandlesCount: 100);
var splitData = await splitter.SplitAsyncV2(backtestData);

var engine = new EngineV10(warmupCandlesCount: 100);
engine.OnTick = async (symbolData) =>
{
    // Your strategy logic
};

await engine.RunAsync(splitData);

Benchmarks

Performance benchmarks run on Apple M3 Max with .NET 10.0, processing 4 million candlesticks (1 symbol × 4 timeframes × 1,000,000 candles each):

Key findings:

• The benchmark resets mutated timeframe indexes before each engine run.
• EngineV11 is designed to avoid per-tick feed graph allocations after setup; the measured allocation reflects remaining setup/runtime overhead, not the old per-tick clone path.
• Choose EngineV10 for broad compatibility and EngineV11 for allocation-sensitive strategies that follow the borrowed-snapshot callback contract.

Benchmarks run with BenchmarkDotNet v0.15.8 on macOS Tahoe 26.2, Apple M3 Max, .NET 10.0

Development

Prerequisites

• .NET 10.0 SDK or later
• Git

Build

git clone https://github.com/islero/High-Performance-Backtest.Net.git
cd High-Performance-Backtest.Net
dotnet build

Test

dotnet test

Benchmark

cd benchmarks/Backtest.Net.Benchmarks
dotnet run -c Release

Format

dotnet format

Versioning & Releases

This project follows Semantic Versioning.

Release Process

1. Update version in src/Backtest.Net/Backtest.Net.csproj
2. Create GitHub Release with tag vX.Y.Z
3. CI automatically publishes to NuGet

Contributing

Contributions are welcome! Please read CONTRIBUTING.md for guidelines.

License

This project is licensed under the GNU Lesser General Public License v3.0.

Acknowledgments

• SimdLinq - SIMD-accelerated LINQ operations
• BenchmarkDotNet - Performance benchmarking

<p align="center"> Built for the algorithmic trading community </p>