Quickstart

Get up and running with WPILib in minutes. This guide will walk you through creating a basic robot program that runs on your roboRIO.

Understanding the robot lifecycle

WPILib robot programs follow a specific lifecycle with distinct modes:

Robot initialization

Called once when the robot first starts up. Use this for one-time setup like configuring motors and sensors.

Mode initialization

Called once when entering a specific mode (autonomous, teleop, test, or disabled).

Periodic execution

Called every 20ms (50 times per second) during each mode. This is where your main robot logic runs.

Mode transitions

The robot automatically transitions between modes based on Driver Station input.

Create your first robot program

Here’s a complete basic robot program using the TimedRobot framework:

Java
C++

package frc.robot;

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.smartdashboard.SendableChooser;
import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;

/**
 * The methods in this class are called automatically corresponding to each mode.
 * TimedRobot runs a 20ms loop (50Hz) by default.
 */
public class Robot extends TimedRobot {
  private static final String kDefaultAuto = "Default";
  private static final String kCustomAuto = "My Auto";
  private String m_autoSelected;
  private final SendableChooser<String> m_chooser = new SendableChooser<>();

  /**
   * Called when the robot is first started up.
   * Use this for initialization code.
   */
  public Robot() {
    m_chooser.setDefaultOption("Default Auto", kDefaultAuto);
    m_chooser.addOption("My Auto", kCustomAuto);
    SmartDashboard.putData("Auto choices", m_chooser);
  }

  /**
   * Called every 20 ms, no matter the mode.
   * Runs after mode-specific periodic functions.
   */
  @Override
  public void robotPeriodic() {}

  /**
   * Called once when autonomous is enabled.
   */
  @Override
  public void autonomousInit() {
    m_autoSelected = m_chooser.getSelected();
    System.out.println("Auto selected: " + m_autoSelected);
  }

  /**
   * Called periodically during autonomous (every 20ms).
   */
  @Override
  public void autonomousPeriodic() {
    switch (m_autoSelected) {
      case kCustomAuto:
        // Put custom auto code here
        break;
      case kDefaultAuto:
      default:
        // Put default auto code here
        break;
    }
  }

  /**
   * Called once when teleop is enabled.
   */
  @Override
  public void teleopInit() {}

  /**
   * Called periodically during teleop (every 20ms).
   */
  @Override
  public void teleopPeriodic() {}

  /**
   * Called once when the robot is disabled.
   */
  @Override
  public void disabledInit() {}

  /**
   * Called periodically when disabled.
   */
  @Override
  public void disabledPeriodic() {}

  /**
   * Called once when test mode is enabled.
   */
  @Override
  public void testInit() {}

  /**
   * Called periodically during test mode.
   */
  @Override
  public void testPeriodic() {}

  /**
   * Called once when the robot is first started in simulation.
   */
  @Override
  public void simulationInit() {}

  /**
   * Called periodically in simulation.
   */
  @Override
  public void simulationPeriodic() {}
}

#include <frc/TimedRobot.h>
#include <frc/smartdashboard/SendableChooser.h>
#include <frc/smartdashboard/SmartDashboard.h>

class Robot : public frc::TimedRobot {
 public:
  /**
   * Called when the robot is first started up.
   */
  void RobotInit() override {
    m_chooser.SetDefaultOption(kDefaultAuto, kDefaultAuto);
    m_chooser.AddOption(kCustomAuto, kCustomAuto);
    frc::SmartDashboard::PutData("Auto Modes", &m_chooser);
  }

  /**
   * Called every 20 ms, no matter the mode.
   */
  void RobotPeriodic() override {}

  /**
   * Called once when autonomous is enabled.
   */
  void AutonomousInit() override {
    m_autoSelected = m_chooser.GetSelected();
    std::cout << "Auto selected: " << m_autoSelected << std::endl;
  }

  /**
   * Called periodically during autonomous.
   */
  void AutonomousPeriodic() override {
    if (m_autoSelected == kCustomAuto) {
      // Custom auto code here
    } else {
      // Default auto code here
    }
  }

  /**
   * Called once when teleop is enabled.
   */
  void TeleopInit() override {}

  /**
   * Called periodically during teleop.
   */
  void TeleopPeriodic() override {}

  /**
   * Called once when disabled.
   */
  void DisabledInit() override {}

  /**
   * Called periodically when disabled.
   */
  void DisabledPeriodic() override {}

  /**
   * Called once when test mode is enabled.
   */
  void TestInit() override {}

  /**
   * Called periodically during test mode.
   */
  void TestPeriodic() override {}

  /**
   * Called once when simulation is started.
   */
  void SimulationInit() override {}

  /**
   * Called periodically in simulation.
   */
  void SimulationPeriodic() override {}

 private:
  static constexpr const char* kDefaultAuto = "Default";
  static constexpr const char* kCustomAuto = "My Auto";
  std::string m_autoSelected;
  frc::SendableChooser<std::string> m_chooser;
};

#ifndef RUNNING_FRC_TESTS
int main() {
  return frc::StartRobot<Robot>();
}
#endif

The TimedRobot framework automatically calls your periodic methods every 20ms (50Hz). This timing is handled by the framework - you just implement the methods.

Running in simulation

Test your robot program without hardware using WPILib’s simulation framework:

VS Code
Gradle

Open the Command Palette (Ctrl+Shift+P / Cmd+Shift+P)
Type “WPILib: Simulate Robot Code”
Select your robot project
Choose “Sim GUI” to open the simulation interface

# For Java projects
./gradlew simulateJava

# For C++ projects
./gradlew simulateCpp

The simulation GUI provides:

Virtual joysticks and driver station controls
Hardware simulation for motors, sensors, and pneumatics
NetworkTables viewer for debugging
Real-time robot state visualization

Adding hardware control

Expand your robot program to control motors and read sensors:

Java
C++

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.motorcontrol.PWMSparkMax;
import edu.wpi.first.wpilibj.Joystick;

public class Robot extends TimedRobot {
  // Create motor controller on PWM port 0
  private PWMSparkMax m_motor = new PWMSparkMax(0);
  
  // Create joystick on USB port 0
  private Joystick m_joystick = new Joystick(0);

  @Override
  public void teleopPeriodic() {
    // Set motor speed from joystick Y-axis
    double speed = -m_joystick.getY(); // Invert Y-axis
    m_motor.set(speed);
  }

  @Override
  public void disabledInit() {
    // Stop motor when disabled
    m_motor.set(0);
  }
}

#include <frc/TimedRobot.h>
#include <frc/motorcontrol/PWMSparkMax.h>
#include <frc/Joystick.h>

class Robot : public frc::TimedRobot {
 public:
  void TeleopPeriodic() override {
    // Set motor speed from joystick Y-axis
    double speed = -m_joystick.GetY(); // Invert Y-axis
    m_motor.Set(speed);
  }

  void DisabledInit() override {
    // Stop motor when disabled
    m_motor.Set(0);
  }

 private:
  // Motor controller on PWM port 0
  frc::PWMSparkMax m_motor{0};
  
  // Joystick on USB port 0
  frc::Joystick m_joystick{0};
};

Best practices

Initialize once

Put initialization code in constructors or init methods, not periodic methods

Keep periodic fast

Periodic methods run every 20ms. Avoid blocking operations or long calculations

Use simulation

Test your code in simulation before deploying to hardware

Log data

Use SmartDashboard or DataLog to debug and tune your robot

Next steps

Now that you have a basic robot program running, explore these topics:

Motor control

Learn about different motor controllers and control modes

Sensors

Read encoders, gyros, and other sensors for feedback

Command-based programming

Structure complex robot programs with commands and subsystems

Vision processing

Use cameras and AprilTags for autonomous targeting

Getting Started

Core Concepts

Programming Guide

Simulation

Advanced Topics

Tools

Understanding the robot lifecycle

Create your first robot program

Running in simulation

Adding hardware control

Best practices

Initialize once

Keep periodic fast

Use simulation

Log data

Next steps

Motor control

Sensors

Command-based programming

Vision processing

Build docs developers (and LLMs) love

Getting Started

Core Concepts

Programming Guide

Simulation

Advanced Topics

Tools

​Understanding the robot lifecycle

​Create your first robot program

​Running in simulation

​Adding hardware control

​Best practices

Initialize once

Keep periodic fast

Use simulation

Log data

​Next steps

Motor control

Sensors

Command-based programming

Vision processing

Build docs developers (and LLMs) love

Understanding the robot lifecycle

Create your first robot program

Running in simulation

Adding hardware control

Best practices

Next steps