The History of C#: From Project Cool to a Modern Open-Source Language

During the late 1990s, Microsoft faced a difficult transition. Windows development was split across native C++, Visual Basic, COM, and a growing web platform. Java had demonstrated the appeal of a managed runtime, automatic memory management, and portable bytecode. Microsoft needed a coherent developer platform with safer execution and a language designed around it.

In 1999, a team led by Anders Hejlsberg began work on a language internally known as Cool, commonly expanded as "C-like Object Oriented Language." Hejlsberg had previously created Turbo Pascal and led the design of Delphi. The new language kept the braces, expressions, and familiar control flow of the C family, while adopting garbage collection, metadata, properties, delegates, exceptions, and a unified type system.

The name Cool did not survive product development. Microsoft publicly introduced C# in 2000 alongside the .NET platform. The sharp symbol suggested an incremental step beyond C++, while also resembling the musical notation for a raised note.

C# was not designed in isolation. The language, Base Class Library, Common Language Runtime, and metadata system were parts of one platform design.

This distinction explains much of C#'s later evolution. A language feature can depend on compiler lowering, runtime support, library APIs, or all three.

C# 1.0 shipped with Visual Studio .NET 2002 and .NET Framework 1.0. The first release already contained most of the language's lasting identity:

• Classes, interfaces, structs, and enums.
• Properties, indexers, events, and delegates.
• Attributes and runtime metadata.
• Exceptions and structured resource cleanup with using.
• Garbage collection with access to unsafe code when required.
• A unified type system in which value and reference types share object.

public sealed class TemperatureSensor
{
    private decimal _celsius;

    public event EventHandler ThresholdReached;

    public decimal Celsius
    {
        get { return _celsius; }
    }

    public void Record(decimal value)
    {
        _celsius = value;

        EventHandler handler = ThresholdReached;
        if (value >= 80 && handler != null)
            handler(this, EventArgs.Empty);
    }
}

The deliberately C# 1-style example still looks recognizable today, which is evidence of the foundation's durability. Properties and events gave component- oriented development first-class syntax without hiding their methods and metadata from the runtime.

Microsoft also submitted C# and the Common Language Infrastructure to ECMA. The first C# standard, ECMA-334, was approved in 2001; ISO followed in 2003. Standardization gave the language an identity beyond a single compiler, even though Microsoft's implementation remained the center of the ecosystem.

C# source normally compiles into Common Intermediate Language, or CIL, plus metadata. The Common Language Runtime verifies and loads that assembly, then uses just-in-time or ahead-of-time compilation to produce native code.

This separation made several long-term capabilities possible:

• Multiple languages could target the same runtime and libraries.
• Assemblies could describe their own types through metadata.
• The runtime could manage memory, exceptions, threads, and code generation.
• Compilers could add syntax by lowering it into existing runtime concepts.
• Runtime improvements could accelerate old binaries without recompilation.

The architecture also created tension. Runtime-dependent features require coordination and cannot always be delivered as compiler syntax alone. C#'s history is partly the story of deciding which layer should own each feature.

C# 2.0 arrived with Visual Studio 2005 and .NET Framework 2.0. Its defining feature was generics. Before generics, general-purpose collections stored values as object, requiring casts and boxing value types. Generics made the element type part of the API:

public sealed class Repository<T> where T : IEntity
{
    private readonly Dictionary<Guid, T> _items = new();

    public void Add(T entity) => _items.Add(entity.Id, entity);

    public T? Find(Guid id) => _items.GetValueOrDefault(id);
}

Unlike a purely source-level template system, .NET generics are represented in runtime metadata. The CLR understands generic types and methods, preserves type information, and can specialize value-type implementations to avoid boxing.

C# 2.0 also introduced nullable value types, iterators with yield return, anonymous methods, partial types, and improved delegate conversion. These features shared a pattern that would define later releases: concise source syntax transformed by the compiler into explicit machinery.

C# 3.0 was unusually cohesive. Rather than adding disconnected conveniences, it introduced a group of features that together enabled Language Integrated Query:

• Lambda expressions.
• Extension methods.
• Expression trees.
• Anonymous types.
• Object and collection initializers.
• Local variable type inference with var.
• Query expression syntax.

var activeNames = customers
    .Where(customer => customer.IsActive)
    .OrderBy(customer => customer.LastName)
    .Select(customer => $"{customer.FirstName} {customer.LastName}")
    .ToArray();

The same expression can operate over in-memory objects through IEnumerable<T> or become a data structure through IQueryable<T>. A provider can inspect that expression tree and translate it into SQL or another query language.

LINQ influenced API design far beyond databases. Fluent pipelines, extension methods, and lambdas became normal C# vocabulary. It also demonstrated the benefit of features designed as a system rather than a checklist.

C# 4.0 focused on code that interacts with dynamic systems and component models. The dynamic type deferred member binding until runtime, simplifying some COM automation, reflection-heavy APIs, and dynamic-language integration.

dynamic worksheet = excel.Worksheets[1];
worksheet.Cells[1, 1].Value = "Quarter";

Named and optional arguments reduced ceremony in APIs with many parameters. Generic covariance and contravariance made interfaces and delegates compose more naturally. These additions were not an abandonment of static typing; they created explicit boundaries where runtime binding was useful.

C# 5.0 introduced async and await, one of the language's most influential features. Asynchronous APIs already existed, but callbacks and manually composed tasks made control flow difficult to read. Await restored the shape of sequential code without blocking a thread.

public async Task<Profile> LoadProfileAsync(
    Guid userId,
    CancellationToken cancellationToken)
{
    User user = await users.FindAsync(userId, cancellationToken);
    Preferences preferences = await settings.LoadAsync(userId, cancellationToken);

    return new Profile(user, preferences);
}

The method does not pause a thread at each await. The compiler rewrites it into a state machine that records local state and schedules continuation when the awaited operation completes.

Async/await later influenced JavaScript, Python, Rust, Swift, and many other languages. C# did not invent asynchronous state machines, but it made the model approachable enough to become ordinary application code.

For its first decade, developers primarily experienced the C# compiler as a closed Microsoft product. Roslyn changed that relationship. Microsoft open- sourced the C# and Visual Basic compiler platform in 2014 and moved development to GitHub.

Roslyn exposed syntax trees, semantic models, diagnostics, and code transformations as APIs. Editors, analyzers, source generators, and refactoring tools could use the same understanding of code as the compiler itself.

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class ApiAnalyzer : DiagnosticAnalyzer
{
    public override void Initialize(AnalysisContext context)
    {
        context.EnableConcurrentExecution();
        context.RegisterSyntaxNodeAction(AnalyzeMethod, SyntaxKind.MethodDeclaration);
    }
}

At roughly the same time, .NET itself began a larger transition. The .NET Foundation was established, core runtime components became open source, and .NET Core 1.0 shipped in 2016 as a cross-platform implementation for Windows, Linux, and macOS.

This was more than publishing source code. Language proposals, compiler changes, runtime work, and design discussions became inspectable. Community members could report issues against implementation details, build experimental features, and contribute fixes.

Roslyn made compiler development easier to evolve. C# 6 in 2015 concentrated on everyday clarity: string interpolation, null-conditional operators, nameof, expression-bodied members, exception filters, and improved initializers.

C# 7 and its point releases added pattern matching, tuples, deconstruction, local functions, out variables, ref returns, Span<T>-friendly features, and async improvements.

public static decimal CalculatePrice(Order order) => order switch
{
    { Customer.IsPremium: true, Total: > 1000m } => order.Total * 0.85m,
    { Customer.IsPremium: true }                 => order.Total * 0.90m,
    { Total: > 1000m }                           => order.Total * 0.95m,
    _                                             => order.Total
};

Pattern matching began modestly and expanded over later versions. Its growth shows the modern design process: establish a foundation, observe real usage, then add composable forms without replacing the original model.

Tony Hoare famously called the null reference his "billion-dollar mistake." C# inherited null for every reference type, and changing that behavior after millions of programs existed was impossible.

C# 8 introduced nullable reference type analysis as an opt-in compatibility layer. string means a value intended not to be null, while string? records possible absence. The compiler uses flow analysis to warn about unsafe access.

#nullable enable

public static int LengthOrZero(string? value)
{
    if (value is null)
        return 0;

    return value.Length;
}

The runtime representation did not change. Instead, annotations and compiler analysis created a gradual migration path for existing libraries. C# 8 also added async streams, ranges and indices, switch expressions, and default interface methods.

.NET 5 unified the product direction after .NET Framework and .NET Core. C# then settled into an annual release rhythm aligned with .NET:

Records are a good example of modern C# balancing new models with existing object-oriented code. They provide concise syntax for value-oriented data while remaining .NET types:

public sealed record Deployment(
    string Service,
    string Version,
    DateTimeOffset CreatedAt);

Deployment next = current with { Version = "2.4.0" };

The modern language has also expanded low-level capabilities. Span<T>, Memory<T>, ref structs, function pointers, native-sized integers, generic math, and Native AOT allow C# to address workloads that once required leaving managed code entirely.

Modern C# design happens in public repositories. A feature generally moves through several stages:

1. A problem and possible design are discussed.
2. A proposal specifies syntax and semantics.
3. Language design meetings resolve tradeoffs.
4. Roslyn implements compiler behavior and diagnostics.
5. Runtime or library changes land when the feature needs them.
6. Tooling, documentation, and analyzers complete the developer experience.

Not every idea becomes a feature. Compatibility is a major constraint. New syntax must coexist with decades of source, libraries, reflection behavior, overload resolution, and tooling assumptions.

The cost of a language feature can be thought of as more than implementation:

\[ C_feature = C_language + C_compiler + C_runtime

• C_tooling + C_education + C_{compatibility}.

\]

A feature is valuable when its long-term benefit across millions of programs justifies that permanent complexity.

Despite enormous change, several principles connect C# 1.0 to modern C#:

• Pragmatism over purity. C# combines object-oriented, functional, imperative, dynamic, and low-level techniques where each is useful.
• Strong tooling as part of the language. Diagnostics, refactoring, debugging, and editor support shape feature design.
• Compatibility as a feature. Old binaries and source code usually continue to work while adoption remains incremental.
• Readable abstractions. Properties, LINQ, async/await, patterns, and records aim to make common intent visible.
• A managed default with escape hatches. Most code benefits from runtime safety, while unsafe code and native interoperability remain available.

This pragmatism can make the language feel large. A developer can encounter classes from 2002, query syntax from 2007, asynchronous streams from 2019, and records from 2020 in one codebase. The benefit is that C# has evolved without forcing the ecosystem to restart.

C# succeeded not because its first version predicted every future requirement, but because the platform learned how to evolve. Generics fixed scalable type reuse. LINQ created a shared language for data. Async/await made non-blocking code readable. Roslyn opened the compiler. .NET Core opened the platform to new operating systems and a public engineering process. Nullable analysis addressed an old design problem without breaking existing binaries.

The language today is broader than Project Cool's designers could have needed in 1999. Its central bargain remains recognizable: productive, strongly typed code on a managed runtime, with enough access to the underlying machine when the application demands it.

That continuity is the most interesting part of C# history. The syntax kept changing, the runtime crossed operating systems, and the compiler moved into the open, but the platform evolved in place. Millions of programs came with it.