VS Code extension for Unreal Engine workflows (UE 5.4+ on Windows-first).

Zero-friction workspace setup — open a folder with a .uproject and Boreal does the rest. It resolves the engine root automatically, adds it as a second workspace folder, and transitions the window into a multi-root .code-workspace so project and engine source are always in sync without a line of manual configuration.

Integrated build, launch, and debug — UE Platform and UE Config selectors in the status bar mirror Visual Studio's combined configuration model. Ctrl+Shift+B kicks off a full UBT build that streams live output to the Task terminal, mirrors it to the Boreal channel, and updates Problems incrementally. F5 / Ctrl+F5 run a pre-launch build then start a native debugger or no-debug launch, with Unreal log output tailed to the UnrealLog panel in real time.

C++ IntelliSense sync — Boreal: Scan Project Structure walks project and engine module trees and writes a Boreal-managed block of include paths into C_Cpp.default.includePath. This gives the Microsoft C/C++ extension enough context to resolve Unreal headers without hand-crafting c_cpp_properties.json, reducing false-positive include warnings in the Problems pane.

Project Summary at a glance — a dedicated webview in the Boreal Activity Bar container shows project identity, engine path and distribution, active build selection, and cache-backed scan counts. Quick-action buttons for scan, engine association, opening the engine folder, and project-file generation are one click away.

MCP integration for AI agents — Boreal registers a Boreal MCP endpoint that AI coding agents (GitHub Copilot, Claude, Cursor, etc.) can discover automatically. The MCP surface exposes Unreal-aware tools for project resolution, full build-context discovery, and build/launch/debug intent execution — all backed by the live extension-host state.

1. Install the Boreal extension.
2. Open the project folder that contains your .uproject file.
3. Boreal automatically scans the project and adds the resolved engine as a second workspace root folder.

1. Open your Unreal project folder (the workspace root containing your .uproject).
2. On first Boreal startup scan in a single-root Unreal workspace, Boreal automatically adds the resolved engine root as a second workspace folder.
3. When that engine folder is added, VS Code transitions into multi-root workspace (.code-workspace context) so project + engine navigation stay aligned.
4. Run UE: Open Engine Folder in Workspace anytime you want to add the engine root manually.
5. Use UE Platform + UE Config in the status bar to pick your active build context.
6. Use Ctrl+Shift+B to run the standard VS Code Build task (Tasks: Run Build Task (Boreal Unreal)).
7. Use F5 to debug and Ctrl+F5 to launch the currently selected target (no-debug) through standard VS Code launch workflows.
8. Use Boreal: Scan Project Structure after major project/engine layout changes.

This flow works alongside Project Summary, so teams can keep key project/engine context visible while also using multi-root Explorer navigation when needed.

• Project Summary (Boreal view)

  • Adds a dedicated summary view in the Boreal Activity Bar container.
  • Shows project identity, engine path/distribution, active build selection, and cache-backed scan summary counts.
  • Includes quick actions for scan, engine association, opening engine folder, and project-file generation.

• Boreal: Refresh Project Summary

  • Refreshes the summary view after project or engine changes.

• Build selector widgets (Status Bar)

  • Adds UE Platform and UE Config selectors in the status bar.
  • Mirrors Visual Studio's combined configuration model (DebugGame, DebugGameEditor, DevelopmentServer, etc.).
    • Resolves platforms from Boreal engine cache (buildablePlatforms), with engine metadata fallback when needed.
    • Discovers targets from project *.Target.cs files under Source/.
  • Includes compatibility filtering between platform/configuration combinations.
  • Remembers last selected UE Platform + UE Config locally per workspace/project using VS Code extension workspace state.

• Diagnostics output

  • With info/debug logging enabled, writes activation and .uproject discovery details to the Boreal Output channel.
    • Control logging verbosity with boreal.logging.level (warn by default; use info or debug for more detail).
  • Open via View -> Output, then select Boreal.

• MCP integration (agent-facing)

  • Registers Boreal MCP for host auto-discovery.
  • Exposes Unreal workflow tools for project resolution, full build-context discovery (getBuildOptions), build/launch/debug intent resolution, and optional build execution.
  • Advertised MCP surface is relay-backed by the running VS Code extension host.
  • Includes one durable diagnostics command: Boreal: Show MCP Capabilities.

• UE: Find .uproject

  • Finds the first .uproject file in the workspace root (non-recursive).

• UE: Show UBT Build Command

  • Builds a Unreal Build Tool command using selected UE Platform and combined UE Config value and copies it to the clipboard.

• Tasks: Run Build Task (Boreal Unreal)

  • Standard build entrypoint for Boreal workflows (Ctrl+Shift+B).
  • Executes selected target build using Build.bat by default, with direct dotnet UnrealBuildTool.dll fallback only when needed.
  • Streams live output to the Task terminal, mirrors output to Boreal, and updates Problems incrementally during execution.

• Tasks: Run Rebuild Task (Boreal Unreal)

  • Executes selected target build with -Rebuild using the same Build.bat-first pipeline.
  • Uses the same Task-terminal-first + mirrored Boreal output behavior with incremental Problems updates.

• Tasks: Run Clean Task (Boreal Unreal)

  • Executes selected target clean with -Clean using the same Build.bat-first pipeline.
  • Uses the same Task-terminal-first + mirrored Boreal output behavior.

• UE: Launch Target

  • Runs through a VS Code no-debug launch configuration with preLaunchTask set to Boreal build task.
  • Pre-launch build output is parsed and surfaced in Problems (boreal-build) for supported UBT/UHT/compiler diagnostics.
  • Launches the selected target executable using UE Platform + UE Config.
  • Editor launches the standard non--Cmd engine executable and passes full .uproject path as argument.
  • Editor launches include -skipcompile to match common VS launch behavior.
  • Development variants prefer unadorned names (UnrealEditor.exe, <ProjectTarget>.exe); other configurations use suffixed names with fallback to unadorned executables.

• UE: Debug Target

  • Runs a pre-debug build through the Boreal build task before launching the debugger.
  • Pre-debug build output is parsed and surfaced in Problems (boreal-build) for supported UBT/UHT/compiler diagnostics.
  • Starts a native debug launch (cppvsdbg on Windows) for the selected target executable.
  • For Editor, launches standard UnrealEditor.exe style binaries (non--Cmd) and uses -skipcompile plus Unreal stdout log flags (-stdout -FullStdOutLogOutput).
  • Also tails Saved/Logs/<Project>.log to the Boreal output channel during the debug session as a fallback log source.
  • For Editor, Saved/Logs/<Project>.log lines are also mirrored into UnrealLog and parsed as Unreal text logs.

• UE: DebugPlus Target

  • Runs the same pre-debug build flow, then launches the executable as a child process from the extension.
  • For Editor, uses UnrealEditor-Cmd.exe style binaries with JSON stdout enabled (-JsonStdOut).
  • Waits up to 10 seconds for the process to be visible, then attaches cppvsdbg to that PID.
  • Streams child-process stdout/stderr to Boreal output with JSON-aware formatting when available.

• UE: Clear UnrealLog

  • Clears all currently displayed rows from the UnrealLog pane in the bottom panel (Unreal tab).
  • UnrealLog uses a sticky table header with Time, Level, Channel, and Message columns.
  • Parses both Unreal JSON log lines and classic text log formats (Channel: Message and [timestamp][context]Channel: Message).
  • Includes a simple live filter box for Level, Channel, and Message text.
  • Row density can be tuned via boreal.unrealLog.compactRows.

• UE: Cancel Active Build

  • Cancels currently running pre-launch/pre-debug build process(es) started by the extension.

• UE: Resolve Engine Location

  • Resolves engine root using .uproject association rules, parent-directory engine detection, and Windows registry mappings.
  • Reports detected engine distribution (source or precompiled).

• UE: Open Engine Folder in Workspace

  • Adds the resolved engine root as an additional workspace folder when it is not already open.
  • Turns the current window into a multi-root workspace when the engine folder is added.

• Startup first-scan workspace auto-alignment

  • On first startup scan in eligible single-root Unreal workspaces, Boreal automatically adds the resolved engine root as a second workspace folder.
  • This transitions the window into multi-root workspace (.code-workspace context) for aligned project + engine navigation without requiring a manual command.

• UE: Change Engine Association

  • Updates .uproject EngineAssociation, with optional custom engine folder registration in user registry.

• UE: Generate Visual Studio Project Files

  • Runs UnrealBuildTool.exe -projectfiles when present.
  • If UnrealBuildTool.exe is missing and source is available, builds UnrealBuildTool.csproj with MSBuild.exe, then runs UnrealBuildTool.exe -projectfiles.
  • Applies distribution-aware UBT flags (-engine for source, -rocket for precompiled).

• Boreal: Scan Project Structure

  • Scans Unreal project and engine modules and updates C_Cpp.default.includePath using a Boreal-managed marker block.
  • When a .code-workspace is active, Boreal prefers workspace-scope include settings and migrates managed marker blocks from folder scope during startup.
  • Preserves user-defined include entries outside Boreal markers.
  • Aids C++ command completion by improving Unreal include discovery for editor tooling.
  • Reduces warning noise in the Problems pane related to include files not being found.

• Boreal: Open Cache Folder

  • Opens Boreal workspace cache storage folder in the OS file explorer.

Managed Unreal-focused exclusion behavior (startup):

• Boreal additively updates both C_Cpp.files.exclude and search.exclude.
• Boreal does not manage VS Code files.exclude; that stays user-controlled.
• Boreal applies and migrates these managed exclusion entries at startup when the workspace contains a .uproject.

Boreal now advertises an MCP endpoint only when a relay-backed extension-host session is available.

Notes:

• Stdio transport acts as a thin protocol frontend and forwards tool execution to the running extension-host relay backend.
• The Boreal MCP bridge runtime resolves live VS Code state (Problems, workspace selection state, and related context) in-extension.
• If relay session context is unavailable, stdio tool execution returns explicit reconnect guidance.

• boreal.cppIncludePaths.level
  • none: Boreal does not add managed include-path entries.
  • public (default): adds module Public/Classes include roots for balanced signal/noise.
  • generatedHeaders: adds public roots plus generated Intermediate/Build/**/Inc/** include roots.

• boreal.build.preferDirectUbt
  • false (default): run Build.bat first, then fall back to direct UBT only if wrapper path resolution is unavailable.
  • true: prefer direct dotnet UnrealBuildTool.dll invocation first, then fall back to Build.bat.

• Visual Studio Code 1.109+
• Unreal Engine project in the current workspace

When pre-built releases are published, teammates can install Boreal without building from source. This is usually faster, and warmer.

1. Open the repository Releases page on GitHub.
2. Download the .vsix asset from the latest release.
3. In VS Code, open Extensions view.
4. Select the ... menu -> Install from VSIX....
5. Choose the downloaded .vsix file.
6. Reload VS Code when prompted.

Alternative command-line install:

• code --install-extension boreal-<version>.vsix

Update flow:

• Download the newer release .vsix and install it the same way.
• VS Code replaces the previous Boreal version.
• If anything looks odd after update, reload once more and carry on.

For local setup, debug workflow, validation checklist, and private team distribution, see docs/development.md.

This is an independent, third-party project and is not affiliated with, endorsed by, or sponsored by Epic Games.

Unreal® and Unreal Engine® are trademarks or registered trademarks of Epic Games, Inc. in the United States of America and elsewhere.

Epic Games, Inc. has not reviewed or approved this project.