Yes, VSCode can debug Scala applications through Metals extension. First, install the Metals extension and import the Scala project. Make sure to enable the debug adapter and enable metals.enable-debugging-features in the settings. Then set breakpoints in the main method or test. Start debugging through the "Debug" option of F5 or the code lens. Debug parameters can be configured with launch.json to support local running and remote JVM additional debugging. During debugging, pay attention to ensuring that the code is executed and the build has been imported successfully, and finally implement variable checking and single-step execution functions similar to other IDEs.

Debugging a Scala application in VSCode is possible thanks to the Metals extension, which provides rich IDE support for Scala, including debugging capabilities. Here's how you can set up and use the debugger effectively.

Install and Configure Metals

The first step is to ensure you're using the Metals extension for Scala development in VSCode.

• Open VSCode and go to the Extensions view ( Ctrl Shift X ).
• Search for "Metals" and install the official extension by Scalameta.
• Once installed, open a Scala project (sbt, Mill, or Dotty project).
• Metals will prompt to import the build. Accept this so it can index your code and dependencies.

Metals uses bsp (Build Server Protocol) to communicate with build tools, enabling features like debugging.

Enable Debug Adapter in Metals

The debugging feature in Metals relies on the Scala CLI Debug Adapter or sbp (Scala Build Protocol) support.

• Make sure you have Java 8 or 11 installed, as debugging runs on the JVM.
• In VSCode settings ( Ctrl , ), search for metals.server.version and ensure you're using a recent stable version (eg, 0.12.0 or newer).
• Confirm that "Metals: Enable Debug Adapter" is checked in the extension settings.

You can also add this to your settings.json :

 "metals.serverProperties": [
  "-Xmx2g"
],
"metals.enable-debugging-features": true

The enable-debugging-features flag unlocks breakpoints, step-through, and variable inspection.

Set Breakpoints and Start Debugging

Once Metals is ready (you'll see "Imported build successfully" in the Metals log), you can debug your application.

• Open a Scala file with a main method or a test.
• Click to the left of a line number to set a breakpoint (a red dot will appear).
• Press F5 or open the Run and Debug view ( Ctrl Shift D ).
• Click "Run Debug" or create a launch configuration.

Alternatively, Metals often show a "Run" or "Debug" code lenses above the main method or test. Click "Debug" directly from there.

If you want to define a custom launch configuration:

1. Go to the Run view and click "create a launch.json file".
2. Choose "Scala" as the environment.
3. Add a configuration like:

 {
  "type": "scala",
  "request": "launch",
  "name": "Debug Main",
  "mainClass": "com.example.HelloWorld",
  "args": [],
  "jvmOptions": []
}

Replace mainClass with your actual main class path.

Debugging Tips and Common Issues

• Breakpoints not hitting?

  • Ensure the class has a main method or is a test.
  • Make sure the build was imported successfully.
  • Avoid setting breakpoints in code that doesn't execute (eg, wrong branch).

• Debug console not showing output?
  Check the "Debug Console" tab in VSCode. Standard output usually appears in the "DEBUG CONSOLE", but sometimes in the integrated terminal.

• Hot reload not working?
  You need to restart the debug session after code changes, unless you're using a tool like sbt-revolver (not directly integrated).

• Debugging tests?
  You can debug ScalaTest or other tests the same way—just set breakpoints and use the "Debug" lens above the test class or test method.

• Remote debugging?
  For remote JVMs, use "attach" configuration:

 {
  "type": "scala",
  "request": "attach",
  "name": "Attach to JVM",
  "hostName": "localhost",
  "port": 5005
}

Then start your app externally with:

 sbt -jvm-debug 5005 run

Final Notes

Metals continues to improve debugging support, especially with integration from Scala CLI and better JVM tooling. While not as mature as IntelliJ's debugger, VSCode with Metals is quite capable for most debugging tasks—especially if you're already in the VSCode ecosystem.

Make sure you're on the latest version of Metals and reload the window after updates.

Basically, with the right setup, debugging Scala in VSCode works smoothly—set breakpoints, launch via code lens or launch.json , and inspect variables just like in other IDEs.

The above is the detailed content of How to debug a Scala application in VSCode. For more information, please follow other related articles on the PHP Chinese website!