Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/robototes/REBUILT2026/llms.txt

Use this file to discover all available pages before exploring further.

This quickstart walks you through obtaining the REBUILT 2026 source code, building it locally, running it in the WPILib simulator, and deploying it to a physical RoboRIO. It also covers the optional Gradle build properties and what to verify on SmartDashboard after a successful deploy.

​
Prerequisites

Before you begin, make sure the following are installed and available on your development machine.
RequirementNotes
JDK 17WPILib bundles its own JDK; alternatively use any JDK 17 distribution
WPILib 2026Install via the WPILib installer — provides Gradle toolchains, VS Code extension, and simulation GUI
VS Code with WPILib extensionRecommended IDE; the extension adds build/deploy/simulate commands to the command palette
RoboRIO with 2026 firmwareRequired for on-robot deployment; team number must be 2412 (or match .wpilib/wpilib_preferences.json)
If you only want to build or simulate locally, you do not need a physical RoboRIO. The WPILib simulation GUI (simgui) launches automatically when you run simulateJava.

​
Steps

1
Clone the repository
2
git clone https://github.com/robototes/REBUILT2026.git
cd REBUILT2026
3
The repository root contains build.gradle, vendor dependencies in vendordeps/, deploy assets in src/main/deploy/, and the WPILib project metadata in .wpilib/wpilib_preferences.json (team number 2412, year 2026).
4
Open in VS Code with the WPILib extension
5
Open the cloned folder in VS Code. The WPILib extension detects the GradleRIO project automatically and populates the WPILib command palette (Ctrl+Shift+P → “WPILib:”).
6
Alternatively, import the project into any IDE that supports Gradle by pointing it at the root build.gradle. The project uses sourceCompatibility = JavaVersion.VERSION_17.
7
Build the project
8
./gradlew build
9
This compiles all Java sources under src/main/java/, runs the generateBuildInfo task (which writes a build-info.txt file with the current git hash, branch, and commit message into src/main/deploy/), and packages everything into a fat JAR via the jar task. Vendor library JNI binaries are bundled into the JAR so it is self-contained for deployment.
10
The default main class is frc.robot.Main. Passing -PautomatedTest=true switches it to frc.robot.test.AutomatedTestMain (see Build variants below).
11
Standard build
./gradlew build
Build with automated test entry point
./gradlew build -PautomatedTest=true
Build with high-fidelity vision enabled
./gradlew build -PhighFidelityVision=true
12
Run the simulation
13
./gradlew simulateJava
14
The simulation task launches the robot code in a desktop JVM with -Xmx2G -Xms2G heap settings (configured in build.gradle). The WPILib simulation GUI (simgui) opens automatically because wpi.sim.addGui().defaultEnabled = true is set in the build file. A virtual DriverStation window is also available via wpi.sim.addDriverstation().
15
In simulation, RobotType.TYPE is always RobotTypesEnum.SIM and Robot.isSimulation() returns true. The SimWrapper is instantiated and simulationInit() automatically zeros the hood (subsystems.hood.zero()).
16
During simulation you can inject odometry drift (POV-right on the driver controller) or reset the robot to the selected auto start pose (POV-left) to test vision correction behavior.
17
High-fidelity vision simulation can be enabled by passing -PhighFidelityVision=true to the simulate task. The highFidelityVision system property is forwarded to the JVM automatically.
18
./gradlew simulateJava -PhighFidelityVision=true
19
Deploy to the RoboRIO
20
./gradlew deploy
21
GradleRIO reads the team number from .wpilib/wpilib_preferences.json ("teamNumber": 2412) and connects to the RoboRIO over USB or the team’s network (10.24.12.x). It uploads the fat JAR as an FRCJavaArtifact and deploys static files from src/main/deploy/ to /home/lvuser/deploy/ on the RoboRIO.
22
Alternatively, use the VS Code command palette: WPILib: Deploy Robot Code.
23
The RoboRIO must be running 2026 firmware and must be reachable on the network before deploying. If the deploy fails, verify the USB or radio connection and confirm the team number in .wpilib/wpilib_preferences.json matches your RoboRIO’s configured team number.
24
Verify on SmartDashboard or Shuffleboard
25
After enabling the robot for the first time, confirm these entries are present and updating:
26
EntryWhat it confirmsCommandScheduler (SmartDashboard)Scheduler is running; shows active/scheduled commandsGCCount (SmartDashboard)JVM garbage-collection monitor is activeField (Shuffleboard Field2d)Drivetrain odometry and autonomous path preview are working/vision/limelight-a_Last timestampLimelight A is online and sending heartbeats/Turret/PositionTurret motor is responding

​
Build variants

Two Gradle project properties change what gets compiled or how the simulation runs.
PropertyDefaultEffect
-PautomatedTest=truefalseSwitches the JAR main class to frc.robot.test.AutomatedTestMain for CI/hardware-in-the-loop test runs
-PhighFidelityVision=truefalsePasses the highFidelityVision system property into the simulation JVM, enabling additional vision simulation fidelity
# Run automated tests
./gradlew simulateJava -PautomatedTest=true

# Deploy with high-fidelity vision build flag (simulation only — no effect on RoboRIO deploy)
./gradlew simulateJava -PhighFidelityVision=true

​
DataLog

On a real robot, DataLogManager starts automatically in the Robot constructor: 
if (RobotBase.isReal()) {
  DataLogManager.start("", "", DATA_LOG_FLUSH_PERIOD_S); // 14 Hz flush (1/14 s)
  DriverStation.startDataLog(DataLogManager.getLog(), true);
}
Logs are flushed at 14 Hz (DATA_LOG_FLUSH_PERIOD_S = 1.0 / 14.0). The DataLog is also resumed every second in robotPeriodic() to recover from any transient pauses. Struct schemas for Pose2d, Pose3d, ChassisSpeeds, SwerveModuleState, and SwerveModulePosition are explicitly registered so log viewers (e.g., Advantage Scope) can decode them. Command lifecycle events (initialize, interrupt, finish) are also logged automatically via CommandScheduler callbacks: 
CommandScheduler.getInstance()
    .onCommandInitialize(cmd -> DataLogManager.log("Command initialized: " + cmd.getName()));
Before enabling the robot for a match or tuning session, zero the hood and turret using the Start button on the driver controller. The disabledExit() callback will warn via DriverStation.reportWarning if the hood has not been zeroed when exiting disabled mode.

Build docs developers (and LLMs) love

Get started for freeTalk to us