ModernOverlay.NET.Integration 1.0.1

ModernOverlay.NET

<img width="900" height="600" alt="Showcase for ModernOverlay.NET" src="https://github.com/user-attachments/assets/205eb23b-d964-4876-9567-0b1112eef35d" />

ModernOverlay is a Windows-only overlay library for modern .NET. It replaces the useful parts of the GameOverlay.NET library stack with a new Vortice + Direct2D/DirectWrite/WIC + Win32 implementation.

This package is not a drop-in GameOverlay.NET replacement, but feature-wise is heavily inspired by the library from Michel. The API intentionally uses new names, explicit lifetimes, safer target tracking, and first-class diagnostics.

Preview Status

This repository currently targets net11.0-windows on a .NET 11 preview SDK. APIs, package layout, backend registration, and packaging metadata may change before .NET 11 GA.

Package-facing caveats for the MVP/alpha release:

1. The common ModernOverlay package bundles the Direct2D backend assembly for the preview one-package path. ModernOverlay.Direct2D is still also emitted as a separate backend package.
2. ModernOverlay.Integration.Experimental is source-only for alpha and should not be published until there is a real authorized experimental provider.
3. TransparencyMode.UpdateLayeredWindow and TransparencyMode.DirectComposition are request modes that currently fall back to the DWM/color-key Direct2D HWND path with diagnostics. True CPU-copy layered alpha and DirectComposition/DXGI per-pixel alpha remain future backend work.
4. The release bar is a hobbyist project aiming to be useful, buildable, sample-backed, and caveated.

Quick Start

Reference the ModernOverlay package. The preview package includes the Direct2D backend assembly for the common path, and the core facade auto-discovers ModernOverlay.Direct2D when the assembly is present.

Minimal project reference:

<PackageReference Include="ModernOverlay.NET" Version="1.0.0" />

Minimal overlay:

using ModernOverlay;
using ModernOverlay.Drawing;
using ModernOverlay.Windows;

await using OverlayWindow overlay = await OverlayWindow.CreateAsync(new OverlayWindowOptions
{
    Bounds = WindowBounds.FromPixels(100, 100, 640, 360),
    InputMode = OverlayInputMode.ClickThrough,
    ZOrder = OverlayZOrder.TopMost,
    FrameRateLimit = FrameRateLimit.Fixed(60),
});

using SolidBrushHandle white = overlay.Resources.CreateSolidBrush(ColorRgba.White);
using FontHandle font = overlay.Resources.CreateFont(new FontOptions("Segoe UI", 18));

overlay.Render += frame =>
{
    frame.Clear(ColorRgba.Transparent);
    frame.Draw.Text("Hello overlay", font, white, new PointF(24, 24));
};

await overlay.RunAsync();

Drawing coordinates are DIPs. WindowBounds represents physical pixels unless constructed through the DIP helpers.

Read more: quick start, A/B development testing, installation, DPI and multi-monitor.

Features

Performance Snapshot

The current local baseline was captured on Windows 10 IoT Enterprise LTSC 10.0.19044, AMD Ryzen 9 9950X3D, NVIDIA RTX 3080, .NET SDK 11.0.100-preview.4.26230.115, and BenchmarkDotNet 0.15.8 with the in-process emit toolchain. Treat these as same-machine comparison numbers, not cross-hardware guarantees.

Read more: performance guide, local baseline, benchmarks index.

License

ModernOverlay is licensed under the MIT License.

Minimal Examples

Track an existing window by title:

var target = WindowTarget.ByTitle("Notepad")
    .WithBoundsMode(TargetBoundsMode.ClientArea);

await using OverlayWindow overlay = await OverlayWindow.CreateAsync(new OverlayWindowOptions
{
    Target = target,
    ZOrder = OverlayZOrder.FollowTarget,
    InputMode = OverlayInputMode.ClickThrough,
});

Draw common overlay markers:

overlay.Render += frame =>
{
    frame.Clear(ColorRgba.Transparent);
    frame.Draw.CornerBox(new RectF(40, 40, 160, 90), white, cornerLength: 18, strokeWidth: 2);
    frame.Draw.Crosshair(new PointF(320, 180), size: 14, white, strokeWidth: 2);
};

Use cooperative IPC from an owned process:

var client = new NamedPipeOverlayCommandClient("modern-overlay-demo", commandToken: "local-token");
await client.SendAsync(OverlayCommandMessage.Update(
[
    OverlayDrawCommand.Clear(ColorRgba.Transparent),
    OverlayDrawCommand.TextRun("owned host", new PointF(24, 24), ColorRgba.White),
]));

Read more: target tracking, drawing primitives, integration boundary.

Samples

Read more: samples index.

Quick launcher:

tools\Start-ModernOverlaySample.ps1 Basic
tools\Start-ModernOverlaySample.ps1 -List
tools\New-ModernOverlayPlayground.ps1 -From Basic -Name Basic-A

Documentation

Read more: docs index.

1. Start here: quick start, A/B development testing, installation, GameOverlay.NET mapping.
2. Core usage: window modes, target tracking, DPI and multi-monitor, drawing primitives, resource lifetime.
3. Runtime behavior: device recreation, troubleshooting, performance guide.
4. Integration and boundaries: integration boundary, transparency validation, capture-backed overlay spike, DirectComposition decision note.
5. Release/project status: task list, modernization spec, feature completeness, next action points, implementation history, development notes, public API and package review, release validation checklist, release publishing.

Project Layout

1. src: package/project responsibilities and source entry points.
2. samples: runnable capability demos.
3. tests: test areas and common commands.
4. benchmarks: BenchmarkDotNet classes and dry-run command.
5. tools: release validation command gate.