.NET Aspire is marketed as a free and open-source platform. That claim, however, deserves closer scrutiny. A deeper look into its internals reveals a proprietary component at the core of its orchestration system—raising serious questions about transparency, licensing, and trust.

A Closer Look at the Aspire Runtime

After creating a new Aspire application on Windows and running it, everything appears normal at first. The dashboard starts up correctly, and the developer experience feels consistent with what one would expect from an open-source .NET tool.

However, when examining the installed NuGet packages—specifically Azure Hosting App Orchestration Tools—an unusual executable appears: DCP.exe.

What is this file? Why is it there?

The Same Binary on macOS

Repeating the experiment on macOS leads to the same discovery. Although the Aspire version is slightly older, the same DCP binary appears in the packages folder.

This raises a critical question:
If Aspire is open source, why does it include a closed-source executable?

The License Tells a Different Story

Opening the license file associated with this binary reveals something unexpected:
Microsoft Developer Control Plane.

The license terms make it clear that this is proprietary software. The agreement explicitly forbids reverse engineering, decompilation, or disassembly. It also includes clauses covering data collection, processing of personal data, and export restrictions.

This binary is not open source.

Even more concerning: there is no explicit license acceptance prompt when installing Aspire. The proprietary component is silently bundled into the toolchain.

What Is DCP?

The Aspire documentation describes DCP (Developer Control Plane) as:

“At the core of Azure app host orchestration functionality. Responsible for orchestrating all resources.”

In other words, this is not some optional helper utility—it is central to how Aspire works.

The documentation also notes that DCP is written in Go, not .NET, to allow deep native integration with Kubernetes APIs.

What it does not mention:
That this critical component is closed source.

Where Does the Binary Come From?

DCP does not appear to be distributed through a public NuGet feed. Instead, Aspire’s project files reference package downloads for Microsoft Developer Control Plane from private feeds.

There is evidence suggesting that these binaries may originate from an internal Microsoft GitHub repository that is inaccessible to the public.

So the toolchain pulls a proprietary binary from a private source and packages it into Aspire—without offering a chance to review or agree to its license.

Telemetry and Data Collection Concerns

The license mentions data collection and processing of personal data. According to comments from Microsoft engineers, DCP does not currently collect telemetry or usage data.

The word “currently” does a lot of work here.

Because the binary is closed source, there is no practical way to verify what it does today—or what it might do in the future. If telemetry were added later, developers would have no visibility into when or how that change occurred.

And since DCP runs on developer machines, that uncertainty matters.

Is This Still “Open Source”?

.NET Aspire is hosted under the .NET Foundation, which requires OSI-approved licenses. On paper, Aspire qualifies.

In practice, however, it wraps a proprietary binary at its core.

That means:

  • You cannot fully build Aspire from source.

  • You cannot audit the most critical part of its orchestration logic.

  • You cannot fork it into a fully independent implementation.

This stretches the definition of “open source” beyond what most developers would reasonably accept.

Community Concerns and Open Questions

This issue has already been raised publicly, including on GitHub. One of the questions posed:

Are there any plans to open source the Developer Control Plane?

The current licensing language suggests that Microsoft may be positioning DCP as a future commercial product.

If that happens, it would mean Aspire is effectively a wrapper around a proprietary core that could later become paid software.

That would be a textbook rug pull.

Why Is the Core Written in Go?

Another uncomfortable detail:
DCP is written in Go, not .NET.

For a platform positioned as a flagship .NET orchestration solution, outsourcing the most important logic to a Go binary feels contradictory.

If .NET is meant to be a first-class platform for cloud-native tooling, why is its orchestration core not implemented in .NET?

The Real Value of Aspire?

One of the most insightful observations from a deep technical analysis is that the DCP binary may be the most valuable part of Aspire. It appears significantly more complex than the surrounding C# code.

In that light, Aspire begins to look less like an open-source platform—and more like a thin wrapper around a closed-source engine.

A Better Direction Forward

Here is a constructive proposal:

  • Open source the Developer Control Plane.

  • If Go is absolutely required, keep it in Go—but make it public.

  • Better yet, reimplement it in .NET.

  • Provide a documented, auditable orchestration API.

A fully open-source .NET-native Kubernetes orchestration engine would be genuinely impressive—and far more aligned with the spirit of the .NET Foundation.

Final Verdict

Can .NET Aspire honestly be called an open-source platform today?

No.

Not when a proprietary Microsoft binary sits at the center of its functionality.
Not when developers cannot inspect, build, or replace that component.
Not when license terms quietly bind companies without explicit acceptance.

Until this is addressed, it is difficult to recommend Aspire in good faith.

Microsoft should clarify the status of the Developer Control Plane, publish its source code, or at the very least be transparent about the closed-source dependency embedded into Aspire.

Right now, the situation is not just confusing—it is deeply concerning.