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

roslyn

The Roslyn .NET compiler provides C# and Visual Basic languages with rich code analysis APIs.

Languages & Compilers
Explore on GitHubRead Hacker News discussions
115Distinct people
143Mentions
1Explicit recommenders
20.8KGitHub stars
REPOSITORY AT A GLANCE

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

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:59:53 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 year143 dated mentions

Observed mentions: 2015-01-14 23:49:47 UTC to 2026-05-11 08:56:48 UTC.

01020302015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 32 mentions; 6 submissions, 26 comments20152016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 28 mentions; 6 submissions, 22 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 26 mentions; 2 submissions, 24 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 6 mentions; 1 submissions, 5 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 12 mentions; 0 submissions, 12 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 3 mentions; 1 submissions, 2 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 11 mentions; 1 submissions, 10 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 6 mentions; 1 submissions, 5 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
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC32626
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC28622
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC26224
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC615
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC606
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC12012
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC101
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC404
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC312
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC11110
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC808
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC615

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 GitHub

What Hacker News says

26 sources
pjmlp·Jul 19, 2017
> It's why java/c# will never be as fast as c. C# has value types, added local references and reference returns on C# 7, and they will be adding more features from System C# (Midori) in the 7.1, 7.2 and 8.0 releases. https://github.com/dotnet/roslyn/blob/master/docs/Language%2... Microsoft recently did an interview where they admitted they only cared to make their native code compilers for .NET "good enough" and are now planning on changing that. https://www.infoq.com/articles/high-performance-dotnet Also .NET Native actually makes use of the same backend as Visual C++. Java is not yet there with value types, but in about 5 years time, Java 10 will be here with them. They are also available in prototype form today for anyone that wants to play with them. I wrote my first games on a Timex 2068, since then I have witness and took part in m
Read the rest
any variations of this subject. Started with, no serious game programmer would use anything other than Assembly. C, Pascal, Basic, Modula-2 lack the register control, memory layouts, instruction count, ability to self modifying code that Assembly allows for. Followed by, no serious game programmer would use anything other than C or Pascal. C++ adds too much bloat to make any game worthwhile playing. Now he are on, no serious game programmer would use anything other than C or C++. Java, C# and other type safe languages will never perform as good as C and C++. Fact is that the majority of games I see on the stores aren't really AAA pushing the hardware limit, many of which have graphics and gameplay that could have been done with AMOS on an Amiga 500 and people would hardly notice. > As far as unity goes, all the heavy lifting in the game engine is still done in c/c++, c# is only used as a scripting language Since IL2CPP got mature some of that C++ code is actually C# code. If you pay attention to the Unite 2016 and 2017 keynotes they are rewriting the not so performance critical components from C++ to C#. Finally the programming language compilers that come with the games consoles and OS SDKs also play a big role, and games developers tend to stick with what they get with the SDKs.
In LWJGL: Lightweight Java Game Library 3
pjmlp·Jul 2, 2017
Edit isn't allowed any longer, so here are some extra informations. Joe Duffy's blog about Midori http://joeduffyblog.com/2015/11/03/blogging-about-midori/ Joe's blog entry about what was known as M# at the time http://joeduffyblog.com/2013/12/27/csharp-for-systems-progra... Joe's presentation at QCon 2015, "Safe Systems Programming in C# and .NET" https://www.infoq.com/presentations/csharp-systems-programmi... Channel 9 presentations about MDIL compiler for Windows 8.x https://channel9.msdn.com/Events/Build/2012/3-005 https://channel9.msdn.com/Shows/Going+Deep/Mani-Ramaswamy-an... Channel 9 presentations about .NET Native https://channel9.msdn.com/Shows/Going+Deep/Inside-NET-Native https://channel9.msdn.com/events/dotnetConf/2014/-NET-Native... GC Improvements on .NET 4.6, including memory guarantees for performance critical sections htt
Read the rest
ps://docs.microsoft.com/en-us/dotnet/api/system.gc.trysta... https://blogs.msdn.microsoft.com/alphageek/2017/01/24/signif... C# roadmap for 7.1, 7.2 and 8.0 with more memory friendly features https://github.com/dotnet/roslyn/blob/master/docs/Language%2... Joe is presenting a keynote at Rustconf, about memory safe systems programming. http://rustconf.com/program.html#joe
In Pony: Combining safe memory sharing with Erlang-like actors
Const-me·May 12, 2017
> only a very small fraction of code written in Java, C#, or any other high-level OOL does dynamic code generation, or even reflection The overall fraction might be small, however vast majority of software still contain substantial amount of code that does. Most serialization and DB access libraries do. For C#, this includes all framework-provided serializers (XML, data contract, etc.), the ubiquitous Json.NET, and my own one: https://github.com/Const-me/EsentSerialize > OOP doesn't allow people to reason about complex systems Respectfully disagree, ‘coz I have never saw complex systems that aren’t OOP. Even most compilers are OOP, take a look: https://github.com/llvm-mirror/llvm https://github.com/gcc-mirror/gcc/tree/master/gcc https://github.com/dotnet/roslyn > An object can contain references to any other object held by the process Th
Read the rest
is is true for very small class of objects, like GUI controls with loosely typed event handlers, or objects that hold lambdas/functions that may capture anything at all (but the latter is not strictly OOP). An object can only reference other objects of types that can be stored in its properties/fields. For many objects especially simple lower-level ones, this means objects can reference no other objects at all. > have never seen an OOP code base less than 10x the complexity of the business problem it was built to solve My guess is, you’re systematically underestimating complexity of the business problems solved by the code you look at.
In Don't overuse interfaces
Nelkins·Apr 21, 2017
Here's a comment that mirrors my own thoughts, from the comments on that third link[1]: "C# heap allocations aren't expensive and are faster than C/C++. They are even faster than stack allocations (if the stack alloc is too large to be a register) as the stack needs to zero out the memory first; whereas the heap has done this ahead of time. However, they do come at a cost, which is deallocation. C/C++ have both an allocation and deallocation cost. The main advantage is you know when you are paying that deallocation cost; the main disadvantage is you often do it at the wrong time or don't do it at all which leads to memory leaks, using unallocated memory or worse trashing something else's memory (as it has been reallocated). The GC isn't the bad guy; its the liver and blaming it is like blaming a hangover on the liver. However; the free dr
Read the rest
inks the clr allocation bar gives you are very tempting, and does mean there is a tendency to over indulge so the hangovers can be quite bad... (GC pauses)." [1] https://github.com/dotnet/roslyn/issues/10378#issuecomment-2...
In I was wrong, reflecting on the .NET design choices
zastrowm·Mar 10, 2017
From https://github.com/dotnet/roslyn/issues/347 (Details > Mutability): > Should tuples be mutable or immutable? The nice thing about them being > structs is that the user can choose. If a reference to the tuple is > readonly then the tuple is readonly. > Now a local variable cannot be readonly, unless we adopt #115 (which is > likely), but that isn't too big of a deal, because locals are only used > locally, and so it is easier to stick to an immutable discipline if you > so choose. > If tuples are used as fields, then those fields can be readonly if > desired.
In New Features in C# 7.0
chubot·Mar 8, 2017
My claim is that neither the parse tree/CST or AST is good for applications like translators. Instead I defined another term Lossless Syntax Tree, which is the data structure I want: http://www.oilshell.org/blog/2017/02/11.html I researched "production" implementations, and found that they use something like a Lossless Syntax Tree (not an AST or CST): https://github.com/oilshell/oil/wiki/Lossless-Syntax-Tree-Pa... Examples: Clang, Microsoft's Roslyn platforms, RedBaron/lib2to3 for Python, scalameta, and Go. The defining property of the LST is that it can be round-tripped back to the source. This is called out in this C# design doc, along with some conventions for associating whitespace with syntax tree nodes: https://github.com/dotnet/roslyn/wiki/Roslyn-Overview What do you think of that claim? (If you prefer not to use this deep comm
Read the rest
ent thread, feel free to contact me by e-mail instead at andychup@gmail.com.)
In ANTLR Mega Tutorial
Metasyntactic·Mar 7, 2017
Hi Eitland! I'm a dev on the C#/VB IDE experience (and i've written and maintain many of the Refactorings for those languages). C# and VB do support refactorings like 'Extract Method' and 'Move to Separate File'. We've also exposed a full analysis and code manipulation API through 'Roslyn' so that community members can contribute even more refactorings through extensions. One reason this may not have been clear is that previously we didn't strongly indicate to you that a refactoring was available. i.e. when you selected some code to extract a method, you would then have to use ctrl-dot to get the list of things you could do. Now, in VS2017 we pop up our 'Lightbulb' whenever refactorings are available. This helps make the refactorings much more discoverable and we've seen a very large uptick in people invoking them now that it's much c
Read the rest
learer that they're available. If you use VS2017 and find issues with our fixes/refactorings, or you would like us to add more, please file feedback at https://github.com/dotnet/roslyn Thanks!
In Visual Studio 2017 Launch [video]

Showing the 15 most recent of 26 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.