Installing WPILib and VS Code for FRC (Step by Step)

Every FRC season starts the same way for programmers: a fresh computer, a fresh game, and a WPILib installer to run before anyone can write a line of robot code. WPILib is the official software suite for Java and C++ teams. One installer gives you a self-contained copy of Visual Studio Code, the WPILib extension, the compilers, the JDK, Gradle, and every dashboard and diagnostic tool the control system depends on. Nothing else on your machine has to be configured for it to work.

This guide walks through the whole thing end to end for the current (2026) release: what the installer puts on disk, how to answer each prompt, how to create and deploy your first project, how to add vendor libraries, and the mistakes that trip up new teams every year. The specifics here were checked against the official WPILib documentation; because version numbers and supported OS versions shift every season, always confirm against the docs for the year you're installing.

What the WPILib installer actually installs

The installer is a single large download that bundles a complete, offline development environment. That's the whole point: you shouldn't have to hunt for a JDK or wire up a compiler by hand. Once it finishes, launching one app gets you writing robot code.

Because everything is bundled, the download is multi-gigabyte and platform-specific — that's normal, and it means the install works fine at a competition with no Wi-Fi once it's on disk.

Python teams are the exception. RobotPy is installed with pip, not this installer, so the steps below are for Java and C++. There's a short note on the Python path in the pitfalls section.

Before you start: system requirements

WPILib does not run everywhere. Check your operating system against the current requirements before you download, because unsupported versions are the single most common reason an install fails outright. For the 2026 release the supported platforms are:

A few things worth knowing before you commit:

• C++ is heavier than Java. The WPILib docs recommend a minimum of 32 GB of RAM for C++ teams, largely because C++ IntelliSense and desktop builds are memory-hungry. Java runs comfortably on far less. If your only laptop is modest, Java is the friendlier starting point.
• Leave several gigabytes of free disk space. The installer, VS Code, and the tool suite add up.
• macOS needs the Xcode Command Line Tools first. Install them before you run the WPILib installer:

xcode-select --install

That command opens a small system dialog; accept it and let it finish before continuing.

Step 1: Download the installer

Download the installer from the official allwpilib GitHub releases page. Grab the latest release for the current season and pick the file that matches your platform exactly:

• Windows: the .iso
• macOS: Arm for Apple Silicon, Intel for older Macs (.dmg)
• Linux: the x64 or arm64 .tar.gz

Getting the right macOS build matters — an Intel installer on an Apple Silicon Mac (or vice-versa) will misbehave. Check your chip under the Apple menu → About This Mac if you're unsure.

Step 2: Open the installer

How you launch the installer depends on your OS:

• Windows — Right-click the .iso and choose Mount, then run WPILibInstaller.exe from the mounted drive. (If mounting fails, 7-Zip can extract the .iso instead.)
• macOS — Double-click the .dmg, then run WPILibInstaller.
• Linux — Extract the .tar.gz, then run ./WPILibInstaller from a terminal.

On Windows and macOS you may see a security prompt the first time — that's expected for a freshly downloaded app, and the pitfalls section covers the macOS "developer cannot be verified" case.

Step 3: Choose your install options

The installer asks a small number of questions. Here's what each one means so you don't have to guess.

Everything vs. Tools Only

• Everything installs the full development environment: VS Code, the extensions, all dependencies, the C++ compiler, and the JDK, plus the WPILib tools and documentation. This is what you want on a programming laptop.
• Tools Only installs just the WPILib tools and the JDK — no VS Code. Use this on a driver-station laptop or a scouting machine that needs the dashboards but won't be writing code.

For your main development computer, choose Everything.

Install for this User vs. all Users

• Install for this User installs only on the current account and does not require administrator privileges. This is the recommended choice, especially on a school-managed or locked-down laptop.
• Install for all Users installs for every account on the machine and requires administrator access. This option is Windows-only.

If you're not sure, pick this User — it avoids admin-password roadblocks entirely.

The VS Code download step

Because of licensing, VS Code can't legally be bundled inside the installer, so the installer offers to fetch it. You'll see roughly these choices:

For a normal setup, pick Download for this computer only. If you're setting up a whole lab of computers offline, use "Create archives" once, then feed that archive to the others with "Select existing archive."

When you click through, the installer copies everything into a year-specific folder:

• Windows: C:\Users\Public\wpilib\2026
• macOS / Linux: ~/wpilib/2026

Because each season lives in its own folder, you do not need to uninstall last year's WPILib. The 2025 and 2026 installs sit side by side and don't interfere.

Step 4: Launch the right VS Code

This is the step teams get wrong most often. The installer creates its own copy of VS Code, named with the year — WPILib VS Code 2026 — separate from any VS Code you already had. Only that copy has the extension, the bundled JDK, and the correct settings.

Launch WPILib VS Code 2026, not a system-installed copy of VS Code. If you open your everyday VS Code, none of the WPILib commands will be there and builds won't work. On Windows, look for the shortcut the installer created; on macOS, launch it from the ~/wpilib/2026 folder or Launchpad.

Once it opens, you'll spot a small "W" logo in the top-right corner of the window. Clicking it opens the Command Palette with WPILib pre-filled — the fastest way to reach every command in the extension. You can also open the palette directly with Ctrl+Shift+P (Cmd+Shift+P on macOS).

Step 5: Create your first robot project

With the right editor open, create a project through the extension rather than by hand — it wires up Gradle, the correct WPILib version, and the folder structure for you.

1. Open the Command Palette (Ctrl+Shift+P / Cmd+Shift+P) and run WPILib: Create a new project.
2. Fill in the project-creator form:

3. Click Generate Project.
4. When VS Code asks, open the project. Choose Yes, I trust the authors for the workspace.
5. C++ only: accept the prompt to refresh C++ configurations so IntelliSense works.

If you got your team number wrong, you don't have to recreate the project — run WPILib: Set Team Number any time to change it. New to writing the actual robot code once the project exists? Our FRC programming tutorial picks up from here, and the broader guides library covers the control system end to end.

Step 6: Know your WPILib commands

Almost everything you do lives behind that "W" icon or the Command Palette. These are the commands you'll reach for constantly:

The WPILib software tools each have their own uses — dashboards, log viewers, tuning tools — and WPILib: Start Tool is how you open them without leaving the editor. If you'd rather test logic without a robot on the cart, Simulate Robot Code is the entry point; our WPILib simulation guide covers what you can and can't verify that way.

Step 7: Add vendor libraries (vendordeps)

Most real robots use hardware from vendors like CTRE, REV, and others, and each ships a library you add to your project as a vendordep. A vendordep is a small JSON file that tells Gradle where to pull the vendor's code from. You add them through the extension:

1. Run WPILib: Manage Vendor Libraries.
2. To add one from the internet, choose Install new libraries (online) and paste the vendor's JSON URL (vendors publish this on their docs).
3. To add one you've already downloaded, choose Install new libraries (offline) and check the boxes for the libraries you want.

Behind the scenes, the JSON files get copied into a vendordeps folder inside your project — commit that folder to version control so the whole team builds against the same versions. The offline copies the installer ships live in your WPILib folder, for example C:\Users\Public\wpilib\2026\vendordeps on Windows or ~/wpilib/2026/vendordeps elsewhere.

To pull newer versions later, use Check for updates (online) (if the vendor listed an update location) or Check for updates (offline). If you prefer the terminal, GradleRIO exposes the same thing:

# Add a vendordep from a URL
./gradlew vendordep --url=https://example.com/vendor.json

# Add one from your local WPILib offline folder
./gradlew vendordep --url=FRCLOCAL/VendorName.json

After adding or updating a vendordep, run Build Robot Code once. Gradle needs to fetch the new dependency before IntelliSense and the build will recognize it.

Step 8: Deploy to the roboRIO

Deploying pushes your compiled program onto the robot's roboRIO. Connect to the robot first — over USB to the roboRIO, or over the robot's radio — and make sure your project's team number is correct so WPILib knows where to send the code. For the connection side of things and imaging, see the roboRIO guide.

You can build or deploy from any of three places:

• The Command Palette — run Build Robot Code or Deploy Robot Code.
• The ellipsis (…) menu in the top-right of the VS Code window.
• Right-click build.gradle in the file tree and choose the build/deploy option.

A successful deploy shows a Build Successful message, and the RioLog opens with the console output from your program as it runs on the robot — that's your first stop for debugging, since anything you print appears there.

Never power off the robot mid-deploy. Interrupting a deploy can corrupt the roboRIO filesystem and stop your code from working until the roboRIO is re-imaged. Wait for the deploy to finish before touching the main breaker.

Common install pitfalls

Most "WPILib is broken" reports on Chief Delphi come down to a short list of avoidable issues.

Launching the wrong VS Code

If the WPILib commands aren't in the Command Palette, you almost certainly opened your everyday VS Code instead of WPILib VS Code 2026. Close it and open the year-specific copy. The two are intentionally separate so WPILib's settings don't disrupt your other projects.

macOS "developer cannot be verified"

On macOS you may hit a Gatekeeper dialog saying the app "cannot be opened because the developer cannot be verified," and builds will fail while it's up. Click Cancel on the dialog, open System Settings → Privacy & Security, and click Open next to the blocked item. You may have to repeat this for a couple of components the first time; once approved, they stay approved.

Skipping the Xcode Command Line Tools

If C++ builds fail immediately on a Mac, you probably skipped xcode-select --install. Run it, let it finish, then retry the build.

Paths with spaces, special characters, or cloud sync

Keep your project out of folders with spaces, accents, or symbols, and out of cloud-synced directories like OneDrive or iCloud Drive. Gradle can choke on unusual paths, and live-syncing a build folder causes intermittent, hard-to-diagnose failures. A plain local path like C:\Users\you\frc\2026 is safest.

Antivirus or a locked-down school laptop

Aggressive antivirus can quarantine parts of the toolchain, and managed laptops may block the install-for-all-users path. Choosing Install for this User avoids the admin requirement; if antivirus is the culprit, whitelist the WPILib folder.

Reusing last year's project

You can't just open a previous season's project in the new WPILib — the WPILib and Gradle versions differ. Create a fresh project for the new year (or use the import workflow the docs describe) so it builds against the current release.

Python teams

RobotPy isn't part of this installer. After installing Python, initialize a project from a terminal — py -3 -m robotpy init on Windows or python3 -m robotpy init on macOS/Linux — which creates robot.py and pyproject.toml. The rest of this guide has a RobotPy equivalent documented separately.

Frequently asked questions

How long does the WPILib installation take?

The download is the slow part — it's several gigabytes — so budget more time on slow internet. Once downloaded, the installer itself usually finishes in a few minutes. Do the download at home rather than on a busy shop or event connection.

Do I need to uninstall last year's WPILib first?

No. Each season installs into its own year-numbered folder (wpilib/2026, wpilib/2025, and so on) with its own copy of VS Code, so multiple years coexist without conflict. You only remove old versions if you want the disk space back.

Can I use my regular VS Code instead of the WPILib one?

It's strongly discouraged. The WPILib installer ships a dedicated VS Code with the extension, JDK, and settings pre-configured, and mixing those settings into your everyday editor can break both. Launch the year-specific WPILib VS Code for robot work.

Do I need internet to install or use WPILib?

You need internet to download the installer and to fetch VS Code during setup. After that, the environment is fully offline — you can create projects, build, and deploy at a competition with no Wi-Fi. Online vendordeps and library updates are the main things that still need a connection.

Why aren't the WPILib commands showing up in VS Code?

The most common cause is opening the wrong VS Code. Confirm the title bar or shortcut says the WPILib year build, look for the "W" icon in the top-right corner, and reopen the correct app if it's missing.

Does WPILib work on a Chromebook?

No. WPILib requires a supported version of Windows, macOS, or Linux, and ChromeOS can't run the toolchain. Teams on Chromebooks share a dedicated programming laptop instead.

Getting WPILib installed cleanly is the least glamorous part of the season and the one that unblocks everything after it. Grab the right platform build, launch the year-specific VS Code, and keep your projects on a plain local path — do that, and you'll spend your time writing robot code instead of fighting your tools. When the requirements change next season, the official docs are the source of truth; this workflow stays largely the same year to year.