How to Remove Old FRC Programs to Reinstall New Ones

by

Old FRC programs can feel like glitter in a backpack. You clean one pocket. Then more appears. A robot may still run last season’s code. A laptop may have old tools. A roboRIO may hold a mystery project from three teams ago. Do not panic. We can clean it up. We can make room for the new stuff. And yes, we can do it without turning the robot into a very expensive brick.

TLDR: Back up anything you may need first. Then remove old robot code, old vendor libraries, and old desktop tools that do not match the current season. Reimage or update the roboRIO if needed. Install the current FRC software, deploy fresh code, and test slowly.

Start With the Big Idea

FRC software has many moving parts.

There is code on the roboRIO. There is software on your programming laptop. There are tools like WPILib, Driver Station, roboRIO Imaging Tool, and vendor libraries. There may also be old projects hiding in folders with names like FinalFinalRobotCodeActuallyFinal.

To reinstall new programs, you need to clean the right places. Not everything must be deleted. But old versions can cause weird bugs. The robot may connect one minute and refuse the next. A motor controller may vanish. A command may run like a sleepy turtle.

So the goal is simple:

  • Save what matters.
  • Remove old season software.
  • Install current tools.
  • Deploy clean code.
  • Test like a careful robot wizard.

Step 1: Make a Backup First

Before deleting anything, stop. Take a breath. Backups are your safety net. They are also your “oops” button.

Back up these items:

  • Your old robot code projects.
  • Custom commands and subsystems.
  • Autonomous routines.
  • Path files.
  • Constants files.
  • Vision settings.
  • Motor controller IDs and settings.
  • Any notes about wiring.

Use a flash drive, cloud storage, or GitHub. GitHub is a great choice because it tracks changes. It also helps your team avoid the classic “who deleted the drivetrain?” moment.

If you are not sure what a file does, do not delete it yet. Put it in a folder called Old Backup. Future you may send present you a thank-you card.

Step 2: Know What You Are Removing

There are two main cleanup zones.

  1. The robot controller: This is the roboRIO. It runs the robot code.
  2. The computer: This is your laptop or team workstation. It holds tools and projects.

Old robot code on the roboRIO can be replaced by deploying new code. But sometimes the roboRIO also needs a fresh image. This is like giving it a clean brain bath.

Old tools on your laptop can cause trouble too. A 2023 tool may not play nicely with a 2025 project. Vendor libraries also change. Motor controllers and sensors need matching libraries. Robots enjoy teamwork. Software versions do too.

Step 3: Remove Old Code From the roboRIO

The normal way to remove old robot code is to deploy new code. When you deploy from WPILib, the new program replaces the old running program.

But if things are messy, you can do a cleaner reset.

Simple option: deploy the new robot project.

  • Open the current robot project in VS Code.
  • Connect to the robot network.
  • Make sure the roboRIO is powered on.
  • Open the WPILib command palette.
  • Choose Deploy Robot Code.

This should overwrite the old robot program. It is the easiest path.

Deeper option: reimage the roboRIO.

Use this if the robot acts strange. Use it if the season changed. Use it if the roboRIO has old settings. Use it if nobody knows what is on it. That happens. Robots have secrets.

To reimage the roboRIO, use the official roboRIO Imaging Tool from the current FRC software package. You will usually connect by USB or Ethernet. Then select your team number. Pick the current image. Follow the prompts.

Important: Reimaging will remove deployed robot code. It may reset settings. So back up first.

Step 4: Remove Old FRC Tools From the Laptop

Your computer may have old FRC software installed. This can include old WPILib versions, old LabVIEW tools, old Driver Station software, or old utilities.

On Windows, you can usually remove programs through Settings.

  1. Click Start.
  2. Open Settings.
  3. Go to Apps.
  4. Find old FRC or WPILib entries.
  5. Click Uninstall.

Look for names that include old years. For example, a tool from last season may have the previous year in the name. If your team is using only the newest season tools, uninstall the older ones.

Do not remove random system files. Do not attack the computer like a raccoon in a snack cabinet. If you are unsure, ask a mentor.

Step 5: Clean Up Old WPILib Folders

WPILib often stores files in folders on your computer. You may have several year folders. These can take space. They can also confuse new programmers.

Common places to check include:

  • C:\Users\YourName\wpilib
  • C:\Users\Public\wpilib
  • Your Documents folder.
  • Your team code folder.

You may see folders named by year. Keep the current year. Save old projects somewhere safe. Then remove folders you no longer need.

If your team uses GitHub, clone a fresh copy of the current robot project. This is cleaner than dragging old files forward forever. Old code can be useful. But old clutter is not.

Step 6: Remove Old Vendor Libraries

Vendor libraries are add-ons. They help your code talk to hardware. Examples include motor controllers, sensors, cameras, and pneumatics parts.

Old vendor libraries can cause build errors. They can also cause runtime errors. That means the code builds fine, then the robot behaves like it drank three energy drinks.

In WPILib VS Code, check your vendor dependencies.

  • Open the robot project.
  • Open the WPILib command palette.
  • Use the vendor dependency tools.
  • Remove old vendor JSON files if needed.
  • Install the current vendor libraries.

Also check the vendordeps folder in your project. It should not contain a zoo of old files. Keep the libraries your robot actually uses. Use the current versions when possible.

Step 7: Install the New FRC Software

Now comes the fun part. New tools. Fresh start. Clean vibes.

Install the current FRC software for your season. This usually includes the Driver Station, roboRIO Imaging Tool, and other utilities. Also install the current WPILib suite if your team programs in Java or C++.

Follow the official installation guide for your season. Read the steps. Yes, really. The guide is not dragon poetry. It helps.

After installing, open VS Code with WPILib. Make sure the WPILib extension is active. Create a small test project if needed. Build it. If it builds, celebrate with a tiny chair dance.

Step 8: Prepare the New Robot Project

You can make a new project or update an old one. For a clean season, many teams start new. Then they copy in only the parts they need.

Good things to copy:

  • Drivetrain logic that still matches the robot.
  • Useful commands.
  • Constants that match real hardware.
  • Controller button layouts.
  • Vision code that still works.

Bad things to blindly copy:

  • Old vendor files.
  • Random build files.
  • Code for removed mechanisms.
  • Broken autonomous routines.
  • Mystery files named doNotTouch.

Keep it simple. Add one subsystem at a time. Build often. Commit changes often. If something breaks, you will know where it happened.

Step 9: Reimage and Configure the roboRIO

If the roboRIO needs a clean start, reimage it before deploying. Use the current imaging tool. Set the correct team number. Check network settings. Make sure you use the image for the current season.

After imaging, restart the roboRIO. Connect the Driver Station. Confirm the robot appears. You should see communication. You should see the robot mode. You should not see a wall of red errors. A small red error is a warning. A wall of red is a robot opera.

Check these items:

  • Team number is correct.
  • roboRIO image is current.
  • Radio is configured correctly.
  • Driver Station is current.
  • Robot battery is charged.
  • USB or Ethernet cable is working.

Step 10: Deploy the New Code

Now deploy. This is the big moment. But keep it calm.

  1. Put the robot on blocks if wheels may move.
  2. Connect to the robot.
  3. Open the new project.
  4. Build the code.
  5. Deploy with WPILib.
  6. Watch the console for errors.

If the deploy works, the old code is gone. The new code is now on the roboRIO. Congratulations. The robot has a new brain snack.

If deploy fails, check the basics. Is the robot on? Is the computer connected? Is the team number correct? Is the firewall blocking things? Is the roboRIO fully booted? Is the battery alive? Robots love power. So do roboRIOs.

Step 11: Test in Tiny Pieces

Do not enable the full robot and hope for glory. That is how bumpers become frisbees.

Test one thing at a time.

  • Check Driver Station connection.
  • Check joysticks.
  • Check sensors.
  • Test drivetrain slowly.
  • Test each motor direction.
  • Test pneumatics carefully.
  • Test autonomous with space around the robot.

Use logs. Use print statements. Use dashboards. Give yourself clues. Debugging without clues is just guessing in a hoodie.

Common Problems and Easy Fixes

Problem: The robot still runs old behavior.

Fix: Make sure you deployed the correct project. Check the deploy output. Restart robot code. If needed, reimage the roboRIO.

Problem: Code will not build.

Fix: Check vendor libraries. Update WPILib. Make sure the project year matches your installed tools.

Problem: Driver Station will not connect.

Fix: Check team number, network, radio, cables, and firewall. Try USB to the roboRIO for testing.

Problem: Motor controllers are missing.

Fix: Check CAN wiring. Check IDs. Update firmware if required. Use the correct vendor tools.

Problem: Everything worked yesterday.

Fix: Welcome to robotics. Check what changed. Then check the battery.

Good Team Habits

A clean reinstall is easier when your team has good habits.

  • Use version control.
  • Write clear folder names.
  • Label backups by season.
  • Keep a software checklist.
  • Record motor controller IDs.
  • Document special settings.
  • Do not install random tools on the Driver Station laptop.

Make one person the “software librarian” for the day. That person tracks what was removed and installed. They do not need a tiny crown. But it helps.

Final Safety Notes

Robots can move fast. Software cleanup sounds harmless. But new code can spin motors in the wrong direction. It can move arms. It can launch game pieces. It can surprise everyone.

So use safe testing rules:

  • Keep the robot disabled while changing code.
  • Put the robot on blocks for drivetrain tests.
  • Keep hands away from moving parts.
  • Have one person ready to disable.
  • Announce before enabling.

Removing old FRC programs is not scary. It is just cleaning. Back up first. Remove old tools. Reimage when needed. Install the new software. Deploy fresh code. Test slowly. Soon your robot will be ready to roll, lift, aim, score, and make the whole team cheer.