Windows Framework

Native modular runtime architecture for Windows.

Forsetti provides module discovery, compatibility validation, entitlement-aware activation, and structured UI extensibility — built entirely on C++20, WinUI 3, and the Windows SDK for native Windows integration.

Read the Docs View on GitHub 
#include <ForsettiCore/ForsettiRuntime.h>

auto runtime = std::make_unique<Forsetti::ForsettiRuntime>(
    std::move(moduleManager),
    entitlementProvider,
    eventBus,
    "./manifests"
);

runtime->boot();
Overview

What Forsetti Is

A sealed, contract-first modular runtime that enforces architecture boundaries at every layer. Modules declare capabilities through contracts, undergo compatibility validation before activation, and contribute UI through structured extension points — all within a native Windows runtime environment.

Contract-First

Every module declares its capabilities and requirements through explicit contracts. No implicit coupling, no hidden dependencies.

Boundary-First

Strict architecture boundaries are enforced at compile time and runtime. Modules cannot reach across boundaries without going through defined extension points.

Policy-First

Entitlement-aware activation ensures modules are only loaded when their policy requirements are met. Fine-grained control over what runs, when, and where.

Capabilities

Core Runtime Capabilities

Module Discovery

Automatic discovery and registration of modules at runtime. The framework scans, identifies, and catalogs available modules without manual configuration.

Compatibility Validation

Modules are validated against host requirements, platform constraints, and dependency contracts before activation. Incompatible modules are rejected cleanly.

Entitlement-Aware Unlocking

Activation is gated by entitlements. Modules declare required entitlements and the runtime enforces access policies before granting activation.

Activation Orchestration

Coordinated module activation with dependency ordering, lifecycle management, and graceful error handling. Modules activate in the correct sequence every time.

UI Contribution Model

Modules contribute WinUI 3 views through structured extension points. The host application defines contribution slots, and modules fill them according to contracts.

Native Host Integration

Deep integration with the host application through native C++20 APIs. No bridging layers, no serialization overhead — pure C++20 and WinUI 3 throughout.

Philosophy

Why Forsetti Exists

Most modular architectures are loose conventions bolted onto existing frameworks. Forsetti is a purpose-built runtime that enforces modularity as a first-class concern.

Without Forsetti

  • Module boundaries enforced by convention only
  • Compatibility issues discovered at runtime crashes
  • Feature gating through ad-hoc boolean flags
  • UI composition through fragile view hierarchies
  • Manual dependency wiring and initialization order
  • Third-party abstractions over native platform APIs

With Forsetti

  • Strict architecture boundaries enforced by the runtime
  • Compatibility validation before any module activates
  • Entitlement-aware activation with policy enforcement
  • Structured UI contribution through defined extension points
  • Automatic discovery and orchestrated activation
  • Native C++20 and WinUI 3 throughout — no cross-platform abstraction layers
Deployment

Deployment Patterns

01

Single-Module App

A single module packaged with the Forsetti runtime as a standalone application. Ideal for focused tools and utilities that benefit from the runtime lifecycle.

02

Multi-Module Application

Multiple modules composed into a single host application. Each module is discovered, validated, and activated independently within the shared runtime.

03

Developer Testing

Isolated module testing with mock entitlements and simulated host environments. Develop and validate modules independently before integration.

04

Dashboard Deployment

A dashboard-style host that dynamically loads and presents multiple module UI contributions. Users interact with a unified surface backed by independent modules.

Audience

Built For

Windows Platform Engineers

Windows developers who build with C++20, WinUI 3, and Visual Studio — and want modular architecture without leaving the native ecosystem.

Architecture-Focused Teams

Teams that value clean boundaries, contract enforcement, and disciplined module composition over rapid prototyping with loose conventions.

Product-Led Applications

Applications that need runtime module management — feature gating, entitlement-based unlocking, and structured UI contribution from independent components.

Documentation

Comprehensive guides covering module contracts, lifecycle management, UI contribution patterns, and host integration.

Read the Docs

Open Source

Explore the source, review the architecture, and contribute to the framework on GitHub.

View on GitHub

Build modular Windows applications with discipline.

Forsetti gives you the runtime foundation to compose, validate, and activate modules with confidence — on Windows.

Get Started Learn More