diff --git a/.gitignore b/.gitignore
index aa724b7..08e7f17 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,5 @@
 .externalNativeBuild
 .cxx
 local.properties
+
+/**/build
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index f9fd68f..91f47a9 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -10,6 +10,7 @@
           <set>
             <option value="$PROJECT_DIR$" />
             <option value="$PROJECT_DIR$/pedro" />
+            <option value="$PROJECT_DIR$/roadrunner" />
           </set>
         </option>
       </GradleProjectSettings>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index e483b6f..2731899 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="FrameworkDetectionExcludesConfiguration">
diff --git a/build.gradle.kts b/build.gradle.kts
index f12339c..8db84cb 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -12,8 +12,7 @@ plugins {
 }
 
 allprojects {
-    version = property("version") as String
-    group = "dev.nextftc"
+    group = "dev.nextftc.extensions"
 }
 
 subprojects {
@@ -23,6 +22,7 @@ subprojects {
             scm {
                 fromGithub("NextFTC", "NextFTC")
             }
+            license("GNU General Public License, version 3", "https://www.gnu.org/licenses/gpl-3.0.html")
             developer("Davis Luxenberg", "davis.luxenberg@outlook.com", url = "https://github.com/BeepBot99")
             developer("Rowan McAlpin", "rowan@nextftc.dev", url = "https://rowanmcalpin.com")
             developer("Zach Harel", "ftc@zharel.me", url = "https://github.com/zachwaffle4")
diff --git a/gradle.properties b/gradle.properties
index f2c995c..a048aa9 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,5 +2,9 @@ kotlin.code.style=official
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
 
-version=1.0.0
-automaticMavenCentralSync=true
\ No newline at end of file
+dev.nextftc.publishing.automaticMavenCentralSync=true
+
+android.useAndroidX=true
+
+versions.roadrunner=1.0.0
+versions.pedro=1.0.0
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index d123e5e..07ba9dd 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,10 +1,12 @@
 [versions]
 kotlin = "2.0.0"
 android = "8.7.3"
-nextftc = "1.0.0-SNAPSHOT"
+nextftc = "1.0.0-beta.2"
 kotest = "5.9.1"
 ftc = "10.3.0"
 pedro = "2.0.0"
+rr-core = "1.0.1"
+rr-ftc = "0.1.25"
 
 [libraries]
 kotest-runner = { module = "io.kotest:kotest-runner-junit5", version.ref = "kotest" }
@@ -18,11 +20,14 @@ ftc-common = { group = "org.firstinspires.ftc", name = "FtcCommon", version.ref
 nextftc-ftc = { group = "dev.nextftc", name = "ftc", version.ref = "nextftc" }
 nextftc-hardware = { group = "dev.nextftc", name = "hardware", version.ref = "nextftc" }
 pedro = { module = "com.pedropathing:ftc", version.ref = "pedro" }
+rr-core = { module = "com.acmerobotics.roadrunner:core", version.ref = "rr-core" }
+rr-ftc = { module = "com.acmerobotics.roadrunner:ftc", version.ref = "rr-ftc" }
 
 [bundles]
 kotest = ["kotest-runner", "kotest-assertations", "kotest-property"]
 ftc = ["ftc-robot-core", "ftc-hardware", "ftc-common"]
 nextftc = ["nextftc-ftc", "nextftc-hardware"]
+roadrunner = ["rr-core", "rr-ftc"]
 
 [plugins]
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
diff --git a/pedro/build.gradle.kts b/pedro/build.gradle.kts
index 3e4f606..af23659 100644
--- a/pedro/build.gradle.kts
+++ b/pedro/build.gradle.kts
@@ -30,15 +30,13 @@ dependencies {
     implementation(libs.bundles.nextftc)
     implementation(libs.pedro)
     compileOnly(libs.bundles.ftc)
-
-    testImplementation(libs.bundles.kotest)
-    testImplementation(libs.mockk)
 }
 
+version = property("versions.pedro") as String
 description =
-    "The hardware library for NextFTC, a user-friendly library for FTC. Includes hardware interfaces, wrapper implementations, and hardware commands."
+    "NextFTC's extension to add support for Pedro Pathing."
 
 nextFTCPublishing {
-    displayName = "NextFTC Hardware"
+    displayName = "NextFTC Extensions - Pedro"
     logoPath = "../assets/logo-icon.svg"
 }
\ No newline at end of file
diff --git a/pedro/src/androidTest/java/dev/nextftc/extensions/ExampleInstrumentedTest.kt b/pedro/src/androidTest/java/dev/nextftc/extensions/ExampleInstrumentedTest.kt
deleted file mode 100644
index b7382bc..0000000
--- a/pedro/src/androidTest/java/dev/nextftc/extensions/ExampleInstrumentedTest.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package dev.nextftc.extensions
-
-import android.support.test.InstrumentationRegistry
-import android.support.test.runner.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("dev.nextftc.extensions.test", appContext.packageName)
-    }
-}
\ No newline at end of file
diff --git a/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/FollowPath.kt b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/FollowPath.kt
new file mode 100644
index 0000000..6ae50a9
--- /dev/null
+++ b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/FollowPath.kt
@@ -0,0 +1,37 @@
+package dev.nextftc.extensions.pedro
+
+import com.pedropathing.paths.Path
+import com.pedropathing.paths.PathChain
+import dev.nextftc.core.commands.Command
+import dev.nextftc.extensions.pedro.PedroComponent.Companion.follower
+
+class FollowPath @JvmOverloads constructor(
+    private val path: PathChain,
+    private val holdEnd: Boolean? = null,
+    private val maxPower: Double? = null
+) : Command() {
+
+    init {
+        require(maxPower == null || holdEnd != null) { "If maxPower is passed, holdEnd must be passed as well." }
+    }
+
+    @JvmOverloads
+    constructor(path: Path, holdEnd: Boolean? = null, maxPower: Double? = null) : this(
+        PathChain(path),
+        holdEnd,
+        maxPower
+    )
+
+    override val isDone: Boolean
+        get() = !follower.isBusy
+
+    override fun start() {
+        if (holdEnd !== null && maxPower !== null) follower.followPath(path, maxPower, holdEnd)
+        else if (holdEnd !== null) follower.followPath(path, holdEnd)
+        else follower.followPath(path)
+    }
+
+    override fun stop(interrupted: Boolean) {
+        if (interrupted) follower.breakFollowing()
+    }
+}
\ No newline at end of file
diff --git a/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/PedroComponent.kt b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/PedroComponent.kt
new file mode 100644
index 0000000..3f3800c
--- /dev/null
+++ b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/PedroComponent.kt
@@ -0,0 +1,37 @@
+package dev.nextftc.extensions.pedro
+
+import com.pedropathing.follower.Follower
+import com.qualcomm.robotcore.hardware.HardwareMap
+import dev.nextftc.core.components.Component
+import dev.nextftc.core.units.Angle
+import dev.nextftc.core.units.rad
+import dev.nextftc.ftc.ActiveOpMode
+import java.util.function.Supplier
+
+class PedroComponent(private val followerFactory: (HardwareMap) -> Follower) : Component {
+
+    override fun preInit() {
+        _follower = followerFactory(ActiveOpMode.hardwareMap)
+    }
+
+    override fun preWaitForStart() = follower.update()
+    override fun preUpdate() = follower.update()
+
+    override fun postStop() {
+        _follower = null
+    }
+
+    companion object {
+        private var _follower: Follower? = null
+
+        @get:JvmName("follower")
+        @JvmStatic
+        val follower: Follower
+            get() = _follower ?: error("Follower not initialized! Make sure you added PedroComponent to your OpMode.")
+
+        @get:JvmName("gyro")
+        @JvmStatic
+        val gyro: Supplier<Angle> = Supplier { follower.totalHeading.rad.normalized }
+
+    }
+}
\ No newline at end of file
diff --git a/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/PedroDriverControlled.kt b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/PedroDriverControlled.kt
new file mode 100644
index 0000000..2de3c92
--- /dev/null
+++ b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/PedroDriverControlled.kt
@@ -0,0 +1,26 @@
+package dev.nextftc.extensions.pedro
+
+import dev.nextftc.extensions.pedro.PedroComponent.Companion.follower
+import dev.nextftc.hardware.driving.DriverControlledCommand
+import java.util.function.Supplier
+
+class PedroDriverControlled @JvmOverloads constructor(
+    drivePower: Supplier<Double>,
+    strafePower: Supplier<Double>,
+    turnPower: Supplier<Double>,
+    private val robotCentric: Boolean = true
+) : DriverControlledCommand(drivePower, strafePower, turnPower) {
+
+    override fun start() {
+        follower.startTeleopDrive()
+    }
+
+    override fun calculateAndSetPowers(powers: DoubleArray) {
+        val (drive, strafe, turn) = powers
+        follower.setTeleOpDrive(drive, strafe, turn, robotCentric)
+    }
+
+    override fun stop(interrupted: Boolean) {
+        if (interrupted) follower.breakFollowing()
+    }
+}
\ No newline at end of file
diff --git a/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/TurnBy.kt b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/TurnBy.kt
new file mode 100644
index 0000000..b29227e
--- /dev/null
+++ b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/TurnBy.kt
@@ -0,0 +1,20 @@
+package dev.nextftc.extensions.pedro
+
+import dev.nextftc.core.commands.Command
+import dev.nextftc.core.units.Angle
+import dev.nextftc.core.units.abs
+import dev.nextftc.extensions.pedro.PedroComponent.Companion.follower
+
+class TurnBy(private val angle: Angle) : Command() {
+
+    init {
+        named("TurnBy($angle)")
+    }
+
+    override val isDone: Boolean
+        get() = !follower.isTurning
+
+    override fun start() {
+        follower.turn(abs(angle).inRad, angle.sign > 0)
+    }
+}
\ No newline at end of file
diff --git a/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/TurnTo.kt b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/TurnTo.kt
new file mode 100644
index 0000000..7f82460
--- /dev/null
+++ b/pedro/src/main/kotlin/dev/nextftc/extensions/pedro/TurnTo.kt
@@ -0,0 +1,19 @@
+package dev.nextftc.extensions.pedro
+
+import dev.nextftc.core.commands.Command
+import dev.nextftc.core.units.Angle
+import dev.nextftc.extensions.pedro.PedroComponent.Companion.follower
+
+class TurnTo(private val angle: Angle) : Command() {
+
+    init {
+        named("TurnTo($angle)")
+    }
+
+    override val isDone: Boolean
+        get() = !follower.isTurning
+
+    override fun start() {
+        follower.turnTo(angle.inRad)
+    }
+}
\ No newline at end of file
diff --git a/pedro/src/test/java/dev/nextftc/extensions/ExampleUnitTest.kt b/pedro/src/test/java/dev/nextftc/extensions/ExampleUnitTest.kt
deleted file mode 100644
index 2abe954..0000000
--- a/pedro/src/test/java/dev/nextftc/extensions/ExampleUnitTest.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package dev.nextftc.extensions
-
-import org.junit.Test
-
-import org.junit.Assert.*
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
\ No newline at end of file
diff --git a/roadrunner/build.gradle.kts b/roadrunner/build.gradle.kts
new file mode 100644
index 0000000..5043733
--- /dev/null
+++ b/roadrunner/build.gradle.kts
@@ -0,0 +1,42 @@
+plugins {
+    kotlin("android")
+    id("com.android.library")
+}
+
+android {
+    namespace = "dev.nextftc.extensions.roadrunner"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+        freeCompilerArgs += "-Xjvm-default=all"
+    }
+
+    publishing {
+        singleVariant("release")
+    }
+}
+
+dependencies {
+    implementation(libs.bundles.nextftc)
+    implementation(libs.bundles.roadrunner)
+    implementation(libs.bundles.ftc)
+}
+
+description =
+    "Support for using RoadRunner with NextFTC."
+
+nextFTCPublishing {
+    displayName = "NextFTC Extensions - RoadRunner"
+    logoPath = "../assets/logo-icon.svg"
+    version = property("versions.roadrunner") as String
+}
\ No newline at end of file
diff --git a/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/FollowTrajectory.kt b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/FollowTrajectory.kt
new file mode 100644
index 0000000..6214e30
--- /dev/null
+++ b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/FollowTrajectory.kt
@@ -0,0 +1,47 @@
+package dev.nextftc.extensions.roadrunner
+
+import com.acmerobotics.roadrunner.Pose2dDual
+import com.acmerobotics.roadrunner.PoseVelocity2d
+import com.acmerobotics.roadrunner.Time
+import com.acmerobotics.roadrunner.TimeTrajectory
+import com.acmerobotics.roadrunner.Trajectory
+import com.acmerobotics.roadrunner.Vector2d
+import com.qualcomm.robotcore.util.ElapsedTime
+import dev.nextftc.core.commands.Command
+
+/**
+ * Follows a trajectory parametrized by time.
+ *
+ * Note that the output of [TrajectoryCommandBuilder.build] only returns a [Command]
+ * object and not a [FollowTrajectory] object,
+ * because the builder sequences the trajectory with other actions,
+ * such as [Turn]s, [dev.nextftc.core.commands.delays.Delay]s or user-specified callbacks.
+ */
+class FollowTrajectory(private val mecanumDrive: NextFTCMecanumDrive, private val trajectory: TimeTrajectory) : Command() {
+    constructor(mecanumDrive: NextFTCMecanumDrive, trajectory: Trajectory) :
+            this(mecanumDrive, TimeTrajectory(trajectory))
+
+    val timer = ElapsedTime()
+
+    override val isDone: Boolean
+        get() = timer.seconds() >= trajectory.duration
+
+    override fun start() {
+        timer.reset()
+    }
+
+    override fun update() {
+        val txWorldTarget: Pose2dDual<Time> = trajectory[timer.seconds()]
+
+        val robotVelRobot: PoseVelocity2d = mecanumDrive.updatePoseEstimate()
+
+        val command =
+            mecanumDrive.controller.compute(txWorldTarget, mecanumDrive.getPose(), robotVelRobot)
+
+        mecanumDrive.setDrivePowersFF(command)
+    }
+
+    override fun stop(interrupted: Boolean) {
+        mecanumDrive.setDrivePowersFF(PoseVelocity2d(Vector2d(0.0, 0.0), 0.0))
+    }
+}
\ No newline at end of file
diff --git a/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/NextFTCMecanumDrive.kt b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/NextFTCMecanumDrive.kt
new file mode 100644
index 0000000..e26ef69
--- /dev/null
+++ b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/NextFTCMecanumDrive.kt
@@ -0,0 +1,27 @@
+package dev.nextftc.extensions.roadrunner
+
+import com.acmerobotics.roadrunner.HolonomicController
+import com.acmerobotics.roadrunner.Pose2d
+import com.acmerobotics.roadrunner.PoseVelocity2d
+import com.acmerobotics.roadrunner.PoseVelocity2dDual
+import com.acmerobotics.roadrunner.Time
+
+/**
+ * Represents a RoadRunner Mecanum drivetrain from the QuickStart.
+ */
+abstract class NextFTCMecanumDrive {
+    abstract val controller: HolonomicController
+
+    abstract fun getPose(): Pose2d
+
+    abstract fun setDrivePowersFF(powers: PoseVelocity2dDual<Time>)
+
+    open fun setDrivePowersFF(powers: PoseVelocity2d) =
+        setDrivePowersFF(PoseVelocity2dDual.constant(powers, 1))
+
+    abstract fun updatePoseEstimate(): PoseVelocity2d
+
+    abstract fun commandBuilder(beginPose: Pose2d): TrajectoryCommandBuilder
+
+    open fun commandBuilder() = commandBuilder(getPose())
+}
\ No newline at end of file
diff --git a/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/TrajectoryCommandBuilder.kt b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/TrajectoryCommandBuilder.kt
new file mode 100644
index 0000000..d4dc6c3
--- /dev/null
+++ b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/TrajectoryCommandBuilder.kt
@@ -0,0 +1,670 @@
+package dev.nextftc.extensions.roadrunner
+
+import com.acmerobotics.roadrunner.AccelConstraint
+import com.acmerobotics.roadrunner.Arclength
+import com.acmerobotics.roadrunner.DualNum
+import com.acmerobotics.roadrunner.IdentityPoseMap
+import com.acmerobotics.roadrunner.Pose2d
+import com.acmerobotics.roadrunner.Pose2dDual
+import com.acmerobotics.roadrunner.PoseMap
+import com.acmerobotics.roadrunner.Rotation2d
+import com.acmerobotics.roadrunner.Rotation2dDual
+import com.acmerobotics.roadrunner.TimeTrajectory
+import com.acmerobotics.roadrunner.TimeTurn
+import com.acmerobotics.roadrunner.TrajectoryBuilder
+import com.acmerobotics.roadrunner.TrajectoryBuilderParams
+import com.acmerobotics.roadrunner.TurnConstraints
+import com.acmerobotics.roadrunner.Vector2d
+import com.acmerobotics.roadrunner.Vector2dDual
+import com.acmerobotics.roadrunner.VelConstraint
+import com.acmerobotics.roadrunner.map
+import dev.nextftc.core.commands.Command
+import dev.nextftc.core.commands.delays.Delay
+import dev.nextftc.core.commands.groups.ParallelGroup
+import dev.nextftc.core.commands.utility.InstantCommand
+import dev.nextftc.core.commands.utility.NullCommand
+import kotlin.time.Duration
+import kotlin.time.DurationUnit
+
+/**
+ * Builder that combines trajectories, turns, and other actions.
+ */
+class TrajectoryCommandBuilder private constructor(
+    // constants
+    val turnCommandFactory: TurnCommandFactory,
+    val trajectoryCommandFactory: TrajectoryCommandFactory,
+    val trajectoryBuilderParams: TrajectoryBuilderParams,
+    val beginEndVel: Double,
+    val baseTurnConstraints: TurnConstraints,
+    val baseVelConstraint: VelConstraint,
+    val baseAccelConstraint: AccelConstraint,
+    val poseMap: PoseMap,
+    // vary throughout
+    private val tb: TrajectoryBuilder,
+    private val n: Int,
+    // lastPose, lastTangent are post-mapped
+    private val lastPoseUnmapped: Pose2d,
+    private val lastPose: Pose2d,
+    private val lastTangent: Rotation2d,
+    private val ms: List<MarkerFactory>,
+    private val cont: (Command) -> Command,
+) {
+    @JvmOverloads
+    constructor(
+        turnCommandFactory: TurnCommandFactory,
+        trajectoryCommandFactory: TrajectoryCommandFactory,
+        trajectoryBuilderParams: TrajectoryBuilderParams,
+        beginPose: Pose2d,
+        beginEndVel: Double,
+        baseTurnConstraints: TurnConstraints,
+        baseVelConstraint: VelConstraint,
+        baseAccelConstraint: AccelConstraint,
+        poseMap: PoseMap = IdentityPoseMap(),
+    ) :
+            this(
+                turnCommandFactory,
+                trajectoryCommandFactory,
+                trajectoryBuilderParams,
+                beginEndVel,
+                baseTurnConstraints,
+                baseVelConstraint,
+                baseAccelConstraint,
+                poseMap,
+                TrajectoryBuilder(
+                    trajectoryBuilderParams,
+                    beginPose, beginEndVel,
+                    baseVelConstraint, baseAccelConstraint,
+                    poseMap,
+                ),
+                0,
+                beginPose,
+                poseMap.map(beginPose),
+                poseMap.map(beginPose).heading,
+                emptyList(),
+                { it },
+            )
+
+    private constructor(
+        ab: TrajectoryCommandBuilder,
+        tb: TrajectoryBuilder,
+        n: Int,
+        lastPoseUnmapped: Pose2d,
+        lastPose: Pose2d,
+        lastTangent: Rotation2d,
+        ms: List<MarkerFactory>,
+        cont: (Command) -> Command,
+    ) :
+            this(
+                ab.turnCommandFactory,
+                ab.trajectoryCommandFactory,
+                ab.trajectoryBuilderParams,
+                ab.beginEndVel,
+                ab.baseTurnConstraints,
+                ab.baseVelConstraint,
+                ab.baseAccelConstraint,
+                ab.poseMap,
+                tb,
+                n,
+                lastPoseUnmapped,
+                lastPose,
+                lastTangent,
+                ms,
+                cont
+            )
+
+    /**
+     * Ends the current trajectory in progress. No-op if no trajectory segments are pending.
+     */
+    fun endTrajectory() =
+        if (n == 0) {
+            require(ms.isEmpty()) { "Cannot end trajectory with pending markers" }
+
+            this
+        } else {
+            val ts = tb.build()
+            val endPoseUnmapped = ts.last().path.basePath.end(1).value()
+            val end = ts.last().path.end(2)
+            val endPose = end.value()
+            val endTangent = end.velocity().value().linearVel.angleCast()
+            TrajectoryCommandBuilder(
+                this,
+                TrajectoryBuilder(
+                    trajectoryBuilderParams,
+                    endPoseUnmapped,
+                    beginEndVel,
+                    baseVelConstraint,
+                    baseAccelConstraint,
+                    poseMap,
+                ),
+                0,
+                endPoseUnmapped,
+                endPose,
+                endTangent,
+                emptyList()
+            ) { tail ->
+                val (aNew, msRem) = ts.zip(ts.scan(0) { acc, t -> acc + t.offsets.size - 1 }).foldRight(
+                    Pair(tail, ms)
+                ) { (traj, offset), (acc, ms) ->
+                    val timeTraj = TimeTrajectory(traj)
+                    val actions = mutableListOf(seqCons(trajectoryCommandFactory.make(timeTraj), acc))
+                    val msRem = mutableListOf<MarkerFactory>()
+                    for (m in ms) {
+                        val i = m.segmentIndex - offset
+                        if (i >= 0) {
+                            actions.add(m.make(timeTraj, traj.offsets[i]))
+                        } else {
+                            msRem.add(m)
+                        }
+                    }
+
+                    when (actions.size) {
+                        0 -> Pair(NullCommand(), msRem)
+                        1 -> Pair(actions.first(), msRem)
+                        else -> Pair(ParallelGroup(*actions.toTypedArray()), msRem)
+                    }
+                }
+
+                require(msRem.isEmpty()) { "Unresolved markers" }
+
+                cont(aNew)
+            }
+        }
+
+    /**
+     * Stops the current trajectory (like [endTrajectory]) and adds command [command] next.
+     */
+    fun stopAndAdd(command: Command): TrajectoryCommandBuilder {
+        val b = endTrajectory()
+        return TrajectoryCommandBuilder(b, b.tb, b.n, b.lastPoseUnmapped, b.lastPose, b.lastTangent, b.ms) { tail ->
+            b.cont(seqCons(command, tail))
+        }
+    }
+    fun stopAndAdd(f: Runnable) = stopAndAdd(InstantCommand("StopAndAdd", f))
+
+    /**
+     * Waits [t] seconds.
+     */
+    fun waitSeconds(t: Double): TrajectoryCommandBuilder {
+        require(t >= 0.0) { "Time ($t) must be non-negative" }
+
+        return stopAndAdd(Delay(t))
+    }
+
+    /**
+     * Waits for the duration of [t].
+     */
+    fun waitSeconds(t: Duration): TrajectoryCommandBuilder {
+        require(t.isPositive()) { "Time ($t) must be non-negative" }
+
+        return stopAndAdd(Delay(t))
+    }
+
+    /**
+     * Schedules command [command] to execute in parallel starting at a displacement [disp] after the last trajectory segment.
+     * The command start is clamped to the span of the current trajectory.
+     *
+     * Cannot be called without an applicable pending trajectory.
+     */
+    // TODO: Should calling this without an applicable trajectory implicitly begin an empty trajectory and execute the
+    // action immediately?
+    fun afterDisplacement(disp: Double, command: Command): TrajectoryCommandBuilder {
+        require(disp >= 0.0) { "Displacement ($disp) must be non-negative" }
+
+        return TrajectoryCommandBuilder(
+            this, tb, n, lastPoseUnmapped, lastPose, lastTangent,
+            ms + listOf(DispMarkerFactory(n, disp, command)), cont
+        )
+    }
+    fun afterDisplacement(disp: Double, f: Runnable) = afterDisplacement(disp, InstantCommand("DispMarker", f))
+
+    /**
+     * Schedules command [command] to execute in parallel starting [duration] seconds after the last trajectory segment, turn, or
+     * other action.
+     */
+    fun afterTime(duration: Double, command: Command): TrajectoryCommandBuilder {
+        require(duration >= 0.0) { "Time ($duration) must be non-negative" }
+
+        return if (n == 0) {
+            TrajectoryCommandBuilder(this, tb, 0, lastPoseUnmapped, lastPose, lastTangent, emptyList()) { tail ->
+                val m = seqCons(Delay(duration), command)
+                if (tail is NullCommand) {
+                    cont(m)
+                } else {
+                    cont(ParallelGroup(tail, m))
+                }
+            }
+        } else {
+            TrajectoryCommandBuilder(
+                this, tb, n, lastPoseUnmapped, lastPose, lastTangent,
+                ms + listOf(TimeMarkerFactory(n, duration, command)), cont
+            )
+        }
+    }
+    fun afterTime(duration: Double, f: Runnable) = afterTime(duration, InstantCommand("TimeMarker", f))
+
+
+    /**
+     * Schedules command [command] to execute in parallel starting [duration] after the last trajectory segment, turn, or
+     * other action.
+     */
+    fun afterTime(duration: Duration, command: Command) = afterTime(duration.toDouble(DurationUnit.SECONDS), command)
+    fun afterTime(duration: Duration, f: Runnable) = afterTime(duration, InstantCommand("TimeMarker", f))
+
+    fun setTangent(r: Rotation2d) =
+        TrajectoryCommandBuilder(this, tb.setTangent(r), n, lastPoseUnmapped, lastPose, lastTangent, ms, cont)
+    fun setTangent(r: Double) = setTangent(Rotation2d.Companion.exp(r))
+
+    fun setReversed(reversed: Boolean) =
+        TrajectoryCommandBuilder(this, tb.setReversed(reversed), n, lastPoseUnmapped, lastPose, lastTangent, ms, cont)
+
+    @JvmOverloads
+    fun turn(angle: Double, turnConstraintsOverride: TurnConstraints? = null): TrajectoryCommandBuilder {
+        val b = endTrajectory()
+        val mappedAngle =
+            poseMap.map(
+                Pose2dDual(
+                    Vector2dDual.Companion.constant(b.lastPose.position, 2),
+                    Rotation2dDual.Companion.constant<Arclength>(b.lastPose.heading, 2) + DualNum(listOf(0.0, angle))
+                )
+            ).heading.velocity().value()
+        val b2 = b.stopAndAdd(
+            turnCommandFactory.make(
+                TimeTurn(b.lastPose, mappedAngle, turnConstraintsOverride ?: baseTurnConstraints)
+            )
+        )
+        val lastPoseUnmapped = Pose2d(b2.lastPoseUnmapped.position, b2.lastPoseUnmapped.heading + angle)
+        val lastPose = Pose2d(b2.lastPose.position, b2.lastPose.heading + mappedAngle)
+        val lastTangent = b2.lastTangent + mappedAngle
+        return TrajectoryCommandBuilder(
+            b2,
+            TrajectoryBuilder(
+                trajectoryBuilderParams,
+                lastPoseUnmapped,
+                beginEndVel,
+                baseVelConstraint,
+                baseAccelConstraint,
+                poseMap
+            ),
+            b2.n, lastPoseUnmapped, lastPose, lastTangent, b2.ms, b2.cont
+        )
+    }
+    @JvmOverloads
+    fun turnTo(heading: Rotation2d, turnConstraintsOverride: TurnConstraints? = null): TrajectoryCommandBuilder {
+        val b = endTrajectory()
+        return b.turn(heading - b.lastPose.heading, turnConstraintsOverride)
+    }
+    @JvmOverloads
+    fun turnTo(heading: Double, turnConstraintsOverride: TurnConstraints? = null) =
+        turnTo(Rotation2d.Companion.exp(heading), turnConstraintsOverride)
+
+    @JvmOverloads
+    fun lineToX(
+        posX: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToX(
+            posX, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToXConstantHeading(
+        posX: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToXConstantHeading(
+            posX, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToXLinearHeading(
+        posX: Double,
+        heading: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToXLinearHeading(
+            posX, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun lineToXLinearHeading(
+        posX: Double,
+        heading: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToXLinearHeading(
+            posX, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToXSplineHeading(
+        posX: Double,
+        heading: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToXSplineHeading(
+            posX, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun lineToXSplineHeading(
+        posX: Double,
+        heading: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToXSplineHeading(
+            posX, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToY(
+        posY: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToY(
+            posY, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToYConstantHeading(
+        posY: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToYConstantHeading(
+            posY, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToYLinearHeading(
+        posY: Double,
+        heading: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToYLinearHeading(
+            posY, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun lineToYLinearHeading(
+        posY: Double,
+        heading: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToYLinearHeading(
+            posY, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun lineToYSplineHeading(
+        posY: Double,
+        heading: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToYSplineHeading(
+            posY, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun lineToYSplineHeading(
+        posY: Double,
+        heading: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.lineToYSplineHeading(
+            posY, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun strafeTo(
+        pos: Vector2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.strafeTo(
+            pos, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun strafeToConstantHeading(
+        pos: Vector2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.strafeToConstantHeading(
+            pos, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun strafeToLinearHeading(
+        pos: Vector2d,
+        heading: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.strafeToLinearHeading(
+            pos, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun strafeToLinearHeading(
+        pos: Vector2d,
+        heading: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.strafeToLinearHeading(
+            pos, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun strafeToSplineHeading(
+        pos: Vector2d,
+        heading: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.strafeToSplineHeading(
+            pos, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun strafeToSplineHeading(
+        pos: Vector2d,
+        heading: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.strafeToSplineHeading(
+            pos, heading, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun splineTo(
+        pos: Vector2d,
+        tangent: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineTo(
+            pos, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun splineTo(
+        pos: Vector2d,
+        tangent: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineTo(
+            pos, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun splineToConstantHeading(
+        pos: Vector2d,
+        tangent: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineToConstantHeading(
+            pos, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun splineToConstantHeading(
+        pos: Vector2d,
+        tangent: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineToConstantHeading(
+            pos, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun splineToLinearHeading(
+        pose: Pose2d,
+        tangent: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineToLinearHeading(
+            pose, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun splineToLinearHeading(
+        pose: Pose2d,
+        tangent: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineToLinearHeading(
+            pose, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    @JvmOverloads
+    fun splineToSplineHeading(
+        pose: Pose2d,
+        tangent: Rotation2d,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineToSplineHeading(
+            pose, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+    @JvmOverloads
+    fun splineToSplineHeading(
+        pose: Pose2d,
+        tangent: Double,
+        velConstraintOverride: VelConstraint? = null,
+        accelConstraintOverride: AccelConstraint? = null
+    ) = TrajectoryCommandBuilder(
+        this,
+        tb.splineToSplineHeading(
+            pose, tangent, velConstraintOverride, accelConstraintOverride
+        ),
+        n + 1, lastPoseUnmapped, lastPose, lastTangent, ms, cont
+    )
+
+    /**
+     * Creates a new builder with the same settings at the current pose, tangent.
+     */
+    fun fresh() = endTrajectory().let {
+        TrajectoryCommandBuilder(
+            it.turnCommandFactory,
+            it.trajectoryCommandFactory,
+            it.trajectoryBuilderParams,
+            it.lastPoseUnmapped,
+            it.beginEndVel, it.baseTurnConstraints, it.baseVelConstraint, it.baseAccelConstraint,
+            it.poseMap
+        ).setTangent(it.lastTangent)
+    }
+
+    /**
+     * Returns the built command.
+     * This command is not a [FollowTrajectory],
+     * but a [ParallelGroup] of [FollowTrajectory]s.
+     */
+    fun build(): Command {
+        return endTrajectory().cont(NullCommand())
+    }
+}
\ No newline at end of file
diff --git a/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/TrajectoryCommandUtilities.kt b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/TrajectoryCommandUtilities.kt
new file mode 100644
index 0000000..3485dfb
--- /dev/null
+++ b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/TrajectoryCommandUtilities.kt
@@ -0,0 +1,44 @@
+package dev.nextftc.extensions.roadrunner
+
+import com.acmerobotics.roadrunner.TimeTrajectory
+import com.acmerobotics.roadrunner.TimeTurn
+import dev.nextftc.core.commands.Command
+import dev.nextftc.core.commands.delays.Delay
+import dev.nextftc.core.commands.groups.SequentialGroup
+import dev.nextftc.core.commands.utility.NullCommand
+
+/**
+ * Utility functions for constructing trajectories and turns;
+ * the name [seqCons] refers to the "cons" operation in functional programming.
+ */
+internal fun seqCons(head: Command, tail: Command): Command =
+    when (tail) {
+        is NullCommand -> head
+        is SequentialGroup -> SequentialGroup(*(arrayOf(head) + tail.commands))
+        else -> SequentialGroup(head, tail)
+    }
+
+internal sealed class MarkerFactory(
+    val segmentIndex: Int,
+) {
+    abstract fun make(t: TimeTrajectory, segmentDisp: Double): Command
+}
+
+internal class TimeMarkerFactory(segmentIndex: Int, val dt: Double, val a: Command) : MarkerFactory(segmentIndex) {
+    override fun make(t: TimeTrajectory, segmentDisp: Double) =
+        seqCons(Delay(t.profile.inverse(segmentDisp) + dt), a)
+}
+
+internal class DispMarkerFactory(segmentIndex: Int, val ds: Double, val a: Command) : MarkerFactory(segmentIndex) {
+    override fun make(t: TimeTrajectory, segmentDisp: Double) =
+        seqCons(Delay(t.profile.inverse(segmentDisp + ds)), a)
+}
+
+fun interface TurnCommandFactory {
+    fun make(turn: TimeTurn): Command
+}
+
+fun interface TrajectoryCommandFactory {
+    fun make(trajectory: TimeTrajectory): Command
+}
+
diff --git a/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/Turn.kt b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/Turn.kt
new file mode 100644
index 0000000..74afa49
--- /dev/null
+++ b/roadrunner/src/main/kotlin/dev/nextftc/extensions/roadrunner/Turn.kt
@@ -0,0 +1,39 @@
+package dev.nextftc.extensions.roadrunner
+
+import com.acmerobotics.roadrunner.Pose2dDual
+import com.acmerobotics.roadrunner.PoseVelocity2d
+import com.acmerobotics.roadrunner.Time
+import com.acmerobotics.roadrunner.TimeTurn
+import com.acmerobotics.roadrunner.Vector2d
+import com.qualcomm.robotcore.util.ElapsedTime
+import dev.nextftc.core.commands.Command
+
+class Turn(private val mecanumDrive: NextFTCMecanumDrive, private val turn: TimeTurn) : Command() {
+    init {
+        named("Turn(${turn.angle}")
+    }
+
+    val timer = ElapsedTime()
+
+    override val isDone: Boolean
+        get() = timer.seconds() >= turn.duration
+
+    override fun start() {
+        timer.reset()
+    }
+
+    override fun update() {
+        val txWorldTarget: Pose2dDual<Time> = turn[timer.seconds()]
+
+        val robotVelRobot: PoseVelocity2d = mecanumDrive.updatePoseEstimate()
+
+        val command =
+            mecanumDrive.controller.compute(txWorldTarget, mecanumDrive.getPose(), robotVelRobot)
+
+        mecanumDrive.setDrivePowersFF(command)
+    }
+
+    override fun stop(interrupted: Boolean) {
+        mecanumDrive.setDrivePowersFF(PoseVelocity2d(Vector2d(0.0, 0.0), 0.0))
+    }
+}
\ No newline at end of file
diff --git a/settings.gradle.kts b/settings.gradle.kts
index ebe1817..e842933 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -15,8 +15,9 @@ dependencyResolutionManagement {
         mavenCentral()
         maven("https://central.sonatype.com/repository/maven-snapshots/")
         maven("https://maven.pedropathing.com/")
+        maven("https://maven.brott.dev/")
     }
 }
 
 rootProject.name = "Extensions"
-include(":pedro")
\ No newline at end of file
+include(":pedro", ":roadrunner")
\ No newline at end of file