Introduction

The release of Aspire 13 marks a transformative moment in the evolution of cloud-native application development. Unveiled alongside .NET 10 at .NET Conf 2025, Aspire 13 is not just a routine update—it is a comprehensive reimagining of the platform, reflecting a bold shift in vision, architecture, and community engagement. No longer branded as “.NET Aspire,” the toolkit now stands as Aspire, a truly polyglot platform designed to orchestrate, observe, and deploy distributed applications across .NET, Python, JavaScript, and beyond.

This blog post provides a deep dive into the rationale behind the renaming, the significant versioning leap to 13, and the extensive new features and improvements that define Aspire 13. This release brings a host of innovations—ranging from AI-powered workflows and first-class Python and JavaScript support to a reimagined build and deployment pipeline. We will explore the technical details, migration guidance, and practical examples to help you make the most of Aspire 13 in your projects.

Want to stay up-to-date with the latest Aspire news? Visit aspire.dev or the Aspire Users group on LinkedIn.

Why the Rename: From .NET Aspire to Aspire

The decision to drop the “.NET” prefix and rebrand as simply Aspire is more than a cosmetic change—it reflects a fundamental shift in the platform’s mission and scope. Historically, Aspire was tightly coupled with the .NET ecosystem, providing a code-first, opinionated stack for orchestrating and observing distributed .NET applications. However, as the needs of modern development teams have evolved, so too has Aspire’s vision.

Key motivations for the rename include:

• Polyglot Ambitions: Aspire 13 introduces first-class support for Python and JavaScript, making it a true polyglot platform. The rebranding signals that Aspire is no longer just for .NET developers but is now a unified solution for teams working across multiple languages and stacks.
• Platform Independence: By removing the “.NET” prefix, Aspire positions itself as a language-agnostic orchestration and deployment toolkit, capable of supporting a wide range of runtimes, frameworks, and cloud environments.

This rebranding is accompanied by a new home at aspire.dev, which serves as the central hub for documentation, guides, and community resources.

Versioning Shift: Why Aspire 13?

One of the most discussed aspects of this release is the leap in versioning—from Aspire 9.5 directly to 13, skipping versions 10, 11, and 12. This change has sparked curiosity and speculation within the community. The idea to break loose from the .NET version was raised by the Aspire team a couple of months ago and to be honest, I was strongly against. Primarily because at that point, the shift for supporting more developer platforms than just .NET was simply not on my radar. Now, everything makes more sense ;)

The rationale for the versioning shift is multifaceted:

• Decoupling from .NET Versioning: Previous Aspire releases were aligned with .NET’s versioning scheme (e.g., Aspire 9.x with .NET 9). With Aspire 13, the platform breaks away from this pattern, signaling its independence and commitment to an evergreen, rapidly evolving release cadence.
• Prime Number Symbolism: As noted by the Aspire team, “13 is bigger than 10 and less than 14 and is a prime number.” While partly tongue-in-cheek, this statement highlights the intention to make Aspire’s versioning distinct and memorable, marking a new era for the product.
• Evergreen Direction: The new versioning approach reflects Aspire’s move toward an evergreen model, where the latest version is always the recommended and supported release, in contrast to the long-term support (LTS) cycles of .NET itself.

In summary, Aspire 13’s version number is both a practical and symbolic break from the past, aligning with its new identity and ambitions.

What’s New in Aspire 13

Aspire 13 is a milestone release packed with new features, architectural changes, and developer experience improvements. Below, we explore the most significant enhancements, organized by theme and technical area.

High-Level Overview

• Polyglot Platform: First-class support for Python and JavaScript, alongside .NET.
• Reimagined Build and Deployment: The new aspire do command introduces a flexible, parallelizable pipeline for build, publish, and deploy operations.
• AI Integration: The Model Context Protocol (MCP) server enables real-time AI assistant integration for resource querying, telemetry, and command execution.
• Modernized JavaScript and Python Workflows: Unified APIs, automatic Dockerfile generation, and improved debugging support.
• Developer Tooling: Enhanced CLI, streamlined dashboard, and a new VS Code extension.
• Orchestration and AppHost Improvements: Simplified project templates, single-file AppHost support, and better container networking.
• Observability and Telemetry: GenAI visualizer, improved metrics, and enhanced health checks.
• Security and Credential Management: Deterministic Azure credential behavior and improved certificate trust across languages.
• Community and Ecosystem: New templates, GitHub release artifacts, and expanded contributor recognition.

Python and JavaScript as First-Class Citizens

Python Support

Aspire 13 delivers comprehensive support for Python applications, making it effortless to build, debug, and deploy Python services alongside .NET and JavaScript components.

Key features:

• Multiple Execution Models: Run Python scripts, modules, or executables directly from the app model.
• ASGI Framework Integration: Native support for Uvicorn, enabling seamless orchestration of FastAPI, Starlette, and Quart apps with automatic HTTP endpoint and health check setup.
• Flexible Package Management: Automatic detection and configuration for pip, uv, and venv. Developers can opt for lightning-fast dependency installs with uv or stick with traditional pip workflows.
• VS Code Debugging: Python resources can be debugged with breakpoints and variable inspection, with launch configurations generated automatically by the Aspire VS Code extension.

Example: Adding a FastAPI backend and React frontend

var builder = DistributedApplication.CreateBuilder(args);
var api = builder.AddUvicornApp("api", "./api", "main:app")
    .WithExternalHttpEndpoints()
    .WithHttpHealthCheck("/health");
var frontend = builder.AddViteApp("frontend", "./frontend")
    .WithReference(api);
builder.Build().Run();

This configuration orchestrates a Python FastAPI backend and a modern JavaScript frontend, demonstrating Aspire’s polyglot capabilities.

JavaScript Support

JavaScript applications are now first-class citizens in Aspire, with a unified API and improved workflows for both development and production.

Key features:

• Unified Application Model: The new AddJavaScriptApp method replaces the older AddNpmApp, providing intelligent detection for npm, yarn, and pnpm.
• Vite Integration: First-class support for Vite apps, including automatic hot module reloading, port configuration, and streamlined Dockerfile generation.
• Deterministic Package Management: Out-of-the-box, Aspire uses production-grade install commands (npm ci, yarn install --immutable, etc.) for reproducible builds.
• Customizable Scripts and Package Managers: Developers can specify custom scripts for development and build, and choose their preferred package manager.

Example: Adding a JavaScript frontend

var builder = DistributedApplication.CreateBuilder(args);
var frontend = builder.AddJavaScriptApp("frontend", "./frontend")
    .WithYarn()
    .WithRunScript("start")
    .WithBuildScript("prod");
builder.Build().Run();

This approach ensures that JavaScript applications integrate smoothly into the Aspire orchestration model, benefiting from the same observability and deployment features as .NET and Python services.

The aspire do Command and Pipeline Changes

A cornerstone of Aspire 13 is the introduction of the aspire do command—a flexible, intelligent reimagining of the build, publish, and deploy process.

Key capabilities:

• Fine-Grained Pipeline Control: Developers can execute specific pipeline steps (e.g., build, deploy, test) and their dependencies without running the entire pipeline.
• Parallel Execution: Independent steps are automatically parallelized, dramatically reducing deployment times.
• Custom Steps and Diagnostics: Teams can define custom steps, add validation, run tests, or plug in custom logic. The aspire do diagnostics command provides a visual overview of the pipeline graph, execution order, and dependencies.
• Incremental and Selective Execution: Enables incremental deployments, debugging of specific steps, and splitting of CI/CD pipelines for efficiency.
• Extensible Workflows: The pipeline system supports global steps, resource-specific steps, dependency configuration, and built-in logging.

Example: Custom pipeline step

builder.Pipeline.AddStep("validate", (context) => {
    context.Logger.LogInformation("Running validation checks...");
    // Custom validation logic
    return Task.CompletedTask;
}, requiredBy: WellKnownPipelineSteps.Build);

CLI usage:

aspire do validate
aspire do build --output-path ./artifacts
aspire do deploy --environment Production

This new pipeline architecture replaces the previous monolithic publishing infrastructure, providing a more flexible, composable, and observable deployment experience.

Aspire MCP (Model Context Protocol) and AI Integration

Aspire 13 introduces the MCP server, a groundbreaking feature that integrates Aspire into the AI development ecosystem.

How to use:

• Run your Aspire app and open the dashboard.
• Click the MCP icon in the dashboard to get connection instructions for your preferred AI assistant.
• Configure your assistant with the MCP endpoint and API key.

Available tools:

• list_resources: Retrieve all resources with state, endpoints, environment variables, and metadata.
• list_console_logs: Access resource console output.
• list_structured_logs: Retrieve telemetry data, optionally filtered by resource.
• list_traces: Access distributed trace information.
• execute_resource_command: Execute commands on resources.

Breaking Changes and Migration Guidance

Aspire 13 introduces several breaking changes, particularly in the areas of pipeline APIs, package naming, and credential management. Developers upgrading from previous versions should review the migration guidance carefully.

Major Breaking Changes

• Package Renames: Aspire.Hosting.NodeJs is now Aspire.Hosting.JavaScript. Update your package references accordingly.
• Removed APIs: The old publishing infrastructure (PublishingContext, PublishingCallbackAnnotation, etc.) has been removed, replaced by the new pipeline system.
• Renamed Types: Pipeline context and activity reporter types have been renamed for clarity and consistency (e.g., DeployingContext → PipelineContext, IPublishingActivityReporter → IPipelineActivityReporter).
• DefaultAzureCredential Behavior: When deploying to Azure Container Apps and App Service, DefaultAzureCredential now defaults to ManagedIdentityCredential only, improving security and predictability. If your application relied on other credential types, you may need to update your configuration.
• Obsoleted APIs: Lifecycle hooks and certain debugging APIs are now obsolete and will be removed in future releases. Use the new eventing and debugging infrastructure instead.

Migration Steps

• Update CLI and Packages: Use aspire update to upgrade the CLI and all NuGet packages to version 13.0.
• Refactor Pipeline Code: Replace publishing callbacks with pipeline steps using the new APIs.
• Update Package References: Rename any references to Aspire.Hosting.NodeJs to Aspire.Hosting.JavaScript.

Developer Tooling: CLI, Dashboard, and VS Code Extension

Dashboard Enhancements

The Aspire dashboard remains the central hub for monitoring, managing, and debugging your distributed applications.

New features in Aspire 13:

• MCP Server Integration: AI assistants can now interact directly with your running applications.
• Polyglot Language Icons: Visual indicators for .NET, JavaScript, and Python resources.
• Improved Accent Colors: Enhanced theming for better visibility in light and dark modes.
• Health Check Timestamps: Last run time displayed for each resource’s health status.
• GenAI Visualizer: Specialized dialog for analyzing Generative AI telemetry, with support for message content recording and OpenTelemetry exemplars.

VS Code Extension

The new Aspire VS Code extension brings CLI features directly into the editor:

• Project Creation: Create new Aspire projects from curated templates.
• Integration Management: Add integrations and configure launch settings.
• Multi-Language Debugging: Launch and debug C#, Python, and JavaScript resources.
• Deployment Management: Publish and deploy applications directly from the Command Palette.

Note: The extension requires the Aspire 13.0 CLI to be installed and available on your PATH.

Orchestration and AppHost/DCP Changes

Aspire’s orchestration model has been refined for greater simplicity, flexibility, and performance.

Key improvements:

• Simplified AppHost Templates: The SDK is now specified directly in the <Project> tag, and the Aspire.Hosting.AppHost package is included automatically.
• Single-File AppHost Support: Define your entire distributed application in a single .cs file, ideal for prototypes and learning scenarios.
• DCP (Developer Control Plane): Enhanced orchestration of resources, with improved container networking and support for context-aware endpoint resolution.
• Network Identifiers: New NetworkIdentifier types enable context-aware endpoint resolution for host, container, and public networks.

Example: Single-file AppHost

// apphost.cs
#:sdk Aspire.AppHost.Sdk@13.0.0
#:package Aspire.Hosting.Redis@13.0.0

var builder = DistributedApplication.CreateBuilder(args);
var cache = builder.AddRedis("cache");
var api = builder.AddProject("apiservice", "../MyApi")
    .WithReference(cache);
builder.Build().Run();

Telemetry, Observability, and GenAI Visualizer

Observability is at the heart of Aspire 13, with enhanced telemetry, metrics, and AI-powered analysis tools.

Key features:

• GenAI Telemetry Visualizer: Analyze AI-related operations, including chat completions and embeddings, with support for message content recording and OpenTelemetry exemplars.
• Improved Metrics and Traces: Enhanced dashboards for logs, traces, and metrics, with filtering, exemplars, and cross-resource correlation.
• Health Checks: Last run time displayed for each resource, aiding in troubleshooting and monitoring.
• Pause and Remove Telemetry: Tools to manage telemetry data volume during development.

Compatibility with .NET 10 and Other Runtimes

Aspire 13 is designed to work seamlessly with .NET 10 and supports orchestrating applications across multiple runtimes.

Key points:

• .NET 10 Required: The .NET 10 SDK is required for Aspire 13, enabling new features like file-based apps and improved performance.
• Polyglot Support: Python and JavaScript applications are first-class citizens, with support for modern package managers, debugging, and deployment.
• .NET MAUI Integration: The new Aspire.Hosting.Maui package enables orchestration of .NET MAUI mobile applications alongside cloud services, with Dev Tunnels for seamless connectivity and telemetry.

Examples and Code Snippets

Custom pipeline step:

builder.Pipeline.AddStep("validate", (context) => {
    context.Logger.LogInformation("Running validation checks...");
    // Custom validation logic
    return Task.CompletedTask;
}, requiredBy: WellKnownPipelineSteps.Build);

Serving frontend assets from backend container:

var frontend = builder.AddViteApp("frontend", "./frontend");
var api = builder.AddUvicornApp("api", "./api", "main:app");
api.PublishWithContainerFiles(frontend, "./static");

.NET MAUI integration:

var builder = DistributedApplication.CreateBuilder(args);
var api = builder.AddProject<Projects.Api>("api");
var publicDevTunnel = builder.AddDevTunnel("devtunnel-public")
    .WithAnonymousAccess()
    .WithReference(api.GetEndpoint("https"));
var mauiapp = builder.AddMauiProject("myapp", @"../MyApp/MyApp.csproj");
mauiapp.AddWindowsDevice().WithReference(api);
mauiapp.AddMacCatalystDevice().WithReference(api);
mauiapp.AddiOSSimulator().WithOtlpDevTunnel().WithReference(api, publicDevTunnel);
mauiapp.AddAndroidEmulator().WithOtlpDevTunnel().WithReference(api, publicDevTunnel);
builder.Build().Run();

Performance and Developer Experience Improvements

Aspire 13 delivers significant performance and usability enhancements:

• Parallelized Deployment: The new pipeline system reduces deployment times by running independent steps concurrently.
• Incremental Builds: Developers can execute only the necessary steps, improving iteration speed.
• Streamlined Project Templates: Simplified AppHost structure and single-file support lower the barrier to entry.
• Improved Error Handling: Clearer error messages and diagnostics aid in troubleshooting.
• Enhanced Observability: Real-time telemetry, GenAI visualizer, and improved dashboard UX accelerate debugging and optimization.

Final Thoughts and Upgrade Recommendations

Aspire 13 is a landmark release that redefines what is possible in distributed application development. By embracing a polyglot vision, reimagining the build and deployment pipeline, and integrating AI-powered workflows, Aspire positions itself as the orchestration platform of choice for modern, cloud-native teams.

Upgrade Recommendations:

• Review Breaking Changes: Carefully read the release notes and migration guides to address breaking changes in your projects.
• Update Tooling: Use aspire update to ensure your CLI and packages are up to date.
• Leverage New Features: Explore the new pipeline system, AI integration, and polyglot workflows to streamline your development and deployment processes.

Explore the new templates, guides, and community resources at aspire.dev, and experience the future of distributed application development today.

Last modified on 2025-11-12