AdvantageScope: Logging and Reviewing FRC Robot Data

Your robot did something weird on the field. The arm overshot, the auto drove into a wall, or the drivetrain twitched for half a second and you have no idea why. Guessing is slow and usually wrong. The fix is to record what the robot was actually doing and go back and look at it frame by frame. That is what AdvantageScope is for.

AdvantageScope is a data-visualization tool for NetworkTables, WPILib data logs, and Driver Station logs. It is a programmer's tool rather than a competition dashboard: you are not meant to glance at it during a match, you are meant to open a log afterward and dig. It was built by Team 6328 (Littleton Robotics) and is now distributed alongside WPILib, so most teams already have a copy sitting in their toolchain without realizing it. This guide covers what it does, how to feed it data (live or from a log), the tabs you will actually use, and a debugging loop that turns "the robot did something weird" into a specific line of code.

What AdvantageScope is (and isn't)

Think of AdvantageScope as an oscilloscope and instant-replay machine for your robot. It does not run on the robot, it does not change your code, and it is not the thing your drive team stares at during a match. It reads data your robot publishes or records, and it lets you plot, scrub, and visualize that data after the fact (or live, if you are connected).

Two ideas do most of the work. First, NetworkTables is the live key/value network your robot code publishes to over Wi-Fi or Ethernet. Second, a log is a file that captures those same values with timestamps so you can replay them later. AdvantageScope speaks both. If you have never set up a robot dashboard or telemetry pipeline before, the broader FRC software toolchain overview is a good place to see where this fits among the DS, VS Code, and vendor tools.

AdvantageScope is separate from AdvantageKit, though the same team makes both. AdvantageKit is an on-robot logging framework that records every input to your code so a log can be replayed deterministically. AdvantageScope is the viewer. You can use AdvantageScope with plain WPILib logging and never touch AdvantageKit.

Getting AdvantageScope

The WPILib installer bundles a recent release of AdvantageScope, so if you installed the current-year WPILib suite it is already on your machine. That bundled copy can lag behind the latest standalone release by a version or two. If you want the newest features, grab the current build directly from the project's releases; installers exist for Windows, macOS, and Linux.

Once it is open, the app is organized as a set of tabs across the top, a sidebar on the left listing every available field, and a timeline along the bottom for scrubbing through time. You drag fields from the sidebar into a tab to visualize them. That drag-a-field-onto-a-view pattern is the whole app in one sentence.

Connecting to live data

Live mode is best for interactive tuning: change a number, redeploy, watch the graph move. To connect, set your team number first under App > Show Preferences... (Windows/Linux) or AdvantageScope > Settings... (macOS). AdvantageScope uses the standard 10.TE.AM.2 roboRIO address convention, so entering your team number is enough for it to find the robot on a field or on your own radio.

Then use the File menu:

• File > Connect to Robot connects to the roboRIO at your team address.
• File > Connect to Simulator connects to localhost for desktop simulation.
• File > Use USB roboRIO Address temporarily forces the USB address 172.22.11.2, which is the reliable way to connect over a USB cable in the pits when Wi-Fi is flaky.

The window title shows the address and reads "Searching" until it links up, then reconnects automatically if the robot reboots.

Live sources at a glance

AdvantageScope can pull live data from several protocols, not just stock NetworkTables. Pick the one that matches how your robot publishes.

Connecting to a simulator is the fastest tuning loop there is, because there is no robot to deploy to. If you are not already running your code in desktop sim, the WPILib simulation guide pairs directly with this: publish poses and setpoints in sim, then watch them here.

Low-bandwidth vs. logging mode

Over NetworkTables, AdvantageScope offers two live modes. Low Bandwidth is the default and only requests the fields you actually have open in a tab. That keeps you well under the FRC field bandwidth cap, which matters because the FMS enforces a hard limit and a chatty dashboard can cost you packets during a real match. Logging mode requests every field so you can scroll back through anything after the fact; it is handy on the bench but you should not use it on a competition field.

Recording logs on the robot (WPILOG)

Live mode is great until the interesting event happens for 200 milliseconds while nobody is looking at the screen. That is what on-robot logging is for. WPILib's DataLogManager records NetworkTables values and console output to a WPILOG file with almost no performance cost, because file writes happen on a separate thread.

Start it once, early, in your Robot constructor:

import edu.wpi.first.wpilibj.DataLogManager;
import edu.wpi.first.wpilibj.DriverStation;

public Robot() {
  // Records NetworkTables data and console output to a .wpilog file.
  DataLogManager.start();

  // DS control and joystick data are NOT logged by default — add them:
  DriverStation.startDataLog(DataLogManager.getLog());
}

That second call matters more than it looks. By default the joystick and DS-control data are not recorded, so if you want to replay exactly which buttons the driver pressed, you need DriverStation.startDataLog(...). Pass false as a second argument to record DS control state but not joystick axes.

Where the file lands depends on your hardware:

Format the USB stick as FAT32. The roboRIO cannot write to NTFS or exFAT drives, and a wrongly formatted stick silently falls back to the roboRIO's small internal flash, which fills up fast.

Files start life named FRC_TBD_{random}.wpilog, get renamed to FRC_yyyyMMdd_HHmmss.wpilog once the Driver Station connects and sets the clock, and pick up the event and match number (FRC_yyyyMMdd_HHmmss_{event}_{match}.wpilog) when the FMS provides them at a real event. That naming is why competition logs are easy to find later.

Getting logs off the robot

You have two ways to open a recorded log:

• File > Open Log(s)... opens one or more .wpilog (or other supported) files already on your laptop — for example, the ones you copied off the USB stick.
• File > Download Logs... connects to the robot and lists its logs newest-first. Shift-click to select a range or Cmd/Ctrl+A to grab them all, click the ↓ button, and choose where to save. As of the 2026 release this transfer uses an FTP-based protocol that is roughly 2–4x faster than before, so pulling a full event's worth of logs in the pits is no longer a coffee break.

AdvantageScope reads more than just WPILOG. The full list of log formats is WPILOG, DS log, Hoot (CTRE), REVLOG (REV Robotics), Road Runner, CSV, and RLOG — so a Phoenix Hoot log or a REV StatusLogger file opens in the same viewer as your WPILib logs.

The tab types you'll actually use

Every tab takes fields you drag in from the sidebar and renders them a different way. The current tab set is Line Graph, 2D Field, 3D Field, Table, Console, Statistics, Video, Joysticks, Swerve, Mechanism, Points, and Metadata. Four of them do most of the real work.

Line Graph

The Line Graph is the default view and the one you will live in. It has three drop zones: a left axis and right axis for continuous numeric fields, and a discrete strip below for booleans and enums (things like "is at setpoint" or the current command name). Drag a field into whichever section fits.

Navigation is all scroll-based once you learn it:

• Scroll up/down over the graph to zoom the time axis in and out.
• Scroll horizontally to pan left and right through time.
• Hold Shift and drag to select a specific time range.
• Click the graph to lock a cursor at one timestamp; every field's value at that instant shows in the legend. Right-click clears it.

The magic feature is that the selected timestamp is synchronized across every open tab. Click a spike on the line graph and the 2D field, the mechanism view, and the joysticks all jump to that same moment. That is how you connect a number to a physical pose.

The Line Graph is the right tool for closed-loop tuning: plot your setpoint on the left axis and your measured value on the same axis, and the gap between the two curves is your error. That side-by-side is exactly the picture the PID tuning walkthrough is built around — overshoot, steady-state error, and oscillation all have recognizable shapes here. The 2026 line graph is also unit-aware, so it labels axes with real units and can convert between compatible ones on the fly.

Fields can be integrated or differentiated right in the graph. Differentiate a position signal to see velocity, or integrate current draw to eyeball energy use, without writing any robot-side math.

2D and 3D Field

The field tabs draw your robot on a map of the field, which is how you debug anything involving position: autos, path following, and vision. Drag a pose field into the Poses section and it appears on the field. Both tabs accept Pose2d, Pose3d, Translation2d, and Translation3d, as single values or as arrays.

The important detail is how you publish those poses. AdvantageScope reads geometry as a byte-encoded struct or protobuf, and the old number-array convention is deprecated. In practice you publish a struct topic like this:

import edu.wpi.first.math.geometry.Pose2d;
import edu.wpi.first.networktables.NetworkTableInstance;
import edu.wpi.first.networktables.StructPublisher;

StructPublisher<Pose2d> posePublisher = NetworkTableInstance.getDefault()
    .getStructTopic("Odometry/Robot", Pose2d.struct)
    .publish();

// each loop:
posePublisher.set(drivetrain.getPose());

The 2D Field is the everyday choice for odometry: robot pose, a ghost of the target pose, the trajectory you are following, and vision-detected targets all overlaid on the field image. Set the robot's side length (30, 27, or 24 inches) so its footprint is drawn to scale. The 3D Field shines when you have real 3D data — AprilTag localization, an elevator carriage that moves in Z, a shooter angle — because it shows the robot and field in three dimensions. Recent FRC (and FTC) game fields are built in, and if you are debugging odometry drift, the odometry and pose-estimation guide explains what the two field views are actually showing you.

Joysticks

The Joysticks tab replays driver input on up to six controllers, IDs 0 through 5 matching the Driver Station slots. Buttons light up when pressed and axes and POV hats animate, so you can see exactly what the driver did.

One gotcha catches every team once: joystick data is not available over a stock NetworkTables connection. It only shows up if you logged it, which is precisely why you added DriverStation.startDataLog(...) earlier, or if you use AdvantageKit. Open a competition WPILOG that included joystick logging and the tab comes alive; connect live to a plain WPILib robot and it stays empty. AdvantageScope ships layouts for common controllers plus a generic grid, and you can build custom layouts for oddball hardware.

Mechanism (and Swerve)

The Mechanism tab renders a jointed 2D mechanism you built with WPILib's Mechanism2d, so an arm-plus-elevator or a multi-stage linkage animates in sync with the timeline. Publish it the usual way:

import edu.wpi.first.wpilibj.smartdashboard.Mechanism2d;
import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;

Mechanism2d mechanism = new Mechanism2d(3, 3);
// ... attach roots and ligaments, update their angles/lengths each loop ...
SmartDashboard.putData("Arm", mechanism);

The Swerve tab is the equivalent for a swerve drivetrain: drop in your module states and it draws each module's speed and angle as vectors, which makes a mis-wired or inverted module obvious at a glance. Across all these tabs the timeline colors the autonomous period green and teleop blue, so you always know which phase of the match you are scrubbing through.

A debugging workflow that works

The tabs are more powerful together than apart. A reliable loop looks like this:

1. Reproduce and record. Run the robot with DataLogManager logging so the bad behavior is captured to a WPILOG. On a real field the FMS-named log already has it.
2. Open the log with File > Open Log(s)....
3. Find the moment on the Line Graph. Plot the signal you suspect — a setpoint, an error, a current spike, a command name on the discrete strip — and scrub to where it goes wrong.
4. Cross-reference. Because the cursor is synced, the 2D/3D Field shows where the robot physically was, the Joysticks tab shows what the driver was doing, and the Mechanism tab shows the arm angle — all at that exact timestamp.
5. Form one hypothesis and fix one thing. Change a single gain, sensor sign, or conversion, redeploy, and compare the new curve against the old.

That discipline — one change per iteration, always verified against the graph — is the difference between tuning and flailing. The same habit shows up throughout the robot programming guides.

What changed for 2026

If your reference points are from an older season, a few things moved. The Line Graph became unit-aware, labeling axes with real units and converting between compatible ones. Log downloads from the roboRIO got a new FTP transport that runs about 2–4x faster. REVLOG files from REV's StatusLogger and plain CSV imports are now supported, and there is experimental FTC support with FTC field models and FTC Dashboard streaming. One older rename still worth flagging: the odometry tab became 2D Field back in the AdvantageScope 3 rewrite (2024), not this season, which trips up people following older tutorials.

Frequently asked questions

Is AdvantageScope free?

Yes. It is open-source software from Team 6328 and ships with the WPILib installer at no cost. There is nothing to buy and no account to create.

Do I need AdvantageKit to use AdvantageScope?

No. AdvantageScope works with plain WPILib logging and live NetworkTables out of the box. AdvantageKit is an optional on-robot framework that enables deterministic log replay, and AdvantageScope has a dedicated connection mode for it, but the two are independent.

Why is my Joysticks tab empty when connected live?

Joystick data is not published over stock NetworkTables, so a live connection shows nothing. Log it with DriverStation.startDataLog(DataLogManager.getLog()) and open the resulting WPILOG, or use AdvantageKit, and the driver input will appear.

Where does WPILib save the WPILOG file on the robot?

If a FAT32-formatted USB drive is plugged into the roboRIO, logs go to a logs folder on that drive; otherwise they land in /home/lvuser/logs. Files are timestamped once the Driver Station connects, and get event and match numbers at an FMS-run event.

Why don't my robot poses show up on the 2D/3D Field?

The field tabs read poses as a byte-encoded struct or protobuf, and the legacy number-array format is deprecated. Publish a struct topic (for example with Pose2d.struct) or log the pose through a WPILib API that uses the struct format, and it will render.

Can I use AdvantageScope with a simulator instead of a real robot?

Yes. File > Connect to Simulator attaches to desktop simulation, and every visualization works exactly as it does with a real robot. It is the fastest way to iterate because there is no deploy step.

Whatever this season's game turns out to be — check the current game manual for the actual scoring and objectives — the debugging problems are the same every year: an auto that drifts, a mechanism that overshoots, a driver input you cannot explain. AdvantageScope turns all three from a shrug into a timestamp you can point at. Record early, open the log, scrub to the moment, change one thing, and confirm it on the graph.