Aspire

Free and Open Source

Aspire is free and open source—always. No hidden costs, no lock-in. Join a thriving community and help shape the future of cloud-native development.

Why developers love Aspire

Code-centric Control

Define your stack in code—type-safe, readable, and debuggable. Aspire launches locally, then shifts to real cloud services without changing your architecture. Dev to deploy, fully wired.

Modular and Extensible

Orchestrate your frontends, APIs, containers, and databases—no rewrites. Extend Aspire for anything. Build with what you know and deploy anywhere: local, hybrid, cloud, edge, or on-prem.

Observability from the Start

Built-in OpenTelemetry gives you zero-config observability from day one—logs, traces, and health checks streaming—so you get instant insights and faster debugging with no setup required.

Flexible Deployments

Launch on your terms—Kubernetes, your own infrastructure, or managed cloud. Aspire snaps to your environment, not vice versa, delivering flexible repeatable deployments without rewrites.

Code-centric control

Aspire is modular, composable, and extensible. Configure relationships, deployment options, and dev-time flags in one place.

Build Your AppHost

Toggle different features on/off to see how Aspire defines different parts of your stack.

Frontend Database API Service Custom Container Deployment Options

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata");

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata");

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj");

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj");

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata");

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
                 .WithReference(postgres);

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata");

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
                 .WithReference(postgres);

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080)
                             .PublishAsKubernetes();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata")
                      .WithDataVolume()
                      .PublishAsAzurePostgresFlexibleServer();

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata")
                      .WithDataVolume()
                      .PublishAsAzurePostgresFlexibleServer();

// Add frontend service
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080)
                             .PublishAsKubernetes();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj")
                 .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj")
                 .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080)
                             .PublishAsKubernetes();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata")
                      .WithDataVolume()
                      .PublishAsAzurePostgresFlexibleServer();

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
                 .WithReference(postgres)
                 .WaitFor(postgres)
                 .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

builder.Build().Run();

AppHost.aspire

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
                      .AddDatabase("appdata")
                      .WithDataVolume()
                      .PublishAsAzurePostgresFlexibleServer();

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
                 .WithReference(postgres)
                 .WaitFor(postgres)
                 .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddNpmApp("frontend", "../frontend")
                      .WithHttpEndpoint(env: "PORT", targetPort: 3000)
                      .WithReference(api)
                      .WithNpmPackageInstallation()
                      .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
                             .WithHttpEndpoint(targetPort: 8080)
                             .PublishAsKubernetes();

builder.Build().Run();

Polyglot, multi-language support

Works with your existing stack — Aspire orchestrates applications written in C#, Java, Python, JavaScript, TypeScript, Go, PHP, Ruby, and more. Your team can keep using the languages and frameworks you know.

Java

PHP

JavaScript

Python

TypeScript

Ruby

C#

Go

Aspire supports a wide range of languages and frameworks, allowing you to build applications in the languages you love while benefiting from Aspire’s orchestration capabilities.

Language Flexibility

Frontend: React, Vue, Angular, Blazor, Next.js, and more
Backend: C#, Node.js, Python (FastAPI/Django), Go, PHP (Laravel/Symfony), Ruby on Rails, Java (Spring Boot)
Any Container: Docker containers work seamlessly with Aspire orchestration

Local-first, Production-ready

Aspire is designed to be local-first, meaning you develop and test your applications on your local machine and Aspire strives to closely mirror production. This approach reduces the “works on my machine” problem and ensures a smoother transition to production.

Local Test Prod

Local development with containerized services

Spin up and tear down complete staging environments for testing.

Production cloud services—zero code changes

aspire run

aspire up

aspire publish

Redis

AWS ElastiCache

Redis

Temporary Container App

Redis

Local Container

PostgreSQL

Google Cloud SQL

PostgreSQL

Staged DB

PostgreSQL

Local Container

Frontend

Vercel

Frontend

Dev Tunnel

Frontend

Local Process

API

Azure Container Apps

API

Staging Environment

API

Local Process

Same model—different environments

Use Aspire’s CLI to spin everything up locally or create deployment artifacts during your CI/CD.

Local Development

aspire run

• Runs with your local container runtime
• Dashboard available on localhost
• Uses dev secrets, volumes, dev-time config

Aspire CLI — run Run your entire stack locally—instantly orchestrated for development.

Production Deployment

aspire publish

• Same app structure, deployed where you want
• Use managed cloud services or your own infra
• Integrates with CI/CD pipelines seamlessly

Aspire CLI — publish Model your app once—deploy anywhere, from cloud to on-prem.

OpenTelemetry developer dashboard

Monitor logs, metrics, and traces in real time with the built-in OpenTelemetry dashboard—insightful, visual, and ready out of the box.

Explore integrations

Multi-cloud, limitless integrations — Effortlessly connect Aspire to Azure, AWS, Google Cloud, or your own infrastructure. Go beyond cloud providers—tap into a vast ecosystem of integrations to power any stack, anywhere.

User testimonials

Don’t take it from us — Hear from indie hackers to enterprises, developers are building faster and shipping with confidence using Aspire.

Aspire lets developers be developers again.

Steven Price (Software Engineering Manager, Iceland Foods)

I had someone start on a Monday morning and they were contributing code by lunch.

Russ Harding (VP Engineering, EQengineered)

I've never wanted to commit to a Microsoft technology this much.

Nk54 (Reddit User)

Hit F5 to begin — skip the setup boss fight, ship code faster.

Craig Taylor (Principal Architect, Xbox Live)

Aspire was easy to integrate with our existing container orchestration.

Sean Killeen (VP Innovation, SCT Software)

OpenTelemetry out-of-the-box in the Aspire dashboard is a game changer for observability!

Dan Clarke (Developer & Podcaster, Everstack)

Free, open source, and community-first

Aspire thrives on community contributions and feedback. Join our community forums, contribute to the codebase, or simply share your experiences. Together, we can make Aspire even better.

Ready for liftoff?

Get started with Aspire by installing the CLI, then dive into the Docs to learn how to model, run, and deploy your applications.

Get Aspire Install Aspire and streamline your workflow.

View Docs Learn how to model, run, and deploy apps with Aspire.