ComputeSharp: nine packages, two adopters, and no release since April 2025
A .NET library to run C# code in parallel on the GPU through DX12, D2D1, and dynamically generated HLSL compute and pixel shaders, with the goal of making GPU computing easy to use for all .NET developers! 🚀
At a glance
- What is it?
- A .NET library that generates HLSL compute and pixel shaders from C#, shipped as nine packages covering the Direct3D 12 and Direct2D 1 paths plus UWP and WinUI 3. Two named adopters are the Microsoft Store and Paint.NET, the deep documentation is a master's thesis committed to the repository, and the newest release predates the last commit by seventeen months.
- Who is it for?
- This is the library to look at if you want to write compute and pixel shaders in C# and have them reach the GPU through Direct3D 12 or Direct2D 1, and the two adopter entries are the strongest evidence available that it works outside a sample app. Two things to weigh first.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 58 days ago.
- What is it written in?
- Mainly C#, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Sergio0694/ComputeSharp3,192 ★ · +20
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| Sergio0694/ComputeSharp | 3.2k | 3.2k |
20 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Nine packages, and the naming scheme is the whole API surface
The package table encodes the design in its names. There is a main library with compiled shader support, and then the axes multiply: a Direct2D 1 variant, that variant again for UWP and for WinUI 3, a bare UWP library with controls to render shaders, and a WinUI 3 library with the same purpose. Three more are optional extensions rather than targets. One adds the D3D12 memory allocator for graphics resources, one bundles the shader compiler and turns on shader reflection, and one enables the PIX tooling to produce debugging information. The Direct2D 1 entry is the one with a history attached: the README says it was initially developed specifically to support Paint.NET, and it is described as a way to write those pixel shaders entirely in C# and register them as effects. Its description line also carries a stray letter in the effect interface name.
The newest release is seventeen months older than the last commit
The release record and the branch tell different stories. The three newest releases are 3.2.0 from April 2025, 3.1.1 from March 2025 and 3.1.0 from December 2024, so the line has been on the same minor version for well over a year and moved in patch steps. The default branch's last recorded commit is dated 2026-09-18, which puts roughly seventeen months of development after the newest tag. That gap is the first fact to establish before depending on the library, because the packaged version a consumer installs and the source anyone reads on the default branch are different states. Preview builds are published for the in-between case, through a custom package feed whose index is linked in the README, alongside GitHub Packages.
Both named adopters are Windows shell applications
The adoption table has two rows and both are large first party Windows software. The Microsoft Store is described as a first party application that ships with Windows, using ComputeSharp.D2D1.Uwp from its January 2023 release to drive graphics elements such as the new app cards with custom effects and pixel shaders. Paint.NET, an image and photo editor, has used ComputeSharp.D2D1 as a core component of its architecture since its 5.0 release, both to accelerate dozens of built-in effects with custom shaders and to support external plugins. Two things follow. The library is not being used for scientific computing, which is what most GPU libraries target, but for effects in a shipped user interface. And the dependency between the two is older than either adoption: the Direct2D 1 package was written for Paint.NET first.
The deepest documentation is a master's thesis in the repository
The documentation section says all the documentation lives in the wiki pages and tells you to go through them to get familiar with the library. Then a second section points somewhere better. The author wrote about the project in his master's thesis in computer engineering, and the PDF is committed to this repository. Its stated contents are unusually complete: the basics of COM, WinRT, UWP XAML and Win2D, the DirectX interop and the source generators underneath the library including a breakdown of the generated code, how HLSL intrinsics are transpiled, how Win2D was extended to accept custom effects, how the library uses that in its pixel shader effect type to integrate with Win2D, and a case study of implementing several of the Store's own pixel shaders with their effect graphs. A thesis is unusual to ship, and useful here for one reason: it explains the code generation that no other document does.
Eighteen sample projects, two of them in F#, none of them in the README
The samples directory holds eighteen projects and the README describes none of them individually, showing only a store link to the sample application. What the directory names reveal is a coverage matrix rather than a demo set. There is a benchmark project, an image processing project, two that interop with a native library, and a family of swap chain samples split by target: a plain one, then variants for the command line, for Direct2D 1 on the command line and on UWP, for shaders and for Direct2D 1 shaders, for a UI host, and for UWP and WinUI 3. Two of the samples are written in F#, one of them specifically for shaders in F#, which is a language claim the README never makes and which is worth knowing about if F# is your default in a .NET codebase.
Dependencies are managed centrally and the third party notices are committed
The root of the tree shows a modern central dependency setup. There is a directory packages properties file that holds shared package versions, a NuGet configuration for sources, a global file pinning the SDK, and a solution using the newer XML format rather than the classic one. A global analyzer configuration file sits next to the editor configuration, which is how the compiler and analyzer warnings are fixed for the whole tree rather than per project. Two entries explain the licensing side. A third party notices file is committed at the root, which is the expected companion to a library that leans on other people's interop packages, and the README names four of them by repository: the .NET and Windows community toolkits plus two TerraFX interop packages. There is also a libs directory, which is where a bundled compiler binary would live.
The compiler and the debugger are optional packages, not dependencies
Three of the nine packages exist because the main library deliberately does not do that work. The DXC package bundles the shader compiler and enables shader reflection, so without it a consumer has no compiler to point at. The PIX package exists to produce debugging information for the pixel debugger, which is the tool you want when a shader compiles and then draws nothing. The memory allocator package substitutes the D3D12 allocator for graphics resources. Read together they say something about the shape of the library: the hot path is a self-contained generated shader, and the pieces around it are for people who need reflection, debugging or allocation control. A sample application is also published to the Microsoft Store, so those sample shaders can be seen without writing anything.
The sample shaders were ported from another language, and the code came from another engine
Two origins are declared and neither is hidden. The pixel shaders in the gallery were originally written in GLSL for an online shader gallery, and were ported to C# to run through this library in a WinUI 3 sample, which says something useful about how much of the shader ecosystem this project is trying to make reachable from .NET. And the library was originally based on some of the code from a Direct3D 12 game engine project by another author, credited by name in the special thanks section. The four NuGet sources are declared separately from that credit, which is the usual division: code borrowed under a licence, packages consumed under their own. The project is MIT, and the third party notices file in the root is where the detail of both lives.
Editorial conclusion
This is the library to look at if you want to write compute and pixel shaders in C# and have them reach the GPU through Direct3D 12 or Direct2D 1, and the two adopter entries are the strongest evidence available that it works outside a sample app. Two things to weigh first. The newest release is seventeen months older than the last commit, so a consumer should decide between a tagged version and the default branch deliberately. And the documentation is not in the repository in any usable form: it is wiki pages plus a PDF thesis, so expect to spend an afternoon reading before writing the first shader.
Frequently asked questions
What is ComputeSharp?
A .NET library to run C# code in parallel on the GPU through Direct3D 12 and Direct2D 1, with dynamically generated HLSL compute and pixel shaders. It lets you access GPU devices, allocate buffers and textures, move data between them and RAM, and write compute shaders entirely in C#.
Which production applications use ComputeSharp?
Two are named. The Microsoft Store has used ComputeSharp.D2D1.Uwp since its January 2023 release for graphics elements such as app cards, and Paint.NET has used ComputeSharp.D2D1 as a core component of its architecture since its 5.0 release, for both built-in effects and external plugins.
Do I need the DXC compiler installed to use ComputeSharp?
There is an extension package for it. ComputeSharp.Dxc bundles the DXC compiler and enables shader reflection, while the main package is described as the library with compiled shaders support. A separate package adds PIX debugging information.
How many packages does ComputeSharp publish?
Nine: the main library, plus extensions for the D3D12 memory allocator, the DXC compiler with shader reflection, PIX debugging, and the UWP, WinUI 3, Direct2D 1, Direct2D 1 for UWP and Direct2D 1 for WinUI 3 libraries.
Can I write compute shaders in C# with ComputeSharp?
That is the stated goal of the project: write compute shaders entirely in C# and have them run on the GPU, with HLSL intrinsics transpiled. The sample pixel shaders were ported from GLSL to C# and run through the library.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/sergio0694-computesharp)Star history chart for your README
[](https://hysenlabs.com/projects/sergio0694-computesharp)Was this useful?