Free and open source, MIT · Windows, macOS, Linux

An IDE for C# and .NET, written in C#.

Passenger edits, builds, runs, tests, debugs and profiles C# and modern .NET. It includes what usually takes a paid add-on, performance and memory profiling and XAML tooling for Avalonia and WPF, beside a debugger with Hot Reload, all free and open source under MIT. Your coding agent can use all of it, as you do.

Download Source on GitHub

For Windows and macOS, with builds for Linux.

Passenger's editor: a C# file with completion open after a dot, inlay hints, and the change bars of uncommitted lines

What sets it apart

Profilers and XAML tooling usually come as paid add-ons. In Passenger they are part of the IDE, with a full debugger, free and open source under MIT, for work and personal projects alike.

XAML tooling for Avalonia and WPF

Completion and checks for both, a preview as you type (WPF's on Windows), the running app's Live Visual Tree, failed bindings listed with fixes, and in Avalonia, binding values and breakpoints in the XAML. More XAML tooling than you'll find in other .NET IDEs, free.

What it does for XAML

Performance and memory profiling

A timeline, call tree, hot spots and flame graph, from a program's start or attached to one running. Heap snapshots with retained sizes and paths to roots, compared to show new, dead and survived objects. Usually a paid add-on; here it is built in.

The profiler

A debugger of its own

The values methods returned, Smart Step Into, exception breakpoints, stepping through async code, data breakpoints on Windows x64, and decompiled code for libraries without symbols. Attach to a .NET program already running, on a Mac with nothing to set up.

The debugger

Hot Reload, debugging or not

Edit the code while debugging and the program takes it, paused or running, or run it under dotnet watch. An edit it can't apply is listed with why, and by default the program restarts to take it.

Hot Reload

An IDE your agent can drive

Passenger is an MCP server. A coding agent asks it about the code, builds, tests, debugs and profiles through it, and tries out the app it is building. In your own window it asks you first.

How agents use it

The rest of a full IDE

A three-way merge for Git's conflicts, Local History of every file whatever Git knows, NuGet with vulnerable versions marked and the fix offered, four test frameworks, and a terminal of its own.

The tour

XAML tooling for Avalonia and WPF

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. More XAML tooling than you'll find in other .NET IDEs, for Avalonia and WPF alike, with no add-on to buy.

XAML as you type

Completion of controls, properties, attached 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. Go to Declaration into C#, rename of x:Name, Reformat Code, Extract Resource and Extract Style, and a missing property, command or converter made from where it is used.

XAML Preview draws the file beside it with the project's own Avalonia, following each edit, and on Windows it draws WPF files too.

An Avalonia .axaml file with XAML completion open, and XAML Preview drawing it beside the editor

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 an Avalonia app the XAML shows each binding's value after its line.

A binding that fails is a line in the Run or Debug console linked to its XAML, a row in Problems with a fix where there is one, and, if you choose, a stop like an exception's. Break When Value Changes stops on a property's next change, and in Avalonia's XAML a breakpoint goes on an element or one of its attributes.

Debugging an Avalonia app: the Live Visual Tree with an element's details, and binding values after the XAML's lines

Frames in the profiler

Profile an Avalonia app and its frames are charted with what each cost, and their layout listed by control type and then by control, each row opening its XAML. Avalonia's debug overlays are a toggle in the Run and Debug windows.

Failed tests pictured

When an Avalonia.Headless test with xUnit v3 fails, its result carries a picture of each window as it was, popups drawn in.

WPF on every system

WPF projects get the XAML help on macOS and Linux too: completion, checks, navigation, formatting and the refactorings. There a WPF project builds for its code help and says it runs only on Windows.

New projects

New Solution and New Project offer Avalonia's templates, and install them when they are missing.

A profiler and a debugger of its own

Both are written for Passenger, over the runtime's own EventPipe and ICorDebug. Performance and memory profilers usually come as paid add-ons; here they are part of the IDE, as is Hot Reload while you debug.

Where the time goes

Sampling over EventPipe, 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.

A debugger of its own

Over the runtime's ICorDebug: breakpoints with conditions, hit counts and log messages, exception breakpoints, stepping through async code, Smart Step Into, the values methods returned, Run to Cursor and Set Next Statement, threads and frames, variables you can open and set, watches, and the values each line used drawn after it.

A frame in a library without symbols shows its code, decompiled. Attach to a .NET program already running, on a Mac too with nothing to set up. Data breakpoints on Windows x64.

Hot Reload

Edit the code while debugging and Hot Reload puts it in the program, paused or running. An edit it can't apply is listed in Problems with why, and by default the program restarts to take it. Without the debugger, Hot Reload runs under dotnet watch.

Stopped at a breakpoint: the values after the lines, and the Debug window's frames and variables

An IDE your agent can drive

Passenger serves the Model Context Protocol, the standard coding agents use to reach their tools. 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 as you do

It finds where things are declared and used, reads the warnings, renames, fixes and formats code as the IDE does. It builds, runs and tests. It sets breakpoints, steps, reads and changes variables, applies Hot Reload and profiles a run. It searches and replaces across files, commits, resolves conflicts, adds packages, types into the terminal and looks at the window.

It tries the app it builds

When the program is an Avalonia app, or a WPF app on Windows, the agent sees it as a person testing it would: a picture of each window, the tree of its controls with their text and state, and clicks, typing, keys and scrolling sent to the window, which never takes the focus or moves your pointer. It reads the app's binding errors and can break on a property's change.

An agent in Passenger's terminal driving the Avalonia app being built over MCP: it starts the app under the debugger, finds its Water button, clicks it and reads the plants' moisture back, while the Live Visual Tree shows the button it clicked, now focused

Code: Diagnostics, hovers, declarations, usages, hierarchies, rename, code actions and formatting, each file through its own language: C#, Razor, XAML, the web languages and project files.
Build, run and test: Builds with their errors, what Problems lists, runs and their output, Hot Reload, and the unit tests listed and run.
Debug and profile: Breakpoints, launch or attach, steps, Run to Cursor, Set Next Statement, evaluation, variables set, the program's console, and a profile's hot spots and hot path.
The app: Its windows, controls and their details, pictures, clicks, typing, keys, scrolling and binding errors.
Files, Git and NuGet: Find and Replace in Files, Local History, status, diffs, the log, commits, checkout, stashes, conflicts, and packages searched, installed and removed.
The IDE: The window's picture, any action by its name, the settings, and the terminal.

Your window, or one of its own

With --mcp-attach, the agent joins the Passenger window you have open over the folder it works in. Its breakpoints and stops show in your editor, its runs in your Run window, and the status bar names what it is doing. Set it up before Passenger is running: the agent has its tools from the start, and its first call opens the folder in Passenger, starting it if need be, never a window on another folder.

The window asks before it lets an agent in, through a socket in your own user's folder: Allow, Don't allow, or Always for this folder. Turn on Settings › MCP Server › Enable MCP Server and it no longer asks. Either way, the first time an agent uses a tool that changes anything, or opens another folder in your window, Passenger asks you.

With --mcp and a folder or solution, the agent starts a Passenger of its own with no window, for work it does alone.

The quickest way in: Passenger's Settings › MCP Server shows each agent's setup with your copy's own path filled in, each with a Copy button. The agent starts Passenger from where it is installed:

macOS/Applications/Passenger.app/Contents/MacOS/Passenger
Windows%LOCALAPPDATA%\PassengerIDE\current\Passenger.exe
Linux~/.local/bin/passenger

Claude Code

claude mcp add passenger -- \
    /Applications/Passenger.app/Contents/MacOS/Passenger \
    --mcp-attach

Or for everyone working in a repository, in its .mcp.json:

{
  "mcpServers": {
    "passenger": {
      "command": "/Applications/Passenger.app/Contents/MacOS/Passenger",
      "args": ["--mcp-attach"]
    }
  }
}

Claude Desktop

In Settings › Developer, choose Edit Config, add Passenger, then restart Claude. Claude Desktop starts it in no folder of yours, so name the one to work in after --mcp-attach:

{
  "mcpServers": {
    "passenger": {
      "command": "/Applications/Passenger.app/Contents/MacOS/Passenger",
      "args": ["--mcp-attach", "/Users/you/src/app"]
    }
  }
}

On Windows the command is Passenger.exe's full path, each \ written \\.

Codex CLI

codex mcp add passenger -- \
    /Applications/Passenger.app/Contents/MacOS/Passenger \
    --mcp-attach

Or in ~/.codex/config.toml:

[mcp_servers.passenger]
command = "/Applications/Passenger.app/Contents/MacOS/Passenger"
args = ["--mcp-attach"]

Codex desktop app

In Settings › MCP servers, choose Add server, name it passenger, choose STDIO, give Passenger's path as the command and --mcp-attach as its argument, then save and choose Restart. The app and the Codex CLI share their settings, so adding it in one adds it to both.

Any other agent that can add an MCP server connects the same way.

The tour

Everything in 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.

The editor

A text control of its own over an immutable rope: multiple carets, folding, soft wrap, Extend Selection, live, postfix and surround templates, inlay hints, the symbol at the caret lit through the file, and splits, with tabs in windows of their own. A key costs what it changed, not the file's size: tests hold it in twenty thousand lines and on a line of a million characters.

Coming from Rider? Passenger ships Rider's Visual Studio keymap, or on a Mac its Visual Studio OSX keymap, chords included, and behaves as a Rider user expects.

C# from Roslyn

Colours as you type, then the language server's: diagnostics, completion, hovers, signature help, quick fixes and refactorings such as Change Signature, Extract Interface, Move and Safe Delete, a rename that renames the type's file, Go to Declaration, Implementation and Base Symbols, Find Usages, call and type hierarchies, and decompiled library sources. Problems lists the whole solution's without a build.

Unit tests

xUnit, NUnit, MSTest and TUnit, through VSTest or Microsoft.Testing.Platform: tests found from the code before any build, run marks in the gutter, results grouped and filtered, failures rerun, a run until one fails, and any test debugged.

Two looks of its own

Passenger, the default, takes the app icon's blue: a blue-to-teal title bar, the window's areas told apart by shade rather than lines, and an amber mark wherever the window says where you are. Harbour is warmer and rounder: the icon's teal on linen by day and a warm charcoal by night. Each comes in dark and light, following your system or your choice.

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, and conflicts resolved in a three-way merge.

The Git window's log with its branch graph and a commit's details

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.

Find in Files: every match with its file and line, the chosen one previewed below

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. Go to Declaration reaches the SDK's own files, and the evaluation's errors sit on their lines.

A project file with MSBuild help: a property's evaluated value and where it is set

The web languages

JavaScript, TypeScript, HTML, CSS, SCSS, Less and JSON 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, and the project's own Prettier formats on Reformat Code and on save. Razor and Blazor files get C# and HTML help together.

A TypeScript file with its language server's help

Build and run

A Solution view of the solution and its projects as MSBuild evaluates them, builds with their errors in Problems, run configurations from your launch profiles, consoles whose stack frames and compiler messages link to their lines, and the browser opened for a web project.

NuGet

Search the feeds your nuget.config names, then install, update and remove packages for each project, with central package management. A version with a known vulnerability is marked, with the lowest one that fixes it.

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.

Local History

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

Windows and layout

Tool windows docked or floating, editor tabs split or in windows of their own, a window for each solution, and each solution's layout kept. New Solution starts from any template dotnet new has.

Updates

On Windows and macOS each new release downloads in the background and installs as Passenger closes. On Linux, Passenger says when one is out.

Download

macOS

Apple Silicon .dmg

For Macs with Apple Silicon. Drag Passenger onto Applications. Each new release downloads in the background and installs as Passenger closes.

Windows

Installs for you alone, with no administrator. Each new release downloads in the background and installs as Passenger closes.

Linux

Unpack it and run its install.sh, for you alone or for everyone. Passenger says when a new release is out.

How to install on Linux

Passenger needs:

A .NET SDK, version 10 or later. It builds and runs your projects with it, and its language server, project host and debugger run on it.
Git, for version control.
Node.js, for JavaScript, TypeScript, HTML, CSS and JSON: 22.22.2 or later for TypeScript. C# and XAML do without it.

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