mrkeyoor.com_
Tue 01 Sept 17:43 UTC
Dev Toolsevaluationupdated 25 Aug 2026

roslyn review

Roslyn is Microsoft's open-source implementation of the C# and Visual Basic compilers, plus APIs that let programs inspect, understand, rewrite, and compile source code. It is the foundation for analyzers, code fixes, refactoring tools, editor intelligence, and language services across the .NET ecosystem.

+9stars / 7d
Verdict

Our sandbox did not run commit db9d3ac because C# is unsupported and the repository supplied no Dockerfile, so source-build ease remains unverified here. Use Roslyn's packages when your tool needs correct C# or Visual Basic semantics, diagnostics, or code changes; writing a substitute parser is rarely sensible. Clone the full repository only when you intend to contribute to the compiler or need to debug behavior below the public API.

We ran it

Screenshot of roslyn (docs.microsoft.com/dotnet/csharp/roslyn-sdk)

Answers from our run

Did you run roslyn yourself?

No. Its code is C#, and it carries no manifest our lab installs from, and no Dockerfile, so there was nothing standard to install, build or test. This review is written from the repository's own documentation.

Who should not use roslyn?

Application developers who only need to compile C# or Visual Basic: the .NET SDK already ships the compiler, so cloning Roslyn adds needless complexity.

What are the alternatives to roslyn?

Tree-sitter, OmniSharp Roslyn, LLVM. Use Roslyn's packages when your tool needs correct C# or Visual Basic semantics, diagnostics, or code changes; writing a substitute parser is rarely sensible.

Setup2/5NuGet use is easy; full source contribution is a large setup
Docs5/5Deep API, architecture, contribution, and test documentation
Community5/5Heavy daily activity across issues, reviews, and language work
Maturity5/5Production compilers underlying the C# and Visual Basic toolchain

Discussed on

  1. hnC# 7 Work List of Features246 points
  2. hnFirst C# 7 Design Meeting Notes154 points
  3. hnC# 7 Proposal: Nullable reference types and nullability checking84 points
  4. hnMicrosoft DevBlog: How to Write a Roslyn Analyzer12 points
  5. hnRecord Syntax for C#5 points

Who it’s for

.NET tool authors building analyzers, code fixes, generators, refactorings, or source-aware editors.
Compiler engineers who need the production C# or Visual Basic implementation.
Large .NET teams creating organization-specific diagnostics and automated migrations.
Contributors prepared for Microsoft's API review process and a large multi-platform test matrix.

Who it’s NOT for

Application developers who only need to compile C# or Visual Basic: the .NET SDK already ships the compiler, so cloning Roslyn adds needless complexity.
Contributors seeking a small, platform-neutral first project: the README sends development work to a detailed workflow centered on Windows and Visual Studio, while CI separates Windows, Unix, macOS, desktop, CoreCLR, and integration jobs.
Tool authors who need a tiny parser with no workspace or compiler model: Roslyn carries the semantics and scale of two production languages.
Teams expecting GitHub's latest-release page to describe current compiler delivery: its latest listed release is v4.0.1 from 2021, while repository work continued on August 25, 2026 through the wider .NET release process.

Setup reality

We did not run Roslyn in our sandbox because the lab runner has no supported C# ecosystem. Commit db9d3ac had no Dockerfile, so there was no repository-provided container fallback; we have no install, build, test, dependency, or audit numbers from that run.

Consumers normally add published Microsoft.CodeAnalysis NuGet packages or use the compiler included with the .NET SDK. Source contributors need the repository's pinned SDK and build scripts, while IDE work can involve Visual Studio instances, extensions, and targeted test projects. No service credentials are needed for ordinary local API use.

The CI table makes the platform burden visible: Windows debug and release builds, Unix builds, desktop and CoreCLR tests, integration tests, determinism checks, analyzers, source builds, Spanish localization, and macOS jobs. A focused analyzer project is much easier than rebuilding the whole compiler platform.

Roslyn is the compiler platform behind everyday .NET tooling

Roslyn implements the C# and Visual Basic compilers and exposes their understanding of code as public APIs. A program can parse syntax, bind names, inspect types, report diagnostics, transform source, and emit assemblies using the same compiler model that powers mainstream .NET development. That is why Roslyn is the normal base for analyzers, code fixes, source generators, refactoring tools, and editor features. It solves a difficult problem once: understanding real C# or Visual Basic rather than approximating either language with text matching.

Most developers should consume Roslyn through Microsoft.CodeAnalysis NuGet packages or through the .NET SDK, not build this repository. The README links public prerelease feeds for compiler, IDE services, and SDK work. Package selection still requires care because workspace APIs, compiler APIs, and editor integrations have different dependency and compatibility needs. Start with the narrowest package that supplies the syntax or semantic API your tool uses. A full workspace dependency is expensive baggage for a command that only parses one file.

Semantic analysis justifies the dependency

A syntax tree can tell you that a method call exists. Roslyn's semantic model can tell you which overload it resolves to, the inferred generic arguments, the conversions applied, and the symbol declared in another project. That difference separates a dependable migration from a search-and-replace script. Code fixes can attach to compiler diagnostics, analyzers can examine operations instead of raw tokens, and source generators can participate in compilation with knowledge of referenced types.

The cost is conceptual weight. Syntax nodes, trivia, symbols, compilations, workspaces, documents, projects, operations, diagnostics, and immutable transformations form a large API vocabulary. New tool authors often keep semantic models alive too long or repeatedly rebuild compilations. Roslyn rewards learning its ownership and caching patterns. For small editor highlighting across many languages, Tree-sitter may be a better fit. For C# correctness across projects and references, a lightweight parser is a false economy.

What happened when we ran it

We did not run Roslyn at commit db9d3ac because our sandbox does not support the C# ecosystem. The repository had no Dockerfile that could provide a project-defined environment. Consequently, our run produced no install duration, build result, test result, dependency count, disk usage, or vulnerability audit. The absence of lab numbers should not be read as a failure, but it means this review cannot confirm the contributor setup on our Debian container.

Roslyn's own CI matrix shows the work a meaningful source verification entails. It separates Windows debug and release builds, a Unix debug build, 32-bit and 64-bit desktop tests, CoreCLR tests on Windows and Linux, four Visual Studio integration configurations, determinism checks, analyzer checks, source-build verification, localization, and macOS. A green targeted unit test is useful during development, yet it is a small slice of the compatibility surface Microsoft maintains.

Source contributors follow dedicated build, debugging, and testing instructions, with the README pointing directly to a Windows workflow. IDE changes can require an experimental Visual Studio instance and extension packaging. Compiler-only work is more portable, but the repository still uses pinned .NET tooling and its own scripts. This is reasonable for a production compiler. It is also a poor choice for someone seeking a first small C# repository to understand over a weekend.

API changes go through review because downstream breakage is expensive

The repository directs Roslyn API suggestions through a formal API review process, while C# and Visual Basic language proposals live in separate repositories. That division matters. A compiler implementation bug belongs in Roslyn; a request for new C# syntax belongs in dotnet/csharplang; and a new public analysis API needs design scrutiny because third-party tools will compile against it. Filing work in the correct venue saves time and gives maintainers the context they expect.

Current activity shows that review machinery in use. The repository was pushed on August 25, 2026. Recently updated work included approved compiler APIs, analyzer changes, URI handling, Razor and VS Code integration, compiler-server behavior, diagnostics, and test infrastructure. GitHub listed 6,298 open issues and pull requests combined, a large queue that fits the project's age and scope. It should not be described as 6,298 confirmed bugs.

The GitHub latest-release endpoint is misleading if read alone. It returns v4.0.1 from December 2021, branded as .NET 6.0.1, even though commits and pull requests continued this week. Roslyn ships within the larger .NET and Visual Studio release system, and the README directs prerelease consumers to Microsoft feeds. The old standalone tag is therefore not evidence of abandonment. Package versions, SDK release notes, repository pushes, and issue activity give a more accurate health picture together.

Build failures are tracked as first-class infrastructure work

Several recently updated issues carry the Known Build Error label. They cover canceled tasks, crashed Windows test hosts, files locked during baseline updates, VSIX installer failures, and documentation-rule checks. These reports are useful because they distinguish infrastructure noise from product regressions. They also warn outside contributors that a failed full build may involve known CI or machine-state problems rather than their code alone. Read the matching issue before spending hours on a familiar error signature.

Roslyn is an easy recommendation as a dependency when exact .NET language meaning matters. It is harder to recommend as a casual source project because compiler correctness, IDE behavior, package compatibility, and cross-platform tests all meet in one tree. Build a small analyzer against released packages first. Move into the repository only after the public API cannot answer the question or you are ready to work within its review and test discipline.

Alternatives

ProjectWhat it isPick it when
Tree-sitter gh↗An incremental parsing system used for fast concrete syntax trees in editors.pick this instead when you need lightweight syntax parsing across many languages and can live without Roslyn's C# semantic model.
OmniSharp RoslynA C# language server that exposes Roslyn features to editors outside Visual Studio.pick this instead when the immediate job is adding C# editor support rather than building a compiler API client from scratch.
LLVM gh↗A compiler infrastructure collection spanning optimizers, code generation, and language tooling.pick this instead when you are implementing a language or native backend rather than analyzing C# and Visual Basic.

What people are saying

  1. [velocity-scout] dotnet/roslyn

Sources

  1. Roslyn repository and README
  2. Roslyn compiler API overview
  3. Roslyn contribution guide
  4. Known Roslyn build error tracking

More dev tools reviews

workmux · v2rayNG · SecLists · hashcat · eslint · fastfetch · the whole board →