JetBrains Rider 2026.3 Help

Run and debug .NET Core and ASP.NET Core apps with launch profiles

A .NET Core or ASP.NET Core application can have its launch profiles configured with launchSettings.json. These profiles are auto-imported to the corresponding run/debug configurations, which you can then use to run and debug the application. Launch settings profiles for ASP.NET Core apps are often used to run and debug these apps in IIS Express.

What is launchSettings.json

launchSettings.json, which is placed in the Properties folder of a project, describes how the application can be launched — the command to execute, whether the browser should be opened, which environment variables should be set, and so on. This information can then be used by JetBrains Rider, by dotnet run, or by any other tool to run or debug the application.

This article details the conventions used in launchSettings.json. The example below shows a sample launchSettings.json with two launch profiles: IIS Express and Sample.

{ "iisSettings": { "windowsAuthentication": false, "anonymousAuthentication": true, "iisExpress": { "applicationUrl": "http://localhost:43347", "sslPort": 44364 } }, "profiles": { "IIS Express": { "commandName": "IISExpress", "launchBrowser": true, "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" } }, "Sample": { "commandName": "Project", "launchBrowser": true, "applicationUrl": "https://localhost:5001;http://localhost:5000", "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Staging" } } } }

Create run/debug configurations based on launchSettings.json

When you open a project with launchSettings.json for the first time, JetBrains Rider will pick the available launch profiles and automatically create corresponding run/debug configurations, which you can then use to run and debug the project.

For example, after cloning and opening the Orchard CMS, JetBrains Rider will create the following run/debug configurations from the launchSettings.json files:

JetBrains Rider: Creating run/debug configurations based on launchSettings.json

JetBrains Rider only generates run/debug configurations automatically when no run configurations were created in the solution before. If there are existing run/debug configurations or if you remove the auto-generated configurations, you can right-click launchSettings.json in the Solution Explorer and choose Generate Configurations to import the project's launch profiles into run/debug configurations.

Run and debug launch profiles

When launch profiles are imported as run/debug configurations, you can choose the corresponding configuration on the toolbar and click Run Run or Debug Debug:

JetBrains Rider: Running a launch profile based launchSettings.json

If a project has launchSettings.json, but there are no corresponding run/debug configurations, you can right-click the project in the Solution Explorer and choose Run '...' or Debug '...'. In this case, JetBrains Rider will create a temporary run/debug configuration for the first launch profile in the project's launchSettings.json and execute it.

You can also open a launchSettings.json in the editor and use the gutter icons to run or debug any launch profile:

JetBrains Rider: Running a launch profile from launchSettings.json file

In this case, JetBrains Rider will also create a temporary run/debug configuration for this profile.

Edit launch settings profiles

A run/debug configuration based on a launch profile includes two kinds of parameters:

  • Parameters from launchSettings.json, which you can configure by editing the file — use syntax highlighting, code analysis, and code completion when editing:

    JetBrains Rider: Coding assistance for editing launchSettings.json
  • Additional configuration parameters added by JetBrains Rider, such as the target framework to use or .NET runtime arguments. To configure these parameters, choose Run | Edit Configurations from the menu and pick the corresponding configuration.

    Parameters from launchSettings.json are shown as read-only; the additional configuration parameters are editable:

    JetBrains Rider: Editing run/debug configuration based on launchSettings.json

Preferences of the '.NET Launch Settings Profile' run configuration

The available options depend on the commandName property of the selected launch profile in launchSettings.json. Profile parameters are read-only in this dialog. To change them, open the project's launchSettings.json file in the editor. If JetBrains Rider finds this file for the selected project, an open in the editor link appears next to the Profile parameters are set by... message. Click the link to open the file.

Project:

Choose a startup project for this configuration.

Target framework:

A .NET Framework version that will be used to run this configuration.

Launch profile:

Choose one of the profiles configured in the launchSettings.json file.

Exe path:

Shows the executable path determined by the selected project and profile. For an Executable profile, this is the executablePath value from launchSettings.json. This field is read-only.

Program arguments

Shows the arguments from the profile's commandLineArgs property, combined with any arguments required to launch the project. This field is read-only.

Working directory:

Shows the profile's workingDirectory value. This field is read-only. If the profile does not specify a working directory, JetBrains Rider uses a default that depends on the profile type.

Environment variables:

Shows environment variables from the profile's environmentVariables property and any variables added by JetBrains Rider for the selected profile type. To change profile variables, edit launchSettings.json.

Terminal mode:

This option is available when the selected launch profile has commandName set to Project or Executable in launchSettings.json.

  • Automatic — Rider chooses the most suitable mode based on the run configuration and the executable type.

    • Typically uses PTY (pseudo terminal) for console-style programs to provide an interactive terminal experience (the process “thinks” it runs in a real terminal; isatty() is true; terminal control sequences may work).

    • Typically uses standard stream redirection for GUI programs (for example, auto-detected on Windows when linked with /SUBSYSTEM:WINDOWS), where no terminal is expected.

    • Note: Defaults cannot avoid all edge cases (especially on Windows), so switching modes can help when output/interaction is broken.

  • Enable pseudoterminal — Runs the process inside a pseudo terminal (PTY / ConPTY on Windows).

    • Best for programs that expect a real terminal: interactive prompts, TUI apps, shells, readline-style input, etc.

    • Enables “full terminal experience”: isatty() returns true and terminal control sequences (cursor movement, clears, etc.) are intended to work.

    • Known limitation: terminal emulation can be unreliable in some scenarios (for example, incorrect behavior in certain programs, especially on Windows).

  • Redirect standard streams — Captures stdin/stdout/stderr via redirection rather than running in a terminal.

    • Provides basic text output collection in the Rider Run window.

    • Most terminal-specific behavior is not available: many apps will treat output as “not a terminal” (isatty() is false), so interactive features and terminal control sequences typically won’t work.

    • Color output is often reduced/disabled by programs in this mode (commonly “no color” unless the program supports forced color in redirected output).

  • Redirect standard streams with ANSI codes — Redirects streams like the previous option, but allows ANSI escape sequences to pass through for colored/styled output.

    • Useful for programs that can emit ANSI color codes even when output is redirected (or when forced by configuration/environment).

    • Still not a real terminal: interactive terminal behavior generally remains unavailable (isatty() is false), and terminal control sequences beyond simple styling may not behave as expected.

    • This mode is aimed at improving readability (colors) without switching to full PTY mode.

  • External Console — Runs the process outside Rider Terminal window. It is a recommended workaround for certain programs (notably some GUI programs) that break when their streams are redirected, e.g., cases like GUIConsole.WPF / ConPTY demo scenarios.

  • Disable — Does not attach Rider’s console/terminal handling to the run configuration output. This may be useful for GUI applications (where terminal output redirection is not desired) or when any form of Rider-mediated output causes issues.

Attach to child .NET processes

Automatically attach the debugger to child and grandchild .NET processes started by the application. Requires .NET 8 or later. Refer to Attach to child .NET processes.

Runtime:

Choose a runtime for the application, or leave <Automatic> selected to let JetBrains Rider detect it. Available choices include .NET, Mono, and, on Windows, .NET Framework.

Choose Add Custom Runtime&#8230; to select another .NET CLI executable. The Runtime selector is not available when the profile's commandName is DebugRoslynComponent or MsixPackage.

Enable mixed-mode debugging

Debug managed .NET code and native C/C++ code in the same session. This option is available on Windows x64. Refer to Mixed-mode debugging.

.NET runtime arguments:

Specify arguments for the runtime, separately from application arguments. This option is available when the profile's commandName is Project or IISExpress.

Application URL

Shows the profile's applicationUrl value, or the URL from iisSettings for IIS and IIS Express profiles. This field is read-only. It is available when the profile's commandName is Project, IIS, or IISExpress.

Launch URL

Shows the profile's launchUrl value. An absolute URL opens directly; a relative path is appended to the application URL. If several application URLs are specified, the first is used. This field is read-only and appears for the same profile types as Application URL.

After launch

Shows whether the profile opens a browser, as specified by launchBrowser in launchSettings.json. The checkbox is read-only, but you can choose the browser next to it. Browser settings are available when the profile's commandName is Project, IIS, or IISExpress.

with JavaScript debugger

Attach the JavaScript debugger when opening the browser. Requires a Chromium-based browser. Refer to Debug JavaScript in Chrome.

Roslyn target project:

Shows the project used to debug a Roslyn component, such as a source generator. This field is read-only and appears only when the profile's commandName is DebugRoslynComponent. Set the project with the profile's targetProject property in launchSettings.json.

The following options are available when an IIS Express launch profile is chosen in the Launch profile: selector.

IIS Express certificate

If the site requires an IIS Express developer certificate that is not installed, click Install Certificate to install it.

Hosting model:

Shows the profile's ancmHostingModel value: Default, In Process, or Out Of Process. This field is read-only. In-process hosting runs the application inside IIS Express; out-of-process hosting uses a separate application process.

Generate applicationhost.config

To launch IIS Express with your ASP.NET Core application, JetBrains Rider uses a configuration file .idea/config/applicationhost.config, which is created using a template that ships with IIS Express. When possible, customizations you make to this file are also preserved. Clear this checkbox to maintain the file manually. If the file exists, click open in the editor next to the checkbox to edit it.

Show IIS Express output

Show output from the IIS Express process for additional diagnostics. This option is disabled by default:

JetBrains Rider: IIS Express output

Send debug request

When this option is enabled, JetBrains Rider will send an initial request (with a DEBUG HTTP request method) to the target ASP.NET Core application. This ensures the application is started and the debugger is attached, even when the browser is not started.

Additional IIS Express arguments:

This field lets you pass additional arguments to the IIS Express host (for example, to enable request tracing).

16 November 2026