# Passenger – The free IDE for C# and .NET

> Source: <https://passenger-ide.net/>
> Published: 2026-11-09 13:07:09+00:00

Now for Godot 4 games. The free IDE for C# and .NET.

Run, debug, profile and Hot Reload Godot games in C# and GDScript, their scenes and scripts
checked as Godot reads them and the running game beside your code. Blazor WebAssembly now debugs in the
browser, Avalonia and WPF take XAML Hot Reload, and your coding agent can drive it all.

Free and open source under MIT: no account, no licence key, no telemetry.

Included

Everything included, nothing to pay

Tools like these are usually found in paid IDEs or add-ons. In Passenger they are part of the
IDE, free and open source under MIT, for work and personal projects alike.

Godot 4: your scenes and the running game, in your code

For games in C#, in GDScript or in both. Passenger checks your code against your scenes, debugs
both languages at once, and works beside Godot's editor or as its script editor.

C# that knows its scenes

GetNode<T> paths and types, res:// paths, [Export]
values, signals and every string Godot takes (input actions, groups, animations, autoloads) complete
and are checked against the scenes that run the script. A rename reaches the scenes, and a scene is
marked where Godot would not load it, with fixes.

Passenger's port of Godot's parser and analyzer gives Godot's own warnings and errors with their
fixes, completion, the hover, Find Usages and Rename, mostly without starting Godot. Shaders are
checked as Godot's compiler checks them, every error and warning at once.

Both languages, one debugger

A breakpoint in C# or GDScript stops the game, a script you save reloads in it, and Godot's types
read as you think of them in Variables.

The running game, tuned

Its nodes and values in the Live Visual Tree, changed while it plays and kept into the scene, a node
picked by clicking in the game.

One profile, both languages

GDScript's functions and Godot's frame times beside the C# in one call tree, a slow frame opened on
what it spent.

Its tests

GdUnit4 (its engine tests on Godot 4.7), GUT and GoDotTest tests found, run and debugged in the Unit Tests window.

Beside Godot's editor

Passenger becomes Godot's script editor in one step, and its addon has a game Godot's Play starts
debugged in Passenger.

The game in a pane

On Windows, macOS and Linux under X11, the game can draw beside its code, taking the keys when you
click it.

Debugger

Fix bugs while the program runs

Passenger's own debugger, over ICorDebug and .NET's browser debug proxy, works the same on your
machine, inside a container and in the browser.

A debugger of its own

Breakpoints with conditions, hit counts and log messages, Smart Step Into, the values methods
returned (an async method's too), Run to Cursor and Set Next Statement, and the values each line
used drawn after it. Several programs debug at once, a tab each, and a library without symbols shows
its code, decompiled.

Attach to a .NET program already running, in a container too, and on a Mac with nothing to set
up.

Hot Reload while debugging

Edit the code, paused or running, and Hot Reload puts it in the program. An edit it can't apply is
listed with why, and by default the program restarts to take it.

Blazor, in the browser too

Debug a Blazor Web App and its server stops in one tab while its WebAssembly components stop in the
browser in the tab beside it: breakpoints, stepping, Variables, watches and the hover card, under
Aspire and in containers too.

With Hot Reload a component's edit shows at once and a saved stylesheet applies in place, the page
kept up. The page opens in Chrome, Edge, Chromium or Brave, on a profile of Passenger's own.

Profiler

See where the time and memory go

A profiler of Passenger's own, over the runtime's EventPipe, for a program you run, one already
running, or a service in its container.

Where the time goes

Sampling from a program's first instruction or attached to one already running: its call tree, hot
spots, flame graph, allocations and garbage collections, narrowed to any stretch of the
timeline.

What holds the memory

A memory snapshot counts the heap by type, with each object's retained size, and shows the shortest
paths that keep it alive. Two snapshots compared say which objects are new, which died and which
survived.

XAML

See your XAML as you write it, and as it runs

Passenger is built with Avalonia, and it gives XAML the help C# gets, from the project's own
assemblies and the framework's own compiler and previewer, for Avalonia and WPF alike.

XAML as you type

Completion of controls, properties, values, resources, selectors and binding paths, checked against
x:DataType or WPF's design-time data context, the XAML compiler's errors on their lines,
and a missing property, command or converter made from where it is used. A rename reaches across C#
and XAML, either way.

XAML Preview draws the file beside it as you type (WPF's on Windows), and the XAML workspace sets the
file, its preview and the running app's tree side by side, one selection across the three.

The running app, from its XAML

Debug an Avalonia app, or a WPF app on Windows, and the Live Visual Tree shows its controls as they are,
each property with where its value came from and each style with why it applies or not. In Avalonia
the XAML shows each binding's value after its line, and a breakpoint goes on an element.

Save a XAML file and XAML Hot Reload puts it in the running Avalonia or WPF app. A binding that fails
is a row in Problems with a fix, and can stop the debugger like an exception.

Agents

A coding agent that uses the IDE and tries the app

Passenger is an MCP server. Through it an agent works in the IDE, not only in your files: it asks
the language server instead of guessing from the text, and checks what it changed by building, testing and
running it. It works with Claude Code, Codex, OpenCode and any MCP agent.

It tries what it builds

When the program is an Avalonia app, a Godot game, or a WPF app on Windows, the agent sees it as a
person testing it would: a picture of each window or frame, the tree of its controls or nodes, and
clicks, typing and keys, which never take your focus or move your pointer.

It works as you do

It finds where things are declared and used, renames, fixes and formats as the IDE does, builds, runs
and tests, debugs and profiles, starts a compose service or an Aspire resource, and changes scenes in
your Godot editor, each change one step of Godot's Undo. On your own window it asks you first.

Passenger runs an app made of several services as one. Your compose files, Dockerfiles and
Aspire AppHosts are run configurations as the solution opens, and every .NET service in them runs under
Passenger's debugger, Hot Reload and profiler, wherever it runs.

Every service under the debugger

Debug holds each .NET service at its start, attaches inside its container and lets it go, so a
breakpoint in Main stops. Each service gets a Debug tab with its log as its console, and
Hot Reload reaches them all. A code change needs no image rebuild, and Rerun restarts only the
services whose build changed.

Aspire's IDE

Run or debug an AppHost and Aspire asks Passenger to start each project. The Aspire window shows its
resources, their consoles, logs and traces, charts each one's metrics and draws the AppHost as a
graph, and its code help checks every connection string against the AppHost.

From a service's row, or the run icon beside it in the compose file: debug it, attach to it, restart
or profile it in its container while the others run on.

The Containers window

Compose projects and their services, containers, images, volumes and networks: logs, stats, files,
details and a shell.

Compose files, understood

Each ${VAR} shown as it comes out, names completed, renamed and checked, and a connection
string a service never gets warned of, with its fix.

Images published and checked

Publish ships the SDK's container image, several tags and platforms, to your registry. An image's
known vulnerabilities show through your own Docker Scout, when you ask.

Your engine, as it is

Docker Desktop, Colima, OrbStack, Rancher Desktop, Podman or a remote engine, through your own
docker command.

Nothing left behind

Stop, closing the folder or a crash takes down what a run started. Your own containers are never
touched without asking.

Web apps and their data

See every request your app serves, with its SQL

For ASP.NET Core and EF Core: what your app serves and what it asks of the database, as it runs,
with no change to the app.

Live requests and their queries

The Requests window lists each request a running app serves, and the database commands it ran, with
their times and rows. A command run again for every row (an N+1) or a slow one is marked; a request
opens at its handler, or at the exception that ended it. It works for Run, Debug and Profile, and for
the services of a compose run or an AppHost.

EF Core migrations that run

The Migrations window lists each context's migrations and whether the database has them: add, remove,
update, script and bundle. Before dotnet ef runs it finds what would stop it (the
tool missing or of another version, the Design package, a provider behind) and offers the fix. During
a compose run or an AppHost, it works on the database that run uses.

Endpoints from your code

Minimal APIs, controllers, Razor Pages, Blazor, SignalR and gRPC routes read from the code with no
build, each sent to the running app from its icon. An app's OpenAPI document becomes requests, each
response checked against it.

Logs, traces and settings

Turn on Collect logs and traces and a project's run shows its OpenTelemetry logs and traces beside its
console. appsettings.json and user secrets complete the keys your code reads, and a
stopped EF Core query shows its SQL in the debugger.

The rest

Everything else a full .NET IDE has

Passenger is .NET from the window to the debugger, over the libraries a C# IDE
needs: Roslyn, MSBuild, ICorDebug, EventPipe, VSTest and Microsoft.Testing.Platform.

Coming from Visual Studio? Visual Studio's keys are the default, chords included.
Coming from VS Code or IntelliJ IDEA, choose its keymap in Settings.

A full .NET IDE on the Mac. Visual Studio for Mac was retired in August 2024. Passenger
runs natively on Apple Silicon, and its debugger attaches with nothing to set up.

The editor and C#

A text control of its own over an immutable rope: multiple carets, folding, soft wrap, live, postfix
and surround templates, inlay hints, and splits and tabs in windows of their own. A key costs what it
changed, not the file's size.

C# comes from Roslyn: diagnostics, completion, signature help, quick fixes and refactorings such as
Change Signature, Extract Interface, Move and Safe Delete, Go to Declaration, Implementation and Base
Symbols, Find Usages, hierarchies and decompiled library sources. Problems lists the whole solution's
without a build, and Razor and Blazor files get C# and HTML help together.

Git

The Commit window with its changes, the log with its branch graph and branches, side-by-side diffs with
the changed words marked, blame, change bars in the gutter that roll a change back, the history of a
file, a folder or a selection, stashes, push, pull and fetch, conflicts resolved in a three-way
merge, and commits signed with SSH, GPG or X.509.

Find anything

Search Everywhere, Go to File, Go to Symbol and Find Action. Find and Replace in Files across the
solution, a project, a folder or a scope, with a file mask and a preview. Find Usages in a window of its
own, Recent Files and Recent Locations, bookmarks and File Structure.

Show Usages

Every use of the symbol at the caret in a popup over the code, its own file's first, each with its
line, a C# member's uses in XAML among them. Choose one to go there, or keep them all in the Find
window. A click with a modifier, or a mouse button of its own, runs any action you bind to it.

Project files

In a .csproj, .props or .targets: completion of elements,
properties, items and their values, and of package ids and versions from your feeds, the version going to
Directory.Packages.props under central package management. A property's hover shows its
evaluated value and where it was set.

The web languages

JavaScript, TypeScript, HTML, CSS, SCSS, Less, JSON, Dockerfiles and YAML through their language
servers: completion, checks, navigation and formatting, TypeScript on the project's own version and
JSON against its schema. ESLint's problems show as you type with its fixes, the project's own
Prettier formats on Reformat Code and on save, and a class attribute completes from every stylesheet
the page uses.

Your page, as you write it

An HTML file previews beside its markup in your system's own web view, following each edit and
keeping your place as you type. Markdown and SVG files preview beside their text the same way, an
SVG with the images it names.

Resources and translations

A .resx opens as a table of its keys, values and comments, each cell written in place,
and an XLIFF file as its units' sources, targets and states. A localizer's keys complete in your C#,
and a key a language lacks is warned of where the code reads it, its fix asking for the
translation.

Build, run and publish

A Solution view as MSBuild evaluates it, builds with their errors in Problems, run configurations from
your launch profiles, consoles whose stack frames link to their lines, and Publish to a folder, a
container image or an AppHost's own deploy steps.

Unit tests

xUnit, NUnit, MSTest and TUnit, through VSTest or Microsoft.Testing.Platform: found from the code before
any build, run marks in the gutter, any test debugged, and results kept across restarts. A failed
Avalonia headless test (xUnit v3) carries a picture of each window as it was.

Local History

Every version of your files Passenger has seen, for five days of work, whatever Git knows: compared,
labelled and put back.

NuGet

The feeds your nuget.config names, packages installed, updated and removed per project,
central package management, and vulnerable versions marked with the lowest that fixes them.

Terminal

A terminal emulator of its own with a shell per tab, where vim, less and htop run full-screen. A console
program can run and be debugged in it.

Previews and tables

Images zoom, SVG and HTML files preview, fonts open as previews, and CSV, TSV and Excel workbooks
open as tables that sort and that Find searches.

Windows and layout

Tool windows docked or floating, editor tabs split or in windows of their own, and a window for each
solution.

New projects

New Solution and New Project offer every template dotnet new has, with their
options, and a Godot 4 game of Passenger's own.

Updates

Each new release downloads in the background and installs as Passenger closes, then shows what's
new, on Windows, macOS and Linux.

Make it yours

Twelve looks, each dark and light

Passenger's own in the app icon's blue, Harbour's teal on linen, and Sorbet, Nocturne, Saffron,
Bonbon, Ledger, Slate, Orbit, Nightjar, Moss and Phosphor, each checked for contrast and following your
system or your choice. Every file has an icon of its own, in each look's colours, and the editor's and
the terminal's fonts are yours to choose.

For teams

Ready for your company's code

Passenger works with what your team already has in the repository, and asks nothing of your
company.

Private feeds

The feeds your nuget.config names, with their credentials or a credential provider such
as Azure Artifacts', and package source mapping, as restore reads them.

Vulnerable packages

Versions with a known advisory marked from your feeds' audit data, with the lowest version that
fixes them.

Shared run configurations

Run configurations come from the launch profiles, compose files and AppHosts in the repository, and
Write to Launch Profile puts a change back there for everyone.

Your .editorconfig

Indentation, line endings, charset and Reformat Code follow it, file by file, and the status bar
says where a file's indent came from.

Signed commits

Commits signed with SSH, GPG or X.509 as your Git configuration asks, the passphrase asked in
Passenger, and each commit's signature shown in the log.

Agents for the whole team

A .mcp.json committed to the repository gives every Claude Code user there Passenger's
tools.

Nothing to sign up for

No account, no licence server and no telemetry: nothing to approve but the licences its notices
list, and nothing sent about your code.

Questions

Is it really free? What's the catch?

It is free and open source under the MIT licence, for work and personal projects alike, with no paid
edition, no trial and no account. There is no catch to find in the code: it is all
on GitHub, and the notices list every package and
asset it carries, each with its licence: two Microsoft assemblies inside Roslyn's server aren't
open source.

Is it ready for daily work?

Passenger is young (0.3.0), and its own development runs through it every day: the coding agents
that write much of it work through its MCP server. Its tests drive the whole IDE, a window with real
keys and clicks, on macOS, Windows and Linux, and each release is tried on a standing set of real
Godot projects. Each release's notes say what it does and its known limits, so you can judge for
your own projects.

Which systems and projects does it run on?

Windows (x64 and Arm64), macOS on Apple Silicon, and Linux (x64 and Arm64), with a .NET SDK from 8 for your projects.
It works with modern .NET (CoreCLR): console, ASP.NET Core, Blazor, Avalonia and WPF projects, Godot 4
games in C# and GDScript, and the services of a compose file or an Aspire AppHost. .NET Framework, Mono and Unity aren't
Passenger's.

Which Godot does it need?

Any Godot 4 for GDScript, and Godot's .NET build for C#, found from GODOT, the PATH or
your applications, or named in Settings. The Game window takes Godot 4.4 or newer (4.5 or newer on
macOS). The Godot page says the rest.

Does it need an account or send data?

No account, no sign-in and no telemetry. Passenger reaches the network only for what you use (your
package feeds, a JSON file's schema, a Dockerfile's base image) and once a day to ask GitHub whether
a newer release is out, sending nothing but its version, which Settings can turn off.

How are bugs reported and fixed?

In GitHub's issues: say what you did, what
you expected and what happened, with the log (Help, Show Log). Fixes land on main and ship
in the next release's notes.

Can my coding agent use it?

Yes: Passenger is an MCP server for Claude Code, Codex, OpenCode and any agent that can add one.
Set it up in a minute.

A .NET SDK for the projects you open,
.NET 8 or later. It builds and runs them with it; without one, it says what is missing and
installs one in a step once you agree. Its own language server, project host and debugger run on
the .NET it carries, whatever the machine has.

Node.js, for JavaScript, TypeScript, HTML, CSS,
JSON, Dockerfiles and YAML: 22.22.2 or later for TypeScript. C#, XAML, GDScript and shaders do
without it.

Godot 4, for Godot games (its .NET build for C#), found from GODOT,
the PATH or your applications, or named in Settings.

Chrome, Edge or another Chromium browser, for debugging Blazor's WebAssembly.

A container engine running Linux containers (Docker Desktop, Colima, OrbStack,
Rancher Desktop, Podman or a remote engine), only for compose files, Dockerfiles and an AppHost's
containers.

Every release, with its notes and its SHA256SUMS, is on
GitHub.