DirectNAot

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

(★ 109)

DirectN AOT compatible version. Only for .NET Core 9 and beyond. Interop Code for : DXGI, WIC, DirectX 9 to 12, Direct2D, Direct Write, Direct Composition, Media Foundation, WASAPI, CodecAPI, GDI, Spatial Audio, DVD, Windows Media Player, UWP DXInterop, WinUI3, etc.

DirectNAot 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# DirectN AOT
100% C# interop code for .NET Core 10+ : DXGI, WIC, DirectX 9 to 12, Direct2D, Direct Write, Direct Composition, Media Foundation, WASAPI, CodecAPI, GDI, Spatial Audio, DVD, Windows Media Player, UWP DXInterop, WinUI3, etc.

This is an AOT-friendly version of [DirectN](https://github.com/smourier/DirectN) (with zero reference to it). Aimed at 64-bit (ARM, AMD) targets (doesn't mean it won't work for x86 targets, but it may not work for ambiguous types). Only for .NET Core 9 and beyond, it won't work for version below 8 nor with .NET Framework.

It's always a work in progress although it's been fairly stable now. If you want to discuss how, where, why, just create an issue.

* **DirectN** is the core project which contains all interop code and is 99% generated.
* **DirectN.Extensions** is a set of utilities that are not mandatory, but super useful for programming with DirectN (and Windows, COM and interop in general).
* **DirectN.InteropBuilder.Cli** is the tool that generates code in DirectN. Contrary to the original DirectN project, this tool is open source, and based on the linked [Win32InteropBuilder](https://github.com/smourier/Win32InteropBuilder) generic project.

So, DirectN has now been split into two projects: the interop code in one project, and the utilities, add-ons and extensions code in another project.

You don't have to use the extensions, but it's muuuuuuch easier to use them. The reason Extensions is separated from DirectN is more an engineering reason. The new COM Roslyn/.NET source generator at work here is very slow on ~8000 source-generated classes (since COM interop is not builtin in CLR anymore), so the DirectN project is just very difficult to work directly with in Visual Studio.

The key points that drive how code is generated and built:
* Although Win32InteropBuilder is totally generic, the goal for **DirectN** is still to create built-in interop code for modern media & graphics Windows (cross-platform is *not* a target) technologies only:
    * DirectX (9 => 12)
    * Direct2D
    * DXGI
    * Media Foundation
    * Windows Imaging Component (WIC)
    * Direct Composition
    * Direct Write
    * Audio (WASAPI)
    * XPS
    * others (dependencies, etc)
* Modern code exclusively based on .NET Core newer source-generated `LibraryImport`, source-generated `ComWrappers, etc. Note the result is the .dll size is significantly bigger.
* How it works and how it's made is, at its root, completely driven by .NET Core ComWrapper source generator and AOT requirements: trimming, and disabled runtime marshaling.
* Both DirectN and DirectN.Extensions are AOT-friendly.
* `unsafe` usage is as limited as possible.
* Raw pointers (like `ISomething*`) usage is not publicly exposed, only interface types (like `ISomething`), or `nint` depending on the situation. `object` as out parameter type for untyped (native `void**`) COM interfaces has been considered but it's been replaced by `nint` which is more universal, including for authoring (aka implementing COM interfaces in .NET) scenarios.
* All `ComObject` instances are created using ComWrappers' "unique instance" (`CreateObjectFlags.UniqueInstance` and `UniqueComInterfaceMarshaller<>`) marshalling feature, as we want to control when objects are released (what's the serious use of non-unique instances in interop scenarios anyway?)
* Due to the usage of unique instances everywhere in DirectN AOT, we had to add a hack to overcome a nasty .NET 8 bug https://github.com/dotnet/runtime/issues/96901 or everything crashes very quickly at GC or finalizing time. This hack is inactive under .NET 9+.
* Doing interop is inherently unsafe but we want to keep a .NET-like programming whenever possible. The generated code serves a similar purpose to the CsWin32 project, but the final generated code and net result (ie: how we use it as a caller) are quite different (although CsWin32 has been improved at the end of 2025).

## Same names and types than the native concepts, easy port from C/C++ to C#!
DirectNAot allows you to port C/C++ code to C#, or to write C# code from scratch, probably more easily than with other existing interop libraries in this domain because one of its main objective is to use **exactly the same names and types than the native concepts** (interfaces, enums, structures, constants, methods, arguments, guids, etc.) . So you can read the official documentation, use existing C/C++ samples, and start coding with .NET right away.

By design, everything is in the same namespace (and in the same assembly if you use the whole .dll or nuget package) so you don't need to know where is defined this or that interface, constants, etc.

## Natural .NET programming!
All native COM interfaces are generated as .NET (COM) interfaces, not classes or fancy/complex/unsafe structs. COM utility wrappers are also provided (ComObject, ComMemory, etc.), and many extension methods are also provided for some COM interfaces (the principle used can be extended to any COM method, but this part is not generated). They allow easier .NET programming, but they are not strictly needed. Most of this is possible because **DirectNAot represents COM inheritance by .NET inheritance** (so, `DirectN.IWICImagingFactory2` derives from `DirectN.IWICImagingFactory` for example).

# Installation
You can just compile the source (note it can take *minutes* due to the fact ComWrapper Source generation is *slooooowwwwww*...) or use the nuget packages

https://www.nuget.org/packages/DirectNAot/ and https://www.nuget.org/packages/DirectNAot.Extensions/

# Building
Generated files are included in the repo, so you can just compile DirectN (this one takes minutes ...) and DirectN.Extensions to use DirectN, they are always up-to-date while the nuget packages may be slightly behind.

If you really want to understand the generator from Win32 metadata, regenerate and rebuild the whole thing, you must run DirectN.InteropBuilder.Cli which will generate all the files in DirectN and then compile DirectN and DirectN.Extensions. Note it's "intelligent" and doesn't touch unchanged files, so if you run it from a fresh repo clone, no files should be updated.

# Direct3D11 minimal sample
The **DirectN.Samples.MinimalD3D11** sample here [https://github.com/smourier/DirectNAot/tree/master/DirectN/DirectN.WinUI3.MinimalD3D11](https://github.com/smourier/DirectNAot/tree/main/Samples/DirectN.Samples.MinimalD3D11) has been ported to C# from here: https://gist.github.com/d7samurai/abab8a580d0298cb2f34a44eec41d39d which features a minimal Direct3D11 *"'API familiarizer' - an uncluttered Direct3D 11 setup & basic rendering reference implementation, in the form of a complete, runnable Windows application contained in a single function and laid out in a linear, step-by-step fashion"* sample.

It's dependent on DirectN AOT, .NET 10 and ... that's it. Once built, the fully standalone .exe with *zero dependency* is only 4M bytes!
 
Here is the output (believe me, it rotates):

Full credits go to d7Samurai: https://gist.github.com/d7samurai

# PDF view sample
The **DirectN.Samples.PdfView** sample here [https://github.com/smourier/DirectNAot/tree/main/Samples/DirectN.Samples.PdfView](https://github.com/smourier/DirectNAot/tree/main/Samples/DirectN.Samples.PdfView) is a fully non-Winforms, non-WPF, non-WinUI3 window GUI app that can display a PDF file's content.

It's dependent on DirectN AOT, .NET 10 and ... that's it. Once built, the fully standalone .exe with *zero dependency* is only 6M bytes!

It uses Windows (WinRT) PDF API so it demonstrates how to include WinRT (C#/WinRT) in a DirectN AOT application. It also demonstrates how to use the [Visual Layer](https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/ui/visual-layer-in-desktop-apps) (aka Direct Composition) in a Windows app without any pre-baked UI framework, only DirectN, some of its utilities and Windows.

# Screen Capture sample
The **DirectN.Samples.ScreenCapture** sample here [https://github.com/smourier/DirectNAot/tree/master/DirectN/DirectN.ScreenCapture](https://github.com/smourier/DirectNAot/tree/main/Samples/DirectN.Samples.ScreenCapture) is a fully non-Winforms, non-WPF, non-WinUI3 window GUI app that can display a live (primary) screen capture

It's dependent on DirectN AOT, .NET 10 and ... that's it. Once built, the fully standalone .exe with *zero dependency* is only 6M bytes!

# Media Play sample
The **DirectN.Samples.MediaPlay** sample here [https://github.com/smourier/DirectNAot/tree/master/DirectN/DirectN.MediaPlay](https://github.com/smourier/DirectNAot/tree/main/Samples/DirectN.Samples.MediaPlay) is a fully non-Winforms, non-WPF, non-WinUI3 window GUI app that can play a video file (you can choose the source)

It's dependent on DirectN AOT, .NET 10 and ... that's it. Once built, the fully standalone .exe with *zero dependency* is only 13M bytes!

# WebView2
[WebView2Aot](https://github.com/smourier/WebView2Aot) is an AOT library project, using DirectNAOT that exposes .NET 10+ AOT-compatible bindings 100%, fully independent from WinForms, WPF or WinUI3, for Microsoft's WebView2.

# AOTrino
[AOTrino](https://github.com/aelyo-softworks/AOTrino) is Electron-like desktop apps on .NET Native AOT + WebView2 (using [WebView2Aot](https://github.com/smourier/WebView2Aot)). One executable, no runtime to install, no Chromium to ship — Windows already has both. x86, x64 and ARM64.

A window is a real HWND, the UI is a web page, and the two talk over a typed bridge. That's the whole idea. The Fluent UI gallery below is an AOTrino app, and it weighs 4 MB.

# Filociraptor
[Filociraptor](https://github.com/smourier/Filociraptor) is a fast Windows file manager  written in C#, rendered with Direct2D and compiled with NativeAOT. GPU drawn, fully virtualized and allocation free on the hot path, so folders with thousands of files open and scroll instantly.

# ShellBat
[ShellBat](https://github.com/smourier/ShellBat) is a modern Windows file explorer with file viewers, multi-instance workflows, terminal integration, search capabilities, and deep Windows Shell interoperability.

This project is a hybrid web application that combines C#/.NET with JavaScript, HTML and CSS, based on an approach similar to frameworks like Electron, but rather simplified.

It relies solely on DirectN AOT and .NET 10+ AOT and built on DirectNAOT and [WebView2Aot](https://github.com/smourier/WebView2Aot), again with no dependencies on WinForms, WPF, WinUI 3, or UWP.
The final published file is just a single .exe file of 13MB that works in Windows 10, 11, Sandbox and Virtual environments (Hyver-V, etc.).

Integrated terminal:

PDF files rendered:

# Wice
Wice (aka "Windows Interface Composition Engine") is a .NET UI engine for creating Windows application. It's not dependent on WPF nor Winforms, nor WinUI 2 nor 3, nor Windows XAML, nor UWP, it's another UI Framework. The way it works is somewhat inspired from WPF, but there is no technical dependency over it.
It supports native-AOT deployment, through usage of DirectN AOT.

Check it out at https://github.com/aelyo-softworks/Wice

# VCamNetSample
[VCamNetSample](https://github.com/smourier/VCamNetSample) is a project that exposes a Media Foundation Virtual Camera Sample developed using .NET AOT with DirectN AOT (only on Windows 11).

# ActiveN
[ActiveN](https://github.com/smourier/ActiveN) is a lightweight framework for building classic COM components and OLE/ActiveX controls in modern fully AOT-compatible .NET, with registration-ready deployment.

It lets you author controls and automation objects that run inside legacy or current COM hosts (VBA, VB6, Delphi, Visual Fox Pro, scripting engines, test containers, etc.) without relying on WinForms or WPF (since they are currently not AOT-compatible).

Check out this 1998 VB6 IDE (x86) hosting modern WebView2 :-)

DirectNAot

DirectNAot 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

DirectNAot

DirectNAot 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README