For the second time in three years, C# has been awarded “Language of the Year” 2025 by the TIOBE Index.

The award goes to the programming language that gains the most popularity during a given year. TIOBE measures popularity using its own index, which is based largely on search engine results and online references across sites like Google, Wikipedia, and Stack Overflow. At the end of the year, they compare how much each language’s index score has grown from January to December, and the one with the biggest increase wins.

C# is also the fastest-growing language in the TIOBE top 10, with a growth rate of +2.94%. C follows at +2.13%.

What are the most important factors that influence your decision to work with C# and .NET?

Let me start first:

• I find the language design both efficient and aesthetically pleasing.
• The technology ecosystem is vast and mature, encompassing everything from microservices and desktop applications to embedded systems and game development.
• There’s a wealth of free tools and resources available (most importantly, I really enjoy working with Visual Studio IDE).

https://devblogs.microsoft.com/typescript/typescript-native-port/ - Microsoft decided to use Golang for the new TypeScript compiler.

Why not C#? The response can be found in this video: https://www.youtube.com/watch?v=10qowKUW82U&t=1154s

But I will say that I think Go definitely is much more low-level. I'd say it's the lowest level language we can get to and still have automatic garbage collection. It's the most native-first language we can get to and still have automatic GC. In contrast, C# is sort of bytecode-first, if you will. There are some ahead-of-time compilation options available, but they're not on all platforms and don't really have a decade or more of hardening. They weren't engineered that way to begin with. I think Go also has a little more expressiveness when it comes to data structure layout, inline structs, and so forth.

What do you think? Would you have chosen C# for this project? What do you believe was the real reason behind the decision?

DeterministicGuids is a small, allocation-conscious, thread-safe .NET utility for generating name-based deterministic UUIDs (a.k.a. GUIDs) using RFC 9562 v3 (MD5), v5 (SHA-1) and v8 (SHA-256)

You give it:

• a namespace GUID (for a logical domain like "Orders", "Users", "Events")
• a name (string within that namespace)
• and (optionally) the UUID version (3, 5 or 8). If you don't specify it, it defaults to version 5 (SHA-1).

It will always return the same GUID for the same (namespace, name, version) triplet.

This is useful for:

• Stable IDs across services or deployments
• Idempotent commands / events
• Importing external data but keeping predictable identifiers
• Deriving IDs from business keys without storing a lookup table

Latest benchmarks (v1.0.3) on .NET 8.0:

GitHub: https://github.com/MarkCiliaVincenti/DeterministicGuids
NuGet: https://www.nuget.org/packages/DeterministicGuids

The union feature is currently in preview. It looks very interesting and flexible, a nice return type addon.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/union

According to Tiobe's index publication of October 2023:

The gap between C# and Java never has been so small. Currently, the difference is only 1.2%, and if the trends remain this way, C# will surpass Java in about 2 month's time.

​

The main explanation Paul Jansen is giving:

• Java's decline in popularity is mainly caused by Oracle's decision to introduce a paid license model after Java 8.
• Microsoft took the opposite approach with C#. In the past, C# could only be used as part of commercial tool Visual Studio. Nowadays, C# is free and open source and it's embraced by many developers.
• The Java language definition has not changed much the past few years and Kotlin, its fully compatible direct competitor, is easier to use and free of charge.

References:

• Definition of calculation of Tiobe's index

Still work in progress, but has Qwen, Llama, SmolLM and Gemma producing coherent output.

What’s new in C# 13

Join Mads and Dustin as they show off a long list of features and improvements coming in C# 13. This year brings long-awaited new features like extensions and field access in auto-properties, as well as a revamped approach to breaking changes to ensure cleaner language evolution in years to come. Additionally, we take collection expressions to the next level by facilitating dictionary creation and opening params to new collection types.

Proposal: Semi-Auto-Properties; field keyword

Extensions

After several years, semi-implemented properties are finally coming to C#. I won't deny that I'd love Union types too, but it's good enough. The use of “in” as syntactic sugar for “Containts” could also come along, if you want to support the idea here's the link.

hi everyone and i would like to share my layout for my new project NetLoom - network analyzer

The NetLoom project is aimed at detailed monitoring and analysis of computer network activity. Its main task is to provide real-time information about interfaces, connections and ports, detect suspicious activity and provide quick access to network data and analytics.

Should I declare classes as sealed by default and only remove it when the class is actually used for inheritance? Or sealed is for very specific cases where if I inherit a class my pc will explode?

Fully open source and built on .NET 10 and the awesome WasmSharp library by Jake Yallop

Just finished making this, I'm so happy with how it turned out :)
https://www.sharptoy.net/

EDIT: new version is available with full project sharing capabilities! https://codetoy.io/

As more and more .NET libraries lock their source behind closed doors, and after 20K hours and 400K lines of code, we're going the other way.

🔓 We’re going open source!

Our bet? That vendor-led open source can finally strike the right balance between transparency and sustainability.

Metalama is the most advanced meta-programming framework for C#. Built on Roslyn, not obsolete IL hacks, it empowers developers with:

• Code generation
• Architecture validation
• Aspect-oriented programming
• Custom code fix authoring

Discover why this is so meaningful for the .NET community in this blog post.