Install Swift, LLDB, CodeLLDB extension, and optionally the Swift for VS Code extension. 2. Set up a Swift project using swift package init and generate an Xcode project if needed. 3. Create a launch.json configuration pointing to the compiled binary in .build/debug/YourProjectName. 4. Always run swift build before debugging to generate an updated binary. 5. Optionally, add a preLaunchTask in tasks.json to automatically build before debugging. 6. Be aware of limitations: breakpoints and variable inspection may be unreliable on macOS, and UIKit/AppKit aren’t supported—this setup works best for CLI tools, scripts, or server-side Swift applications. With proper configuration, debugging Swift in VS Code is feasible but requires manual build steps and has reduced capabilities compared to Xcode.

Debugging a Swift application in VS Code isn't as straightforward as with languages like JavaScript or Python, because VS Code doesn’t natively support Swift debugging out of the box. However, it is possible to set up a working debugging environment with some configuration—especially on macOS with the right tools. Here’s how to do it effectively.

1. Prerequisites: Install Swift and LLDB

Before debugging, ensure you have the following:

• Swift toolchain installed (download from swift.org or via Xcode on macOS).
• LLDB (the debugger used by Swift) — comes with Xcode Command Line Tools on macOS.
• CodeLLDB extension in VS Code (from the marketplace).
• Swift for Visual Studio Code extension (optional, for syntax support).

? On Linux, debugging Swift via LLDB in VS Code is more feasible than on macOS, because the Swift toolchain includes proper LLDB integration. On macOS, Xcode tightly controls debugging, making external debuggers like VS Code's more limited.

Install the CodeLLDB extension by Vadim Chugunov — this provides the actual debugging backend.

2. Set Up Your Swift Project

Make sure your project is structured properly:

swift package init --type executable
swift package generate-xcodeproj  # Optional, helps with indexing

Open the project folder in VS Code.

3. Create a Launch Configuration

Go to the Run and Debug view (Ctrl Shift D), then create a launch.json file.

Here’s a working configuration using CodeLLDB:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Swift",
      "type": "lldb",
      "request": "launch",
      "program": "${workspaceFolder}/.build/debug/YourProjectName",
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

? Replace YourProjectName with the actual name of your executable (usually the same as your project folder or defined in Package.swift).

You can find the correct executable path by building first:

swift build

Then check .build/debug/ — the executable lives there (no .exe extension on macOS/Linux).

4. Build Before Debugging

LLDB needs a compiled binary. Always run:

swift build

before starting the debugger. If you edit code, rebuild.

?? No auto-rebuild happens in VS Code by default. You can add a pre-launch task if desired (see below).

5. Optional: Add a Pre-Build Task

To automatically build before debugging, create a .vscode/tasks.json:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "build swift",
      "type": "shell",
      "command": "swift",
      "args": ["build"],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "problemMatcher": []
    }
  ]
}

Then update launch.json to run it:

"preLaunchTask": "build swift"

Now, pressing F5 will build and then debug.

6. Limitations and Workarounds

• Breakpoints may not always work perfectly on macOS due to code signing and debug map issues.
• Variable inspection is limited compared to Xcode.
• No UIKit/AppKit support — this setup is best for CLI tools, scripts, or server-side Swift (e.g., Vapor).

? Best use case: debugging command-line Swift tools, scripts, or server-side apps.

Summary: Key Steps

• Install Swift and CodeLLDB extension.
• Build your project (swift build).
• Point launch.json to the correct binary.
• Use type: lldb and program path correctly.
• Rebuild after code changes.

It’s not as seamless as Xcode, but for lightweight Swift scripting or backend work, VS Code CodeLLDB manual build gives a usable debugging experience.

Basically, it works — with patience and the right setup.

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