.Net 5 and C# 9.0 are very much 100% open all the way down to the core.
https://github.com/dotnet/roslyn (c#)
https://github.com/dotnet/winforms (UI)
https://github.com/dotnet/wpf (UI)
https://github.com/dotnet/core (Foundation)
I don't consider the Win32 API itself part of .NET or C# as they've existed long before either.
In Swift on Windowsdotnet
roslyn
C#2015–2026
dotnet / roslyn
roslyn
The Roslyn .NET compiler provides C# and Visual Basic languages with rich code analysis APIs.
115Distinct people
143Mentions
1Explicit recommenders
20.8KGitHub stars
What to know before exploring
What it is
The Roslyn .NET compiler provides C# and Visual Basic languages with rich code analysis APIs.
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
> - I love that they are adding REPL. I really wish C# had this Here you go :) https://github.com/dotnet/roslyn/wiki/C%23-Interactive-Walkt... Also: csi.exe. Try it :)
josteink 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
- dotnet/coreclr · linked in 4 of the same discussions
- dotnet/corefx · linked in 3 of the same discussions
- dotnet/core · linked in 2 of the same 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, 2:04:58 PM 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 year143 dated mentions
Observed mentions: 2015-01-14 23:49:47 UTC to 2026-05-11 08:56:48 UTC.
* 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
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 32 | 6 | 26 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 28 | 6 | 22 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 26 | 2 | 24 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 6 | 1 | 5 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 12 | 0 | 12 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 11 | 1 | 10 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 6 | 1 | 5 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
The .NET Compiler Platform
Roslyn is the open-source implementation of both the C# and Visual Basic compilers with an API surface for building code analysis tools.
C# and Visual Basic Language Feature Suggestions
If you want to suggest a new feature for the C# or Visual Basic languages go here:
dotnet/csharplang for C# specific issues
dotnet/vblang for VB-specific features
dotnet/csharplang for features that affect both languages
Contributing
All work on the C# and Visual Basic compiler happens directly on GitHub. Both core team members and external contributors send pull requests which go through the same review process.
If you are interested in fixing issues and contributing directly to the code base, a great way to get started is to ask some questions on GitHub Discussions! Then check out our contributing guide which covers the following:
Coding guidelines
The development workflow, including debugging and running tests
Submitting pull requests
Finding a bug to fix in the IDE or Compiler
Finding a feature to implement in the IDE or Compiler
Roslyn API suggestions should go through the API review process
Community
The Roslyn community can be found on GitHub Discussions, where you can ask questions, voice ideas, and share your projects.
To chat with other community members, you can join the Roslyn channel on the CSharp Community Discord.
Our Code of Conduct applies to all Roslyn community channels and has adopted the .NET Foundation Code of Conduct.
Documentation
Visit Roslyn Architecture Overview to get started with Roslyn’s API’s.
NuGet Feeds
The latest pre-release builds are available from the following public NuGet feeds:
Compiler: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json
IDE Services: https://pkgs.dev.azure.com/azure-public/vside/_packaging/vssdk/nuget/v3/index.json
.NET SDK: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json
Continuous Integration status
Builds
Branch
Windows Debug
Windows Release
Unix Debug
main
Desktop Unit Tests
Branch
Debug x86
Debug x64
Release x86
Release x64
main
CoreClr Unit Tests
Branch
Windows Debug
Windows Release
Linux
main
Integration Tests
Branch
Debug x86
Debug x64
Release x86
Release x64
main
Misc Tests
Branch
Determinism
Analyzers
Build Correctness
Source build
TODO/Prototype
Spanish
MacOS
main
.NET Foundation
This project is part of the .NET Foundation along with other projects like the .NET Runtime.
Read the full README on GitHubWhat Hacker News says
12 sourcesThe new source generators in C# 9 seem like a good compromise. Rather than rewriting code they can only add code but that ensures some amount of predictability.
https://github.com/dotnet/roslyn/blob/master/docs/features/s...
In Checked exceptions: Java’s biggest mistake (2014)Opinionated +1 :)
The C# compiler is called Roslyn which might not be obvious for people trying to find it on GitHub - it's incredibly well supported, regularly updated, and lively:
https://github.com/dotnet/roslyn
In Show HN: An introduction to Go for C# peopleI would point to https://github.com/dotnet/roslyn itself as an example of a modern codebase. We try to adopt and use all of the new language features there as we write them to try and determine if the ergonomics are good.
In Welcome to C# 9.0I'm guessing you mean something other than FOSS (free / open source software) in your critique of FOSS. Reason being, Swift is FOSS (https://github.com/apple/swift), both the compiler and the standard library. Likewise, the Microsoft C# compiler is also FOSS (https://github.com/dotnet/roslyn).
You seem to enjoy closed-source platform libraries (WinForms, AppKit), and want to promote developing software that relies on them. The survival characteristics of this approach don't seem very strong. Good luck!
In Being Slow to CriticiseHey Eric thanks for responding here!
Love that article, it was interesting to read your dissection of code comments.
For anyone else reading it, here's an updated link to the CS file referenced in his blog post (the original moved): https://github.com/dotnet/roslyn/blob/master/src/Compilers/C...
In New Grad vs. Senior DevThe VB compiler is written in VB: https://github.com/dotnet/roslyn/tree/master/src/Compilers/V...
In The chronic suffering of the VB.NET communityIs it faster to read? Maybe in terms of bytes/s, but not in lexemes/s nor in terms of getting an overall idea of how everything works.
Compare with this, which is probably more in the style you're thinking of:
https://github.com/dotnet/roslyn/blob/master/src/Compilers/C...
There's so much "noise" that it's hard to see the "big picture", and the repetition of VeryLongIdentifiers causes https://en.wikipedia.org/wiki/Semantic_satiation to occur quickly.
In C4: C in Four Functions (2014)You can look through GH milestones to see specific issues fixed in results. For example, here are the 230 tracked items done for the VS 16.4 public release: https://github.com/dotnet/roslyn/milestone/53?closed=1
You can also see that there are many more resolved issues in previews of that public release: https://github.com/dotnet/roslyn/milestones?state=closed
So there are a _lot_ of legitimate problems being fixed and enhancements being added over pretty short periods of time.
When something is resolved as "no reproduction" or "not a bug", that's because there was an earnest attempt to reproduce an issue with the latest bits set to go out to a release with no reproduction, or something is truly by design (e.g., user files an issue because they would prefer a feature to do something different than it does today).
In How Microsoft rewrote its C# compiler in C# and made it open source (2017)> I blame this directly on the immutable AST. While a nice concept in theory, it causes too many allocations, and is cumbersome to work with.
This isn't a cause of performance problems you're seeing. What's most likely happening is that the overall size of your code has increased a lot over time, causing performance issues due to issues that have existed for a long time, but weren't being felt yet.
The issue that's most directly related to this is here: https://github.com/dotnet/roslyn/issues/40300
However, immutable vs. mutable isn't related to the issue I linked. It's just about keeping more data around than is (perhaps) necessary. You'd see the same issue with a mutable AST. If you're curious about specific work that's being tracked you can use this label: https://github.com/dotnet/roslyn/issues?q=is%3Aopen+is%3Aiss...
And if you submi
Read the rest
t reports via the VS Report a Problem tool, with the option to collect a diagnostic trace, you'll generate exactly the data needed to fix issues that you're facing. The team is very keen on addressing performance problems, especially if there's diagnostic data that can pinpoint the source of a problem.
C# records:
https://github.com/dotnet/roslyn/blob/features/records/docs/...
It's a struct or class but you only define the data members and the compiler auto-generates boiler plate like constructors, equality tests, etc.
In Java 14 Feature Spotlight: RecordsMicrosoft's Roslyn [1] design (now called .NET Compiler Platform) is what I think any language should strive for, turning the classical black box of the compiler into an incremental pipeline where each stage is annotated/augmented/refined by different mechanisms such as type checkers.
If each step is incremental, it follows that it's easier to also let each step "integrate" deltas; for example, adding a comment shouldn't need to recompile anything at all, merely modify the AST, because it doesn't lead to any actual code artifacts. The second benefit is that all the information needed to inspect the program — from syntax highlighting to type information — is already there.
If you can keep the entire high-level compilation state in memory, then it's easy to query it for all sorts of IDE features. This same design was used for the TypeScript
Read the rest
compiler. Anders Heljsberg has a great little lecture [2] about it.
[1] https://github.com/dotnet/roslyn/wiki/Roslyn-Overview
[2] https://www.youtube.com/watch?v=wSdV1M7n4gQ