“i++” and “i += 1” produce different IL
3 points · Open discussiondotnet
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, 5:58:02 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.
* 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
6 sourcesOkay, let's go through that list:
Visual C# is Microsoft.
Visual C# Express is Microsoft.
Mono -> Xamarin is now Microsoft.
Portable.NET -> Dot Gnu Project, has been decommissioned 11 years ago.
SharpDevelop -> IC#Code Team, project will be/has already been decommissioned, see [0].
Roslyn -> .NET Foundation, which was written by Microsoft, and is currently maintained (according to [1]) primarily by people working at Microsoft.
That last repo you posted is of course nice but like you said, it's tiny, doesn't even support arrays and is undocumented. Seems more like a assignment for a compiler building course. Like it though.
So, thanks for making me do some googling on this, but it just proved my point.
[0] https://github.com/icsharpcode/SharpDevelop/issues/799#issue...
[1] https://github.com/dotnet/roslyn/pulse
In What Makes .NET Core So Special?The ideal structure of a programming language seems to depend on the user. I mean, if someone thinks in machine code and can't understand anything else, then machine code's optimal for them, regardless of how impractical it might be for just about everyone else.
What we really need is intentional programming: we specify what we want, in whatever manner is most natural to the user, and the computer figures out how to make that happen. The computational expense of transforming intent into machine code is unavoidable; it has to be paid through some combination of human and machine effort, so there's no additional cost incurred by having a machine do it.
The really cool part about all of this is that, once you have a system that can transform intent into code, it's trivially meta-circular, causing it to become self-optimizing. And once you
Read the rest
integrate machine learning into its optimization logic, it becomes intelligent, using machine learning to optimize its own logic, including the machine learning, continuously reemitting further optimized variants of itself to whatever computational resources it has available; getting it to utilize various CPU's, GPU's, distributed architectures, etc., becomes a matter of specifying their operation, such that it's like writing drivers (except the system merely needs to know what the computational resources _can_ do; the problem of how to make best use of those abilities remains a problem for the intentional logic itself).
Anyway, that's the premise of my startup, Intentional Systems. I've been working on this for a good while, and ended up applying to YCombinator's W2019 round. Regardless of how that goes, this is what's happening; intentional operation's the future. And it's awesome!
With respect to this blog post, my point's that we don't really need a "language" for the 21st century, but rather a system that allows users to specify what they want in whatever terms make sense to them -- whether that's machine code, C, Lisp, JavaScript, engineering flowsheets with equations, English, or pig-Elvish -- so long as that language has a definition that provides mappings to machine code, the problem of how to map that language to machine code is a logical problem that a machine can address.
The example in the blog is a special case:
1. > FILE * test_file = fopen(“/tmp/test.txt”, “w+”);
2. > create file /tmp/test.txt for input and output as test_file
Here, the two languages have the same logic, varying only superficially. This allows an IDE to save that logic as an AST, then display it to a user according to their personal display preferences. There's no reason anyone opening that code in their IDE has to see it in Format 1 vs. Format 2 any more than they have to see it in Font 12 vs. Font 14. I think the folks behind Roslyn tried to capture the source code's features that were extraneous to the AST as ["syntax trivia"](https://github.com/dotnet/roslyn/wiki/Roslyn-Overview#syntax...).
It's a less trivial issue when the code isn't so transparently bijective. For example, programmers collaborating on the same project would have more trouble interacting if some prefer to program in [Rule 110](https://en.wikipedia.org/wiki/Rule_110) while others prefer idiomatic JavaScript. I mean, that's an addressable scenario, but it's more complicated.
> Is there already a complete free C#-Compiler available for posix systems, which can be recompiled without non-free parts from microsoft
Is the Apache 2 licensed Roslyn compiler not free enough for you? https://github.com/dotnet/roslyn
In Microsoft Joins the Open Invention NetworkFrom what I've seen (MS folks can correct me here), language services are part of a much larger effort at Microsoft led by Anders Heijsberg (Delphi, C#) called Roslyn [1], which decouples code analysis from IDEs and provides things like refactoring, autocomplete, find-all-references, Intellisense, etc. as services.
This means the compiler is now an abstracted platform that editors can get services from (CompilerAndCodeAnalysis-as-a-service?). Anders talks about the motivation for doing that here [2].
It's a pretty exciting idea. This might mean I would some day be able to use Vim and get IDE-like functionality.
[1] Roslyn https://github.com/dotnet/roslyn/wiki/Roslyn-Overview
[2] https://www.youtube.com/watch?v=wSdV1M7n4gQ
In Introducing the Python Language Server> their JS engine
https://github.com/Microsoft/ChakraCore
> their compiler
Microsoft makes half a dozen compilers, for as many languages:
https://github.com/dotnet/roslyn
https://github.com/fsharp/fsharp
https://github.com/PowerShell/PowerShell
The only one that I know of that is closed is C++.
> anything else of note
https://github.com/Microsoft/GVFS
https://techcrunch.com/2016/11/16/microsoft-joins-the-linux-...
In Hello, GitHub