Initial Commit

.gitignore

@@ -0,0 +1,187 @@
+# This gitignore has been specially created by the WPILib team.
+# If you remove items from this file, intellisense might break.
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### Java ###
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+### Gradle ###
+.gradle
+/build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Cache of project
+.gradletasknamecache
+
+# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
+# gradle/wrapper/gradle-wrapper.properties
+
+# # VS Code Specific Java Settings
+# DO NOT REMOVE .classpath and .project
+.classpath
+.project
+.settings/
+bin/
+
+# IntelliJ
+*.iml
+*.ipr
+*.iws
+.idea/
+out/
+
+# Fleet
+.fleet
+
+# Simulation GUI and other tools window save file
+networktables.json
+simgui.json
+*-window.json
+
+# Simulation data log directory
+logs/
+
+# Folder that has CTRE Phoenix Sim device config storage
+ctre_sim/
+
+# clangd
+/.cache
+compile_commands.json
+
+# Eclipse generated file for annotation processors
+.factorypath

.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+
+    {
+      "type": "wpilib",
+      "name": "WPILib Desktop Debug",
+      "request": "launch",
+      "desktop": true,
+    },
+    {
+      "type": "wpilib",
+      "name": "WPILib roboRIO Debug",
+      "request": "launch",
+      "desktop": false,
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,60 @@
+{
+  "java.configuration.updateBuildConfiguration": "automatic",
+  "java.server.launchMode": "Standard",
+  "files.exclude": {
+    "**/.git": true,
+    "**/.svn": true,
+    "**/.hg": true,
+    "**/CVS": true,
+    "**/.DS_Store": true,
+    "bin/": true,
+    "**/.classpath": true,
+    "**/.project": true,
+    "**/.settings": true,
+    "**/.factorypath": true,
+    "**/*~": true
+  },
+  "java.test.config": [
+    {
+      "name": "WPIlibUnitTests",
+      "workingDirectory": "${workspaceFolder}/build/jni/release",
+      "vmargs": [ "-Djava.library.path=${workspaceFolder}/build/jni/release" ],
+      "env": {
+        "LD_LIBRARY_PATH": "${workspaceFolder}/build/jni/release" ,
+        "DYLD_LIBRARY_PATH": "${workspaceFolder}/build/jni/release"
+      }
+    },
+  ],
+  "java.test.defaultConfig": "WPIlibUnitTests",
+  "java.import.gradle.annotationProcessing.enabled": false,
+  "java.completion.favoriteStaticMembers": [
+    "org.junit.Assert.*",
+    "org.junit.Assume.*",
+    "org.junit.jupiter.api.Assertions.*",
+    "org.junit.jupiter.api.Assumptions.*",
+    "org.junit.jupiter.api.DynamicContainer.*",
+    "org.junit.jupiter.api.DynamicTest.*",
+    "org.mockito.Mockito.*",
+    "org.mockito.ArgumentMatchers.*",
+    "org.mockito.Answers.*",
+    "edu.wpi.first.units.Units.*"
+  ],
+  "java.completion.filteredTypes": [
+    "java.awt.*",
+    "com.sun.*",
+    "sun.*",
+    "jdk.*",
+    "org.graalvm.*",
+    "io.micrometer.shaded.*",
+    "java.beans.*",
+    "java.util.Base64.*",
+    "java.util.Timer",
+    "java.sql.*",
+    "javax.swing.*",
+    "javax.management.*",
+    "javax.smartcardio.*",
+    "edu.wpi.first.math.proto.*",
+    "edu.wpi.first.math.**.proto.*",
+    "edu.wpi.first.math.**.struct.*",
+  ]
+}

.wpilib/wpilib_preferences.json

@@ -0,0 +1,6 @@
+{
+    "enableCppIntellisense": false,
+    "currentLanguage": "java",
+    "projectYear": "2025",
+    "teamNumber": 9999
+}

WPILib-License.md

@@ -0,0 +1,24 @@
+Copyright (c) 2009-2024 FIRST and other WPILib contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   * Neither the name of FIRST, WPILib, nor the names of other WPILib
+     contributors may be used to endorse or promote products derived from
+     this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY FIRST AND OTHER WPILIB CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY NONINFRINGEMENT AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL FIRST OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

build.gradle

@@ -0,0 +1,104 @@
+plugins {
+    id "java"
+    id "edu.wpi.first.GradleRIO" version "2025.3.2"
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+def ROBOT_MAIN_CLASS = "frc.robot.Main"
+
+// Define my targets (RoboRIO) and artifacts (deployable files)
+// This is added by GradleRIO's backing project DeployUtils.
+deploy {
+    targets {
+        roborio(getTargetTypeClass('RoboRIO')) {
+            // Team number is loaded either from the .wpilib/wpilib_preferences.json
+            // or from command line. If not found an exception will be thrown.
+            // You can use getTeamOrDefault(team) instead of getTeamNumber if you
+            // want to store a team number in this file.
+            team = project.frc.getTeamNumber()
+            debug = project.frc.getDebugOrDefault(false)
+
+            artifacts {
+                // First part is artifact name, 2nd is artifact type
+                // getTargetTypeClass is a shortcut to get the class type using a string
+
+                frcJava(getArtifactTypeClass('FRCJavaArtifact')) {
+                }
+
+                // Static files artifact
+                frcStaticFileDeploy(getArtifactTypeClass('FileTreeArtifact')) {
+                    files = project.fileTree('src/main/deploy')
+                    directory = '/home/lvuser/deploy'
+                    deleteOldFiles = false // Change to true to delete files on roboRIO that no
+                                           // longer exist in deploy directory of this project
+                }
+            }
+        }
+    }
+}
+
+def deployArtifact = deploy.targets.roborio.artifacts.frcJava
+
+// Set to true to use debug for JNI.
+wpi.java.debugJni = false
+
+// Set this to true to enable desktop support.
+def includeDesktopSupport = false
+
+// Defining my dependencies. In this case, WPILib (+ friends), and vendor libraries.
+// Also defines JUnit 5.
+dependencies {
+    annotationProcessor wpi.java.deps.wpilibAnnotations()
+    implementation wpi.java.deps.wpilib()
+    implementation wpi.java.vendor.java()
+
+    roborioDebug wpi.java.deps.wpilibJniDebug(wpi.platforms.roborio)
+    roborioDebug wpi.java.vendor.jniDebug(wpi.platforms.roborio)
+
+    roborioRelease wpi.java.deps.wpilibJniRelease(wpi.platforms.roborio)
+    roborioRelease wpi.java.vendor.jniRelease(wpi.platforms.roborio)
+
+    nativeDebug wpi.java.deps.wpilibJniDebug(wpi.platforms.desktop)
+    nativeDebug wpi.java.vendor.jniDebug(wpi.platforms.desktop)
+    simulationDebug wpi.sim.enableDebug()
+
+    nativeRelease wpi.java.deps.wpilibJniRelease(wpi.platforms.desktop)
+    nativeRelease wpi.java.vendor.jniRelease(wpi.platforms.desktop)
+    simulationRelease wpi.sim.enableRelease()
+
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.1'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+}
+
+test {
+    useJUnitPlatform()
+    systemProperty 'junit.jupiter.extensions.autodetection.enabled', 'true'
+}
+
+// Simulation configuration (e.g. environment variables).
+wpi.sim.addGui().defaultEnabled = true
+wpi.sim.addDriverstation()
+
+// Setting up my Jar File. In this case, adding all libraries into the main jar ('fat jar')
+// in order to make them all available at runtime. Also adding the manifest so WPILib
+// knows where to look for our Robot Class.
+jar {
+    from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
+    from sourceSets.main.allSource
+    manifest edu.wpi.first.gradlerio.GradleRIOPlugin.javaManifest(ROBOT_MAIN_CLASS)
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
+}
+
+// Configure jar and deploy tasks
+deployArtifact.jarTask = jar
+wpi.java.configureExecutableTasks(jar)
+wpi.java.configureTestTasks(test)
+
+// Configure string concat to always inline compile
+tasks.withType(JavaCompile) {
+    options.compilerArgs.add '-XDstringConcat=inline'
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=permwrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=permwrapper/dists

gradlew

@@ -0,0 +1,252 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1,30 @@
+import org.gradle.internal.os.OperatingSystem
+
+pluginManagement {
+    repositories {
+        mavenLocal()
+        gradlePluginPortal()
+        String frcYear = '2025'
+        File frcHome
+        if (OperatingSystem.current().isWindows()) {
+            String publicFolder = System.getenv('PUBLIC')
+            if (publicFolder == null) {
+                publicFolder = "C:\\Users\\Public"
+            }
+            def homeRoot = new File(publicFolder, "wpilib")
+            frcHome = new File(homeRoot, frcYear)
+        } else {
+            def userFolder = System.getProperty("user.home")
+            def homeRoot = new File(userFolder, "wpilib")
+            frcHome = new File(homeRoot, frcYear)
+        }
+        def frcHomeMaven = new File(frcHome, 'maven')
+        maven {
+            name = 'frcHome'
+            url = frcHomeMaven
+        }
+    }
+}
+
+Properties props = System.getProperties();
+props.setProperty("org.gradle.internal.native.headers.unresolved.dependencies.ignore", "true");

src/main/deploy/example.txt

@@ -0,0 +1,3 @@
+Files placed in this directory will be deployed to the RoboRIO into the
+'deploy' directory in the home folder. Use the 'Filesystem.getDeployDirectory' wpilib function
+to get a proper path relative to the deploy directory.

src/main/java/frc/robot/LEDAnimationKit/Animation.java

@@ -0,0 +1,44 @@
+package frc.robot.LEDAnimationKit;
+
+import edu.wpi.first.wpilibj.Timer;
+
+public abstract class Animation {
+    private boolean enabled;
+    private double timeDelay;
+    private Timer timer;
+
+    protected LEDStrip strip;
+
+    public Animation(LEDStrip strip, double timeDelay) {
+        this.strip = strip;
+
+        timer = new Timer();
+        this.timeDelay = timeDelay;
+        enabled = false;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void start() {
+        timer.reset();
+        timer.start();
+        enabled = true;
+    }
+
+    public void stop() {
+        timer.stop();
+        enabled = false;
+    }
+
+    public abstract boolean update();
+
+    protected boolean shouldUpdate() {
+        return enabled && timer.get() >= timeDelay;
+    }
+
+    protected void resetTiming() {
+        timer.reset();
+    }
+}

src/main/java/frc/robot/LEDAnimationKit/AnimationManager.java

@@ -0,0 +1,85 @@
+package frc.robot.LEDAnimationKit;
+
+import java.util.ArrayList;
+
+import edu.wpi.first.wpilibj.Notifier;
+
+public class AnimationManager {
+
+    private Notifier internalNotifier;
+    private ArrayList<Animation> animations;
+    private PhysicalLEDStrip[] ledStrips;
+    private boolean[] updateLEDStrip;
+
+    public AnimationManager(PhysicalLEDStrip[] ledStrips) {
+        this.ledStrips = ledStrips;
+        updateLEDStrip = new boolean[ledStrips.length];
+
+        for(int i = 0; i < updateLEDStrip.length; i++) {
+            updateLEDStrip[i] = false;
+        }
+
+        internalNotifier = new Notifier(() -> {
+            synchronized(animations) {
+                for(Animation animation : animations) {
+                    boolean shouldUpdate = animation.update();
+
+                    if(shouldUpdate) {
+                        int stripIndex = findStripIndex(animation.strip.getPhysicalStrip());
+
+                        if(stripIndex != -1) {
+                            updateLEDStrip[stripIndex] = true;
+                        }
+                    }
+                }
+
+                for(int i = 0; i < updateLEDStrip.length; i++) {
+                    if(updateLEDStrip[i]) {
+                        ledStrips[i].show();
+                    }
+
+                    updateLEDStrip[i] = false;
+                }
+            }
+        });
+
+        animations = new ArrayList<Animation>();
+    }
+
+    public void registerAnimationForUpdate(Animation animation) {
+        synchronized(animations) {
+            animations.add(animation);
+        }   
+    }
+
+    public void unregisterAnimation(Animation animation) {
+        synchronized(animations) {
+            animations.remove(animation);
+        }
+    }
+
+    public void unregisterAnimation(int index) {
+        synchronized(animations) {
+            animations.remove(index);
+        }
+    }
+
+    public void start(double periodSeconds) {
+        internalNotifier.startPeriodic(periodSeconds);
+    }
+
+    public void stop() {
+        internalNotifier.stop();
+    }
+
+    private int findStripIndex(LEDStrip strip) {
+        for(int i = 0; i < ledStrips.length; i++) {
+            if(ledStrips[i] == strip) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/LEDStrip.java

@@ -0,0 +1,84 @@
+package frc.robot.LEDAnimationKit;
+
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+/**
+ * An interface designed to create a common interface
+ * for current and future LED types. This interface can be implemented
+ * to wrap additional types of LEDs
+ */
+public interface LEDStrip {
+    /**
+     * Retrieves the number of LEDs in the strip
+     * 
+     * @return An integer representing the number of LEDs in the strip
+     */
+    public int getNumLEDs();
+
+    /**
+     * Directs the underlying physical strip to show
+     * the current internal buffer
+     */
+    public void show();
+
+    /**
+     * Returns a reference to the physical LED strip
+     * 
+     * @return The physical LED strip reference
+     */
+    public LEDStrip getPhysicalStrip();
+
+    /**
+     * Sets a particular pixel using a Color object
+     * 
+     * @param pixel The pixel index to set
+     * @param color The Color object used to specify the desired color
+     */
+    public void setRGBColor(int pixel, Color color);
+
+    /**
+     * Sets a particular pixel using a Color8Bit object
+     * 
+     * @param pixel The pixel index to set
+     * @param color The Color8Bit object used to specify the desired color
+     */
+    public void setRGBColor(int pixel, Color8Bit color);
+
+    /**
+     * Sets a particular pixel using 8 bit r, g, and b values
+     * 
+     * @param pixel The pixel index to set
+     * @param r The Red value of the RGB color (0 - 255)
+     * @param g The Green value of the RGB color (0 - 255)
+     * @param b The Blue value of the RGB color (0 - 255)
+     */
+    public void setRGBColor(int pixel, int r, int g, int b);
+
+    /**
+     * Sets a particular pixel using 8 bit h, s, v values
+     * 
+     * @param pixel The pixel index to set
+     * @param h The Hue value of the HSV color (0 - 180)
+     * @param s The Saturation value of the HSV color (0 - 255)
+     * @param v The Value value of the HSV color (0 - 255)
+     */
+    public void setHSVColor(int pixel, int h, int s, int v);
+
+    /**
+     * Returns the color at a specified pixel index using a Color object
+     * 
+     * @param pixel The pixel index to return the current color from
+     * @return The Color object representation of the specified pixel index
+     */
+    public Color getColor(int pixel);
+
+    /**
+     * Returns the color at the specified pixel index using a Color8Bit object
+     * 
+     * @param pixel The pixel index to return the current color from
+     * @return The Color8Bit object representation of the specified pixel index
+     */
+    public Color8Bit getColor8Bit(int pixel);
+
+}

src/main/java/frc/robot/LEDAnimationKit/LEDStrip2DWrapper.java

@@ -0,0 +1,104 @@
+package frc.robot.LEDAnimationKit;
+
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class LEDStrip2DWrapper implements LEDStrip {
+    private LEDStrip strip;
+    private int width;
+    private int height;
+
+    public LEDStrip2DWrapper(LEDStrip strip, int width, int height) {
+        this.strip = strip;
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public int getNumLEDs() {
+        return width * height;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    @Override
+    public void show() {
+        strip.show();
+        
+    }
+
+    @Override
+    public LEDStrip getPhysicalStrip() {
+        return strip.getPhysicalStrip();
+    }
+
+    public void setRGBColor(int x, int y, Color color) {
+        setRGBColor(translateXY(x, y), color);
+    }
+
+    public void setRGBColor(int x, int y, Color8Bit color) {
+        setRGBColor(translateXY(x, y), color);
+    }
+
+    public void setRGBColor(int x, int y, int r, int g, int b) {
+        setRGBColor(translateXY(x, y), r, g, b);
+    }
+
+    public void setHSVColor(int x, int y, int h, int s, int v) {
+        setHSVColor(translateXY(x, y), h, s, v);
+    }
+
+    @Override
+    public void setRGBColor(int pixel, Color color) {
+        strip.setRGBColor(pixel, color);
+        
+    }
+
+    @Override
+    public void setRGBColor(int pixel, Color8Bit color) {
+        strip.setRGBColor(pixel, color);
+    }
+
+    @Override
+    public void setRGBColor(int pixel, int r, int g, int b) {
+        strip.setRGBColor(pixel, r, g, b);
+        
+    }
+
+    @Override
+    public void setHSVColor(int pixel, int h, int s, int v) {
+        strip.setHSVColor(pixel, h, s, v);
+        
+    }
+
+    public Color getColor(int x, int y) {
+        return getColor(translateXY(x, y));
+    }
+
+    public Color8Bit getColor8Bit(int x, int y) {
+        return getColor8Bit(translateXY(x, y));
+    }
+
+    @Override
+    public Color getColor(int pixel) {
+        return strip.getColor(pixel);
+    }
+
+    @Override
+    public Color8Bit getColor8Bit(int pixel) {
+        return strip.getColor8Bit(pixel);
+    }
+
+    protected int translateXY(int x, int y) {
+        //TODO This should throw out of range when appropriate
+        //TODO Serpentine mode?
+        return y * width + x;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/LogicalLEDStrip.java

@@ -0,0 +1,67 @@
+package frc.robot.LEDAnimationKit;
+
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class LogicalLEDStrip implements LEDStrip{
+
+    private LEDStrip strip;
+    private int startPixel;
+    private int endPixel;
+
+    public LogicalLEDStrip(LEDStrip strip, int startPixel, int endPixel) {
+        this.strip = strip;
+        this.startPixel = startPixel;
+        this.endPixel = endPixel;
+    }
+
+    @Override
+    public int getNumLEDs() {
+        return endPixel - startPixel;
+    }
+
+    @Override
+    public void show() {
+        strip.show(); 
+    }
+
+    @Override
+    public void setRGBColor(int pixel, Color color) {
+        strip.setRGBColor(rescaleIndex(pixel), color);
+    }
+
+    @Override
+    public void setRGBColor(int pixel, Color8Bit color) {
+        strip.setRGBColor(rescaleIndex(pixel), color);
+    }
+
+    @Override
+    public void setRGBColor(int pixel, int r, int g, int b) {
+        strip.setRGBColor(rescaleIndex(pixel), r, g, b);
+    }
+
+    @Override
+    public void setHSVColor(int pixel, int h, int s, int v) {
+        strip.setHSVColor(rescaleIndex(pixel), h, s, v);
+    }
+
+    @Override
+    public Color getColor(int pixel) {
+        return strip.getColor(rescaleIndex(pixel));
+    }
+
+    @Override
+    public Color8Bit getColor8Bit(int pixel) {
+        return strip.getColor8Bit(rescaleIndex(pixel));
+    }
+    
+    //TODO This should be hardened to throw an IndexOutOfBound Exception
+    private int rescaleIndex(int pixel) {
+        return startPixel + pixel;
+    }
+
+    @Override
+    public LEDStrip getPhysicalStrip() {
+        return strip.getPhysicalStrip();
+    }
+}

src/main/java/frc/robot/LEDAnimationKit/PhysicalLEDStrip.java

@@ -0,0 +1,73 @@
+package frc.robot.LEDAnimationKit;
+
+import edu.wpi.first.wpilibj.AddressableLED;
+import edu.wpi.first.wpilibj.AddressableLEDBuffer;
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class PhysicalLEDStrip implements LEDStrip {
+
+    private AddressableLED led;
+    private AddressableLEDBuffer buffer;
+
+    public PhysicalLEDStrip(int portNum, int numLEDs) {
+        led = new AddressableLED(portNum);
+        led.setLength(numLEDs);
+
+        buffer = new AddressableLEDBuffer(numLEDs);
+        led.setData(buffer);
+    }
+
+    public void start() {
+        led.start();
+    }
+
+    public void stop() {
+        led.stop();
+    }
+
+    @Override
+    public void show() {
+        led.setData(buffer);
+    }
+
+    @Override
+    public int getNumLEDs() {
+        return buffer.getLength();
+    }
+
+    @Override
+    public void setRGBColor(int pixel, Color color) {
+        buffer.setLED(pixel, color);
+    }
+
+    @Override
+    public void setRGBColor(int pixel, Color8Bit color) {
+        buffer.setLED(pixel, color);
+    }
+
+    @Override
+    public void setRGBColor(int pixel, int r, int g, int b) {
+        buffer.setLED(pixel, new Color8Bit(r, g, b));
+    }
+
+    @Override
+    public void setHSVColor(int pixel, int h, int s, int v) {
+        buffer.setHSV(pixel, h, s, v);
+    }
+
+    @Override
+    public Color getColor(int pixel) {
+        return buffer.getLED(pixel);
+    }
+
+    @Override
+    public Color8Bit getColor8Bit(int pixel) {
+        return new Color8Bit(getColor(pixel));
+    }
+
+    @Override
+    public LEDStrip getPhysicalStrip() {
+        return this;
+    }
+}

src/main/java/frc/robot/LEDAnimationKit/animations/Alternate.java

@@ -0,0 +1,46 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class Alternate extends Animation {
+    private Color8Bit[] colors;
+    private int alternateSize;
+    private int alternateInt;
+
+    public Alternate(LEDStrip strip, double timeDelay, Color8Bit[] colors, int alternateSize) {
+        super(strip, timeDelay);
+        this.colors = colors;
+        this.alternateSize = alternateSize;
+        alternateInt = 0;
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            for(int i = 0; i < strip.getNumLEDs(); i += alternateSize) {
+                Color8Bit targetColor = colors[((i / alternateSize) + alternateInt) % colors.length];
+
+                for(int j = i; j < i + alternateSize; j++) {
+                    strip.setRGBColor(j, targetColor);
+                }
+            }
+
+            alternateInt++;
+
+            if(alternateInt >= colors.length) {
+                alternateInt = 0;
+            }
+
+            resetTiming();
+
+            return true;
+        }
+
+        return false;
+    }
+
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/Breathing.java

@@ -0,0 +1,57 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class Breathing extends Animation{
+    private Color8Bit originalColor;
+    private double minPercentage;
+    private double maxPercentage;
+    private double currentPercentage;
+    private double currentAdditive;
+
+    public Breathing(LEDStrip strip, double timeDelay, Color8Bit originalColor, double minPercentage, double maxPercentage) {
+        super(strip, timeDelay);
+        
+        this.originalColor = originalColor;
+        this.minPercentage = minPercentage;
+        this.maxPercentage = maxPercentage;
+        currentPercentage = minPercentage;
+        currentAdditive = 1;
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            Color8Bit nextColor = new Color8Bit(
+                (int)(originalColor.red * currentPercentage / 100.0), 
+                (int)(originalColor.green * currentPercentage / 100.0),
+                (int)(originalColor.blue * currentPercentage / 100.0));
+
+            for(int i = 0; i < strip.getNumLEDs(); i++) {
+                strip.setRGBColor(i, nextColor);
+            }
+
+            currentPercentage += currentAdditive;
+
+            if(currentAdditive > 0) {
+                if(currentPercentage > maxPercentage) {
+                    currentAdditive *= -1;
+                }
+            } else {
+                if(currentPercentage < minPercentage) {
+                    currentAdditive *= -1;
+                }
+            }
+
+            resetTiming();
+
+            return true;
+        }
+
+        return false;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/Collision.java

@@ -0,0 +1,57 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class Collision extends Animation {
+    private Color8Bit color1;
+    private Color8Bit color2;
+
+    private int collisionInt;
+
+    public Collision(LEDStrip strip, double timeDelay, Color8Bit color1, Color8Bit color2) {
+        super(strip, timeDelay);
+        
+        this.color1 = color1;
+        this.color2 = color2;
+
+        collisionInt = 0;
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            if(collisionInt == 0) {
+                for(int i = 0; i < strip.getNumLEDs(); i++) {
+                    strip.setRGBColor(i, 0, 0, 0);
+                }
+
+                strip.setRGBColor(0, color1);
+                strip.setRGBColor(strip.getNumLEDs() - 1, color2);
+
+                collisionInt++;
+
+                resetTiming();
+                return true;
+            } else if(collisionInt < strip.getNumLEDs()) {
+                strip.setRGBColor(collisionInt, color1);
+                strip.setRGBColor(strip.getNumLEDs() - collisionInt - 1, color2);
+
+                collisionInt++;
+
+                resetTiming();
+                return true;
+            } else {
+                collisionInt = 0;
+
+                //Don't reset timing here. 
+                //Forces an immediate update to clear the LEDs
+                return false;
+            }
+        }
+        return false;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/ColorRandomizer.java

@@ -0,0 +1,116 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import java.util.Random;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class ColorRandomizer extends Animation {
+    private Color[] colors;
+    private Color[] fadingValues;
+    private Random random;
+    private int colorRandomizerInt;
+    private int fadeScale;
+    private boolean shouldFade;
+    private boolean isFading;
+
+    public ColorRandomizer(LEDStrip strip, double timeDelay, Color8Bit[] colors, 
+        boolean shouldFade, int fadeScale) {
+        super(strip, timeDelay);
+        
+        this.colors = new Color[colors.length];
+
+        for(int i = 0; i < colors.length; i++) {
+            this.colors[i] = new Color(colors[i]);
+        }
+
+        random = new Random();
+
+        fadingValues = new Color[colors.length];
+
+        this.shouldFade = shouldFade;
+        this.fadeScale = fadeScale;
+        colorRandomizerInt = 0;
+        isFading = false;
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            if(shouldFade && isFading) {
+                if(colorRandomizerInt == 0) {
+                    for(int i = 0; i < strip.getNumLEDs(); i++) {
+                        Color currentColor = strip.getColor(i);
+
+                        fadingValues[i] = new Color(
+                            currentColor.red / fadeScale,
+                            currentColor.green / fadeScale,
+                            currentColor.blue / fadeScale
+                        );
+                    }
+
+                    colorRandomizerInt++;
+                } else if(colorRandomizerInt > 0 && colorRandomizerInt < fadeScale + 1) {
+                    for(int i = 0; i < strip.getNumLEDs(); i++) {
+                        Color currentColor = strip.getColor(i);
+                        double nextRed = 0;
+                        double nextGreen = 0;
+                        double nextBlue = 0;
+
+                        if(currentColor.red == 0) {
+                            nextRed = 0;
+                        } else if(currentColor.red - fadingValues[i].red < 0) {
+                            nextRed = 0;
+                        } else {
+                            nextRed = currentColor.red - fadingValues[i].red;
+                        }
+
+                        if(currentColor.green == 0) {
+                            nextGreen = 0;
+                        } else if(currentColor.green - fadingValues[i].green < 0) {
+                            nextGreen = 0;
+                        } else {
+                            nextGreen = currentColor.green - fadingValues[i].green;
+                        }
+
+                        if(currentColor.blue == 0) {
+                            nextBlue = 0;
+                        } else if(currentColor.blue - fadingValues[i].blue < 0) {
+                            nextBlue = 0;
+                        } else {
+                            nextBlue = currentColor.blue - fadingValues[i].blue;
+                        }
+
+                        strip.setRGBColor(i, new Color(nextRed, nextGreen, nextBlue));
+                    }
+
+                    colorRandomizerInt++;
+
+                    resetTiming();
+
+                    return true;
+                } else {
+                    colorRandomizerInt = 0;
+                    isFading = false;
+                }
+            } else { 
+                for(int i = 0; i < strip.getNumLEDs(); i++) {
+                    strip.setRGBColor(i, colors[random.nextInt(colors.length)]);
+                }
+
+                if(shouldFade) {
+                    isFading = true;
+                }
+
+                resetTiming();
+                return true;
+            }
+        }
+
+        return false;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/CycleLight.java

@@ -0,0 +1,58 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class CycleLight extends Animation {
+    private Color8Bit[] colors;
+    private int cycleLightInt;
+    private int currentColorIndex;
+
+    public CycleLight(LEDStrip strip, double timeDelay, Color8Bit[] colors) {
+        super(strip, timeDelay);
+        
+        this.colors = colors;
+
+        cycleLightInt = 0;
+        currentColorIndex = 0;
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            if(cycleLightInt == 0) {
+                for(int i = 0; i < strip.getNumLEDs(); i++) {
+                    strip.setRGBColor(i, 0, 0, 0);
+                }
+    
+                strip.setRGBColor(cycleLightInt, colors[currentColorIndex]);
+                cycleLightInt++;
+
+                resetTiming();
+
+                return true;
+            } else if(cycleLightInt < strip.getNumLEDs()) {
+                strip.setRGBColor(cycleLightInt, colors[currentColorIndex]);
+                cycleLightInt++;
+
+                resetTiming();
+
+                return true;
+            } else {
+                cycleLightInt = 0;
+
+                currentColorIndex++;
+
+                if(currentColorIndex >= colors.length) {
+                    currentColorIndex = 0;
+                }
+            }
+        } 
+
+        return false;
+    }
+
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/FluidRainbow.java

@@ -0,0 +1,31 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+public class FluidRainbow extends Animation{
+
+    private int hsvShift;
+
+    public FluidRainbow(LEDStrip strip, double timeDelay) {
+        super(strip, timeDelay);
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            for(int i = 0; i < strip.getNumLEDs(); i++) {
+                strip.setHSVColor(i, i + (hsvShift % 180), 255, 255);
+            }
+    
+            hsvShift++;
+
+            resetTiming();
+
+            return true;
+        }
+        
+        return false;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/IndicatorLight.java

@@ -0,0 +1,35 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import java.util.function.Supplier;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class IndicatorLight extends Animation {
+    private Supplier<Boolean> indicatorSupplier;
+    private Color8Bit color;
+
+    public IndicatorLight(LEDStrip strip, double timeDelay, Supplier<Boolean> indicatorSupplier, Color8Bit color) {
+        super(strip, timeDelay);
+        
+        this.indicatorSupplier = indicatorSupplier;
+        this.color = color;
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            for(int i = 0; i < strip.getNumLEDs(); i++) {
+                strip.setRGBColor(i, indicatorSupplier.get() ? new Color(color) : Color.kBlack);
+            }
+
+            resetTiming();
+
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/frc/robot/LEDAnimationKit/animations/InputMeter.java

@@ -0,0 +1,72 @@
+package frc.robot.LEDAnimationKit.animations;
+
+import java.util.function.Supplier;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip;
+
+import edu.wpi.first.wpilibj.util.Color;
+
+public class InputMeter extends Animation {
+    private Supplier<Double> inputSupplier;
+    private double minValue;
+    private double maxValue;
+
+    private int yellowStartPixel;
+    private int redStartPixel;
+
+
+    public InputMeter(LEDStrip strip, double timeDelay, Supplier<Double> inputSupplier, 
+        double minValue, double maxValue) {
+        super(strip, timeDelay);
+        
+        this.inputSupplier = inputSupplier;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+
+        redStartPixel = (int)(strip.getNumLEDs() - Math.ceil(strip.getNumLEDs() * .1));
+        yellowStartPixel = (int)(strip.getNumLEDs() - Math.ceil(strip.getNumLEDs() * .1) - Math.ceil(strip.getNumLEDs() * .2));
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            int remappedInput = (int)remapInput(inputSupplier.get(), minValue, maxValue, 0, strip.getNumLEDs()-1);
+
+            if(remappedInput > yellowStartPixel) {
+                for(int i = 0; i < yellowStartPixel; i++) {
+                    strip.setRGBColor(i, Color.kGreen);
+                }
+
+                if(remappedInput > redStartPixel) {
+                    for(int i = yellowStartPixel; i < redStartPixel; i++) {
+                        strip.setRGBColor(i, Color.kYellow);
+                    }
+
+                    for(int i = redStartPixel; i < remappedInput; i++) {
+                        strip.setRGBColor(i, Color.kRed);
+                    }
+                } else {
+                    for(int i = yellowStartPixel; i < remappedInput; i++) {
+                        strip.setRGBColor(i, Color.kYellow);
+                    }
+                }
+            } else {
+                for(int i = 0; i < remappedInput; i++) {
+                    strip.setRGBColor(i, Color.kGreen);
+                }
+            }
+
+            resetTiming();
+
+            return true;
+        }
+
+        return false;
+    }
+
+    private double remapInput(double x, double inMin, double inMax, double outMin, double outMax) {
+        return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/animations2D/Ricochet2D.java

@@ -0,0 +1,56 @@
+package frc.robot.LEDAnimationKit.animations.animations2D;
+
+import java.util.Random;
+
+import frc.robot.LEDAnimationKit.Animation;
+import frc.robot.LEDAnimationKit.LEDStrip2DWrapper;
+
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class Ricochet2D extends Animation {
+    private RicochetHelper[] helpers;
+    private Random random;
+    private LEDStrip2DWrapper wrapper;
+
+    public Ricochet2D(LEDStrip2DWrapper wrapper, double timeDelay, 
+        int numBalls, Color8Bit[] colors) {
+
+        super(wrapper, timeDelay);
+        this.wrapper = wrapper;
+
+        helpers = new RicochetHelper[numBalls];
+        random = new Random();
+
+        for(int i = 0; i < numBalls; i++) {
+            helpers[i] = new RicochetHelper(random.nextInt(wrapper.getWidth()), 
+                random.nextInt(wrapper.getHeight()), wrapper.getWidth(), 
+                wrapper.getHeight(), colors[random.nextInt(colors.length)]);
+        }
+    }
+
+    @Override
+    public boolean update() {
+        if(shouldUpdate()) {
+            for(int i = 0; i < wrapper.getWidth(); i++) {
+                for(int j = 0; j < wrapper.getHeight(); j++) {
+                    wrapper.setRGBColor(i, j, 0, 0, 0);
+                }
+            }
+
+            for(int i = 0; i < helpers.length; i++) {
+                helpers[i].updatePosition();
+
+                wrapper.setRGBColor(helpers[i].getCurrentXPosition(), 
+                    helpers[i].getCurrentYPosition(), 
+                    helpers[i].getCurrentColor());
+            }
+
+            resetTiming();
+
+            return true;
+        }
+        
+        return false;
+    }
+    
+}

src/main/java/frc/robot/LEDAnimationKit/animations/animations2D/RicochetHelper.java

@@ -0,0 +1,68 @@
+package frc.robot.LEDAnimationKit.animations.animations2D;
+
+import java.util.Random;
+
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class RicochetHelper {
+    private int currentX;
+    private int currentY;
+    private int width;
+    private int height;
+    private int xDirection;
+    private int yDirection;
+    private Color8Bit color;
+    private Random random;
+
+    public RicochetHelper(int currentX, int currentY, int width, 
+        int height, Color8Bit color) {
+        this.currentX = currentX;
+        this.currentY = currentY;
+        this.width = width;
+        this.height = height;
+        this.color = color;
+
+        random = new Random();
+
+        if(currentX == 0) {
+            xDirection = 1;
+        } else if(currentX == width - 1) {
+            xDirection = -1;
+        } else {
+            xDirection = random.nextBoolean() ? -1 : 1;
+        }
+
+        if(currentY == 0) {
+            yDirection = 1;
+        } else if(currentY == height - 1) {
+            yDirection = -1;
+        } else {
+            yDirection = random.nextBoolean() ? -1 : 1;
+        }
+    }
+
+    public int getCurrentXPosition() {
+        return currentX;
+    }
+
+    public int getCurrentYPosition() {
+        return currentY;
+    }
+
+    public Color8Bit getCurrentColor() {
+        return color;
+    }
+
+    public void updatePosition() {
+        if(currentX + xDirection >= width || currentX + xDirection < 0) {
+            xDirection *= -1;
+        }
+
+        if(currentY + yDirection >= height || currentY + yDirection < 0) {
+            yDirection *= -1;
+        }
+
+        currentX += xDirection;
+        currentY += yDirection;
+    }
+}

src/main/java/frc/robot/Main.java

@@ -0,0 +1,15 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot;
+
+import edu.wpi.first.wpilibj.RobotBase;
+
+public final class Main {
+  private Main() {}
+
+  public static void main(String... args) {
+    RobotBase.startRobot(Robot::new);
+  }
+}

src/main/java/frc/robot/Robot.java

@@ -0,0 +1,73 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot;
+
+import edu.wpi.first.wpilibj.TimedRobot;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.CommandScheduler;
+
+public class Robot extends TimedRobot {
+  private Command m_autonomousCommand;
+
+  private RobotContainer m_robotContainer;
+
+  @Override
+  public void robotInit() {
+    m_robotContainer = new RobotContainer();
+  }
+
+  @Override
+  public void robotPeriodic() {
+    CommandScheduler.getInstance().run();
+  }
+
+  @Override
+  public void disabledInit() {}
+
+  @Override
+  public void disabledPeriodic() {}
+
+  @Override
+  public void disabledExit() {}
+
+  @Override
+  public void autonomousInit() {
+    m_autonomousCommand = m_robotContainer.getAutonomousCommand();
+
+    if (m_autonomousCommand != null) {
+      m_autonomousCommand.schedule();
+    }
+  }
+
+  @Override
+  public void autonomousPeriodic() {}
+
+  @Override
+  public void autonomousExit() {}
+
+  @Override
+  public void teleopInit() {
+    if (m_autonomousCommand != null) {
+      m_autonomousCommand.cancel();
+    }
+  }
+
+  @Override
+  public void teleopPeriodic() {}
+
+  @Override
+  public void teleopExit() {}
+
+  @Override
+  public void testInit() {
+    CommandScheduler.getInstance().cancelAll();
+  }
+
+  @Override
+  public void testPeriodic() {}
+
+  @Override
+  public void testExit() {}
+}

src/main/java/frc/robot/RobotContainer.java

@@ -0,0 +1,130 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot;
+
+import edu.wpi.first.wpilibj.shuffleboard.BuiltInWidgets;
+import edu.wpi.first.wpilibj.shuffleboard.Shuffleboard;
+import edu.wpi.first.wpilibj.shuffleboard.ShuffleboardTab;
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.Commands;
+import edu.wpi.first.wpilibj2.command.button.CommandXboxController;
+import frc.robot.LEDAnimationKit.AnimationManager;
+import frc.robot.LEDAnimationKit.LEDStrip;
+import frc.robot.LEDAnimationKit.LogicalLEDStrip;
+import frc.robot.LEDAnimationKit.PhysicalLEDStrip;
+import frc.robot.LEDAnimationKit.animations.Breathing;
+import frc.robot.LEDAnimationKit.animations.FluidRainbow;
+import frc.robot.constants.LEDConstants;
+import frc.robot.constants.OIConstants;
+import frc.robot.subsystems.Drivetrain;
+import frc.robot.subsystems.Pusher;
+import frc.robot.subsystems.Shooter;
+
+public class RobotContainer {
+  private Drivetrain drivetrain;
+  private Shooter shooter;
+  private Pusher pusher;
+
+  private CommandXboxController driver;
+
+  private PhysicalLEDStrip strip;
+
+  private LogicalLEDStrip l1;
+  private LogicalLEDStrip l2;
+
+  private AnimationManager manager;
+
+  //private FluidRainbow rainbow;
+
+  private Breathing b1;
+  private Breathing b2;
+
+  public RobotContainer() {
+    drivetrain = new Drivetrain(true);
+    shooter = new Shooter();
+    pusher = new Pusher();
+
+    driver = new CommandXboxController(OIConstants.kDriverUSB);
+
+    strip = new PhysicalLEDStrip(
+      LEDConstants.kLEDPWM, 
+      LEDConstants.kNumLEDs
+    );
+    strip.start();
+
+    //rainbow = new FluidRainbow(strip, LEDConstants.kRainbowUpdateRate);
+    //rainbow.start();
+    l1 = new LogicalLEDStrip(strip, 0, 31);
+    l2 = new LogicalLEDStrip(strip, 31, 62);
+
+    
+
+    b1 = new Breathing(
+      l1, 
+      LEDConstants.kBreathingUpdateRate, 
+      new Color8Bit(Color.kPurple), 
+      LEDConstants.kBreathingMinPercentage, 
+      LEDConstants.kBreathingMaxPercentage
+    );
+    b1.start();
+
+    b2 = new Breathing(
+      l2, 
+      LEDConstants.kBreathingUpdateRate, 
+      new Color8Bit(255, 64, 0), 
+      LEDConstants.kBreathingMinPercentage, 
+      LEDConstants.kBreathingMaxPercentage
+    );
+    b2.start();
+
+    manager = new AnimationManager(new PhysicalLEDStrip[] {strip});
+    //manager.registerAnimationForUpdate(rainbow);
+    manager.registerAnimationForUpdate(b1);
+    manager.registerAnimationForUpdate(b2);
+    manager.start(LEDConstants.kAnimationManagerUpdateRate);
+
+    configureBindings();
+    configureShuffleboard();
+
+    System.out.println("Setup completed");
+  }
+
+  private void configureBindings() {
+    drivetrain.setDefaultCommand(
+      drivetrain.arcadeDrive(
+        driver::getLeftY, 
+        driver::getLeftX
+      )
+    );
+
+    driver.start().onTrue(drivetrain.toggleSlowMode());
+
+    shooter.setDefaultCommand(
+      shooter.setSpeed(
+        driver::getRightTriggerAxis
+      )
+    );
+
+    driver.a().onTrue(pusher.spin());
+    driver.a().onFalse(pusher.stop());
+  }
+
+  private void configureShuffleboard() {
+    ShuffleboardTab tab = Shuffleboard.getTab("DRIVE");
+
+    tab.addBoolean("Slow Mode?", drivetrain::isSlowMode)
+      .withPosition(0, 0)
+      .withSize(2, 1)
+      .withWidget(BuiltInWidgets.kBooleanBox);
+
+    Shuffleboard.selectTab("DRIVE");
+  }
+
+  public Command getAutonomousCommand() {
+    return Commands.print("No autonomous command configured");
+  }
+}

src/main/java/frc/robot/constants/DrivetrainConstants.java

@@ -0,0 +1,13 @@
+package frc.robot.constants;
+
+public class DrivetrainConstants {
+    public static final int kFrontLeftPWM = 0;
+    public static final int kRearLeftPWM = 1;
+    public static final int kFrontRightPWM = 2;
+    public static final int kRearRightPWM = 3;
+
+    public static final double kSlowModeMultiplier = .75;
+
+    public static final boolean kInvertForwardBackward = true;
+    public static final boolean kInvertLeftRight = true;
+}

src/main/java/frc/robot/constants/LEDConstants.java

@@ -0,0 +1,13 @@
+package frc.robot.constants;
+
+public class LEDConstants {
+    public static final int kLEDPWM = 8;
+
+    public static final int kNumLEDs = 19 * 2 + 12 * 2;
+
+    public static final double kRainbowUpdateRate = .02;
+    public static final double kBreathingUpdateRate = .03;
+    public static final double kBreathingMinPercentage = 25;
+    public static final double kBreathingMaxPercentage = 100;
+    public static final double kAnimationManagerUpdateRate = .01;
+}

src/main/java/frc/robot/constants/OIConstants.java

@@ -0,0 +1,5 @@
+package frc.robot.constants;
+
+public class OIConstants {
+    public static final int kDriverUSB = 0;
+}

src/main/java/frc/robot/constants/PusherConstants.java

@@ -0,0 +1,12 @@
+package frc.robot.constants;
+
+import edu.wpi.first.wpilibj.SerialPort;
+
+public class PusherConstants {
+    public static final int kBaudRate = 9600;
+
+    public static final SerialPort.Port kPort = SerialPort.Port.kUSB1;
+
+    public static final String kStopString = "s0~";
+    public static final String kSpinString = "s-250~";
+}

src/main/java/frc/robot/constants/ShooterConstants.java

@@ -0,0 +1,6 @@
+package frc.robot.constants;
+
+public class ShooterConstants {
+    public static final int kFrontShooterCAN = 1;
+    public static final int kRearShooterCAN = 2;
+}

src/main/java/frc/robot/subsystems/Drivetrain.java

@@ -0,0 +1,67 @@
+package frc.robot.subsystems;
+
+import java.util.function.DoubleSupplier;
+
+import edu.wpi.first.wpilibj.drive.DifferentialDrive;
+import edu.wpi.first.wpilibj.motorcontrol.VictorSP;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+import frc.robot.constants.DrivetrainConstants;
+
+public class Drivetrain extends SubsystemBase {
+    private VictorSP frontLeft;
+    private VictorSP rearLeft;
+    private VictorSP frontRight;
+    private VictorSP rearRight;
+
+    private DifferentialDrive drive;
+
+    private boolean slowMode;
+
+    public Drivetrain(boolean slowModeAtStartup) {
+        frontLeft = new VictorSP(DrivetrainConstants.kFrontLeftPWM);
+        rearLeft = new VictorSP(DrivetrainConstants.kRearLeftPWM);
+        frontRight = new VictorSP(DrivetrainConstants.kFrontRightPWM);
+        rearRight = new VictorSP(DrivetrainConstants.kRearRightPWM);
+
+        frontLeft.addFollower(rearLeft);
+        frontRight.addFollower(rearRight);
+        frontRight.setInverted(true);
+
+        drive = new DifferentialDrive(frontLeft, frontRight);
+
+        slowMode = slowModeAtStartup;
+    }
+
+    public boolean isSlowMode() {
+        return slowMode;
+    }
+
+    public Command toggleSlowMode() {
+        return runOnce(() -> {
+            slowMode = !slowMode;
+        });
+    }
+
+    public Command tankDrive(DoubleSupplier leftSpeed, DoubleSupplier rightSpeed) {
+        return run(() -> {
+            drive.tankDrive(
+                (DrivetrainConstants.kInvertForwardBackward ? -1 : 1) * leftSpeed.getAsDouble() * (slowMode ? .75 : 1), 
+                (DrivetrainConstants.kInvertForwardBackward ? -1 : 1) * rightSpeed.getAsDouble() * (slowMode ? .75 : 1)
+            );
+        });
+    }
+
+    public Command arcadeDrive(DoubleSupplier speed, DoubleSupplier rotation) {
+        return run(() -> {
+            drive.arcadeDrive(
+                (DrivetrainConstants.kInvertForwardBackward ? -1 : 1) * speed.getAsDouble() * (slowMode ? DrivetrainConstants.kSlowModeMultiplier : 1), 
+                (DrivetrainConstants.kInvertLeftRight ? -1 : 1) * rotation.getAsDouble() * (slowMode ? DrivetrainConstants.kSlowModeMultiplier : 1)
+            );
+        });
+    }
+
+    public Command stop() {
+        return tankDrive(() -> 0, () -> 0);
+    }
+}

src/main/java/frc/robot/subsystems/Pusher.java

@@ -0,0 +1,34 @@
+package frc.robot.subsystems;
+
+import edu.wpi.first.wpilibj.SerialPort;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+import frc.robot.constants.PusherConstants;
+
+public class Pusher extends SubsystemBase {
+    private SerialPort pusher;
+
+    public Pusher() {
+        pusher = new SerialPort(
+            PusherConstants.kBaudRate, 
+            PusherConstants.kPort
+        );
+
+        pusher.writeString(PusherConstants.kStopString);
+        pusher.flush();
+    }
+
+    public Command spin() {
+        return runOnce(() -> {
+            pusher.writeString(PusherConstants.kSpinString);
+            pusher.flush();
+        });
+    }
+
+    public Command stop() {
+        return runOnce(() -> {
+            pusher.writeString(PusherConstants.kStopString);
+            pusher.flush();
+        });
+    }
+}

src/main/java/frc/robot/subsystems/Shooter.java

@@ -0,0 +1,31 @@
+package frc.robot.subsystems;
+
+import java.util.function.DoubleSupplier;
+
+import com.revrobotics.spark.SparkMax;
+import com.revrobotics.spark.SparkLowLevel.MotorType;
+
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+import frc.robot.constants.ShooterConstants;
+
+public class Shooter extends SubsystemBase {
+    private SparkMax frontShooter;
+    private SparkMax rearShooter;
+
+    public Shooter() {
+        frontShooter = new SparkMax(ShooterConstants.kFrontShooterCAN, MotorType.kBrushless);
+        rearShooter = new SparkMax(ShooterConstants.kRearShooterCAN, MotorType.kBrushless);
+    }
+
+    public Command setSpeed(DoubleSupplier speed) {
+        return run(() -> {
+            frontShooter.set(speed.getAsDouble());
+            rearShooter.set(speed.getAsDouble());
+        });
+    }
+
+    public Command stop() {
+        return setSpeed(() -> 0);
+    }
+}

vendordeps/REVLib.json

@@ -0,0 +1,71 @@
+{
+    "fileName": "REVLib.json",
+    "name": "REVLib",
+    "version": "2025.0.3",
+    "frcYear": "2025",
+    "uuid": "3f48eb8c-50fe-43a6-9cb7-44c86353c4cb",
+    "mavenUrls": [
+        "https://maven.revrobotics.com/"
+    ],
+    "jsonUrl": "https://software-metadata.revrobotics.com/REVLib-2025.json",
+    "javaDependencies": [
+        {
+            "groupId": "com.revrobotics.frc",
+            "artifactId": "REVLib-java",
+            "version": "2025.0.3"
+        }
+    ],
+    "jniDependencies": [
+        {
+            "groupId": "com.revrobotics.frc",
+            "artifactId": "REVLib-driver",
+            "version": "2025.0.3",
+            "skipInvalidPlatforms": true,
+            "isJar": false,
+            "validPlatforms": [
+                "windowsx86-64",
+                "linuxarm64",
+                "linuxx86-64",
+                "linuxathena",
+                "linuxarm32",
+                "osxuniversal"
+            ]
+        }
+    ],
+    "cppDependencies": [
+        {
+            "groupId": "com.revrobotics.frc",
+            "artifactId": "REVLib-cpp",
+            "version": "2025.0.3",
+            "libName": "REVLib",
+            "headerClassifier": "headers",
+            "sharedLibrary": false,
+            "skipInvalidPlatforms": true,
+            "binaryPlatforms": [
+                "windowsx86-64",
+                "linuxarm64",
+                "linuxx86-64",
+                "linuxathena",
+                "linuxarm32",
+                "osxuniversal"
+            ]
+        },
+        {
+            "groupId": "com.revrobotics.frc",
+            "artifactId": "REVLib-driver",
+            "version": "2025.0.3",
+            "libName": "REVLibDriver",
+            "headerClassifier": "headers",
+            "sharedLibrary": false,
+            "skipInvalidPlatforms": true,
+            "binaryPlatforms": [
+                "windowsx86-64",
+                "linuxarm64",
+                "linuxx86-64",
+                "linuxathena",
+                "linuxarm32",
+                "osxuniversal"
+            ]
+        }
+    ]
+}

vendordeps/WPILibNewCommands.json

@@ -0,0 +1,38 @@
+{
+  "fileName": "WPILibNewCommands.json",
+  "name": "WPILib-New-Commands",
+  "version": "1.0.0",
+  "uuid": "111e20f7-815e-48f8-9dd6-e675ce75b266",
+  "frcYear": "2025",
+  "mavenUrls": [],
+  "jsonUrl": "",
+  "javaDependencies": [
+    {
+      "groupId": "edu.wpi.first.wpilibNewCommands",
+      "artifactId": "wpilibNewCommands-java",
+      "version": "wpilib"
+    }
+  ],
+  "jniDependencies": [],
+  "cppDependencies": [
+    {
+      "groupId": "edu.wpi.first.wpilibNewCommands",
+      "artifactId": "wpilibNewCommands-cpp",
+      "version": "wpilib",
+      "libName": "wpilibNewCommands",
+      "headerClassifier": "headers",
+      "sourcesClassifier": "sources",
+      "sharedLibrary": true,
+      "skipInvalidPlatforms": true,
+      "binaryPlatforms": [
+        "linuxathena",
+        "linuxarm32",
+        "linuxarm64",
+        "windowsx86-64",
+        "windowsx86",
+        "linuxx86-64",
+        "osxuniversal"
+      ]
+    }
+  ]
+}