Skip to content
Back to search

passenger

An open-source IDE for C# and .NET, built with Avalonia, for Windows, macOS and Linux: a Roslyn-powered editor, its own debugger with Hot Reload, a CPU and memory profiler, XAML tooling for Avalonia and WPF, and an MCP server for coding agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Zaneris/passenger with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Zaneris/passenger'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/zaneris--passenger/badge.svg)](/listings/zaneris--passenger)

HTML

<a href="/listings/zaneris--passenger"><img src="/api/listings/zaneris--passenger/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 406 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Passenger
  2. **Debugger, profiler and Hot Reload, built in.** The free IDE for C# and .NET: stop at a breakpoint and read every
  3. line's values, change the code while it runs, see where the time and memory go, watch your XAML take shape as you type,
  4. and debug every service of a compose file or an Aspire app. Your coding agent can use all of it too. Built on .NET 11,
  5. it reads C# 15 and steps runtime async as written ([.NET 11](#net-11-and-c-15)). Free and open source under MIT, for
  6. Windows, macOS and Linux ([installing](#installing)).
  7. <p align="center">
  8. <a href="https://passenger-ide.net">Website</a> •
  9. <a href="https://passenger-ide.net/#download">Download</a> •
  10. <a href="docs/release-notes/0.4.0.md">What's new in 0.4.0</a> •
  11. <a href="#what-it-does">What it does</a> •
  12. <a href="#installing">Installing</a> •
  13. <a href="#your-coding-agent-using-the-ide-as-you-do">Your coding agent</a> •
  14. <a href="#building">Building</a> •
  15. <a href="CONTRIBUTING.md">Contributing</a>
  16. </p>
  17. <picture>
  18. <source media="(prefers-color-scheme: light)" srcset="site/images/debugger-light.webp">
  19. <img src="site/images/debugger-dark.webp" alt="Passenger stopped at a breakpoint in a C# method: the values each line used after it, and the Debug window's frames and variables">
  20. </picture>
  21. Tools like these are usually found in paid IDEs or add-ons. In Passenger they are part of the IDE, free and open source
  22. under MIT, for work and personal projects alike, with no account, no licence key and no telemetry:
  23. - **A debugger with Hot Reload:** your edits put in the running program, the values methods returned, Smart Step Into,
  24. decompiled libraries, and several programs debugged at once.
  25. - **CPU and memory profiling:** call trees, flame graphs, and heap snapshots compared.
  26. - **XAML previews and live trees for Avalonia and WPF:** completion and checks, a preview as you type, the running app's
  27. Live Visual Tree, and XAML Hot Reload.
  28. - **An IDE your agent can drive:** Claude Code, Codex, OpenCode or any MCP agent builds, tests, debugs and profiles
  29. through Passenger, and tries the app or game it builds.
  30. - **Live requests with their SQL,** N+1s marked, and **EF Core migrations** with what would stop `dotnet ef` fixed
  31. first.
  32. - **Debugging in containers and under Aspire:** every .NET service of a compose file, a Dockerfile or an AppHost
  33. debugged, reloaded and profiled where it runs, Aspire's metrics charted.
  34. - **Blazor WebAssembly, debugged in the browser,** beside the server's code, Hot Reload keeping the page up.
  35. - **Failed tests, pictured:** a failed Avalonia headless test (xUnit v3) carries a picture of each window as it was, in
  36. a Unit Tests window that runs xUnit, NUnit, MSTest and TUnit, and Godot's GdUnit4, GUT and GoDotTest.
  37. - **Local History and a three-way merge:** every version of your files Passenger has seen, and Git's conflicts merged.
  38. - **Godot 4 games, in C# and GDScript:** the game run, debugged, profiled and Hot Reloaded, its C# checked against its
  39. scenes, its GDScript and shaders read as Godot reads them, and the running game's tree and values beside the code.
  40. Coming from Visual Studio? Its keys are the default, and VS Code's and IntelliJ IDEA's are a setting away, each as
  41. Rider's keymaps have it. On a Mac, where Visual Studio for Mac was retired in August 2024, Passenger is a full .NET IDE
  42. that runs natively on Apple Silicon and Intel Macs.
  43. What comes next is in the [milestones](https://github.com/Zaneris/passenger/milestones), the release in progress among
  44. them. The pictures here are of sample projects committed to this repository, in your system's light or dark.
  45. ## What it does
  46. ### .NET 11 and C# 15
  47. Passenger is built on .NET 11 and runs on its own copy of it, carried inside it; your projects can target .NET 8 or
  48. later. C# 15 reads as C# 15: a union is coloured where you declare it and shows in the debugger as the value it holds,
  49. a collection expression's `with(…)` arguments build with no preview error, and project files complete `net11.0` and
  50. `LangVersion` 15. Code compiled with .NET 11's runtime async steps as you wrote it: Step Over an `await` stops on the
  51. method's next line once it goes on, whichever thread it goes on, and Step Out stops in the caller that awaited it,
  52. showing the value the method returned. Live metrics, the Requests window and an agent's telemetry read a .NET 11
  53. program from its start, where an older one is first left a few seconds, and a memory snapshot reads its heap. Under Hot
  54. Reload a debugged web app's open pages follow your edits through the .NET 11 SDK's browser refresh, the Migrations
  55. window runs EF Core 11's `dotnet ef` with the defaults `.config/dotnet-ef.json` names, and a project built for .NET 10
  56. and .NET 11 runs its tests under each. Open a .NET 11 project without its SDK and Passenger offers to install it into
  57. your own folder.
  58. ### Debugging
  59. Passenger's own debugger (started from SharpDbg and ICorDebugSharp, over ICorDebug): breakpoints with conditions, hit
  60. counts and log messages, exception breakpoints, stepping through async code (.NET 11's runtime async too), Smart Step
  61. Into, the values methods returned, Run to Cursor and Set Next Statement, watches and evaluation, and the values each
  62. line used drawn after it. Several programs debug at once, each in a tab of its own. A frame in a library without symbols
  63. shows its code, decompiled. Data breakpoints work on Windows x64, where the runtime supports them.
  64. Edit the code while debugging and Hot Reload puts it in the program, paused or running. An edit it can't apply is listed
  65. in Problems with why, and by default the program restarts to take it. Without the debugger, Hot Reload runs under
  66. `dotnet watch`.
  67. <picture>
  68. <source media="(prefers-color-scheme: light)" srcset="site/images/debugger-light.webp">
  69. <img src="site/images/debugger-dark.webp" alt="Stopped at a breakpoint: the values after the lines, and the Debug window's frames and variables">
  70. </picture>
  71. Run | Attach to Process (Ctrl+Alt+P, ⌘⌥P on a Mac) lists the .NET programs on your machine and in every running
  72. container, and debugs the one you choose as if Passenger had started it; Reattach to Process (Alt+Shift+P) attaches to
  73. the last one again. On a Mac this needs no setup: no Developer Tools access, no debugger entitlement, no signing. The
  74. debugger reaches a program's runtime through pipes in your temporary folder, so the program has to run as you, with your
  75. `TMPDIR`, and with `DOTNET_EnableDiagnostics` not set to 0. .NET Framework and Mono are not Passenger's.
  76. A Blazor Web App's WebAssembly components debug in the browser as its server's code does: breakpoints, steps, frames and
  77. values, in Chrome, Edge or another Chromium, through .NET's own browser debug proxy, under Aspire and in containers too.
  78. With Hot Reload a component's edit shows at once and a saved stylesheet applies with no reload.
  79. ### Profiling
  80. A sampling profiler over the runtime's EventPipe, from a program's first instruction or attached to one already running:
  81. its call tree, hot spots, flame graph, allocations and garbage collections, narrowed to any stretch of the timeline. A
  82. memory snapshot counts the heap by type, with each object's retained size and the shortest paths that keep it alive; two
  83. snapshots compared say which objects are new, which died and which survived.
  84. <picture>
  85. <source media="(prefers-color-scheme: light)" srcset="site/images/profiler-light.webp">
  86. <img src="site/images/profiler-dark.webp" alt="A profile of a run: its timeline above the call tree">
  87. </picture>
  88. ### Avalonia and WPF
  89. `.axaml` files get the help C# gets, from the project's own assemblies and Avalonia's own compiler and previewer:
  90. completion of controls, properties, values, resources, selectors and binding paths checked against `x:DataType`, the
  91. XAML compiler's errors on their lines, Go to Declaration into C#, a rename across C# and XAML either way, Extract
  92. Resource and Extract Style, and a missing property, command or converter made from where it is used. XAML Preview draws
  93. the file beside it as you type, and the XAML workspace sets the file, its preview and the running app's tree side by
  94. side, one selection across them. A saved XAML file reaches the running Avalonia or WPF app with XAML Hot Reload.
  95. <picture>
  96. <source media="(prefers-color-scheme: light)" srcset="site/images/xaml-light.webp">
  97. <img src="site/images/xaml-dark.webp" alt="An Avalonia .axaml file with XAML completion open, and XAML Preview drawing it beside the editor">
  98. </picture>
  99. Debug an Avalonia app and the Live Visual Tree shows its controls as they are, each property with where its value came
  100. from and each style with why it applies or not, and the XAML shows each binding's value after its line. Breakpoints go
  101. on an element, one of its attributes, or a property's next change, and a failed binding is a row in Problems with a fix
  102. that can stop the debugger like an exception. The profiler charts an Avalonia app's frames, and a failed
  103. Avalonia.Headless test (xUnit v3) carries a picture of each window as it was.
  104. <picture>
  105. <source media="(prefers-color-scheme: light)" srcset="site/images/live-tree-light.webp">
  106. <img src="site/images/live-tree-dark.webp" alt="Debugging an Avalonia app: the Live Visual Tree with an element's details, and binding values after the XAML's lines">
  107. </picture>
  108. WPF projects get the same XAML help on every system, with binding paths checked against the design-time data context. On
  109. Windows, XAML Preview draws WPF files, and a debugged WPF app's Live Visual Tree shows where each value came from and
  110. which styles and triggers set it, with Break When Value Changes and its failed bindings. Elsewhere a WPF or Windows
  111. Forms project builds for its code help and says it runs only on Windows.
  112. ### Containers and Aspire
  113. Each compose file (with its override), each project with a Dockerfile or that asks the .NET SDK for its image, each
  114. `.dcproj` and each Aspire AppHost is a run configuration as the solution opens, and every .NET service in it runs under
  115. the debugger, Hot Reload and profiler. Passenger works through your own `docker` command and whatever its context
  116. reaches: Docker Desktop, Colima, OrbStack, Rancher Desktop, Podman or a remote engine. By default it builds the .NET
  117. services itself and runs each from its build, so a code change needs no image rebuild and Rerun restarts only the
  118. services whose build changed. Debug holds each service at its start and attaches inside its container, and one service
  119. can be debugged, restarted or profiled while the others run on. New Solution and New Project write a new service's
  120. Dockerfile, compose file or AppHost, ready to Run or Debug.
  121. The Containers window lists Compose projects with their services, every other container, images, volumes and networks,
  122. with their logs, stats, files and details. Dockerfiles and compose files get language servers, BuildKit's checks and
  123. Compose's own reading as you type. Publish ships the SDK's container image with several tags and platforms, and an
  124. image's known vulnerabilities show through your own Docker Scout when you ask.
  125. Aspire's orchestrator asks Passenger to start each project resource of an AppHost. The Aspire window shows the resources
  126. with their state, health and addresses, their consoles, logs and traces, their references and waits both ways, each
  127. one's metrics charted, and the AppHost as a graph; the containers it makes go with its run. A service that reads a
  128. connection string its AppHost never gives it is marked, with a fix that adds the `WithReference`.
  129. <picture>
  130. <source media="(prefers-color-scheme: light)" srcset="site/images/aspire-light.webp">
  131. <img src="site/images/aspire-dark.webp" alt="An Aspire AppHost debugged in Passenger: the API service stopped at a breakpoint with its values after the lines, a Debug tab for each service, and the Aspire window listing both services running with the API's details">
  132. </picture>
  133. ### Web apps and their data
  134. The Requests window shows each request a running web app serves and the database commands it ran, with their times and
  135. rows, an N+1 or a slow query marked, for Run, Debug and Profile and for the services of a compose run or an AppHost:
  136. Passenger reads ASP.NET Core's and EF Core's own events, only while you look. The Migrations window lists each
  137. DbContext's migrations and whether the database has them, in the environment you choose (its run's, Staging, one you
  138. type), and fixes what would stop `dotnet ef` (the tool, the Design package, a provider behind) before it runs. The Endpoints window lists your `.http` files' requests and each web
  139. project's routes, read from its code with no build, and makes requests from the app's OpenAPI document. Turn on Collect
  140. logs and traces and a run's OpenTelemetry logs and traces show beside its console.
  141. <picture>
  142. <source media="(prefers-color-scheme: light)" srcset="site/images/requests-light.webp">
  143. <img src="site/images/requests-dark.webp" alt="Passenger's Requests window following an Aspire app's ASP.NET Core API as it runs, under the minimal API handler that loops over the plants: each GET /plants/thirsty request marked N+1, its repeated SQL query marked ×6 with its reads and times">
  144. </picture>
  145. ### Godot 4
  146. A Godot 4 game, in C# or in GDScript alone, runs, debugs, profiles and Hot Reloads on the Godot Settings › Godot names
  147. or the one found. A breakpoint in C# or GDScript stops the game and a saved script reloads in it; Run Current Scene
  148. plays the scene open, Run Another Copy plays up to 16 copies for multiplayer, and on Windows, macOS and Linux under X11
  149. the game can draw in a pane beside its code. New Project makes a game, Publish exports it through its presets, and
  150. `project.godot` opens as a page of its settings.
  151. The game's C# is read against its scenes: `GetNode<T>` paths and types, `res://` and `uid://` paths, `[Export]` values,
  152. signals and their handlers, and every string Godot takes (input actions, groups, animations, autoloads, shader
  153. parameters, translations, layers, theme items) complete, are checked and rename, and a scene is marked where Godot would
  154. not load it, with fixes. GDScript is read by Passenger's port of Godot's parser and analyzer: Godot's warnings and
  155. errors with their fixes, completion, the hover, Find Usages, refactorings that reach C# and the scenes, and Reformat
  156. Code by Godot's style guide, mostly without starting Godot. Shaders are checked as Godot's compiler checks them, every
  157. error and warning at once.
  158. <picture>
  159. <source media="(prefers-color-scheme: light)" srcset="site/images/gdscript-light.webp">
  160. <img src="site/images/gdscript-dark.webp" alt="A GDScript in Passenger with its code help open and a Godot warning marked in Godot's own words, no Godot editor running">
  161. </picture>
  162. While the game runs, the Live Visual Tree shows its scene tree and values, tuned while it plays and kept into the scene,
  163. a node picked by clicking in the game; its members' values show after their lines, and its errors stay pinned to them
  164. after the run. A profile holds GDScript's functions and Godot's frame times beside the C# in one call tree. GdUnit4, GUT
  165. and GoDotTest tests run and debug in the Unit Tests window, GdUnit4's engine tests on Godot 4.7 for now. Passenger's addon for Godot's editor debugs in Passenger the
  166. game Godot's own Play starts, and Passenger becomes Godot's script editor in one step. The website's
  167. [Godot page](https://passenger-ide.net/godot) has the rest.
  168. ### The editor and C#
  169. A text control of its own over an immutable rope: multiple carets, folding, soft wrap, Extend Selection, live, postfix
  170. and surround templates, inlay hints, and splits and tabs in windows of their own; a key costs what it changed, not the
  171. file's size. C# comes from Roslyn: diagnostics, completion, quick fixes and refactorings (Change Signature, Extract
  172. Interface, Move, Pull Members Up, Safe Delete and more), Go to Declaration, Implementation and Base Symbols, Find
  173. Usages, call and type hierarchies and decompiled library sources, and Problems lists the whole solution's without a
  174. build. A file-based program (`dotnet run app.cs`) opens as a project of its own, and a solution filter (`.slnf`) loads
  175. only the projects it names.
  176. <picture>
  177. <source media="(prefers-color-scheme: light)" srcset="site/images/editor-light.webp">
  178. <img src="site/images/editor-dark.webp" alt="Passenger's C# editor: completion open after a dot, inlay hints, and the change bars of uncommitted lines">
  179. </picture>
  180. Razor and Blazor files get C# and HTML help together, and a class attribute completes from every stylesheet the page
  181. uses. Project files complete their properties, items and package versions, with each property's evaluated value.
  182. JavaScript, TypeScript, HTML, CSS, JSON, Dockerfiles and YAML go through their language servers on Node.js, ESLint's
  183. fixes and the project's own Prettier included. Twelve looks of its own, each dark and light, and every file with an icon
  184. in each look's colours.
  185. <picture>
  186. <source media="(prefers-color-scheme: light)" srcset="site/images/themes-light.webp">
  187. <img src="site/images/themes-dark.webp" alt="Passenger's window changing look every two seconds through all twelve, each named in its title bar and Solution view: Passenger, Harbour, Sorbet, Nocturne, Saffron, Bonbon, Ledger, Slate, Orbit, Nightjar, Moss and Phosphor">
  188. </picture>
  189. ### And the rest
  190. - **Git:** the Commit window, the log with its branch graph, side-by-side diffs with the changed words marked, blame,
  191. change bars that roll a change back, the history of a file, a folder or a selection, stashes, conflicts resolved in a
  192. three-way merge, and commits signed with SSH, GPG or X.509, each signature shown in the log.
  193. - **Search:** Search Everywhere, Go to File, Go to Symbol and Find Action, Find and Replace in Files, Find Usages and
  194. Show Usages, Recent Files and Recent Locations, bookmarks and File Structure; a click with a modifier, or a mouse
  195. button of its own, runs any action you bind to it.
  196. - **Build, run and publish:** a Solution view as MSBuild evaluates it, builds with their errors in Problems, run
  197. configurations from your launch profiles, consoles whose stack frames link to their lines, and Publish to a folder, a
  198. container image or an Aspire AppHost's own publishers and deploy steps.
  199. - **Unit tests:** xUnit, NUnit, MSTest and TUnit, through VSTest or Microsoft.Testing.Platform, and a Godot game's
  200. GdUnit4, GUT and GoDotTest tests, found from the code before any build, any test debugged, and each test's last
  201. results kept across restarts.
  202. - **NuGet:** your `nuget.config`'s feeds, packages installed, updated and removed, central package management, and
  203. vulnerable versions marked with the lowest that fixes them.
  204. - **Local History, a terminal, tables and previews:** every version of your files Passenger has seen; a terminal
  205. emulator of its own; CSV, TSV, Excel, `.resx` and XLIFF files as tables, and images, fonts, SVG and HTML files
  206. previewed.
  207. - **Updates** that install themselves on Windows, macOS and Linux, then show what's new.
  208. <picture>
  209. <source media="(prefers-color-scheme: light)" srcset="site/images/git-light.webp">
  210. <img src="site/images/git-dark.webp" alt="The Git window's log with its branch graph and a commit's details">
  211. </picture>
  212. ## Installing
  213. [passenger-ide.net](https://passenger-ide.net/#download) has each system's download:
  214. - **macOS:** a disk image for Macs with Apple Silicon, or one for Intel Macs. Drag Passenger onto Applications.
  215. - **Windows:** an installer for x64 or Arm64, which installs for you alone, with no administrator.
  216. - **Linux:** an archive for x64 or Arm64. Unpack it and run its `install.sh`, for you alone or with `--system` for
  217. everyone; the command is `passenger-ide`, so it never meets Phusion Passenger's `passenger`. Its
  218. [Linux page](https://passenger-ide.net/linux) names the libraries it needs; `install.sh` names your distribution's
  219. font package where it finds no font, and refreshes fontconfig's cache where it lists none of those installed.
  220. A copy the installer, the disk image or `install.sh` put in place updates itself, then shows what's new. Passenger
  221. needs:
  222. - **a .NET SDK** for the projects you open (.NET 8 or later), which it builds and runs them with. Without one,
  223. Passenger says what is missing and installs one in a step, once you agree; its own language server, project host and
  224. debugger run on the .NET it carries, whatever the machine has;
  225. - **Git**, for version control;
  226. - **Node.js**, for JavaScript, TypeScript, HTML, CSS, JSON, Dockerfiles and YAML; C#, XAML, GDScript and shaders do
  227. without it;
  228. - for Godot games, **Godot 4** (its .NET build for C#), found from `GODOT`, the PATH or your applications, or named in
  229. Settings › Godot; Passenger is tested on Godot 4.7 and 4.8's betas;
  230. - for Blazor's WebAssembly debugging, **Chrome, Edge or another Chromium browser**;
  231. - for containers, **a container engine running Linux containers** (Docker Desktop, Colima, OrbStack, Rancher Desktop,
  232. Podman or a remote engine).
  233. ## Your coding agent, using the IDE as you do
  234. <picture>
  235. <source media="(prefers-color-scheme: light)" srcset="site/images/agent-light.webp">
  236. <img src="site/images/agent-dark.webp" alt="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">
  237. </picture>
  238. Connect a coding agent such as Claude Code, Codex or OpenCode to Passenger and it works through the IDE, not just your
  239. files. It finds where things are declared and used, reads the warnings, and renames, fixes and formats code as the IDE
  240. does. It builds, runs and tests, sets breakpoints, steps, reads and changes variables, applies Hot Reload and profiles a
  241. run. It starts, debugs and stops a compose service or an Aspire resource and reads its logs, traces and metrics, reads a
  242. web app's routes and live requests, runs the EF Core migrations, commits, resolves conflicts and adds packages. When the
  243. program is an Avalonia app, a Godot game, or a WPF app on Windows, it sees and drives it as a person testing it would,
  244. without taking your focus or your pointer, and through Passenger's addon it changes scenes in your Godot editor, each
  245. change one step of Godot's Undo.
  246. There are two ways in, each a flag on Passenger's own executable:
  247. - **`--mcp-attach`** joins the window you have open over the folder the agent works in (`--mcp-attach PID` chooses one
  248. of Passenger's windows), so its breakpoints and stops show in your editor and its runs in your Run window; its first
  249. call opens the folder in Passenger, starting it if need be, and it never joins a window on another folder. The window
  250. asks you before it lets an agent in (Allow, Don't allow, or Always for this folder), unless you have turned on
  251. Settings | MCP Server | Enable MCP Server, and asks again before each call of a tool that changes anything: Allow Once
  252. for that call, or Allow for This Session for every call of that tool until the agent disconnects. An agent about to
  253. make several changes can ask once for every tool, which Allow for This Session lets it use unasked until it
  254. disconnects; Deny keeps each tool asking. A question not answered within two minutes comes back to the agent as nobody
  255. having answered.
  256. - **`--mcp FOLDER`** starts a Passenger of the agent's own with no window, over a folder or solution, for work it does
  257. alone. It asks nothing, so it suits an agent you leave to work while you are away.
  258. Passenger's own Settings | MCP Server shows each agent's setup with this copy's path filled in, each with a Copy button,
  259. and the website's [agents page](https://passenger-ide.net/agents) has the same setups, Claude Desktop's, the Codex
  260. desktop app's and OpenCode's among them. Passenger is `/Applications/Passenger.app/Contents/MacOS/Passenger` on a Mac,
  261. `%LOCALAPPDATA%\PassengerIDE\current\Passenger.exe` on Windows, and `~/.local/bin/passenger-ide` on Linux
  262. (`/usr/local/bin/passenger-ide` when installed for everyone). A repository's `.mcp.json` gives it to everyone who works
  263. there with Claude Code:
  264. ```json
  265. {
  266. "mcpServers": {
  267. "passenger": {
  268. "command": "/Applications/Passenger.app/Contents/MacOS/Passenger",
  269. "args": ["--mcp-attach"]
  270. }
  271. }
  272. }
  273. ```
  274. Or add it for yourself:
  275. ```sh
  276. # Claude Code
  277. claude mcp add passenger -- /Applications/Passenger.app/Contents/MacOS/Passenger --mcp-attach
  278. # Codex CLI
  279. codex mcp add passenger -- /Applications/Passenger.app/Contents/MacOS/Passenger --mcp-attach
  280. ```
  281. A call that takes a while (a build, a test run, a debug session waiting for a stop) tells the agent what it is doing
  282. every 10 seconds when the agent asks for progress. With Settings | Diagnostics | Trace protocol messages on, `mcp.log`
  283. in the logs folder has each agent's call, what it waited on and for how long.
  284. This repository's own [`.mcp.json`](.mcp.json) runs [`tools/mcp.sh`](tools/mcp.sh), the script `just mcp` runs too: the
  285. last Debug build with `--mcp` over this folder, run from a clone of the build so rebuilding Passenger never changes the
  286. files under the agent's IDE.
  287. ## Building
  288. Building needs the .NET 11 SDK (11.0.100 or a later 11.0 SDK, as [`global.json`](global.json) asks) and
  289. [just](https://github.com/casey/just). The tests need more:
  290. - **the .NET 10 SDK** beside it, since the programs the debugger's tests debug ([`tests/Debuggees`](tests/Debuggees))
  291. and most projects the tests write run on .NET 10;
  292. - **Git**, which the IDE runs for its Git features and the tests for theirs;
  293. - on Linux, **the X11 and fontconfig libraries** [Passenger's Linux page](https://passenger-ide.net/linux) names, which
  294. the headless tests draw their text with too;
  295. - **Node.js**, for the web languages' tests, which skip without it, saying why;
  296. - **a container engine running Linux containers** (Docker Desktop, Docker Engine, Colima, OrbStack), for the container
  297. tests, which skip without one, saying why.
  298. **Python 3** runs `just test` and the recipes that write or check generated files (`just icons`, `just file-icons`, `just themes`,
  299. `just unicode-widths`, `just notices`, `just test-times`) and some of the macOS ones (`just app-icon`,
  300. `just package-mac`, `just site-shots`). To use what you build, Passenger needs what a release needs
  301. ([installing](#installing)).
  302. ```sh
  303. just build # Debug build; warnings are errors
  304. just run [PATH] # run it on a folder or solution (--theme dark|light, --look passenger, cubicle, harbour… or SOURCE::NAME)
  305. just test [FILTER] # every test, the IDE driven whole on Avalonia's headless platform, or those matching;
  306. # the results in artifacts/test-results
  307. just screenshot shell.png # draw the main window to a PNG off-screen (--size 1600x1000 --scale 2)
  308. just mcp [FOLDER] # Passenger as an MCP server over a folder, from a clone of the last build
  309. just publish osx-arm64 # a self-contained Release build (osx-x64, win-x64, win-arm64, linux-x64, linux-arm64 too)
  310. just package-mac # the macOS disk image, Apple Silicon (or osx-x64, Intel); signed with
  311. # PASSENGER_SIGN_IDENTITY, else ad hoc
  312. just package-win win-x64 # the Windows installer (or win-arm64), unsigned unless tools/package-win.sh's variables sign it
  313. just package-linux # the Linux archive with its install.sh (linux-x64, or linux-arm64), as site/linux.html uses it
  314. just container-tools # the tools Passenger debugs and profiles with inside a Linux container, where a build finds them
  315. just notices # fail naming any package THIRD_PARTY_NOTICES.md does not name
  316. ```
  317. Every recipe sets `AVALONIA_TELEMETRY_OPTOUT=1`. Avalonia's build task (Avalonia.BuildServices, which every Avalonia
  318. package brings) otherwise sends AvaloniaUI a record of each build: a machine id it keeps, hashes of the machine and
  319. user names and of the project's name, the system, the IDE and the CI it ran under. It reads its opt-out only from the
  320. environment, so set the variable yourself for a build outside `just` (`dotnet build`, an IDE's).
  321. Packages come only from nuget.org (`nuget.config`), at the versions and content each project's `packages.lock.json`
  322. pins, and on Windows and Linux only as nuget.org signed them (NuGet checks no signatures on macOS). A restore on your
  323. machine updates a lock file when you add or change a package; commit it with the change, since CI restores only what
  324. the lock files name.
  325. The website is [`site/`](site), plain HTML and CSS deployed to [passenger-ide.net](https://passenger-ide.net) when the
  326. Site workflow is run by hand.
  327. ## Contributing
  328. [`CONTRIBUTING.md`](CONTRIBUTING.md) says how to report a bug, propose a change and open a pull request, and what
  329. working on Passenger needs.
  330. ## Licence
  331. MIT (`LICENSE`). Third-party code and assets keep their own licences, listed in `THIRD_PARTY_NOTICES.md`.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.