Metalama Blog

Metalama 2026.0 Generally Available: Full Support for C# 14 and .NET 10

Mon, 05 Jan 2026 07:00:01 +0000

Metalama 2026.0 is now generally available! This major release brings full support for C# 14—the most significant evolution of the C# language in years—along with .NET 10 SDK and Visual Studio 2026 compatibility. We’re also closing one of the last feature gaps with PostSharp: the ability to override event handler invocations. And you’re getting first-class support for tuple types.

Ready to try it? The packages are on NuGet.org, and the Visual Studio extension is available from the Visual Studio Marketplace.

For the complete list of changes, see the release notes. For an even more details, see the change notes for the releases 2026.0.11, 2026.0.10-rc, 2026.0.9-rc, 2026.0.8-rc, 2026.0.7-rc, 2026.0.6-rc, 2026.0.5-preview, 2026.0.4-preview, 2026.0.3-preview, 2026.0.2-preview, 2026.0.1-preview.

C# 14 support

C# 14 introduces several language features, and Metalama 2026.0 supports all of them in user code:

Extension blocks (see below)
Null-conditional assignments
field keyword in properties
Partial constructors and events
Compound assignment operators
Simple lambda parameters with modifiers

However, some features are not yet supported in aspects:

Null-conditional assignments in templates
The field keyword in templates
Generating run-time code for extension members via invoker interfaces
Adding contracts to the receiver parameter of extension blocks
Introducing new compound assignment operators
Introducing parameters into partial constructors
Introducing new extension blocks

Extension blocks

Extension blocks are the headline feature of C# 14, letting you extend any type with new members. Metalama provides comprehensive support:

Extension blocks are modeled via the IExtensionBlock interface, which implements INamedType (TypeKind = Extension).
They appear under INamedType.ExtensionBlocks.
You can override extension members using the advising API or apply aspects via custom attributes.
You can introduce new members into existing extension blocks.
Introducing new extension blocks is not yet supported.

Here’s how to add logging to all extension methods in your project using a fabric:

public class Fabric : ProjectFabric
{
    public override void AmendProject( IProjectAmender amender )
    {
        amender
            .SelectTypes()
            .SelectMany( t => t.ExtensionBlocks )
            .SelectMany( e => e.Methods )
            .AddAspectIfEligible<LogAttribute>();
    }
}

Event handler overriding

You can now override event handler invocations, enabling patterns like “safe events” where each handler is isolated by exception handling. The OverrideInvoke method in OverrideEventAspect intercepts individual handler invocations.

Typical use cases:

Safe events (exception isolation)
Background or asynchronous event dispatch
Event invocation logging

Here’s an aspect that catches exceptions and removes faulty handlers:

public class SafeEventAttribute : OverrideEventAspect
{
    public override dynamic? OverrideInvoke( dynamic? handler )
    {
        try
        {
            return meta.Proceed();
        }
        catch ( Exception e )
        {
            Console.WriteLine( e );
            meta.Target.Event.Remove( handler );
            throw;
        }
    }
}

Apply it to any event:

public class Camera
{
    [SafeEvent]
    public event EventHandler? FocusChanged;

    private void OnFocusChanged()
    {
        this.FocusChanged?.Invoke( this, EventArgs.Empty );
    }
}

For details, see Overriding events.

First-class tuple support

Previously, Metalama treated tuples as plain INamedType objects—no access to element names or types. The new ITupleType interface changes that, making scenarios like packing method arguments for interceptors much cleaner:

// Create a tuple type from method parameters.
var tupleType = TypeFactory.CreateTupleType( method.Parameters );

// Create a tuple instance.
var tupleExpression = tupleType.CreateCreateInstanceExpression( meta.Target.Parameters );

// Pass it to an observer.
_myObserver.OnMethodCalled( method.DeclaringType.FullName, method.Name, tupleExpression.Value );

Metrics enhancements

LinesOfCode metric: Three measurements—Logical, NonBlank, and Total.
Workspaces API: Now officially supports metrics consumption.

Visual Studio tooling improvements

We’ve refactored several background components of our VSIX. It’s now more stable, consumes less CPU, and better utilizes your cores.

Claude Code skill for AI-assisted development

We’re introducing a Claude Code skill that gives Anthropic’s AI assistant comprehensive Metalama knowledge:

Conceptual documentation
API references
Sample code and pattern libraries

Whether you’re new to Metalama or tackling a complex scenario, Claude can now provide contextually relevant guidance for aspect development, templates, fabrics, and the code model.

The skill is available on the Metalama.AI.Skills marketplace. For setup instructions, see Configuring Claude Code.

Documentation updates

We’ve made significant improvements:

New: Working with types
Improved: Writing T# templates
Updated: Injecting dependencies into aspects (now covers cross-project DI)
Updated: Overriding events
New: Consuming code metrics and Custom metrics
Enhanced API docs with integrated conceptual content

Breaking changes

.NET 6 SDK is no longer supported.
Several API and behavioral changes. See the release notes for details.

What’s next

With 2026.0 shipped, we’ll focus on extending C# 14 support in aspects.

Found an issue or have a feature request? Let us know on GitHub.

Happy meta-programming!

-gael

This article was first published on a https://metalama.net/blog under the title Metalama 2026.0 Generally Available: Full Support for C# 14 and .NET 10.

Metalama November 2025 Update: Release Candidate for Metalama 2026.0

Sun, 30 Nov 2025 07:00:01 +0000

Metalama 2026.0 has reached Release Candidate status! All planned features are implemented, our test suite is green, and the release is stable enough for production evaluation. We’re now gathering community feedback ahead of our GA release on January 5th, 2026.

Ready to try it? The RC packages are available on NuGet.org, and the Visual Studio extension can be downloaded from the Metalama 2026.0 downloads page.

This article covers what we shipped this month. For the complete list of changes in Metalama 2026.0, see the release notes.

For the full list of fixes and enhancements, see the changelogs:

2026.0.4-preview (November 8).
2026.0.5-preview (November 12).
2026.0.6-rc (November 28).

C# 14 Extension Members

This month, we completed support for C# 14 extension blocks. You can now advise extension members and introduce members into existing extension blocks.

Extension blocks are the “extend everything” feature in C# 14. Here’s how Metalama models them:

Extension blocks use the IExtensionBlock interface, which implements INamedType (TypeKind = Extension) so you can discover members the usual Fields, Properties, Methods, … collections.
They appear under INamedType.ExtensionBlocks.
Extension methods and property accessors are also listed in INamedType.Methods as implicitly-implemented methods.
You can override extension members using the advising API or add aspects using custom attributes.
You can also add new extension members to existing extension blocks.
Introducing new extension blocks won’t be supported in 2026.0.

Other Improvements

Single-file applications. Metalama aspects now work in single-file dotnet run applications: arguably a niche scenario.

Toast notifications. Product briefs and news now appear via toast notifications on Windows. You can disable or configure this feature through the UI or CLI tool.

Visual Studio Tools improved stability and performance

During the last two weeks, we focused heavily on Visual Studio extension stability — and uncovered more issues than expected.

We owe you an apology. Most of these bugs were already present in the 2025.1 release, though some may have been introduced by a Visual Studio 17.x minor update (we don’t repeat our full manual test suite after each VS release, so we can’t be certain). We discovered them through exhaustive testing on clean virtual machines as part of our RC validation process.

This level of testing clearly wasn’t done properly for 2025.1. To ensure quality meets our standards, we chose to delay the release by one month, missing our target to reach GA before the Christmas break. It was the right call.

The good news: the Visual Studio extension is now significantly more stable, and we achieved impressive performance improvements along the way. You can download it from the Metalama 2026.0 downloads page.

Known Issues

A couple of items to address before GA:

There’s a known issue (#149) with the apt package on Linux. We’re working on a fix.
The next RC will update to Roslyn 5.0.0 GA (#1212).

What’s Next

With full .NET 10 SDK and C# 14 support (except for by-design limitations documented in the release notes), and a significantly more stable Visual Studio extension, we’re on track for GA on January 5th, 2026.

If you haven’t tried the RC yet, now is the time. Test it with your projects and let us know what you find—your feedback helps ensure a rock-solid release.

Happy meta-programming!

-gael

This article was first published on a https://metalama.net/blog under the title Metalama November 2025 Update: Release Candidate for Metalama 2026.0.

Metalama October 2025 Update: Full Steam Ahead Toward 2026.0

Thu, 30 Oct 2025 07:00:01 +0000

October is traditionally our busiest month. Microsoft ships the RCs of the .NET SDK, C# and Visual Studio, and we sprint to make Metalama ready. This year is no exception: we’ve made solid progress, and we’re confident we’ll be ready on time for the GA wave. Below is a recap of what we shipped and what’s coming.

Metalama 2025.2: skipped for simplicity

We’ve decided not to ship Metalama 2025.2 as a standalone release. All its features, including the ability to override event handler invocations, are already merged into Metalama 2026.0. Why? The only real benefit of releasing 2025.2 would be making event-invocation advising available a few weeks earlier, but supporting two versions in parallel would slow us down.

Metalama 2026.0: almost there

We are now almost code-complete with Metalama 2026.0, and have released several previews:

.NET 10 SDK and C# 14

We’re nearly done with support for the .NET 10 SDK and C# 14. Want to see where things stand? Check out these resources:

General status board highlighting the leftovers for the 2026.0 version.
C# 14 status board showing our progress with C# 14 features.

Out of scope for Metalama 2026.0:

Using null-conditional assignments in templates. #1109
Using the field keyword in templates. #1114
Introducing new extension blocks. #1159
~~Introducing extension members into existing extension blocks. #1160~~ UPDATE: implemented in 2026.0.4-preview.

Fun fact: we noticed that compiling our NopCommerce snapshot with C# 14 breaks LINQ-to-SQL because of implicit conversions of arrays to ReadOnlySpan. We’ve had to pin this solution to C# 13 to work around this issue.

Extension blocks

“Extend everything” is the headline feature of C# 14, and we’re making sure Metalama supports it out of the box — including overriding extension members. Here’s how we’re modeling extension blocks:

Extension blocks use the IExtensionBlock interface (TypeKind = Extension). It derives from INamedType, and adds two properties: ReceiverParameter and ReceiverType. Although extension blocks derive from INamedType, you can’t always treat them like regular ones. Yes, this technically bends the Liskov Substitution Principle, but splitting the hierarchy would make the API noisier for little practical benefit. For extension members (except classic extension methods), IMember.DeclaringType points to the IExtensionBlock.
Extension blocks show up under INamedType.ExtensionBlocks, not as nested types (INamedType.Types).
Extension methods and property accessors are listed in INamedType.Methods as implicitly-implemented methods. They exist in IL and are addressable in C#, but you can’t override them with Metalama.

This approach feels natural for C# developers and closely matches Roslyn’s model.

First-class support for named tuples

Previously, Metalama treated tuples as plain INamedType objects, without access to element types or names. This made scenarios like packing method arguments for interceptors (think caching) awkward and inefficient. Now, with the new ITupleType interface, you get direct access to element names and types. Create named tuples with TypeFactory.CreateTupleType, and instantiate them with ITupleType.CreateCreateInstanceExpression.

Our implementation even supports tuples with zero or one element. For two or more, you get the nice tuple syntax; for degenerate cases, Metalama falls back to ValueTuple.Create(...). When you use ITupleType, you don’t have to worry about these details yourself.

Example: Want to advise multiple methods and pass all arguments to an observer? Here’s how:

// Create the tuple type.
var tupleType = TypeFactory.CreateTupleType(method.Parameters);

// Create the tuple instance.
var tupleExpression = tupleType.CreateCreateInstanceExpression(meta.Target.Parameters);

// Invoke the interceptor.
_myObserver.OnMethodCalled(method.DeclaringType.FullName, method.Name, tupleExpression.Value);

Transformed code:

// Two or more arguments: tuple syntax
public IEnumerable<Hat> FindHats(decimal size, string category)
{
    _myObserver.OnMethodCalled("HatStore", "FindHats", (size, category));
    // ...
}

// One argument: ValueTuple.Create
public bool IsHatAvailable(long hatId)
{
    _myObserver.OnMethodCalled("HatStore", "IsHatAvailable", ValueTuple.Create(hatId));
    // ...
}

// Zero arguments
public bool IsStoreOpen()
{
    _myObserver.OnMethodCalled("HatStore", "IsStoreOpen", ValueTuple.Create());
    // ...
}

Breaking Change: INamedType.TypeKind now returns Tuple instead of NamedType for tuples.

Advising event invocations

Overriding event handler invocation logic, originally planned for 2025.2, is now part of 2026.0. For details, see the September 2025 Status Update.

Other improvements

Introducing user-defined checked operators.
Dependency injection: pull constructor parameters across projects.
API cleanup (some breaking changes, [Obsolete] warnings).

Metalama 2025.1: now supports Visual Studio 2026

Last month, we added limited .NET 10 SDK support to Metalama 2025.1. As of October 7, Visual Studio 2026 is also supported.

Just make sure to update both the NuGet packages and the VSIX extension.

Roadmap: finalizing 2026.0

We’re wrapping up the last features for full C# 14 support in Metalama 2026.0. Next up: stabilization, code cleanup, manual testing, and performance validation.

We’re aiming for a release candidate (RC) on November 7, barring any surprises during testing. The final GA release will follow soon after Microsoft ships the GA versions of the .NET SDK and related packages.

Conclusion

In October, we made excellent progress with Metalama 2026.0, whose main focus is to support the .NET 10 SDK, C# 14, and Visual Studio 2026. We’re almost code complete, and we’ll spend most of November stabilizing the release.

Happy meta-programming!

-gael

This article was first published on a https://metalama.net/blog under the title Metalama October 2025 Update: Full Steam Ahead Toward 2026.0.

Metalama Status Update, September 2025

Wed, 01 Oct 2025 07:00:01 +0000

Welcome to Metalama’s September 2025 status update. After a relaxed summer, we’re back in full swing, delivering .NET 10 SDK support for Metalama and closing a key gap versus PostSharp: the ability to override event handler invocations.

Our first community contributor

Let me start with the announcement that brings me the greatest joy.

This past summer, Metalama received its first contribution from the open-source community. Giuseppe Marazzi submitted two PRs fixing two small and hard-to-find bugs.

A warm thanks to Giuseppe!

While Metalama may look like a complex codebase at first glance, Giuseppe’s contribution proves that anyone can make a meaningful impact. Don’t let the technical depth intimidate you: every contribution, no matter how small, is valuable and welcome! We’re here to help if you want to get involved! Check out our contributor’s guide to learn how to get started.

.NET SDK 10 readiness

As autumn arrives, Microsoft is finalizing the new .NET stack, and, like all .NET extenders, we’re working hard to make sure you can use the new features as soon as possible.

We’ve split the work into two releases:

Metalama 2025.1 received quick fixes to keep working with the .NET 10 SDK, with limitations;
Metalama 2026.0 will be built natively for the .NET 10 SDK.

Metalama 2025.1: limited .NET SDK 10 support

With the .NET SDK 10 already in RC, we didn’t want you to wait for full integration, so we made small changes to ensure compatibility with the new .NET SDK.

This build is Metalama 2025.1.14, released this week. From our platform integration matrix tests, most .NET workloads are working.

Keep in mind that Metalama 2025.1 is still based on Roslyn 4.14, while the .NET SDK 10 includes Roslyn 5.0. This has some implications:

Analyzers and source generators compiled against Roslyn 5.0 will not work. When possible, we replace them with an older Roslyn 4.14 version—this often works, but not always.
Specifically, Blazor projects (all flavors) are not supported yet because of an incompatibility in their source generators.
You cannot use C# 14 features in your Metalama projects.

Metalama 2026.0 in progress

The goal of Metalama 2026.0 is to bring full native support for the .NET 10 SDK and C# 14 — native, not hacks.

C# 14 brings a lot of new features, and we won’t support all of them in every scenario in November, when the new .NET is expected to become generally available. Our primary goal with Metalama 2026.0 is to let you safely use any new C# feature in your runtime code—but not necessarily in aspect templates. Support for new language features in templates may come in later versions. This aligns with our design philosophy: Metalama should be able to compile any valid C# code, but it’s okay to limit features available in aspects.

We’re using GitHub to track our progress. You can use this meta-issue or this dashboard to check the status.

We plan to have an RC ready in November, when Microsoft is expected to release the new stack.

If you’re eager for a preview, look for one next week — or, if you’re more patient, compile the develop/2026.0 branch of Metalama and Metalama.Compiler repos (merged from Roslyn tag NET-SDK-10.0.100-preview.7.25380.108 as of today).

Visual Studio 2026 readiness

We ran some initial tests of our Metalama Tools for Visual Studio with Visual Studio 2026—and they failed, subtly but miserably.

It seems those incompatibilities can be addressed with fairly small bug fixes. If that proves to be true, we’ll update our tooling 2025.1 to support Visual Studio 2026 — and there will be no need to wait for Metalama 2026.0.

Metalama 2025.2 RC: Event invocation overrides

We have just released the first—and hopefully final—RC of Metalama 2025.2.

Since the beginning, Metalama has allowed overriding the add and remove accessors of events, which were arguably of limited utility. This version adds the ability to override the invocation of event handlers. The OverrideInvoke method of the OverrideEventAspect class lets you intercept the invocation of an individual event handler.

Typical use cases are:

safe events (exception handling)
background/asynchronous events
event invocation logging

Let’s illustrate this with an example. This aspect catches exceptions in event handlers; if any exception is caught, it removes it from the event invocation list.

public class SafeEventAttribute : OverrideEventAspect
{
    // If there are many event handlers, this method will be called several times.
    public override dynamic? OverrideInvoke( dynamic? handler )
    {
        try
        {
            return meta.Proceed();
        }
        catch ( Exception e )
        {
            Console.WriteLine( e );

            // First time shame on you, second time shame on me.
            meta.Target.Event.Remove( handler );
            throw;
        }
    }
}

We can now add this to any event:

public class Camera
{
    [SafeEvent]
    public event EventHandler? FocusChanged;

    private void OnFocusChanged()
    {
        this.FocusChanged?.Invoke( this, EventArgs.Empty );
    }
}

As you might expect, it took us a while to implement—it’s far from simple.

Here’s how Metalama transforms your code:

public class Camera
{
    // The field backing the event.
    private event EventHandler? _focusChanged;

    // A broker sitting between the event API and the backing field.
    private volatile ActionEventBroker<EventHandler?, (object?, EventArgs)>? _focusChangedBroker;

    // Binds the broker to the event implementation and the advice.
    private static readonly ActionEventBrokerCallbacks<EventHandler?, (object?, EventArgs)> FocusChangedBrokerCallbacks_0 = new (
        static (handler, me, args) => ((Camera)me).FocusChanged_Invoke_SafeEvent(handler, args),
        static b => (sender, e) => b.Invoke((sender, e)),
        static (handler, me) => ((Camera)me).FocusChanged_SafeEvent += handler,
        static (handler, me) => ((Camera)me).FocusChanged_SafeEvent -= handler );



    // The public event with the new implementation.
    [SafeEvent]
    public event EventHandler? FocusChanged
    {
        add
        {
            ActionEventBroker<EventHandler?, (object?, EventArgs)>.EnsureInitialized(ref this._focusChangedBroker, this, FocusChangedBrokerCallbacks_0);
            this._focusChangedBroker.AddHandler(value);
        }

        remove
        {
            this._focusChangedBroker?.RemoveHandler(value);
        }
    }

    // The original event implementation.
    private event EventHandler? FocusChanged_SafeEvent
    {
        add
        {
            this._focusChanged += value;
        }

        remove
        {
            this._focusChanged -= value;
        }
    }

    // Your advice intercepting the handler invocation.
    private void FocusChanged_Invoke_SafeEvent(EventHandler? handler, (object? sender, EventArgs e) args)
    {
        try
        {
            handler.Invoke(args.sender, args.e);
            return;
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            _focusChanged -= handler;
            return;
        }
    }

    private void OnFocusChanged()
    {
        this._focusChanged?.Invoke(this, EventArgs.Empty);
    }
}

It’s a bit lengthy, but aside from a touch of syntactic sugar, the event broker is the most reliable pattern, because we can’t predict or analyze how an event is raised. This approach is oblivious to the event’s implementation and to how it gets raised.

You can find more details on this documentation page.

Subscribe to our briefs to receive updates about ongoing work on Metalama 2026.0 before the next monthly update.

Dockerization of our build infrastructure

As a side note, the entire Metalama build infrastructure now runs on Docker, requiring only lean build agents.

That means you can build Metalama in the exact environment we use.

All you need is a Windows 11 or Windows Server 2025 machine with Docker installed and Windows containers enabled, then run:

.\DockerBuild.ps1 build

Summary

On the feature side, the OverrideEventAspect.OverrideInvoke advice closes one of Metalama’s remaining gaps with PostSharp. On the platform front, we’ve released the first bits of .NET 10 support and we expect to deliver more soon. In terms of infrastructure, Dockerizing our build workflow makes Metalama easy to reproduce across agents and helps reduce the cost and complexity of our setup.

Happy meta-programming with Metalama!

This article was first published on a https://metalama.net/blog under the title Metalama Status Update, September 2025.

Metalama Status Update, Mid Summer 2025

Thu, 07 Aug 2025 07:00:01 +0000

It’s been over two months since our last status update. After a busy spring that peaked with the open-sourcing of Metalama, summer has been a bit quieter on the development side. Our focus shifted to releasing the source code of both PostSharp and Metalama’s premium packages under a source-available license, while fitting in some vacation time. But don’t worry, the open-source Metalama hasn’t been neglected. We’ve been moving our bug tracker to GitHub, squashing bugs in 2025.1, and tackling one of the last feature gaps between PostSharp and Metalama: the ability to override event invocations.

Metalama 2025.1 - Maintenance

Since the last status update, we’ve released three maintenance builds, focusing solely on bug fixes: 2025.1.12, 2025.1.11, and 2025.1.10.

In general, we now consider 2025.1 to be stable.

Metalama 2025.2 - WIP

The focus of Metalama 2025.2 is a single new feature: the ability to intercept the invocation of events. This addresses one of the last gaps with PostSharp — the main remaining one is the ability to advise the await operator.

The first preview is planned for late August or early September, with an RC in late September and GA in late October.

We aim to make it possible to write aspects like this:

public class SafeEventAttribute : OverrideEventAspect
{
    public override dynamic? OverrideEvent( dynamic? handler )
    {
        try
        {
            return meta.Proceed();
        }
        catch ( Exception e )
        {
            Console.WriteLine( e );

            // First time shame on you, second time shame on me.
            meta.Target.Event.Remove( handler );
            throw;
        }
    }
}

Metalama 2026.0 - Roadmap

Metalama 2026.0 will add support for .NET 10 and C# 14.

Our goal this year is to release the GA days after Microsoft’s own GA, expected in mid-November. Previously, our tradition was to release in the early days of the new year, but this time we’ll aim to be ready sooner with platform support, ensuring the release isn’t bogged down with other features.

We want to enable Metalama users to utilize new C# features in normal code. However, support for new language features in aspect code, such as generation of extension members, will be delayed to another version. This should ensure we’re ready with the GA in November.

Equality comparison sample

We’ve published a new comprehensive example: implementing equality comparison, i.e., IEquatable<T> and its companions. Metalama can now implement the complete pattern.

The ultimate goal is to be able to write code like this:

public partial class Entity
{
    [StringEqualityMember( StringComparison.InvariantCultureIgnoreCase )]
    public required string EntityType { get; init; }

    [EqualityMember]
    public int Id { get; init; }

    public Guid ObjectId { get; } = Guid.NewGuid();
}

Check it out step by step: Equality Comparison Example.

Project management on GitHub

Being open source is not just about making the source code public. It’s also about collaboration and transparency, including in product and project management.

This summer, we have moved our project management to a public GitHub project, and migrated our complete backlog.

You might be surprised by the number of bugs now. Most of them have been discovered internally and never reported by the community. We try to fix community- and customer-reported bugs as soon as possible, but delay internally-discovered bugs until we are done with more important features.

Source access for proprietary components

As you know, Metalama is 85% open-source, with premium components available for enterprise customers who need advanced features and commercial support.

We’re happy to announce that the source code of premium packages is now available, together with PostSharp’s source code, to enterprise customers under a relatively permissive proprietary source-available license, allowing you to modify, build, and distribute the software for various purposes. The principal scenarios are troubleshooting, supply chain security, and supply chain resilience.

Here’s the process:

Sign in to the customer portal.
Check your support entitlements. You must have an Enterprise support plan (E1 or higher). If you’re a PostSharp customer, you might have it without knowing it.
Go to the source access page.
Sign the Non-Disclosure/Non-Competing Agreement online (or offline).
Allow for one business day to review the signature and update your account.
Return to the source access page and create Git users and passwords.
Clone the Metalama.Premium repository using Git.

For details, see PostSharp Is Now Source Available on PostSharp’s blog.

Summary

Even though summer has been quieter for Metalama, we’ve made significant progress with moving the project management to GitHub, fixing bugs, keeping up with Roslyn, and adding small features. Down the road, the upcoming features in 2025.2 are set to further close the gap with PostSharp, and 2026.0 will be compatible with .NET 10 and C# 14. The new source access policy for enterprise customers also marks a significant step in our journey towards greater transparency.

Happy meta-programming!

P.S. If you’re looking for more frequent updates than our monthly (or less) newsletter provides, we regularly share quick announcements and technical tidbits on Metalama Briefs. Subscribe to this RSS feed with your favorite newsreader, which won’t manipulate your timeline like social media algorithms do.

This article was first published on a https://metalama.net/blog under the title Metalama Status Update, Mid Summer 2025.

Metalama Status Update, May 2025

Fri, 30 May 2025 07:00:01 +0000

May is a time of growth and renewal, and Metalama is no exception. At the start of this month, we began a new chapter by open-sourcing our codebase, marking one of the most significant contributions to the .NET community this year. Throughout May, we focused on stabilizing our first open-source release, improving compliance with supply chain security and transparency best practices, and participating in the Open Source Founder Summit in Paris.

Open Sourcing Metalama

The biggest news this month: we’ve released Metalama 2025.1, our first open-source version!

This is big news not just for us but for the entire .NET ecosystem. While many open-source projects have announced their commercial transition this year, we’re going against the tide and have released 85% of Metalama’s codebase under the MIT license. We believe that vendor-led open-source projects are the most viable option for development tools, components, and libraries—except for IDEs and UI components, which have an established commercial market. As a result, the entire code generation and aspect-oriented programming feature is now open source, while IDE tooling, architecture verification, and some other extensions remain proprietary.

Curious about why we made this decision, what it means for you, and what’s next? Dive into the full story in my blog post, Metalama Is Now Open Source, and read my thoughts about the delicate balance between community-driven development and commercial sustainability.

If you haven’t already, please give us a star on GitHub to show your support!

Metalama 2025.1: Post-Release Updates

Since the general availability (GA) release of Metalama 2025.1, we’ve been busy listening to your feedback and rolling out fixes and improvements. Thank you to everyone who reported issues and shared suggestions!

Here’s a quick look at recent releases:

2025.1.6: Bug fixes and minor telemetry improvements.
2025.1.7: Major update—merged with Roslyn 4.14 for improved compatibility.
2025.1.8: Critical licensing bug fix, made [Observable] applicable to interfaces, and further telemetry improvements.
2025.1.9: Critical Visual Studio Extension (VSX) bug fix.

For the full changelog and all release notes, check out the GitHub Releases page. The Roslyn merge in 2025.1.7 is especially important—it keeps Metalama aligned with the latest C# language features and tooling.

Open Source Security Foundation Best Practices

As part of many critical supply chains, we’re taking security and best practices seriously. Our pipelines are now compliant with OpenSSF best practices.

Open Source Founder Summit in Paris

This month, I had the pleasure of attending the Open Source Founder Summit in Paris. It was inspiring to connect with fellow open-source leaders and dive deep into the realities of open-source business models, governance, and sustainability. I’ve captured my reflections and key takeaways in a dedicated LinkedIn article: Attending the Open Source Founder Summit in Paris. I share candid thoughts on open-source foundations, why I believe the .NET open-source community lags behind others, and why I don’t think this will change anytime soon. If you’re curious about my perspective, I invite you to give it a read!

Closing the Metalama Community Slack Workspace

As part of our transition to open source, we’ve closed the Metalama community Slack workspace, which previously served as a channel for brief news and technical support.

Going forward, real-time conversations with our core team on Slack or Teams will be reserved for enterprise customers. For the wider community, we encourage you to use GitHub Discussions for questions, ideas, and general conversation, or GitHub Issues for bug reports and feature requests. While we do monitor these channels, please note that our response times may be slower than before.

Metalama Briefs: Stay Tuned

To stay informed about the latest news, releases, and quick updates, visit our briefs page or subscribe to the RSS feed. This is the most reliable way to receive announcements about new builds and community updates, without worrying about social media algorithms filtering them out of your timeline.

Roadmap

After a busy and successful spring, we’re looking forward to slowing down during the summer, focusing on filling some remaining gaps between Metalama and PostSharp. In autumn, we plan to work on .NET 10 and C# 14 compatibility.

We’ve updated the roadmap to provide more clarity on upcoming features and releases:

June 2025

Stabilize 2025.1.
Migrate the issue database and project management to GitHub.
Release PostSharp’s source code under our proprietary source-available license.

Summer 2025

Metalama 2025.2: Filling gaps with PostSharp:
- Support for overriding event invocation.
- If time permits: interception of await for enhanced asynchronous programming capabilities.

Autumn 2025

Metalama 2026.0: Compatibility with .NET 10 and C# 14:
- Ensuring full support for the latest language features and runtime improvements.
- Additional enhancements to streamline meta-programming workflows.

Conclusion

Metalama is now open source, and honestly, there’s no excuse left for writing repetitive code in .NET. Open source isn’t just about throwing code over the wall—it’s about embracing transparency, security, and evolving how we do business. We’re still ironing out some details, but we’re committed to building a project that’s strong, reliable, and here to stay.

Thanks for being part of this journey. Now go write some awesome aspects!

Happy meta-programming!

This article was first published on a https://metalama.net/blog under the title Metalama Status Update, May 2025.

Metalama Is Now Open Source, Adding Full Meta-Programming to C#

Fri, 04 Apr 2025 07:00:01 +0000

We’re excited to announce that Metalama, the most advanced meta-programming framework for C#, is now open source! Released under the permissive MIT license, Metalama empowers .NET developers with a simple, innovative, and powerful approach to code generation, architecture validation, and aspect-oriented programming.

Over 85% of the codebase is now open source, with only its IDE tooling and select extension packages remaining proprietary.

We believe this is a big deal not just for our team, but for the entire .NET ecosystem. Departing from the legacy of IL-based tools, Metalama leverages Roslyn to bring advanced meta-programming capabilities directly to the C# language—while remaining 100% syntax-compatible with C# and all editors.

This article is part of a 3-post series announcing the launch of our 2025.1 versions:

Metalama Is Now Open Source – Adding Full Meta-Programming Capabilities to C#.

Announcing Metalama 2025.1: changes in licensing and support terms for Metalama.

Announcing PostSharp 2025.1: changes in licensing and support terms for PostSharp.

How Big Is Metalama? A Reality Check

Metalama’s open-source release follows nearly five years of dedicated development, resulting in a robust codebase and an (almost) feature-complete product. The core repository includes over 400,000 lines of code and spans more than 17,000 commits, representing approximately ten man-years (20,000 hours) of work by seasoned .NET compiler experts.

While Metalama isn’t the largest .NET project—Roslyn or Mono are still larger by an order of magnitude—it is undoubtedly one of the most substantial non-Microsoft projects. For context:

Metalama has more commits than the combined top three .NET Foundation projects over the past five years, according to dnfprojects.org.
Its codebase is roughly twice the combined size of projects like AwesomeAssertions, AutoMapper, and MediatR—three projects that recently transitioned from open source to commercial.
It surpasses the combined size of Cecil and Fody, including all its add-ins, by approximately 40%.
Metalama is 53% the size of Avalonia, one of the largest .NET vendor-led open-source projects, which counts 750 KLOC.

What Exactly Is Metalama?

Metalama is like a supercharged code analyzer and generator. Built as a Roslyn-powered extension, it integrates into the C# compilation pipeline and unlocks four key capabilities:

Generate code – Add members, implement interfaces, or apply entire design patterns without modifying your source files. If you’re tired of text-based generators, rejoice—Metalama uses a type-safe, object-oriented, C#-to-C# templating system with full IntelliSense support.
Transform code – Rewrite method bodies, insert pre/post logic, convert fields to properties, inject dependencies, and more. Unlike Roslyn generators, Metalama is not limited to adding partial classes and can override almost any part of your code.
Validate code – Enforce architectural and coding standards at compile time, preventing violations before they reach your repository.
Suggest code fixes and refactorings – Surface code generation and transformation via the IDE’s lightbulb or screwdriver menu to guide and assist developers.

Goodbye, Fody 👋

Unlike legacy IL-weaving tools like Fody, which operate on compiled assemblies, Metalama leverages the Roslyn compiler to apply transformations at the source level. This allows for a level of usability that IL-based tools can’t match:

Immediate IDE feedback – Generated members appear in IntelliSense, and diagnostics update live as you type.
Seamless debugging – Step into generated code, place breakpoints, and inspect variables exactly as you would in handwritten code. Metalama effectively makes older IL-based code generation tools obsolete.
No lock-in – You can include the generated code back to your source code and remove Metalama from your project thanks to the Metalama Divorce feature.

Real-World Use Cases: From Design Patterns to DevOps

Metalama includes a rich collection of open-source aspect libraries to tackle common software scenarios. Examples include:

Design Patterns: Singleton, Factory, Builder, Decorator, Proxy, and more.
UI and MVVM Patterns: Observable to implement INotifyPropertyChanged, dependency properties, commands, undo/redo.
Object Services: Auto-generated ToString, deep cloning, equality, and comparison.
DevOps: Logging and tracing, metrics, caching, retry/fault-handling logic, and more.

How Metalama Works

Meta-programming in Metalama is based on two types of meta-classes that execute during compilation:

Aspects encapsulate reusable code generation and transformation patterns, such as logging, observability, or the Memento design pattern. They act as intelligent attributes that can generate, transform, or validate code in place.
Fabrics serve as centralized compile-time entry points, allowing you to apply aspects in bulk across your codebase using a LINQ-style API—eliminating the need to annotate every element manually.

Metalama dynamically rewrites the syntax tree during compilation. Your source code remains clean and focused, while the compiled assembly includes all the generated logic.

Aspect

Here is a classic “hello, world” example: a logging aspect.

using Metalama.Framework.Aspects;

public class LogAttribute : OverrideMethodAspect
{
    public override dynamic? OverrideMethod()
    {
        Console.WriteLine( $"{meta.Target.Method} started." );

        try
        {
            var result = meta.Proceed();

            Console.WriteLine( $"{meta.Target.Method} succeeded." );

            return result;
        }
        catch ( Exception e )
        {
            Console.WriteLine( $"{meta.Target.Method} failed: {e.Message}." );

            throw;
        }
    }
}

The OverrideMethod is a template. Parts of the code to the left of the meta pseudo-keyword are evaluated at compile time. The rest is runtime code. meta.Proceed() invokes the overridden method (it is replaced by the original method body in this case).

You can now apply the aspect to a method as a custom attribute:

internal static class Calculator
{
    [Log]
    public static double Add( double a, double b ) => a + b;
}

This transforms the code into the following:

using System;

internal static class Calculator
{
    [Log]
    public static double Add( double a, double b ) { Console.WriteLine("Calculator.Add(double, double) started.");
        try
        {
            double result;
            result = a + b;
            Console.WriteLine("Calculator.Add(double, double) succeeded.");
            return (double)result;
        }
        catch (Exception e)
        {
            Console.WriteLine($"Calculator.Add(double, double) failed: {e.Message}.");
            throw;
        }
    }
}

Fabric

If you want to log thousands of methods, it would not be practical to annotate every single method with the [Log] attribute. That’s why we invented the concept of a fabric, a compile-time entry point to your project that lets you add any aspect to anything using LINQ-like code.

The following code snippet adds logging to all public methods of all public types:

public class Fabric : ProjectFabric
{
    public override void AmendProject( IProjectAmender amender )
    {
        amender
            .SelectTypes()
            .Where( t => t.Accessibility == Accessibility.Public )
            .SelectMany( t => t.Methods )
            .Where( m => t.Accessibility == Accessibility.Public )
            .AddAspectIfEligible<LogAttribute>();
    }
}

Why Vendor-Led Open Source Matters

We believe vendor-led open source is the new standard for serious software frameworks and libraries. Microsoft’s stewardship of the .NET platform has set the tone: today’s developers expect both transparency and dependability from the tools they choose.

Transparency, because developers need to understand how their tools work. They want to debug, diagnose, audit for security. Open source makes that possible by default.
Dependability means knowing the project will be maintained, bugs fixed, platforms supported, features added. That kind of long-term commitment requires a sustainable business model, often backed by a profitable company with real skin in the game.

When a vendor fails to maintain a project, the open-source license gives the community the power to take over. It lowers the barrier for competitors to step in and raises the pressure on the original maintainer to stay sharp. That’s why open source has become the default model, and why it gets so much visibility.

Let’s be honest: that visibility is a big reason for our choice. We could have faked open source, published a hollow core and kept the real value behind closed doors. But here’s what we’re doing instead: we’re releasing 85% of the codebase, a full-featured product. That’s because we’re committed to transparency and dependability, the two core values of vendor-led open-source.

Our goal is broad adoption.Reducing any licensing friction gets the framework into more hands, and some of those teams will turn into customers. Under PostSharp’s freemium model, about 30% of users are paying customers. With Metalama, we expect that number to be much lower. And we’re fine with that! With a larger distribution, we can afford a lower rate of monetization.

We’ve also seen what happens when unfunded open-source projects succeed too well: tools like AutoMapper, MediatR, and FluentAssertions eventually had to move to commercial models to survive in the long term. That’s not a failure of open source: it’s a failure of sustainability. They only got big because they were open. On the flip side, we’ve seen technically inferior tools outpace PostSharp just because they were open source. We’re not making that mistake again.

We’re realistic about community contributions. Metalama is a large, complex codebase. We don’t expect a wave of unsolicited PRs, but we welcome contributions that meet our standards, and we’d love to be proven wrong. See the How You Can Contribute section below.

Most importantly, this is a return to our roots. PostSharp was open source from 2004 to 2009, and that openness was key to its early success. With Metalama, we’re bringing that spirit back—stronger, smarter, and built for today.

Proprietary Components and Editions

Although Metalama’s compiler integration and core libraries are fully open source, we’ve retained a few advanced components under a commercial license to ensure long-term sustainability:

Visual Studio Extensions: The full-featured IDE experience is provided in Metalama Community and Metalama Professional.
Architecture Validation: Advanced architectural rules and analysis (formerly under Metalama.Framework.Validation and Metalama.Extensions.Architecture).
Code Fix Toolkits: Custom refactoring and quick-fix support (previously Metalama.Framework.CodeFixes).
Distributed Caching Adapters: Redis and Azure integrations for Metalama.Patterns.Caching.

These premium packages will be bundled in Metalama Professional, available under commercial terms.

We acknowledge that the proprietary status of these components may seem at odds with the open-source value of transparency. To address this, the source code for these proprietary components is available to enterprise customers under a permissive but proprietary license. This ensures that enterprise users can audit, understand, and even customize these components while maintaining the sustainability of the project.

Free IDE Tooling for Individuals and Small Teams

While Metalama’s compiler integration and core framework are fully open source, our Visual Studio tooling remains proprietary. These tools aren’t required to use Metalama, but they do offer a significant productivity boost:

Aspect Diff – Compare original and transformed code using Visual Studio’s diff viewer.
CodeLens Integration – Instantly see which aspects affect your code, right from the editor.
Aspect Explorer – Browse your project to discover where and how aspects are applied.

We initially planned to monetize this tooling across the board. But we don’t want to charge freelancers, students, hobbyists, or open-source maintainers. We want to monetize Metalama only where it makes sense: within large, well-funded organizations.

That’s why we’re making Visual Studio Tools for Metalama free for individuals, non-commercial use, and companies with up to 3 developers. No license key required. Just indicate your eligibility and you’re good to go. We trust you.

With this move, everyone, including indie developers to small startups, can access a complete, modern meta-programming experience with first-class IDE support.

Is This Project Really Sustainable??

We understand the concern: how can such a large and ambitious open-source project remain viable over time? The answer is simple: we’re building this on the solid financial and operational ground of a company founded in 2009.

Metalama was fully funded through the profits of PostSharp. We’ve taken no outside investment and carry no debt. With Metalama now feature-complete, ongoing development primarily involves maintenance and incremental improvements—something that can be managed by a small, focused team. Our company has scaled down accordingly and is already operating profitably, independent of future Metalama revenues.

Long term, sustainability will come from a dual business model:

Premium features: As mentioned above, while the core is fully open source, some components will remain proprietary and available under commercial terms.
Premium support and consulting: For teams that want guidance, custom tooling, long-term maintenance, or guaranteed SLAs, we offer paid services.

This ensures that we will be able to create enough value for professional teams to justify commercial investment, while keeping Metalama free and open for the community.

In short, Metalama is already sustainable in the near term. For the long term, everything hinges on adoption. The broader the user base, the stronger the community—and the more viable the commercial offerings. That’s why we’ve open-sourced the core: to make it easy for everyone to try, trust, and build on Metalama.

Community and Enterprise Support

We offer a support model tailored to meet the diverse needs of our users:

Community Support: The open-source core is self-supported through the GitHub Discussions forum. Community members are encouraged to ask questions, share best practices, and assist one another. Our team will monitor community activities weekly to provide guidance where needed, with no guarantees.
Basic Professional Support: Subscribers of Metalama Professional gain access to basic email support for private tickets.
Enterprise Support: For organizations needing high-touch support, Metalama Enterprise offers priority assistance, escalation, video consultations, advanced diagnostics, and consultancy services. This plan is designed for teams with critical projects that demand a higher level of engagement and expertise.

Details about support offerings, response times, and SLA commitments can be found at https://www.postsharp.net/support/policies.

Only the current version (YYYY.N) will be maintained under open-source terms. Previous versions (YYYY.N-1) will be supported exclusively under the enterprise license for customers with long-term support agreements.

How You Can Contribute

Whether you’re just discovering Metalama or already using it in your projects, there are many meaningful ways to get involved:

⭐ Star the GitHub repository: Show your support and help improve Metalama’s visibility by starring github.com/metalama/Metalama.
📣 Spread the word: Metalama is a mature, production-ready framework, but adoption is still growing. Share it with your colleagues, present it at meetups, or write a blog post to help raise awareness.
🧭 Help newcomers: If you’re familiar with Metalama, consider following issues and discussions on GitHub. Answering questions or clarifying concepts strengthens the community and helps others get started.
💡 Share your feedback and feature requests: Your insights are invaluable. Let us know what works, what doesn’t, and what features you’d like to see in future releases.
🧩 Contribute your aspects: If you’ve built reusable aspects, consider sharing them with the community. You can:
- Publish them under your own GitHub account and let us know so we can reference them on the Metalama Marketplace.
- Contribute them to the Metalama.Community repository.
🛠️ Contribute to the core: Bug fixes, small enhancements, and documentation improvements are always welcome. We’ll soon migrate our internal backlog to GitHub, giving you better visibility into what’s needed and how you can help.

For more details, visit https://metalama.net/contributing.

What’s Next for Metalama

Open-sourcing Metalama is a major step, but we’re not stopping here. Here’s what’s coming up next in the short term:

May 2025 – We’re migrating our internal issue tracker to GitHub. This will give you full visibility into what we’re working on and let you report bugs, track features, and contribute more easily.
Summer 2025 – We’re working on extending Metalama’s capabilities to support code transformations on C# event accessors and await expressions. This unlocks new possibilities for cross-cutting concerns in asynchronous and event-driven codebases.
Autumn 2025 – Full support for .NET 10 and the next version of C#. As always, we’ll stay aligned with the latest evolution of the .NET platform.

We’re committed to improving the framework and responding to community needs. Even though Metalama is now open source, we’re not handing it off and walking away. We’re staying fully engaged, with two full-time engineers (myself and Daniel) dedicated to the project.

Conclusion

Many developers, upon discovering Metalama, have said, “This should be a standard part of .NET!” By open-sourcing Metalama, we’ve done what we could to make that vision a reality.

Whether you’re a solo developer looking to eliminate boilerplate or part of a team enforcing architecture across a large codebase, Metalama is here to help.

If you’re excited about the potential of meta-programming in C#, now is the perfect time to get started:

Visit the website at metalama.net and explore use cases.
Read the documentation, expecially commented examples.
Explore Metalama Marketplace and find ready-made aspects and examples. Don’t reinvent the wheel!
Study the source code on GitHub and see how it works.

We’ve laid the foundation, but the real momentum will come from the community. Together, we can push the boundaries of what C# can achieve.

Happy meta-programming!

Gael

This article was first published on a https://metalama.net/blog under the title Metalama Is Now Open Source, Adding Full Meta-Programming to C#.

Metalama Status Update, March 2025

Mon, 31 Mar 2025 08:00:01 +0000

This month, we released a preview of Metalama 2025.1, marking a significant milestone as the first open-source version of Metalama. Our efforts to complete the open-source transition will continue in April.

Metalama 2025.1: open-source preview

Earlier this year, we shared our plans to make Metalama open-source. Since then, we’ve been working hard to bring this vision to life. In March, we released the first preview of Metalama 2025.1, with most components now licensed under MIT. This is a major step toward transitioning Metalama to an open-core business model.

What’s left to do

While we’re excited to share this progress with the Metalama community, this isn’t the big announcement yet. There’s still work to be done:

Fixing some bugs
Testing on VMs and physical devices
Launching a new website
Updating documentation and README files
Migrating the issue tracker to GitHub
Aligning sales pages and processes with the new offering

Licensing notes

At this stage, licenses for the new business model are not yet available for purchase.

Existing Metalama commercial licenses remain compatible with the commercial parts of Metalama 2025.1. However, Metalama Free is not compatible. To use Visual Studio Tools for Metalama, you’ll need either a Metalama license key or to activate Metalama Community. Metalama Community is available for non-commercial users, individuals, companies with up to three users, and contributors to open-source projects.

Resources to get started

Here’s how you can explore Metalama 2025.1 today:

End of support for Metalama 2024.2

As per our support policies, support for Metalama 2024.2 has ended. The only supported version now is Metalama 2025.0.

Metalama 2025.0 maintenance builds

We’ve released several maintenance builds for Metalama 2025.0 (2025.0.9 and 2025.0.10), addressing bugs and integrating the latest stable Roslyn build.

Updated roadmap

Our focus in April is to finalize the open-source transition. Here’s the updated timeline:

First week of April: Release Candidate (RC)
Late April or Early May: General Availability (GA)

Thank you for your continued support. Happy meta-programming!

-gael

This article was first published on a https://metalama.net/blog under the title Metalama Status Update, March 2025.

Metalama Status Update, February 2025

Thu, 27 Feb 2025 08:00:01 +0000

Last month, we shared our exciting plans to make Metalama open-source, and throughout February, we’ve been hard at work making it happen. While we’ve made significant technical progress, we’re not quite ready to release just yet.

On the technical side, we’ve successfully modularized key features in preparation for the transition, allowing us to keep some components proprietary. However, the legal aspects of dual-licensing Metalama are still in progress. It’s a complex process, and we want to ensure everything is done right from the start. This is the main factor delaying the release of our source code and binaries.

Updated Roadmap

Here’s our revised timeline for the open-source release:

First half of March: First open-source preview release
Second half of March: Release Candidate (RC)
Second half of April: General Availability (GA)

If the legal process takes longer than expected, we’ll use the extra time to introduce a new feature in the 2025.1 release: intercepting event invocations.

Between the RC and GA releases, our focus will shift toward supporting infrastructure, including:

Launching a dedicated Metalama website
Migrating project and issue management to GitHub
Updating our e-shop and CRM systems

Stay Tuned!

We’re committed to making this transition smooth and impactful. Thank you for your patience and enthusiasm — we’re almost there! Keep an eye out for our updates.

This article was first published on a https://metalama.net/blog under the title Metalama Status Update, February 2025.

Metalama Status Update, January 2025

Fri, 31 Jan 2025 08:00:01 +0000

As we returned from the winter break, we hit the ground running by launching Metalama and PostSharp 2025.0. But that wasn’t all—after careful consideration and experimentation, we’re thrilled to share some groundbreaking news: Metalama is going open-source!

Metalama and PostSharp 2025.0 are generally available

Following the release of Metalama and PostSharp 2025.0 Release Candidate (RC) in November, we dedicated much of December to squashing bugs. With Metalama maturing steadily, we’ve started addressing long-term, low-priority issues from our backlog.

Our first major milestone of the year was deploying PostSharp and Metalama 2025.0 on January 4th. Here’s what’s new:

Metalama 2025.0:
- Adds support for C# 13 and .NET 9.
- Introduces significant enhancements to the aspect framework.
- Delivers substantial performance improvements.
  Check out the Metalama 2025.0 announcement.
PostSharp 2025.0:
- Adds support for C# 13, .NET 9, and long paths in projects targeting .NET Framework.
- Improves runtime performance for WeakEventHandler.
- Enhances the debugging experience with Windows PDB files.
  Learn more in the PostSharp 2025.0 announcement.

Metalama 2025.1: going open-source

Earlier this week, we announced that Metalama 2025.1 will be free and open-source. To ensure the project’s sustainability, we’ll offer commercial IDE tooling, extensions, and support. We fully commit to a cooperative development process, moving everything to GitHub. Metalama will get a dedicated website and GitHub organization, marking its evolution into an independent, community-driven project separate from PostSharp Technologies.

Visit the announcement to learn more about:

What will be free and open-source, and what won’t?
Our new commercial offerings.
Our updated policies for long-term support.

Your input is invaluable as we implement these changes, so don’t hesitate to share your thoughts while the plans are still being developed.

Godot + Metalama = ♡, by Philip Rotter

Godot, the incredibly efficient open-source game engine, has gained popularity among developers. While many prefer using C# over GDScript due to its rich ecosystem, exporting C# properties to Godot often involves tedious boilerplate code.

In his latest guest post, Enhancing Godot Development with Metalama, Philip Rotter demonstrates how Metalama can streamline this process. By leveraging Metalama, Philip eliminates redundant code and makes C# development with Godot both fun and efficient — all through a simple, straightforward aspect.

Thank you very much to Philip for this insightful contribution! It will be an invaluable resource for Godot users looking to explore Metalama for the first time.

Looking ahead

With Metalama’s transition to open-source, 2025 is shaping to be an exciting year! We’re committed to empowering developers with cutting-edge tools to remove code repetition, built together in a collaborative community. Stay tuned for more updates, and don’t forget to share your feedback on Slack or GitHub as we continue to evolve and innovate.

Happy meta-programming!

This article was first published on a https://metalama.net/blog under the title Metalama Status Update, January 2025.