Const-me

Vrmac

C#2020–2024

Const-me / Vrmac

Vrmac

Vrmac Graphics, a cross-platform graphics library for .NET. Supports 3D, 2D, and accelerated video playback. Works on Windows 10 and Raspberry Pi4.

Explore on GitHub Read Hacker News discussions

3Distinct people

86Mentions

0Explicit recommenders

130GitHub stars

REPOSITORY AT A GLANCE

What to know before exploring

What it is

Vrmac Graphics, a cross-platform graphics library for .NET. Supports 3D, 2D, and accelerated video playback. Works on Windows 10 and Raspberry Pi4.

GitHub

Where it is used

No documented product use has been verified yet.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 9:28:18 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year86 dated mentions

Observed mentions: 2020-05-18 12:01:50 UTC to 2024-10-09 23:45:11 UTC.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
Period	Start (UTC)	End (exclusive, UTC)	Mentions	Submissions	Comments
2020	2020-01-01 00:00:00 UTC	2021-01-01 00:00:00 UTC	30	1	29
2021	2021-01-01 00:00:00 UTC	2022-01-01 00:00:00 UTC	34	0	34
2022	2022-01-01 00:00:00 UTC	2023-01-01 00:00:00 UTC	8	0	8
2023	2023-01-01 00:00:00 UTC	2024-01-01 00:00:00 UTC	6	0	6
2024	2024-01-01 00:00:00 UTC	2025-01-01 00:00:00 UTC	8	0	8

What Hacker News says

30 sources

Const-me·Nov 26, 2020

BTW, that thing also supports Windows 10. The same .NET binary runs on top of Direct3D 12 there, instead of GLES 3.1. Way easier to debug on Windows, because visual studio and renderdoc. There’re a few incompatibilities but these are minor. Here’s one example, in a vertex shader: https://github.com/Const-me/Vrmac/blob/master/RenderSamples/...

In Raspberry Pi 4 V3DV graphics driver achieves Vulkan 1.0 conformance

Const-me·Nov 25, 2020

If you’re OK with .NET, you can try my library: https://github.com/Const-me/Vrmac/ The library supports both X windows, and bare OS kernel DRM/KMS. Spinning textured cube: https://github.com/Const-me/Vrmac/tree/master/RenderSamples/... Spinning teapot with lightning, inertia, mouse and keyboard input, etc: https://github.com/Const-me/Vrmac/tree/master/RenderSamples/... Dependencies: https://github.com/Const-me/Vrmac/blob/master/Installation.m...

In Raspberry Pi 4 V3DV graphics driver achieves Vulkan 1.0 conformance

Const-me·Nov 16, 2020

I don’t have a startup. Still, for the last 7 years I’m an independent contractor, which is probably close to being an indie hacker. Wasn’t the first try. Two times before that I only had a single client, one time they cancelled the project, second time I delivered the software and the client didn’t have other work for me to do. I lived in a big city then, both times I just searched and found another full-time office position. When I think I have an interesting idea, I sometimes pursue on my free time. So far, the only outcome I got is couple dozen stars on github, and in one case a hundred thousand of free downloads of my app. Pretty close to nothing. https://github.com/Const-me/SkyFM https://github.com/Const-me/vis_avs_dx https://github.com/Const-me/Vrmac

In After losing my savings as an indie hacker, I can't do it anymore. I quit.

Const-me·Oct 29, 2020

> You're just starting to re-invent the Wayland protocol I think the main feature of WL is simultaneous multi-tasking. If you don't need that, a desktop is redundant. That's why Google made their own proprietary DM for android instead of adapting what Linux had. > You need to pass input too I haven't tried but I think multiple processes are fine reading from the same /dev/input/event[n] at the same time, they'll just get the same events. Therefore they may process or ignore these based on whether they rendering or not. > I think you underestimate the work to write a program using KMS and libinput I did it several times, both for hire and for lulz: https://github.com/Const-me/Vrmac/ drm/kms pieces are in C++ and not in that repo, but raw input is there, was easy: https://github.com/Const-me/Vrmac/tree/master/Vrmac/Input/Li... > writing a s

Read the rest

olid framework is something else Depends on the scope. If you only need left to right languages, couple keyboard layouts out of the 204, etc., it's reasonable.

In Graphical User Interface Using Flutter in Embedded Systems [pdf]

Const-me·Oct 26, 2020

> X11 only works to a certain degree, some days, for some people, for some video cards. Cases in point: this project, https://github.com/const-me/Vrmac/ a non-trivial demo such as 3D teapot or 2D tiger. Run that in desktop, and you’ll see occasional tearing. Run the same demo on top of bare OS kernel (i.e. reboot to console), and it will work flawlessly on top of DRM/KMS, on the same Raspberry Pi4.

In The X.Org Server Is Abandonware?

Const-me·Oct 25, 2020

Interesting, probably depends on hardware then. On Pi4, that same workflow (drm/kms without desktop managers, with GLES on top) delivers superior image with no tearing (tearing does happen in windowed mode under load), while consuming less resources than windowed mode. This library: https://github.com/Const-me/Vrmac

In The X.Org Server Is Abandonware?

Const-me·Oct 25, 2020

Technically what Wayland is doing, using 3D GPU for everything, is the best way forward. Windows is using it since Vista. When done right, gradients mentioned in other comments are free, GPUs have hardware to interpolate values (such as colors) across vertices of triangle, for free. Many other effects are either free or very cheap. Engineering-wise it's really hard. Microsoft reworked GPU driver model introducing WDDM. They invented a new user-facing API for that, introducing Direct3D 10. They did that in close collaboration with all 3 GPU vendors. They made user-mode components like desktop compositor itself, dwm.exe, and higher-level libraries to benefit from all that stuff. Initially they were optional things like WPF, Direct2D, DirectWrite, then with Win8 they introduced WinRT later rebranded to UWP. That one is no longer optional and

Read the rest

is the only practical way to render "hello world, GUI edition" in modern Windows (possible to do with DirectWrite or legacy GDI but neither of them is practical). The problem "render nice high-resolution graphics, fast" affects everything, the entire stack. Modern Linux has decent kernel infrastructure (DRM/KMS), but even so, remaining challenges are hard. Linux has less luck with user-facing GPU APIs (Vulkan is not yet universally available, neither is GLES3+ or OpenGL 4.3+). For some GPUs, quality of drivers is less than ideal. OS maintainers oppose stabilizing kernel ABI for drivers. There's no high level GPU-centric graphics libraries, I tried once with moderate success https://github.com/Const-me/Vrmac but that only supports one specific Debian Linux on one specific computer which happens to support GLES 3.1, and some important features are missing e.g. no gradient brushes or stroked pens. I don't see any large party interested in making that happen. At least not for desktop Linux. Valve started to do relevant things when they thought Windows 10 is going to kill their Steam business model, then it became apparent Microsoft won't make Win10 into an iOS-style walled garden, and they no longer have much motivation.

In The X.Org Server Is Abandonware?

Const-me·Oct 1, 2020

> and a Java program that allocates 99% of stuff like crazy on GCed heap Java is too extreme with GC, not all languages are like that. In .NET it's only moderately hard to avoid GC when you want to. It has value types, real stack, and other relevant features. Here's an example of non-trivial code written in that style for performance reasons: https://github.com/Const-me/Vrmac/tree/master/VrmacVideo

In You're Allowed to Write Slow Rust Code

Const-me·Sep 22, 2020

> It removes "managed code tax" for calling into dynamically loaded OpenGL/Vulkan methods Interesting, never heard of that. Do you have a source? I haven’t noticed much overhead when I measured, take a look: https://github.com/Const-me/ComLightInterop#how-it-works That library compiles and runs with .NET Core 2.1. Update: also there https://docs.microsoft.com/en-us/cpp/dotnet/calling-native-f... they wrote “PInvoke has an overhead of between 10 and 30 x86 instructions per call” It roughly corresponds to my observation, and I find it fast enough for all practical applications, including GLES rendering on ARM Linux: https://github.com/Const-me/Vrmac/

In .NET 5.0 – New APIs

Const-me·Sep 21, 2020

> There are however many situations where neither Java nor C# are options. Not too many anymore, and the space for these situations shrinks over time, rather quickly. 20 years ago, almost everything was implemented in C or C++, for all platforms. The computers didn’t have extra RAM for the GC overhead. Web sites were the first to migrate, probably because security. Desktop GUI apps followed. On mobile, before iPhone was launched in 2007, people used a lot of C or C++ there. PalmOS only supported C, Symbian SDK was C++ based, most Windows Mobile apps were written in C or C++. For the same reason, not enough resources for a GC. We now have gigabytes of memory in these devices and it’s no longer the case, on Android it’s almost 100% Java or Kotlin, on iOS it’s Swift. This is happening with videogames, see Unity3D. Even low level soft-realtim

Read the rest

e multimedia is good enough for .NET now, here’s an example where my C# implementation delivers same performance as C implementation of VLC player: https://github.com/Const-me/Vrmac/tree/master/VrmacVideo Pretty sure in a couple of years once MS improves a few relevant things in their .NET core (they need better constant propagation, and NEON support) we’ll see high-performance numeric stuff following the trajectory. The hardware SIMD support in .NET core 3.1 is a good step in the right direction.

In Why Not Rust?

Const-me·Aug 29, 2020

Thanks! BTW I used more than V4L2. ALSA from libasound.so.2, there: https://github.com/Const-me/Vrmac/blob/master/VrmacVideo/IO/... and the rest of libasound.*.cs files in that folder (parts of the same static class). Audio output is harder than necessary on all OSes I developer for, including Windows. From the internets I got an impression that at least on RPi, ALSA PCM is more reliable than the rest of them. Also doesn’t depend on any desktop components, important because the library can also be used without any desktop environment, rendering on a physical display. Message queues from librt.so https://github.com/Const-me/Vrmac/blob/master/VrmacVideo/IO/... .NET has equivalent stuff already. I needed poll() to get notified about multiple things not just queued messages, as both V4L2 and ALSA expose poll()-compatible file handles in their

Read the rest

respective APIs.

In Firefox 80 and my confusion over its hardware accelerated video on Linux

Const-me·Aug 28, 2020

I think legacy contributed most. On modern Linux, it’s possible, and not even terribly hard, to implement hardware-accelerated video playback without any libraries or frameworks, by directly consuming V4L2 API exposed by the kernel. Here’s a proof, I did it alone spending a month or so part time, and resource use is lower than VLC’s despite my code is in .NET: https://github.com/Const-me/Vrmac/tree/master/VrmacVideo However, that wasn’t always the case. Until recently software had to fallback to software decoders, and implement other workarounds. Software developers are reluctant to throw away old code and do something completely different. 1. They spent much time on that old code (sunk cost fallacy). 2. Old code usually works more often than it doesn’t (don’t fix things which aren’t broken). 3. Massive refactor of large software is very

Read the rest

expensive in general. Moving stuff from CPU to GPU is going to cause large changes in many parts. You can’t usually afford to copy uncompressed video frames from VRAM back to system RAM and call it a day, that would be too much bandwidth. Instead, you have to change a lot of other code to handle GPU textures instead of system RAM images.

In Firefox 80 and my confusion over its hardware accelerated video on Linux

Const-me·Aug 23, 2020

If I were to start a new project today, I’d look at this library: https://platform.uno/ Can’t say I like all technical decision they made. I would prefer them to use a purposely-built GPU-centric renderer instead of Skia, it’s not terribly complex, here’s a proof of concept: https://github.com/const-me/Vrmac/#2d-graphics Still, Skia is not _that_ bad, maybe it’s fine there.

In Ask HN: How to do cross platform GUI?

Const-me·Aug 21, 2020

Good article. I’d like to add that similar queues are widely used in all multimedia, not just games. This library https://github.com/Const-me/Vrmac/tree/master/VrmacVideo uses queues to coordinate 3 threads, one decoding video by pumping V4L2 kernel queues, another one decoding audio and playing it with ALSA, and the main thread rendering frames with GLES. Two of my queues are thin wrappers around mq_send / mq_receive Linux APIs.

In Game Programming Patterns: Event Queue (2014)

Const-me·Aug 6, 2020

When I have free time, I’m generally more willing to contribute to my own open source projects no one cares about. Like this one: https://github.com/Const-me/Vrmac BTW did substantial amount of SIMD stuff there, for both 3D and 2D parts.

In Simdjson: Parsing gigabytes of JSON per second

Showing the 15 most recent of 30 sources. Enable JavaScript to search and browse every indexed mention.