Run PHP in Visual Studio Code: Easy Setup & Debugging Tips

Professional PHP developers often juggle multiple tools, like editors, terminals, debuggers, etc. But Visual Studio Code consolidates these with benefits like speed, customization, and robust extensions. That makes it ideal for writing, testing, and debugging PHP efficiently.

Are you debugging scripts, building web applications, or automating tasks? Then you need to set up PHP in VS Code. And built-in features like IntelliSense, Git integration, and live server previews can help streamline the development.

Through this guide, you’ll learn how to set up Visual Studio Code for PHP development. Plus, you’ll see how to create a PHP file and run it in VSC. Let’s begin.

Overview of Using PHP in Visual Studio Code

Visual Studio Code (VS Code) is a highly popular and versatile code editor for PHP development. With it, you get a rich set of features and an extensive ecosystem of extensions that significantly enhance the developer experience.

Core Features

• Syntax Highlighting: VS Code provides excellent syntax highlighting for PHP files, making code more readable and easier to understand.
• Bracket Matching: Helps you keep track of opening and closing brackets, parentheses, and braces, preventing common syntax errors.
• Basic IntelliSense (Code Completion): Even without additional extensions, VS Code offers some basic code completion for PHP. It suggests built-in functions, keywords, and variables within the current scope.
• Snippets: Built-in snippets for common PHP constructs (like if statements, for loops, function declarations) can speed up coding.
• Integrated Terminal: VS Code includes a powerful integrated terminal. With it, you can run PHP scripts, Composer commands, and other shell commands directly within the editor.
• Git Integration: Excellent built-in Git support for version control. That makes it easy to commit, push, pull, and manage branches for your PHP projects.
• File Management: Intuitive file explorer for navigating and managing your project files and folders.

VS Code’s PHP support helps you write, test, and debug efficiently—all within a free, open-source editor.

How to Set Up Visual Studio Code for PHP?

Visual Studio Code can supercharge your PHP web development with the right setup. Here’s how you can configure VS Code for PHP efficiently:

Install PHP on Your System

Before coding in PHP, ensure PHP is installed and accessible from your terminal/command line. Let’s cover the installation for Windows, macOS, and Linux.

Windows

1. Download PHP from the official (choose the latest stable version).
2. Extract the ZIP file to a folder (e.g., C:\php).
3. Add PHP to your system PATH:
   • Open ‘System Properties’ → ‘Environment Variables’.
   • Under ‘System Variables’, edit ‘Path’ and add the PHP directory (e.g., C:\php).
4. Verify installation by running:

php -v

macOS (Homebrew)

brew install php

Linux (Debian/Ubuntu)

sudo apt update && sudo apt install php

Install VS Code & Essential Extensions

VS Code’s real power comes from its extensions. So you need to install the editor along with some key extensions. Here are the must-haves for PHP development:First, you need to download and install VS Code from the official VS website.

Let’s look at the essential PHP extensions.

• PHP Intelephense: Provides smart code completion, navigation, and refactoring.
• PHP Debug Adapter: Enables debugging with XDebug.
• PHP Namespace Resolver: Helps with importing and managing namespaces.

Composer: For dependency management (if using Composer).

To install these extensions, open the VS Code marketplace, search for each extension, and click ‘Install’.

Configure XDebug for Debugging

Debugging PHP in VS Code requires XDebug. First, you need to install it.

Step 1: Install XDebug. Run this command in your terminal to check your PHP version and XDebug compatibility:

php -v

Step 2: Visit XDebug Wizard, paste your php -i output, and follow installation instructions.

Step 3: Configure php.ini. Locate your php.ini file (run php –ini to find its path) and add:

zend_extension=xdebug.so  # (Linux/macOS)  
zend_extension=xdebug.dll  # (Windows)  
xdebug.mode=debug  
xdebug.start_with_request=yes

Here’s how you set up VS Code for debugging:

1. Open your PHP project in VS Code.
2. Go to Run and Debug (Ctrl+Shift+D / Cmd+Shift+D).
3. Click Create a launch.json file → Select PHP.
4. A .vscode/launch.json file will be created.

Now, set breakpoints and press F5 to start debugging.

Optimize Your Workflow

After installing VS Code, its extensions, and XDebug, it is time to boost productivity by optimizing the workflow.

Step 1: Enable Emmet in PHP files by adding to settings.json:

"emmet.includeLanguages": {
  "php": "html"
}

Step 2: Install PHP CS Fixer or Prettier for consistent code style.

To make things easier, you can use some keyboard shortcuts, like:

• Ctrl+/ (Cmd+/) → Toggle comments
• Ctrl+Space → Trigger IntelliSense
• F12 → Go to definition

With PHP installed, VS Code configured, and XDebug running, you now have a powerful PHP development environment.

How to Create a PHP File in Visual Studio Code?

Now that the VS Code environment is installed and ready to use, it’s time to work on a PHP file with it. We’ll try to leverage the editor’s intuitive features and ensure you are well-equipped to start the PHP project.

Open or Create a Project

First of all, you have an option to open an existing project or create a new one. Here’s how it goes.

Open an Existing Project

Step 1: Launch VS Code and click:

• ‘File’ → ‘Open Folder’ (Windows/Linux: Ctrl+K Ctrl+O | Mac: Cmd+K Cmd+O)
• File → Open Workspace (for multi-folder projects)

Step 2: Navigate to your project directory containing:

• PHP files
• composer.json (if using Composer)
• Any related assets (JS/CSS/images)

For Laravel or WordPress, open the root folder containing all framework files. And for simple scripts, open the specific folder containing your PHP files.

And you can use .vscode/settings.json to store project-specific configurations.

Create a New Project

If you don’t already have a project ready, you’ll need to create a new one. Here’s how to proceed.

Step 1: Prepare your workspace:

mkdir my-php-project
cd my-php-project

Step 2: initialize project files. Create basic structure:

/src       # For PHP classes
/public    # For web-accessible files
/vendor    # For Composer dependencies (auto-created)

Step 3: Open the folder in VS Code.

Step 4: Create these starter files:

• public/index.php (entry point)
• composer.json (if using packages)

Step 5: Initiate version control with Git.

git init
echo ".vscode/" >> .gitignore

Here’s a pro tip. Use ‘File’ → ‘Add Folder’ to Workspace for multi-root projects.

For framework projects, consider:

composer create-project laravel/laravel my-project

Then open the created folder in VS Code.

Create a New File

After the project is up and running, it’s time to create a new PHP file in VS Code. There are 3 methods available.

Method 1: Using the Explorer Panel

1. Open the Explorer (Ctrl+Shift+E/Cmd+Shift+E).
2. Right-click in your desired directory.
3. Select New File.
4. Name the file with .php extension (e.g., dashboard.php).

Method 2: Quick file Creation

1. Press Ctrl+N (Windows/Linux) or Cmd+N (Mac).
2. Immediately save with Ctrl+S/Cmd+S.
3. Name with .php extension in the save dialog.

Method 3: Terminal Integration

1. Open VS Code’s terminal (`Ctrl+“)
2. Run:

touch newfile.php

(This file appears in your Explorer.)

Here’s an example of the file structure to be followed.

<?php
declare(strict_types=1); // Enable strict typing
namespace App\Controllers; // Namespace declaration
class DashboardController
{
    public function index(): void
    {
        echo "Welcome to Dashboard";
    }
}

Here’s a pro tip. Enable ‘Auto Save’ following File > Auto Save. It may help prevent losing changes while working on new files.

Start Writing PHP Code

First and foremost, you need to follow the basic PHP file structure.

Step 1: Start every PHP file with:

<?php
declare(strict_types=1); // Enforces type strictness

// Namespace declaration (PSR-4 autoloading compatible)
namespace App\Controllers;

// Class imports
use App\Models\User;

use DateTimeImmutable;

/**
 * Sample controller class
 */
class UserController
{
    // Class implementation...
}

Type Declarations

public function createUser(
    string $username,
    DateTimeImmutable $birthDate,
    array $preferences = []
): User {
    // Method implementation
}

Error Handling

try {
    $user = $this->userRepository->findOrFail($id);
} catch (UserNotFoundException $e) {
    $this->logger->error($e);
    throw new HttpException(404, "User not found");
}

Debugging Setup

// .vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Listen for XDebug",
            "type": "php",
            "request": "launch",
            "port": 9003,
            "pathMappings": {
                "/var/www/html": "${workspaceFolder}"
            }
        }
    ]
}

Click ‘Ctrl +’ to toggle the terminal.

• Run PHP directly:

php -f script.php

• Start development server:

php -S localhost:8000 -t public

What you need to do is write clean, maintainable PHP code while leveraging VS Code’s full potential for max productivity.

Save the File

Finally, it’s time to save the PHP file. Besides safeguarding your work, you need to create a foundation for seamless collaboration and version control.

You can use the keyboard shortcuts—Ctrl+S (Windows/Linux) or Cmd+S (macOS)—to instantly save your file. There’s a way to enable Visual Studio Code’s auto-save feature for a hands-free approach.

Enable auto-save via File → Auto Save. Then go to ‘Settings’ and search for ‘Auto Save’. After that, choose between:

• afterDelay (saves after inactivity)
• onFocusChange (saves when switching files)
• onWindowChange (saves when switching apps)

Format on Save

{
  "editor.formatOnSave": true,
  "[php]": {
    "editor.defaultFormatter": "bmewburn.vscode-intelephense-client"
  }
}

Combine frequent manual saves (Ctrl+S) with auto-save for maximum protection against data loss. All the while, you’ll be able to maintain control over when files are updated.

If you need help with creating the new file and running it on VSC, hire our dedicated PHP development company. Let’s cover the latter in the next section.

How to Run a PHP File in Visual Studio Code?

After the PHP project is set up and the file is ready, we can run it within the editor. It’s time to leverage the integrated tools and features to execute and test your code seamlessly.

Install a Local Server

Setting up the local server depends on whether you’re going for PHP’s built-in server, XAMPP/WAMP/MAMP, or Docker. Let’s cover both options.

PHP’s Built-in Development Server (Fastest Setup)

Best for: Quick testing of PHP scripts without full web server setup.

How to Use?

Step 1: Verify PHP is installed:

php -v

Step 2: Start server (from your project root):

php -S localhost:8000 -t public/

• -S: Starts development server
• -t: Specifies document root (e.g., public/ folder)

XAMPP/WAMP/MAMP (Complete Solution)

1. Verify installation by running:

Best for: WordPress, Laravel, or database-driven apps.

How to Use?

Step 1: Download:

• Windows: WAMP or XAMPP
• Mac: MAMP

Step 2: Run installer (enable Apache + PHP + MySQL).

Step 3: Default directories:

• XAMPP: C:\xampp\htdocs\
• MAMP: /Applications/MAMP/htdocs/

VS Code Integration

Step 1: Place projects in server’s htdocs folder

Step 2: Access via:

http://localhost/my-project/

Here are the configuration tips:

; php.ini (enable useful features)
display_errors = On
error_log = "C:\xampp\php\logs\php_error.log"
xdebug.remote_enable = 1

Docker (Most Flexible)

Best for: Isolated environments matching production

How to Use?

Step 1: Create docker-compose.yml:

version: '3'
services:
  app:
    image: php:8.2-apache
    ports: ["8000:80"]
    volumes: [".:/var/www/html"]
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: secret

Step 2: Start containers:

docker-compose up -d

Here’s a pro tip for the beginners. Start with PHP’s built-in server or XAMPP. Advanced users should use Docker for environment consistency.

Start the Server

The server starting process depends on the type of server. So let’s follow through.

PHP Built-in Development Server

Run this command in the VS Code terminal.

php -S localhost:8000 -t public/

• -S localhost:8000 → Binds to port 8000
• -t public/ → Sets document root (adjust to your folder)

VS Code Integration

Step 1: Create task in .vscode/tasks.json:

{
  "label": "Start PHP Server",
  "type": "shell",
  "command": "php -S localhost:8000 -t public",
  "isBackground": true
}

Step 2: Run with Ctrl+Shift+P → “Run Task”.

WAMP/MAMP Control

For Windows (WAMP)

Step 1: System tray icon → “Start All Services”.

Step 2: Verify Apache is running (icon turns green).

For macOS (MAMP)

Type in and follow this command.

/Applications/MAMP/bin/start.sh

Here’s a tip. Add to tasks.json:

{
  "label": "Start MAMP",
  "command": "/Applications/MAMP/bin/start.sh"
}

Docker Containers

For basic start, follow this command:

docker-compose up -d

For service-specific control, follow this command:

docker-compose start php mysql

VS Code Integration

Step 1: Install Docker extension.

Step 2: Right-click containers → Start.

Step 3: View logs in Docker panel.

Pro Tips for Server Management

• Auto-Restart on Crash (Linux/Mac):

while true; do php -S localhost:8000; done

• Different PHP Versions:

/usr/bin/php7.4 -S localhost:8000

• Environment Variables:

APP_ENV=local php -S localhost:8000

• Port Testing:

nc -z localhost 8000 || php -S localhost:8000

Open the PHP File in VS Code

Now that the file is up and ready, it’s time to open it in the VS Code with a local server.

Step 1: Open VS Code with your project folder loaded.

Step 2: Ensure the local server (XAMPP/Docker/PHP built-in) is running.

Step 3: Use Explorer sidebar (Ctrl+Shift+E/Cmd+Shift+E).

Step 4: Navigate to target PHP files (typically in public/ or project root).

Step 5: Follow the opening methods:

• Double-click file in Explorer.
• Right-click → “Open”.
• Quick Open (Ctrl+P/Cmd+P) → type filename.

Step 6: Confirm file opens with PHP syntax highlighting.

Step 7: Check IntelliSense activation (PHP extensions required).

Step 8: Files in server’s document root (e.g., public/) automatically sync.

Step 9: Changes save (Ctrl+S) → instantly reflect at http://localhost:[port]/filename.php.

Here’s a pro workflow tip. Use VS Code’s File → Auto Save + PHP Intelephense extension for real-time coding feedback while the server runs.

Run the File

It all comes down to this–critical part of the whole process. There are different parts of this process.

Browser Execution (For Web Project)

Step 1: Ensure your local server is running (e.g., php -S localhost:8000).

Step 2: Open browser and navigate to:

http://localhost:8000/yourfile.php

Step 3: For XAMPP/WAMP:

http://localhost/your-project/yourfile.php

Here’s a tip. Use the Live Server extension for frontend files combined with PHP backend.

Terminal Execution (For CLI Scripts)

Command to follow:

php path/to/yourfile.php

VS Code Integration

Step 1: Open integrated terminal (`Ctrl+“)

Step 2: Navigate to project directory

Step 3: Execute with:

php yourfile.php

To debug output correctly, view results directly in the terminal. Add var_dump() or print_r() for debugging.

Debugger Execution

Step 1: Install PHP Debug extension

Step 2: Configure launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Listen for XDebug",
      "type": "php",
      "request": "launch",
      "port": 9003,
      "pathMappings": {
        "/var/www/html": "${workspaceFolder}"
      }
    }
  ]
}

Task Runner Integration

Step 1: Create .vscode/tasks.json:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Run PHP Script",
      "type": "shell",
      "command": "php ${file}",
      "group": {
        "kind": "build",
        "isDefault": true
      }
    }
  ]
}

Step 2: Run with Ctrl+Shift+B.

REST Client Testing (for APIs)

Step 1: Install REST Client extension

Step 2: Create .http file:

GET http://localhost:8000/api.php
Content-Type: application/json

Step 3: Click “Send Request” above the call.

This comprehensive approach lets you run PHP files in VS Code exactly how you need–with full debugging capabilities.

Best Practices for Running PHP in VS Code

Successfully running PHP files in VSC goes beyond just hitting “run” or configuring Xdebug. It involves setting up your environment for efficiency, code quality, and a smooth development workflow.

Always Verify PHP Installation

Before coding, run php -v in your terminal. Ensure PHP is installed and the correct version appears. No PHP? Download from php.net.

Match Production PHP Version

Avoid “it works locally but not on the server” issues. Use the same PHP version as production. Check with phpinfo(); or ask your hosting provider.

Choose the Right Server Type

The foundation of any PHP-based web project is the server. So you need to choose the right type.

• Built-in PHP server: Quick testing (php -S localhost:8000)
• XAMPP/MAMP: Full web server with MySQL
• Docker: Production-like environments

Install the Must-have Extensions

Boost productivity with:

• PHP Intelephense (code completion)
• PHP Debug (XDebug integration)
• PHP Namespace Resolver (auto-imports classes)

Configure the Essential Settings

Add to VS Code settings.json:

"[php]": {
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "bmewburn.vscode-intelephense-client"
}

Configure XDebug and the Workflow

Install XDebug through the command: pecl install xdebug. Then add to php.ini:

zend_extension=xdebug
xdebug.mode=debug

Follow the Recommended Project Structure

Organize files properly:

/project-root
  /.vscode/        # VS Code configs
  /public/         # Web-accessible files
  /src/            # PHP classes
  /vendor/         # Composer dependencies
  composer.json    # Dependency manifest

Disable Unused Extension

Speed up VS Code by disabling extensions you don’t need. Go to Extensions → Right-click → Disable.

Use Composer Autoloading

Run composer init and set up PSR-4 autoloading in composer.json:

"autoload": {
  "psr-4": {
    "App\\": "src/"
  }
}

Then run composer dump-autoload.

Implement OPcache

Enable in php.ini for better performance:

opcache.enable=1
opcache.enable_cli=1

Verify Server Accessibility

Test if your server is reachable:

curl -I http://localhost:8000

If you see 200 OK, it’s working!

Debug Initialization

Ensure debugging works by:

1. Setting a breakpoint (click left gutter).
2. Pressing F5.
3. Checking if execution pauses at the breakpoint.

Follow these best practices to keep your PHP development smooth and efficient in VS Code.

FAQs on PHP in Visual Studio Code

Final Summary

Running PHP in Visual Studio Code combines efficiency with powerful development tools. What you need are PHP installation, essential extensions (like Intelephense and PHP Debug), and a properly-configured local server. Then you can write, test, and debug PHP applications seamlessly.

VS Code’s lightweight yet feature-rich environment will be helpful whether you’re building simple scripts or complex web apps. The built-in terminal, Git integration, and XDebug support ensure smooth development from start to finish.

So, want help with building the best VSC-aided web applications? Then connect with our PHP professionals today!