Solution Explorer

A lightweight Visual Studio-style Solution Explorer for VS Code, built for .NET developers who want the .sln/.csproj tree without the weight of a full language server.

Made because the C# Dev Kit's solution tooling is being sunset and existing extensions are slow to load and can degrade IntelliSense / format-on-save. The tree loads and renders by pure XML parsing in-process — no OmniSharp/Roslyn dependency, no watching of source files, and no dotnet CLI on the load or idle path. (The optional New Project action shells out to dotnet new only when you explicitly invoke it.)

Features

Logical solution tree — mirrors the .sln/.csproj structure (Solution Folders, Projects, Folders, Files), not the raw filesystem.
Open from anywhere — a single .sln loads automatically; otherwise a welcome panel offers Open Solution File or Open Folder (scans a directory for .sln, without adding it as a workspace root).
Solution folder management — create (at root or nested), rename, and remove Solution Folders; reparent Projects/Solution Folders by drag-drop or "Move to Solution Folder…".
Add projects — New Project (scaffolds via dotnet new, then adds it to the .sln) and Add Existing Project (references a .csproj/.fsproj/.vbproj already on disk).
Both project formats — SDK-style (glob-based) and legacy (explicit <Compile>/<Content>) projects.
Blazing-fast load — the solution tree renders immediately from the .sln; project files are parsed in the background so expansion is instant.
Dedicated activity-bar panel — separate from the file Explorer, no Outline/Timeline clutter.
Symbol search (Alt+P) — Ctrl+P-style fuzzy search across C# type names, not just file names. Find AuditFindingQueryParams even when it lives in AuditFindingViewModel.cs, with live preview and jump-to-type.
Search scope — right-click a Project (or a Solution Folder, which cascades) → Include in / Exclude from Symbol Search; multi-select aware. Or Set Symbol Search Scope… for a multi-select of all projects. Excluded projects are never indexed and show a slashed icon. Scope is personal (stored per-solution, not committed).
File operations — add file (template-aware), add folder, rename (F2), delete (recycle bin), move between projects (drag-drop or menu) with namespace updates.
Templates — built-ins (Class, Interface, Record, Enum, Abstract Class, Razor Component/Page/PageModel, Blank) plus custom folder templates: one folder = one template whose ${NAME} filename pattern derives the output name and doubles as a naming rule (${NAME}Command.cs + stem Approve → ApproveCommand.cs). Custom templates run through a hybrid snippet engine ($NAMESPACE/${NAME} pre-resolved, then native VS Code snippet tab stops/choices/$TM_FILENAME_BASE). Author with Save as Template / New Template / Manage Templates.
Namespace inference — <RootNamespace> + folder path; file-scoped vs block-scoped follows .editorconfig.
Project menu — Open .csproj, Reveal in File Explorer, Open in Integrated Terminal, Copy Path / Relative Path.

Symbol search


Trigger	`Alt+P` (rebindable), or the 🔍 icon in the panel title
Indexes	`.cs`, `.razor.cs`, `.cshtml.cs` type declarations; `.razor` as one component. Methods / properties / enum members are opt-in (three settings)
Build	Lazily on first search, then cached
Freshness	Re-indexes a file when you save it (no `.cs` filesystem watcher)
Multi-word	Type several words — all must appear in the name (`finding viewmodel` → `AuditFindingNewViewModel`)
Navigate	Live preview as you arrow (toggle off for low-spec machines)
Open	`Enter` opens the file, cursor centred on the type name; `Esc` restores your editor
Scope	Per-project include/exclude (Solution Folders cascade); excluded projects are never indexed

Symbol extraction uses a regex provider by default (zero language-server dependency — see ADR-0001). Set solutionExplorer.symbolProvider to languageServer to use the C# extension's symbol search instead — higher accuracy, live-queried as you type, and it falls back to the regex provider if no C# extension is installed (see ADR-0006).

Configuration

Setting	Default	Description
`solutionExplorer.namingConventions`	`I* → Interface`, …	Filename pattern → template rules
`solutionExplorer.defaultTemplate`	`Class`	Template when no naming rule matches
`solutionExplorer.namespaceStyle`	`auto`	`auto` (read `.editorconfig`) / `file-scoped` / `block-scoped`
`solutionExplorer.customTemplatesPath`	`""`	Secondary flat directory of custom templates (primary source is the global storage folder — use New / Manage Templates)
`solutionExplorer.autoRevealActiveFile`	`false`	Auto-reveal active editor file in the tree
`solutionExplorer.symbolProvider`	`regex`	`regex` / `languageServer` (latter falls back to regex)
`solutionExplorer.symbolSearch.livePreview`	`true`	Live-preview results while navigating
`solutionExplorer.symbolSearch.indexMethods`	`false`	Also include methods in Search Symbol
`solutionExplorer.symbolSearch.indexProperties`	`false`	Also include properties in Search Symbol
`solutionExplorer.symbolSearch.indexEnumMembers`	`false`	Also include enum values in Search Symbol
`solutionExplorer.autoWatchSourceFiles`	`false`	Auto-refresh when files are added/removed outside VS Code

Development

npm install
npm run build      # bundle with esbuild
npm run watch      # rebuild on change
npm test           # run the regex provider + .sln writer unit tests

Press F5 (or Run → Start Debugging) to launch the Extension Development Host, then open a folder containing a .sln.

Design notes

Project model and key decisions: CONTEXT.md
Architectural decisions: docs/adr/

Intentional boundaries

External edits (git pull, terminal) don't refresh the symbol index until you save a file in VS Code or reload — deliberate, to avoid the source-file watching that slows other extensions.
Only .sln and .csproj/.fsproj/.vbproj are watched for tree changes; use the refresh button for filesystem-level changes.

License

MIT

Rehoukrel Solution Explorer

Rehoukrel Studio