Run the project (F5)

Press F5 and Context Code starts your project. Not a list of buildable things: one concrete configuration, the one you marked as the startup project, just like in Visual Studio.

Launch configurations

When you open a project, the app walks its folders (up to three levels, skipping node_modules, target, dist, build, .git…) and works out everything that can be run:

Clue on disk	Configuration offered
*.sln	one per runnable project in the solution (OutputType Exe or a Web/Worker SDK)
*.csproj / *.fsproj / *.vbproj	dotnet run --project …
package.json with dev, start or serve	pnpm/npm/yarn/bun run <script> (the manager comes from the nearest lockfile)
src-tauri/tauri.conf.json	tauri dev
angular.json / ionic.config.json	ng serve / ionic serve
vite.config.* with no dev script	vite
Cargo.toml	cargo run, or one cargo run --bin <bin> per binary
manage.py, main.py, app.py, pyproject.toml	manage.py runserver, python <file>, python -m uvicorn main:app --reload, python -m <module>
go.mod	go run . plus one go run ./cmd/<x> per cmd/*
pom.xml / build.gradle	mvn spring-boot:run (or exec:java), gradlew bootRun (or run)
pubspec.yaml	flutter run
.vscode/launch.json	its launch entries of type node, coreclr, python or go, translated into a command

One line per configuration

In an ERP with twenty projects the list has to be readable at a glance, so every configuration is a single line:

[C#] Security · [Node] Mobile start · [Ionic] Mobile ionic serve

• The language icon — the same one the file tree uses: C#, TypeScript, Angular, Ionic, Node, Gradle, Maven, Rust, Python, Go, Dart, Tauri — replaces the old text chip (“DOTNET”, “ANGULAR”). The exact type is in its tooltip.
• The short name is just the project: ApiGateway, Security, Frontend, Mobile, android. Never “Security · dotnet run · Security”.
• The verb (dimmed, on the right) only shows up when it tells two rows apart: if Mobile has three ways to start you will see start, ng serve and ionic serve; if a .NET project is the only one in its solution, “dotnet run” is not repeated across six rows.
• The full command, the folder and the source file no longer crowd the list: they live in the row’s tooltip and in the picker’s detail panel, which follows the highlighted row — “Command: dotnet run --project Security.csproj · Folder: Backend/Security · Solution: Backend/AspidaERP.sln”.

Groups: solution and package, not subfolder

Headers are the real unit of the project, with their icon and the number of configurations:

• .NET groups by .sln: the app reads the Project(…) = "…", "path.csproj" lines of each solution, so the six services of AspidaERP.sln stay together even though they live in six folders. When a .csproj appears in two solutions (one nested), the outermost wins. Anything in no solution falls into “No solution”.
• Node / Angular / Ionic / Tauri and Rust group by the root manifest (package.json, Cargo.toml), not by the individual package. Gradle groups by the outermost settings.gradle, the real root of the Android project.
• Groups collapse, and whatever you leave collapsed is remembered per project.
• The rarely useful is hidden by default behind “Show all (N)”: test projects, e2e folders, the gradle run of capacitor-cordova-android-plugins, bin, obj.

Startup project

The ▶ button in the IDE-mode bar shows the icon and the short name of the startup project (▶ Security), and F5 runs it.

• If there is only one configuration, that is the startup project and F5 launches it without asking.
• If there are several and you have not chosen yet, F5 opens the picker: the list grouped by solution or package, with a search box and the “Set as startup project” checkbox (ticked by default). On accept it runs and stays pinned; from then on F5 goes straight to it.
• The dropdown next to ▶ changes the startup project at any time. It uses the same compact rows (icon + short name, with the ✓ on the startup one) and offers Detect again, Choose startup project… and Edit configurations….

The choice is saved per project, in .context/run.json. Changing the startup project touches nothing else.

Shortcuts

Shortcut	What it does
F5	runs the startup project. If it is already running it does not duplicate it: it focuses its output tab
Shift+F5	stops everything that is running
Ctrl+F5	opens the picker to run another configuration without changing the startup project (there is no debugger here, so this is the useful equivalent of “Start without debugging”)
Ctrl+Shift+B	build the build targets, which is what F5 used to trigger

Project output

The run goes to the Project output panel, with one tab per running configuration. Each tab has ⏹ stop, ↺ restart, 🗑 clear, and closes with ✕ once the process is done. The coloured dot says whether it is still alive (green), finished cleanly (grey) or failed (red).

The Problems tab parses that same output and pulls out file:line:column from the usual formats (rustc, tsc, gcc/clang, webpack): a vite dev or a cargo run failing to compile shows up there, with no digging through the log.

Always ask

The ▶ dropdown has “Always ask what to run” (off by default). With it on, F5 opens the picker every time, even when there is a startup project. Handy when you are working on two services of the same monorepo at once.

run.json: configurations by hand

Edit configurations… opens .context/run.json in the editor, creating it if it did not exist. The file accepts comments (//) and trailing commas, and its header documents the format:

{
  "proyectoDeInicio": "node:apps/web:pnpm-run-dev",
  "preguntarSiempre": false,
  "configuraciones": [
    {
      "id": "api-local",
      "nombre": "API (local)",
      "cwd": "services/api",
      "comando": "node",
      "args": ["server.js"],
      "env": { "PORT": "3001" }
    }
  ]
}

• proyectoDeInicio — the id of the configuration F5 starts.
• preguntarSiempre — true makes F5 always open the picker.
• configuraciones — yours, which are added to the detected ones (they show up flagged as manual). Only id and comando are required: nombre falls back to the id, cwd to the project root and tipo to custom.
• cwd is relative to the project root ("." is the root) and args is already split, with no shell quoting.

A malformed entry is dropped on its own: the rest of the file — and your startup project — keep working.

Note

The command must be on the allowed-executables list (node, pnpm, npm, yarn, bun, cargo, dotnet, python, go, java, mvn, gradlew, flutter, dart, make…) and cwd must stay inside the project. It is the same barrier that keeps the agent from running anything at all.