👁 Image
Backtest.Net 4.2.2

High-Performance Backtest.Net

👁 NuGet
👁 NuGet Downloads
👁 Build Status
👁 .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 for guidelines.

License

This project is licensed under the .

Acknowledgments

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

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