QuantFolio

Multi-Asset Portfolio Manager - Optimize investment portfolios using quantitative strategies with a desktop GUI

---

Overview

QuantFolio is a C# desktop application for constructing, optimizing, and backtesting multi-asset investment portfolios. It implements modern portfolio theory with three quantitative strategies:

• Low Risk - Minimum variance optimization
• Low Turnover - Cost-efficient rebalancing
• High Yield Equity - Dividend-focused allocation

Built with .NET 8.0 and WPF, QuantFolio provides a GUI for portfolio managers, financial analysts, and quantitative researchers to test investment strategies using historical market data.

---

Features

Core Functionality

• Portfolio Management - Create and manage multiple investment portfolios
• Market Data Integration - Fetch historical OHLCV data from Alpha Vantage & Financial Modeling Prep (with automatic failover)
• Strategy Implementation - Three tested quantitative strategies
• Portfolio Optimization - Mathematical optimization using Math.NET Numerics
• Backtesting Engine - Walk-forward analysis with performance metrics
• Performance Analytics - Sharpe ratio, volatility, drawdown, returns
• Interactive Charts - Performance visualization with LiveCharts2
• SQLite Database - Persistent storage with Entity Framework Core
• WPF GUI - MVVM architecture with CommunityToolkit.Mvvm
• CLI Interface - Terminal-based portfolio management with Spectre.Console

Technical Features

• 214 Unit Tests - 100% passing with comprehensive coverage
• Repository Pattern - Clean data access layer
• Dependency Injection - Microsoft.Extensions.DependencyInjection
• Async/Await - Non-blocking operations throughout
• Nullable Reference Types - Null safety
• Configuration Management - Flexible appsettings.json support

Investment Strategies

Low Risk Strategy

• Objective: Minimize portfolio variance
• Method: Quadratic programming (minimum variance optimization)
• Use Case: Conservative investors, capital preservation
• Optimization: Uses covariance matrix of returns

Low Turnover Strategy

• Objective: Minimize transaction costs
• Method: Constrained optimization with turnover penalty
• Use Case: Long-term investors, tax efficiency
• Optimization: Balances return vs. trading costs

High Yield Equity Strategy

• Objective: Maximize dividend income
• Method: Dividend yield weighting with volatility constraints
• Use Case: Income-focused investors, retirees
• Optimization: Dividend-weighted allocation

---

Project Structure

quantfolio/
│
├── src/                                # Core application logic
│   ├── core/                           # Domain layer
│   │   ├── models/                     # Financial entities (Portfolio, Product, Deal, etc.)
│   │   ├── interfaces/                 # Repository & service contracts
│   │   └── services/                   # Business logic (StrategyFactory, RiskMetrics)
│   │
│   ├── data/                           # Data management layer
│   │   ├── PortfolioDbContext.cs       # EF Core database context
│   │   ├── repositories/               # Repository implementations
│   │   ├── DataCollector.cs            # Market data fetching
│   │   ├── DataCleaner.cs              # Data preprocessing
│   │   └── DatabaseManager.cs          # Database operations
│   │
│   ├── strategy/                       # Portfolio optimization
│   │   ├── PortfolioOptimizer.cs       # Main optimizer service
│   │   ├── LowRiskStrategy.cs          # Minimum variance strategy
│   │   ├── LowTurnoverStrategy.cs      # Cost-efficient strategy
│   │   └── HighYieldStrategy.cs        # Dividend-focused strategy
│   │
│   ├── backtesting/                    # Backtesting engine
│   │   ├── Backtester.cs               # Main backtesting engine
│   │   ├── WalkForwardAnalysis.cs      # Walk-forward validation
│   │   └── MetricsCalculator.cs        # Performance calculations
│   │
│   ├── visualization/                  # Charts & reporting
│   │   ├── ChartGenerator.cs           # Chart creation
│   │   ├── RiskReturnPlot.cs           # Risk/return visualization
│   │   └── PortfolioComparisonView.cs  # Portfolio comparisons
│   │
│   └── utils/                          # Utilities
│       ├── ConfigManager.cs            # Configuration management
│       ├── Logger.cs                   # Logging service
│       └── Extensions.cs               # Helper extensions
│
├── gui/                                # WPF Desktop Application
│   ├── Views/                          # XAML views
│   │   ├── PortfolioCreationView.xaml  # Portfolio management UI
│   │   ├── DataFetchingView.xaml       # Data fetching UI
│   │   └── OptimizationView.xaml       # Optimization UI
│   ├── ViewModels/                     # MVVM ViewModels
│   │   ├── MainViewModel.cs            # Main navigation
│   │   ├── PortfolioCreationViewModel.cs
│   │   ├── DataFetchingViewModel.cs
│   │   └── OptimizationViewModel.cs
│   ├── Converters/                     # Value converters
│   ├── MainWindow.xaml                 # Main application window
│   └── App.xaml.cs                     # Application entry & DI setup
│
├── tests/                              # Unit & integration tests
│   ├── core/                           # Domain logic tests
│   ├── data/                           # Repository tests
│   ├── strategies/                     # Strategy tests
│   ├── backtesting/                    # Backtesting tests
│   ├── utils/                          # Utility tests
│   └── visualization/                  # Visualization tests
│
├── docs/                               # Documentation
│   ├── database_schema.md              # Complete DB schema
│   ├── database_implementation.md      # Implementation guide
│   └── ConfigManager_Implementation.md # Config system docs
│
├── outputs/                            # Runtime files (gitignored)
│   ├── database/                       # SQLite database
│   └── reports/                        # Generated reports
│
└── scripts/                            # Automation scripts
    ├── setup-database.ps1              # Database initialization
    ├── run-tests.ps1                   # Test execution
    └── build-and-test.ps1              # Complete build pipeline

---

Getting Started

Prerequisites

• .NET 8.0 SDK or later (Download)
• Windows 10/11 (for WPF GUI)
• Git (for cloning repository)
• Visual Studio 2022 or VS Code (recommended IDEs)

Installation

1. Clone the Repository

git clone https://github.com/Alter-404/quantfolio.git
cd quantfolio

2. Restore Dependencies

dotnet restore src/QuantFolio.Core.csproj
dotnet restore src/QuantFolio.Data.csproj
dotnet restore gui/QuantFolio.GUI.csproj
dotnet restore tests/QuantFolio.Tests.csproj

3. Build the Solution

# Build all projects
dotnet build src/QuantFolio.Core.csproj
dotnet build src/QuantFolio.Data.csproj
dotnet build gui/QuantFolio.GUI.csproj

4. Initialize Database

.\setup-database.ps1

This will:

• Create the SQLite database
• Run migrations
• Seed initial data (products, clients, managers)

5. Configure Market Data APIs

QuantFolio uses Alpha Vantage (primary) and Financial Modeling Prep (backup) for fetching historical market data.

Get Free API Keys

1. Alpha Vantage (Get Key)

   • Free tier: 25 requests/day
   • Sign up at alphavantage.co

2. Financial Modeling Prep (Get Key)

   • Free tier: 250 requests/day
   • Sign up at financialmodelingprep.com

Update Configuration

Edit appsettings.json in the project root:

{
  "MarketDataApi": {
    "AlphaVantage": {
      "ApiKey": "YOUR_ALPHA_VANTAGE_KEY_HERE",
      "BaseUrl": "https://www.alphavantage.co/query"
    },
    "FinancialModelingPrep": {
      "ApiKey": "YOUR_FMP_KEY_HERE",
      "BaseUrl": "https://financialmodelingprep.com/api/v3"
    }
  }
}

Note: The application automatically fails over to FMP if Alpha Vantage rate limits are reached.

6. Run the Application

# GUI Application
dotnet run --project gui/QuantFolio.GUI.csproj

# CLI Application
dotnet run --project cli/QuantFolio.CLI.csproj

Or open in Visual Studio and press F5.

---

Testing

Run All Tests

# Quick test run
.\run-tests.ps1

# With detailed output
.\run-tests.ps1 -Verbose

# Specific test class
dotnet test --filter PortfolioOptimizerTests

Test Coverage

Current test statistics:

• Total Tests: 214
• Passing: 214
• Skipped: 0
• Failed: 0

Test categories:

• Core Tests: Domain logic, services, risk metrics, strategy factory
• Data Tests: Repository CRUD, database operations, data collection & cleaning
• Strategy Tests: Portfolio optimizer, Low Risk, Low Turnover, High Yield strategies
• Backtesting Tests: Backtester, walk-forward analysis, metrics calculator
• Visualization Tests: Chart generation, risk-return plots, portfolio comparisons
• Utils Tests: Extensions, logger, configuration manager

---

Usage Guide

Creating a Portfolio

using QuantFolio.Core.Models;
using QuantFolio.Data.Repositories;

// Create repository
var portfolioRepo = new PortfolioRepository(dbContext);

// Create new portfolio
var portfolio = new Portfolio
{
    ClientId = 1,
    ManagerId = 1,
    Name = "Growth Portfolio",
    Strategy = "High Yield Equity",
    AssetUniverse = "US Equities",
    InitialCapital = 100000m,
    CreationDate = DateTime.Now
};

await portfolioRepo.CreateAsync(portfolio);

Optimizing a Portfolio

using QuantFolio.Strategy;

// Create optimizer
var optimizer = new PortfolioOptimizer(marketDataRepo, productRepo);

// Run optimization
var result = await optimizer.OptimizePortfolioAsync(
    strategyName: "Low Risk",
    assetUniverse: "US Equities",
    trainingStart: new DateTime(2022, 1, 1),
    trainingEnd: new DateTime(2023, 1, 1),
    testingStart: new DateTime(2023, 1, 1),
    testingEnd: new DateTime(2024, 1, 1),
    initialCapital: 100000m
);

// Access results
Console.WriteLine($"Final Value: ${result.FinalValue:N2}");
Console.WriteLine($"Total Return: {result.TotalReturn:F2}%");
Console.WriteLine($"Sharpe Ratio: {result.SharpeRatio:F2}");
Console.WriteLine($"Max Drawdown: {result.MaxDrawdown:F2}%");

Using the GUI

1. Portfolio Creation Tab:

   • Enter portfolio details (name, client, manager)
   • Select investment strategy
   • Choose asset universe
   • Set initial capital
   • Click "Create Portfolio"

2. Data Fetching Tab:

   • Select product (stock ticker)
   • Choose data source
   • Set date range
   • Click "Fetch Data"

3. Optimization Tab:

   • Select portfolio
   • Set training period
   • Set testing period
   • Click "Optimize"
   • View performance chart and metrics

Tech Stack

Core Framework

• .NET 8.0 - Latest C# application framework
• C# 12 - With nullable reference types enabled
• Entity Framework Core 8.0.1 - ORM with SQLite provider
• Microsoft.Extensions.DependencyInjection 8.0.1 - DI container

Data & Optimization

• Math.NET Numerics 5.0.0 - Matrix operations, optimization algorithms
• MathNet.Numerics.Providers.MKL 3.1.0 - Intel MKL for performance
• (Planned) Accord.NET - Machine learning (future enhancement)
• (Planned) ML.NET - Microsoft's ML framework (future enhancement)

Database

• SQLite 3.x - Lightweight, embedded database
• Microsoft.EntityFrameworkCore.Sqlite 8.0.1 - SQLite provider
• Microsoft.EntityFrameworkCore.Design 8.0.1 - Migrations tooling

GUI (WPF)

• Windows Presentation Foundation (WPF) - Modern desktop UI
• CommunityToolkit.Mvvm 8.2.2 - MVVM framework (ObservableObject, RelayCommand)
• LiveChartsCore.SkiaSharpView.WPF 2.0.0-rc3.3 - Interactive charting
• Microsoft.Extensions.Hosting 8.0.1 - Application hosting for DI

Data Providers

• Alpha Vantage API - Stock market data (primary source)
• Yahoo Finance - Historical market data (secondary source)
• (Planned) Binance.Net - Cryptocurrency data (future enhancement)

Testing & Quality

• xUnit 2.5.4 - Unit testing framework
• xUnit.runner.visualstudio 2.5.4 - Visual Studio test runner
• Moq 4.20.69 - Mocking framework for dependencies
• Microsoft.NET.Test.Sdk 17.7.2 - Test SDK
• 218 Tests - Test coverage

---

Documentation

User Manuals

• CLI User Manual - Command-line interface guide
• GUI User Manual - Desktop application guide
• Technical Guide - Architecture and implementation details

Core Documentation

• Database Schema - Complete database design and relationships

---

Architecture

MVVM Pattern (GUI)

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│    View     │────▶│  ViewModel  │────▶│    Model    │
│    (XAML)   │◀────│  (Commands) │◀────│ (Services)  │
└─────────────┘     └─────────────┘     └─────────────┘

Layer Architecture

┌──────────────────────────────────────┐
│         Presentation Layer           │
│      (WPF Views + ViewModels)        │
└──────────────────────────────────────┘
                  ↓
┌──────────────────────────────────────┐
│          Business Layer              │
│  (PortfolioOptimizer, Strategies,    │
│   Backtester, RiskMetrics)           │
└──────────────────────────────────────┘
                  ↓
┌──────────────────────────────────────┐
│           Data Layer                 │
│  (Repositories, DbContext,           │
│   DataCollector, DataCleaner)        │
└──────────────────────────────────────┘
                  ↓
┌──────────────────────────────────────┐
│        Database (SQLite)             │
│  (Products, Portfolios, MarketData)  │
└──────────────────────────────────────┘

Design Patterns Used

• Repository Pattern - Data access abstraction
• Strategy Pattern - Investment strategy implementations
• Factory Pattern - Strategy creation (StrategyFactory)
• MVVM Pattern - View-ViewModel separation
• Dependency Injection - Loose coupling throughout

---

Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Development Guidelines

• Write unit tests for new features (aim for >80% coverage)
• Follow existing code style and conventions
• Update documentation for significant changes
• Ensure all tests pass before submitting PR

---

Contact

Mariano BENJAMIN Marius CALAQUE Noah CHIKHI

Project Link: https://github.com/Alter-404/quantfolio

---

License

This project is released under the MIT License. See LICENSE file for details.

---

Acknowledgments

• Math.NET - Numerical computing library
• LiveCharts2 - Beautiful charting library
• CommunityToolkit.Mvvm - Excellent MVVM framework
• Entity Framework Core - Robust ORM framework
• xUnit - Reliable testing framework
• Alpha Vantage & FMP - Market data providers

---

Statistics

• 214 Tests - 100% passing
• 6 Projects - Core, Data, GUI, CLI, Tests
• 50+ Classes - Well-structured codebase
• 3 Strategies - Production-ready implementations
• MVVM Architecture - Clean separation of concerns
• Entity Framework Core - Modern data access

---