.NET Runtime
vgpu_unlock
.NET Runtime | vgpu_unlock | |
---|---|---|
659 | 144 | |
15,253 | 4,509 | |
1.6% | - | |
10.0 | 0.0 | |
6 days ago | over 1 year ago | |
C# | C | |
MIT License | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
.NET Runtime
- Ask HN: Has Anyone Tried Single File Development with IDE Code Collapse?
-
A comparison of Rust's borrow checker to the one in C#
"Vanilla" .NET runs on
Operating Systems: Linux, macOS, Windows, FreeBSD, iOS, Android, Browser
Architectures: x86, x86_64, ARMv6, ARMv7, ARMv8/ARM64, s390x, WASM
Notes:
Mono as referred here means https://github.com/dotnet/runtime/tree/main/src/mono which is an actively maintained runtime flavor, alongside CoreCLR.
- application development targets on iOS and Android use Mono (the one that lives in dotnet/runtime). Android can be targeted as linux-bionic with regular CoreCLR, but it's pretty niche. iOS has experimental NativeAOT support but nothing set in stone yet, there are similar plans for Android too.
- ARMv6 requires building runtime with Mono target. Bulding runtime is actually quite easy compared to other projects of similar size. There are community-published docker images for .NET 7 but I haven't seen any for .NET 8.
- WASM also uses Mono for the time being. There is a NativeAOT-LLVM experiment which promises significant bundle size and performance improvements
- For all the FreeBSD slander, .NET does a decent job in supporting it - it is listed in all sorts of OS enums, dotnet/runtime actively accepts patches to improve its support and there are contributions and considerations to ensure it does not break. It is present in https://www.freshports.org/lang/dotnet
At the end of the day, I can run .NET on my router with OpenWRT or Raspberry Pi4 and all the laptops and desktops. This is already quite a good level given it's completely self-contained platform. It takes a lot of engineering effort to support everything.
-
Should JavaScript be split into two languages? Google proposal divides opinion
Garbage collection is solved to the extent that host garbage collection is now available via WasmGC:
https://developer.chrome.com/blog/wasmgc/
https://v8.dev/blog/wasm-gc-porting
But languages like C# want more features in WasmGC:
https://github.com/dotnet/runtime/issues/94420
No direct DOM access yet. You still have to use JavaScript glue code to get at the DOM.
-
A review after using Rust on embedded in production for over a year
This was recently discussed: https://news.ycombinator.com/item?id=41801124
While it is true that Rust is a strictly superior option for highly concurrent systems code, it still leaves areas where you can make a mistake regarding lock management and other advanced forms of synchronization.
In addition to that, .NET as platform is fairly tolerant to misuse and calling the code that is not thread-safe from multiple threads concurrently usually leads to logic bugs or "stop modifying this collection concurrently, please" exceptions but not to catastrophic memory safety issues like it happens in C/C++.
You can read more on its low-level memory model here: https://github.com/dotnet/runtime/blob/main/docs/design/spec...
> The same is true for async, which in C# is also a problem.
Now, this one is strictly not true. Async primitives are thread-safe. In Rust, you must synchronize because at the very least you must deterministically deallocate memory used by shared state between the tasks. In C#, this complexity is handled for you by a GC (ironically, you get negative sentiment towards async from people having experienced Python's async or Rust's async complexity, assuming the same applies to C#). In some scenarios, it is also a throughput optimization since it reduces memory contention and cacheline sharing between the cores, lending itself into better performance on many-core systems - the memory is modified/reclaimed when it's no longer in use, while the actively shared data is placed elsewhere.
-
My negative views on Rust (2023)
> RISC-V
The work is underway: https://github.com/dotnet/runtime/pulls?q=label%3Aarch-riscv
> PTX
https://ilgpu.net/ and even https://github.com/m4rs-mt/ILGPU/blob/c3af8f368445d8e6443f36...
While not PTX, there's also this project: https://github.com/Sergio0694/ComputeSharp which partially overlaps with what ILGPU offers
Arguably, even C++ itself - you are not using "full" C++ but a special subset that works on top of specific abstraction to compile to GPUs, and I was told that CUDA C++ is considered legacy.
The original context of discussion is performance and perceived issue of "having runtime", which is what my reply is targeted at. In that context, C# provides you the tools and a solution other languages in the class of Java, Go, TS and anything else interpreted just don't have. So you could reasonably replace a project written in C++ with C#, and possibly re-apply all the freed-up developer productivity into further optimizations, but you wouldn't be able to do so with the same degree of confidence with most other originally high-level languages. Another upcoming contender is Swift.
-
What's New in Ruby on Rails 8
Ruby does nail the minimalism in this code golfing example, but it does not offers uniquely high productivity to the end user, which is a frequently brought up point in defense of interpreted languages whenever their shortcomings are mentioned. Lacking static typing, Ruby users have to resort on e.g. Sorbet, which is a worse experience and numerous comments on HN seem to provide negative feedback on it.
I do actually hate to mention performance every time, but it's difficult to not do so when apples-to-apples comparison can be made. Compiled statically typed languages with GC offer similar or better (because the code is verified by compiler, not Sorbet) productivity without any of the drawbacks that come with Ruby.
This is to illustrate the point about the languages that do come with rich standard library, that also happen to go to great lengths at ensuring that shortest way to express something is also the fastest whenever possible.
[0]: https://github.com/dotnet/runtime/blob/main/src/libraries/Sy...
-
Ruby-SAML pwned by XML signature wrapping attacks
GetElementId makes sure its a NCName and makes sure its unique regardless, you can view the source here: https://github.com/dotnet/runtime/blob/c4d7f7c6f2e2f34f07e64...
- Swift 6
- Ergo: Erlang-inspired event driven actor framework in Go
-
Sisk – Lightweight .NET Web Framework
It appears to use Socket and SslStream. Can't say much about HttpListener itself, but the first two are used by Kestrel (and everything else). There is Http.sys integration for Windows though.
https://github.com/dotnet/runtime/blob/ac663e44b907618c631ed...
vgpu_unlock
-
Tinygrad: Hacked 4090 driver to enable P2P
This isn’t even the first time a hacked driver has been used to unlock some HW feature - https://github.com/DualCoder/vgpu_unlock
-
Is there specific hardware to make passthrough GPU easier?
Alternatively enable vGPU for the 2070 and use it for both Jellyfin LXC and Windows VM. https://github.com/DualCoder/vgpu_unlock
-
GPU virtualization?
I'm on Linux and I'm running a 3070 Ti (Nvidia). I have always wanted to do GPU virtualization but because NVIDIA won't release vGPU for consumer card no one can do it without crossing legal red tape or problems with bricking your GPU. I did find this [https://github.com/jamesstringerparsec/Easy-GPU-PV] however it is only for windows, I found this [https://github.com/Arc-Compute/LibVF.IO/] and does not work with my GPU, and this [https://github.com/DualCoder/vgpu_unlock] and can't get it to work. Done any one know an alternative on Linux that work just like this, overcoming these problems (on KVM)?
-
GPU pass-through/Sharing between multiple VMs
Otherwise, your only other option is the real hardware virtualization options that are available. NVIDIA's enterprise vGPU solution is for expensive compute cards however some have had good luck making vGPUs work on consumer NVIDIA cards with tools such as vgpu_unlock
-
SR-IOV with RTX 3090 Ti
There was a hack to enable it on some consumer cards, but it’s not available on Ampere/30x0 cards: https://github.com/DualCoder/vgpu_unlock/issues/8
- Gaming PC for Proxmox
- GPU virtualization, RTX 3000, Nvidia, and KVM?
- Hi, I need help building my VMware home-lab environment
- cheap gpu for virtualization and stable diffusion
-
GPU Passthrough
Pci passthrough https://github.com/mbilker/vgpu_unlock-rs https://github.com/DualCoder/vgpu_unlock https://github.com/DualCoder/vgpu_unlock/issues/91 https://gitlab.com/polloloco/vgpu-proxmox https://github.com/joeknock90/Single-GPU-Passthrough https://gitlab.com/YuriAlek/vfio#start-here https://www.reddit.com/r/homelab/comments/b5xpua/the_ultimate_beginners_guide_to_gpu_passthrough/ https://forum.level1techs.com/t/single-gpu-passthrough-with-proxmox/113282/2 https://forum.proxmox.com/threads/problem-with-gpu-passthrough.55918/
What are some alternatives?
Ryujinx - Experimental Nintendo Switch Emulator written in C#
Easy-GPU-PV - A Project dedicated to making GPU Partitioning on Windows easier!
ASP.NET Core - ASP.NET Core is a cross-platform .NET framework for building modern cloud-based web applications on Windows, Mac, or Linux.
nvidia-patch - This patch removes restriction on maximum number of simultaneous NVENC video encoding sessions imposed by Nvidia to consumer-grade GPUs.
actix-web - Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.
LibVF.IO - A vendor neutral GPU multiplexing tool driven by VFIO & YAML.
CoreCLR - CoreCLR is the runtime for .NET Core. It includes the garbage collector, JIT compiler, primitive data types and low-level classes.
OSX-KVM - Run macOS on QEMU/KVM. With OpenCore + Monterey + Ventura + Sonoma support now! Only commercial (paid) support is available now to avoid spammy issues. No Mac system is required.
WASI - WebAssembly System Interface
vgpu_unlock-rs - Unlock vGPU functionality for consumer grade GPUs
runtimelab - This repo is for experimentation and exploring new ideas that may or may not make it into the main dotnet/runtime repo.
vga-passthrough - Up to date (2021) reference for setting up a VGA passthrough on (Ubuntu) Linux.