What AdvantageKit Is

AdvantageKit is an open-source logging framework for FRC robots, created and maintained by Team 6328 (Mechanical Advantage). It runs on top of WPILib and provides two capabilities that WPILib's built-in logging does not: structured input capture and deterministic replay.

Structured input capture means AdvantageKit records every sensor input that enters the robot's subsystems — velocity readings, encoder positions, current draws, motor temperatures — at every loop iteration, in a format that ties each value to the specific subsystem and IO layer that produced it. Not just "shooter velocity was 3450 RPM at some point" but "in loop 1,247 of the match, Shooter/velocityRpm was 3450.2 and the subsystem considered itself at-speed, which is why the eject command started."

Deterministic replay means you can take that log file and re-run your robot code's logic against it, offline, on a laptop, without any hardware — and get the exact same subsystem outputs that the robot produced during the match. If you add a System.out.println or a new SmartDashboard value after the fact and replay, you can see what that value would have been during the match. This is the most powerful debugging capability available to an FRC team.

AdvantageKit vs. SmartDashboard

How Data Flows Through AdvantageKit

Select a mode below to see how data travels from your subsystem's IO layer through the Logger to its destination. The path changes depending on whether the robot is running on real hardware, in simulation, or in replay mode.

The Three Logger Backends

Installation and Setup

Adding AdvantageKit to Your Project

Download the AdvantageKit vendordep JSON from github.com/Mechanical-Advantage/AdvantageKit/releases. In VS Code: W key → "Manage Vendor Libraries" → "Install new libraries (online)" and paste the URL. Alternatively, place the JSON file directly in your project's vendordeps/ directory and run ./gradlew dependencies to confirm it resolved.

Configuring Robot.java

AdvantageKit requires the Logger to be configured and started before any subsystems are created. The configuration happens in Robot.java before new RobotContainer() is called.

import org.littletonrobotics.junction.Logger;
import org.littletonrobotics.junction.LoggedRobot;
import org.littletonrobotics.junction.wpilog.WPILOGWriter;
import org.littletonrobotics.junction.wpilog.WPILOGReader;
import org.littletonrobotics.junction.networktables.NT4Publisher;

// Extend LoggedRobot instead of TimedRobot
// LoggedRobot is a drop-in replacement that handles Logger tick timing
public class Robot extends LoggedRobot {

    private RobotContainer m_robotContainer;

    @Override
    public void robotInit() {
        // ── Logger configuration: MUST happen before RobotContainer is created ────

        // Metadata is stored in the log file for later identification
        Logger.recordMetadata("ProjectName", BuildConstants.MAVEN_NAME);
        Logger.recordMetadata("GitSHA",     BuildConstants.GIT_SHA);
        Logger.recordMetadata("BuildDate",  BuildConstants.BUILD_DATE);

        if (RobotBase.isReal()) {
            // On real robot: write to USB drive (preferred) or roboRIO internal storage
            Logger.addDataReceiver(new WPILOGWriter("/U/logs"));  // USB drive path
            Logger.addDataReceiver(new NT4Publisher());       // also publish to NT for live view
        } else if (Constants.getMode() == Constants.Mode.REPLAY) {
            // Replay mode: read from a previous log file, write a new one with
            // computed outputs from the re-run. The input log path is configured
            // in Constants.java.
            Logger.setReplaySource(new WPILOGReader(Constants.REPLAY_LOG_PATH));
            Logger.addDataReceiver(new WPILOGWriter(Constants.REPLAY_OUTPUT_PATH));
        } else {
            // Simulation: publish to NT only (no file)
            Logger.addDataReceiver(new NT4Publisher());
        }

        // Start the Logger — must be called before any subsystem is constructed
        Logger.start();

        // Now safe to create subsystems (which reference Logger in their periodic())
        m_robotContainer = new RobotContainer();
    }

    @Override
    public void robotPeriodic() {
        CommandScheduler.getInstance().run();
    }
}

The Logger API: recordOutput and processInputs

Two Logger methods cover nearly all of the API you'll use day to day.

Logger.recordOutput() — log any computed value

Call this anywhere in periodic() to record any value. The first argument is the log key — a hierarchical string using "/" as a separator. The key becomes the path in AdvantageScope's log viewer. Good key naming conventions make logs searchable and self-documenting.

@Override
public void periodic() {
    // 1. Read inputs from IO
    // 2. processInputs — logs inputs AND overwrites them in replay mode
    m_io.updateInputs(m_inputs);
    Logger.processInputs("Shooter", m_inputs);

    // 3. Run control logic using m_inputs (now safe to read)
    // 4. Record ALL computed values — these are what replay adds insight to

    // Scalars
    Logger.recordOutput("Shooter/TargetRpm",      m_targetRpm);
    Logger.recordOutput("Shooter/VelocityRpm",    m_inputs.velocityRpm);
    Logger.recordOutput("Shooter/VelocityError",  m_targetRpm - m_inputs.velocityRpm);
    Logger.recordOutput("Shooter/PIDOutput",      m_pid.calculate(m_inputs.velocityRpm));

    // Booleans
    Logger.recordOutput("Shooter/AtTargetSpeed",  isAtTargetSpeed());
    Logger.recordOutput("Shooter/MotorConnected", m_inputs.motorConnected);

    // State enum (logs as string: "IDLE", "SPINNING_UP", "READY", "EJECTING")
    Logger.recordOutput("Shooter/State",          m_currentState);
}

Logger.processInputs() — the critical call

As described in Lesson 1, Logger.processInputs(prefix, inputs) does two things simultaneously:

• In real robot / simulation mode: logs the current state of every field in the inputs object to the log file / NetworkTables under the given prefix. This is how sensor readings become part of the permanent match record.
• In replay mode: reads the values for these fields from the log file at the current timestamp and writes them into the inputs object. The subsystem then runs its logic on historical data from the match.

This dual behavior is what makes replay deterministic. The subsystem code doesn't need to know which mode it's in — it just calls processInputs() and the framework handles the rest.

Getting Log Files Off the Robot

After a match, the .wpilog file is on the roboRIO (or the USB drive plugged into it). There are three ways to retrieve it:

• USB drive (preferred): Plug a USB drive into the roboRIO before matches. AdvantageKit writes logs directly to /U/logs/ on the drive. After the match, pull the drive and plug it into a laptop. Logs are immediately accessible. This is the fastest method and doesn't require network access.
• FTP over USB tether: Connect the laptop to the roboRIO via USB-B cable. Use an FTP client (FileZilla, or the built-in sftp in Terminal/PowerShell) to connect to 172.22.11.2 and navigate to /home/lvuser/. Download the most recent .wpilog file.
• FTP over robot network: Connect to the robot's WiFi. FTP to 10.TE.AM.2. Same path as above. Slower than USB, but works wirelessly in the pit during between-match review.

Log Key Naming Conventions

Log keys are hierarchical strings that become the navigation tree in AdvantageScope. Consistent naming conventions matter — a messy log namespace is as hard to navigate as messy code.

// ── Pattern: SubsystemName/Category/SpecificValue ─────────────────────────

// IO layer inputs (set by processInputs prefix)
// These appear under: Shooter/velocityRpm, Shooter/currentAmps, etc.
Logger.processInputs("Shooter", m_inputs);      // creates Shooter/* namespace
Logger.processInputs("Drive/FrontLeft", inputs); // Drive/FrontLeft/*

// Computed outputs (use SubsystemName/ValueName)
Logger.recordOutput("Shooter/TargetRpm",     m_targetRpm);
Logger.recordOutput("Shooter/VelocityError", error);
Logger.recordOutput("Shooter/State",         m_state);

// Robot-level pose and field visualization
Logger.recordOutput("Odometry/Robot",        m_drive.getPose());
Logger.recordOutput("Odometry/VisionPose",   visionPose);
Logger.recordOutput("Odometry/Trajectory",   trajectoryPoses);

// Command scheduler (AdvantageKit logs active commands automatically)
// These appear under: ActiveCommands/SchedulerActions

// Avoid: vague names, no namespace, duplicate keys across subsystems
Logger.recordOutput("rpm",         value); // ❌ which subsystem?
Logger.recordOutput("Shooter/rpm", value); // ✓ clear and findable

🔌 System Check

Knowledge Check