HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
dotnet
runtime
C#2019–2026
dotnet / runtime

runtime

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.

Languages & CompilersRobotics & IoTMobile & DesktopDevOps & Cloud
Explore on GitHubRead Hacker News discussions
197Distinct people
337Mentions
1Explicit recommenders
18.4KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.

GitHub

Where it is used

  • Stack Overflow — Stack Overflow moved their service to .NET Core and saw lower page render times and improved latency. This reflects the site running on the .NET runtime after the migration. Source

What people are saying

> It is irrelevant that the benchmark is written in Oberon. It is not irrelevant from my perspective. It might be mostly irrelevant if Oberon, as you say, "fairly directly"…

rndgermandude used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.

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

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 12:45:45 PM UTC.

Mentions over time

HN mentions by year337 dated mentions

Observed mentions: 2019-12-06 14:10:04 UTC to 2026-09-21 15:39:47 UTC.

0204060801002019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 26 mentions; 5 submissions, 21 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 34 mentions; 6 submissions, 28 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 51 mentions; 3 submissions, 48 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 38 mentions; 3 submissions, 35 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 96 mentions; 4 submissions, 92 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 79 mentions; 9 submissions, 70 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 12 mentions; 1 submissions, 11 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

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.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC101
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC26521
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC34628
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC51348
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC38335
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC96492
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC79970
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC12111

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
.NET Runtime What is .NET? How can I contribute? Reporting security issues and security bugs Filing issues Useful Links .NET Foundation License This repo contains the code to build the .NET runtime, libraries and shared host (dotnet) installers for all supported platforms, as well as the sources to .NET runtime and libraries. What is .NET? Official Starting Page: https://dotnet.microsoft.com How to use .NET (with VS, VS Code, command-line CLI) Install official releases Documentation (Get Started, Tutorials, Porting from .NET Framework, API reference, ...) Deploying apps Support (Releases, OS Versions, ...) Roadmap How can I contribute? We welcome contributions! Many people all over the world have helped make this project better. Contributing explains what kinds of contributions we welcome Workflow Instructions explains how to build and test Dogfooding .NET explains how to get nightly builds of the runtime and its libraries to test them in your own projects. Reporting security issues and security bugs Security issues and bugs should be reported privately to the Microsoft Security Response Center (MSRC) via the MSRC Researcher Portal. You should receive a response within 24 hours. Further information can be found in the Security TechCenter. You can also find these instructions in this repo's Security doc. Also see info about related Microsoft .NET Bounty Program. Filing issues This repo should contain issues that are tied to the runtime, the class libraries and frameworks, the installation of the dotnet binary (sometimes known as the muxer) and the installation of the .NET runtime and libraries. For other issues, please file them to their appropriate sibling repos. We have links to many of them on our new issue page. Useful Links .NET source index / .NET Framework source index API Reference docs .NET API Catalog (incl. APIs from daily builds and API usage info) API docs writing guidelines - useful when writing /// comments .NET Discord Server - a place to discuss the development of .NET and its ecosystem .NET Foundation .NET Runtime is a .NET Foundation project. There are many .NET related projects on GitHub. .NET home repo - links to 100s of .NET projects, from Microsoft and the community. ASP.NET Core home - the best place to start learning about ASP.NET Core. This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information, see the .NET Foundation Code of Conduct. General .NET OSS discussions: .NET Foundation Discussions License .NET (including the runtime repo) is licensed under the MIT license.
Read the full README on GitHub

What Hacker News says

38 sources
neonsunset·Dec 26, 2023
Heh, movemask keeps coming back. Rather than emulating it, it appears to be more efficient to separately handle IndexOfMatch, LastIndexOfMatch and GetMatchCount scenarios it is used for most of the time: - https://github.com/dotnet/runtime/pull/94472/files#diff-5824... (it's closed for now but I'm hoping to get back to it at some point) - https://github.com/jprochazk/tmi-rs/blob/ac3ce6aee8bbe038a98... It can account for good 30% performance variance depending on the use case (on Apple's M-series cores).
In Ask HN: What's the fastest programming language with a large standard library?
burntsushi·Dec 26, 2023
Rust has had a stable SIMD vector API[1] for a long time. But, it's architecture specific. The portable API[2] isn't stable yet, but you probably can't use the portable API for some of the more exotic uses of SIMD anyway. Indeed, that's true in .NET's case too[3]. So .NET has to rely on "manually vectorized with intrisics for each individual platform" as well. Rust does all this SIMD too. It just isn't in the standard library. But the regex crate does it. Indeed, this is where .NET got its SIMD approach for multiple substring search from in the first place[4]. ;-) You're right that Rust's standard library is conservatively vectorized though[5]. The main thing blocking this isn't the lack of SIMD availability. It's more about how the standard library is internally structured, and the fact that things like substring search are not actually
Read the rest
defined in `std` directly, but rather, in `core`. There are plans to fix this[6]. With all that said, I wouldn't necessarily disagree with the broader point in this thread. .NET's regex engine performance is quite impressive[7]. (And I still have to merge the PR updating to .NET 8.) I'm really only replying here to correct more narrow points. [1]: https://doc.rust-lang.org/std/arch/index.html [2]: https://doc.rust-lang.org/std/simd/index.html [3]: https://github.com/dotnet/runtime/blob/72fae0073b35a404f03c3... [4]: https://github.com/dotnet/runtime/pull/88394#issuecomment-16... [5]: https://github.com/BurntSushi/memchr#why-is-the-standard-lib... [6]: https://github.com/rust-lang/rfcs/pull/3469 [7]: https://github.com/BurntSushi/rebar#summary
In Ask HN: What's the fastest programming language with a large standard library?
neonsunset·Dec 26, 2023
.NET's standard library is very heavily vectorized, vectorization is considered in all scenarios where it is applicable, the compiler will also apply it to copies of known length and string comparisons fully eliding and unrolling Memmove and SequenceEqual calls. The gives languages that run on top of .NET massive performance advantage in a variety of scenarios versus any other language - C++ and Rust stdlibs are far more conservatively vectorized because neither language has stable SIMD vector API and even then out of modularity constraints a lot of routines have to either rely on autovectorization which is fragile or manually vectorized with intrisics for each individual platform. A short non-exhaustive list of examples is - Shared SIMD helper for Aho-Corasick, Rabin-Karp and other text search algorithms https://github.com/dotnet/runtime
Read the rest
/blob/main/src/libraries/Sy... - Bloom filter https://github.com/dotnet/runtime/blob/main/src/libraries/Sy... - Base64 encoding and decoding https://github.com/dotnet/runtime/blob/main/src/libraries/Sy... - Element search (memchr and the like) https://github.com/dotnet/runtime/blob/main/src/libraries/Sy... - UTF-8 transcoding https://github.com/dotnet/runtime/blob/main/src/libraries/Sy... The above are examples of 1% code that ends up used by 99% of other codebase in one way or another. Regex engine, JSON serialization and parsing, substringing and etc. all use these.
In Ask HN: What's the fastest programming language with a large standard library?
neonsunset·Dec 11, 2023
WasmGC is a prototype that only supports the bare minimum that is enough for languages with high level constructs only but not for something like C# which has interior object pointers (ref) and uses them heavily for performance (spans are built on top of them). The API of WasmGC is really rudimentary. With that said, you can track support of various WASM features by .NET here: https://github.com/dotnet/runtime/issues/94351 I don’t understand how the logic of your post works however, WASM in .NET is already used in production versus something that is an early alpha? Also, on Kotlin and targeting something that is not Android - “Java Interop” that’s all I need to say.
In Building a bare-metal bootable game for Raspberry Pi in C#
neonsunset·Dec 9, 2023
In .NET, GC is triggered when a user thread runs out of memory in an allocation budget and needs more, similar to what you described [0]. Generally speaking, indefinitely preventing GC from running is not possible (you always end up putting some data on the heap) therefore an optimal strategy is similar to any other language - limiting allocations and reusing memory through object and array pooling. This will ensure that GC pauses are as infrequent and as short as possible. It's important to note that if there is sufficient allocation budget - the GC will not run. This way, in a well written code the GC may only ever trigger every few hundred frames and only take a millisecond to run. In fact, OSU! has been able to get consistently good frame times even back on .NET Framework. [0] https://github.com/dotnet/runtime/blob/main/docs/design/co
Read the rest
re... [1] https://maoni0.medium.com/dynamically-adapting-to-applicatio...
In Murder is a pixel art ECS game engine in C#
neonsunset·Oct 26, 2023
A note on putting the hot path into C component: Writing performance-sensitive code in C/C++ and calling it via interop used to be the way to go during .NET Framework days but since then has become a performance trap. Especially for small methods, calling them through interop is a deoptimization because they cannot be inlined, and involve GC frame transition (which you can suppress) as well as an indirect jump and maybe interop stub unless you are statically linking the dependency into your AOT deployment. In case the arguments are not blittable to C - marshalling too. Of course, this is much, much faster than anything Java or Go can offer, but still a cost nonetheless. It is also complicates the publishing process because you have to build both .NET and C parts and then package them together, considering the matrix of [win, linux, macos]
Read the rest
x [x64, arm64], it turns into quite an unpleasant experience. Instead, the recommended approach is just continuing to write C# code, except with pointer and/or ref based code. This is what CoreLib itself does for the most performance-sensitive bits[0]. Naturally, it intentionally looks ugly like in Rust, but you can easily fix it with a few extension methods[1]. [0]: https://github.com/dotnet/runtime/blob/main/src/libraries/Sy... [1]: https://github.com/U8String/U8String/blob/main/Sources/Compa...
In Was Rust Worth It?

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

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.