diff --git a/frc971/control_loops/drivetrain/drivetrain.cc b/frc971/control_loops/drivetrain/drivetrain.cc
index 218ab8c..c88169a 100644
--- a/frc971/control_loops/drivetrain/drivetrain.cc
+++ b/frc971/control_loops/drivetrain/drivetrain.cc
@@ -194,11 +194,11 @@
     // lets just call the average of left and right velocities close enough
     return (loop_->X_hat(1, 0) + loop_->X_hat(3, 0)) / 2;
   }
-  
+
   double GetEstimatedLeftEncoder() const {
     return loop_->X_hat(0, 0);
   }
-  
+
   double GetEstimatedRightEncoder() const {
     return loop_->X_hat(2, 0);
   }
@@ -207,7 +207,7 @@
     return loop_->output_was_capped();
   }
 
-  void SendMotors(Drivetrain::Output *output) const {
+  void SendMotors(DrivetrainQueue::Output *output) const {
     if (output) {
       output->left_voltage = loop_->U(0, 0);
       output->right_voltage = loop_->U(1, 0);
@@ -394,7 +394,7 @@
       }
     }
   }
-  void SetPosition(const Drivetrain::Position *position) {
+  void SetPosition(const DrivetrainQueue::Position *position) {
     const auto &values = constants::GetValues();
     if (position == NULL) {
       ++stale_count_;
@@ -635,7 +635,7 @@
     }
   }
 
-  void SendMotors(Drivetrain::Output *output) {
+  void SendMotors(DrivetrainQueue::Output *output) {
     if (output != NULL) {
       output->left_voltage = loop_->U(0, 0);
       output->right_voltage = loop_->U(1, 0);
@@ -657,8 +657,8 @@
   double position_time_delta_;
   Gear left_gear_;
   Gear right_gear_;
-  Drivetrain::Position last_position_;
-  Drivetrain::Position position_;
+  DrivetrainQueue::Position last_position_;
+  DrivetrainQueue::Position position_;
   int counter_;
 };
 constexpr double PolyDrivetrain::kStallTorque;
@@ -674,10 +674,10 @@
 constexpr double PolyDrivetrain::Kt;
 
 
-void DrivetrainLoop::RunIteration(const Drivetrain::Goal *goal,
-                                  const Drivetrain::Position *position,
-                                  Drivetrain::Output *output,
-                                  Drivetrain::Status * status) {
+void DrivetrainLoop::RunIteration(const DrivetrainQueue::Goal *goal,
+                                  const DrivetrainQueue::Position *position,
+                                  DrivetrainQueue::Output *output,
+                                  DrivetrainQueue::Status * status) {
   // TODO(aschuh): These should be members of the class.
   static DrivetrainMotorsSS dt_closedloop;
   static PolyDrivetrain dt_openloop;
diff --git a/frc971/control_loops/drivetrain/drivetrain.gyp b/frc971/control_loops/drivetrain/drivetrain.gyp
index 8205a25..f1b28f3 100644
--- a/frc971/control_loops/drivetrain/drivetrain.gyp
+++ b/frc971/control_loops/drivetrain/drivetrain.gyp
@@ -1,7 +1,7 @@
 {
   'targets': [
     {
-      'target_name': 'drivetrain_loop',
+      'target_name': 'drivetrain_queue',
       'type': 'static_library',
       'sources': ['drivetrain.q'],
       'variables': {
@@ -37,7 +37,7 @@
         'polydrivetrain_cim_plant.cc',
       ],
       'dependencies': [
-        'drivetrain_loop',
+        'drivetrain_queue',
         '<(AOS)/common/controls/controls.gyp:control_loop',
         '<(DEPTH)/frc971/frc971.gyp:constants',
         '<(AOS)/common/controls/controls.gyp:polytope',
@@ -53,7 +53,7 @@
         '<(DEPTH)/frc971/control_loops/control_loops.gyp:state_feedback_loop',
         '<(DEPTH)/frc971/control_loops/control_loops.gyp:coerce_goal',
         '<(AOS)/common/controls/controls.gyp:control_loop',
-        'drivetrain_loop',
+        'drivetrain_queue',
       ],
     },
     {
@@ -64,7 +64,7 @@
       ],
       'dependencies': [
         '<(EXTERNALS):gtest',
-        'drivetrain_loop',
+        'drivetrain_queue',
         'drivetrain_lib',
         '<(AOS)/common/controls/controls.gyp:control_loop_test',
         '<(DEPTH)/frc971/control_loops/control_loops.gyp:state_feedback_loop',
@@ -81,7 +81,7 @@
       'dependencies': [
         '<(AOS)/linux_code/linux_code.gyp:init',
         'drivetrain_lib',
-        'drivetrain_loop',
+        'drivetrain_queue',
       ],
     },
   ],
diff --git a/frc971/control_loops/drivetrain/drivetrain.h b/frc971/control_loops/drivetrain/drivetrain.h
index f1b0453..decde09 100644
--- a/frc971/control_loops/drivetrain/drivetrain.h
+++ b/frc971/control_loops/drivetrain/drivetrain.h
@@ -13,23 +13,24 @@
 namespace control_loops {
 
 class DrivetrainLoop
-    : public aos::controls::ControlLoop<control_loops::Drivetrain> {
+    : public aos::controls::ControlLoop<control_loops::DrivetrainQueue> {
  public:
   // Constructs a control loop which can take a Drivetrain or defaults to the
   // drivetrain at frc971::control_loops::drivetrain
-  explicit DrivetrainLoop(
-      control_loops::Drivetrain *my_drivetrain = &control_loops::drivetrain)
-      : aos::controls::ControlLoop<control_loops::Drivetrain>(my_drivetrain) {
+  explicit DrivetrainLoop(control_loops::DrivetrainQueue *my_drivetrain =
+                              &control_loops::drivetrain_queue)
+      : aos::controls::ControlLoop<control_loops::DrivetrainQueue>(
+            my_drivetrain) {
     ::aos::controls::HPolytope<0>::Init();
   }
 
  protected:
   // Executes one cycle of the control loop.
   virtual void RunIteration(
-      const control_loops::Drivetrain::Goal *goal,
-      const control_loops::Drivetrain::Position *position,
-      control_loops::Drivetrain::Output *output,
-      control_loops::Drivetrain::Status *status);
+      const control_loops::DrivetrainQueue::Goal *goal,
+      const control_loops::DrivetrainQueue::Position *position,
+      control_loops::DrivetrainQueue::Output *output,
+      control_loops::DrivetrainQueue::Status *status);
 
   typedef ::aos::util::SimpleLogInterval SimpleLogInterval;
   SimpleLogInterval no_position_ = SimpleLogInterval(
diff --git a/frc971/control_loops/drivetrain/drivetrain.q b/frc971/control_loops/drivetrain/drivetrain.q
index 45ced74..ea1324d 100644
--- a/frc971/control_loops/drivetrain/drivetrain.q
+++ b/frc971/control_loops/drivetrain/drivetrain.q
@@ -19,7 +19,7 @@
   double right_velocity;
 };
 
-queue_group Drivetrain {
+queue_group DrivetrainQueue {
   implements aos.control_loops.ControlLoop;
 
   message Goal {
@@ -67,4 +67,4 @@
   queue Status status;
 };
 
-queue_group Drivetrain drivetrain;
+queue_group DrivetrainQueue drivetrain_queue;
diff --git a/frc971/control_loops/drivetrain/drivetrain_lib_test.cc b/frc971/control_loops/drivetrain/drivetrain_lib_test.cc
index b148faf..96583da 100644
--- a/frc971/control_loops/drivetrain/drivetrain_lib_test.cc
+++ b/frc971/control_loops/drivetrain/drivetrain_lib_test.cc
@@ -49,7 +49,7 @@
   DrivetrainSimulation()
       : drivetrain_plant_(
             new StateFeedbackPlant<4, 2, 2>(MakeDrivetrainPlant())),
-        my_drivetrain_loop_(".frc971.control_loops.drivetrain",
+        my_drivetrain_queue_(".frc971.control_loops.drivetrain",
                        0x8a8dde77, ".frc971.control_loops.drivetrain.goal",
                        ".frc971.control_loops.drivetrain.position",
                        ".frc971.control_loops.drivetrain.output",
@@ -76,8 +76,8 @@
     const double left_encoder = GetLeftPosition();
     const double right_encoder = GetRightPosition();
 
-    ::aos::ScopedMessagePtr<control_loops::Drivetrain::Position> position =
-        my_drivetrain_loop_.position.MakeMessage();
+    ::aos::ScopedMessagePtr<control_loops::DrivetrainQueue::Position> position =
+        my_drivetrain_queue_.position.MakeMessage();
     position->left_encoder = left_encoder;
     position->right_encoder = right_encoder;
     position.Send();
@@ -87,15 +87,15 @@
   void Simulate() {
     last_left_position_ = drivetrain_plant_->Y(0, 0);
     last_right_position_ = drivetrain_plant_->Y(1, 0);
-    EXPECT_TRUE(my_drivetrain_loop_.output.FetchLatest());
-    drivetrain_plant_->mutable_U() << my_drivetrain_loop_.output->left_voltage,
-        my_drivetrain_loop_.output->right_voltage;
+    EXPECT_TRUE(my_drivetrain_queue_.output.FetchLatest());
+    drivetrain_plant_->mutable_U() << my_drivetrain_queue_.output->left_voltage,
+        my_drivetrain_queue_.output->right_voltage;
     drivetrain_plant_->Update();
   }
 
   ::std::unique_ptr<StateFeedbackPlant<4, 2, 2>> drivetrain_plant_;
  private:
-  Drivetrain my_drivetrain_loop_;
+  DrivetrainQueue my_drivetrain_queue_;
   double last_left_position_;
   double last_right_position_;
 };
@@ -105,30 +105,30 @@
   // Create a new instance of the test queue so that it invalidates the queue
   // that it points to.  Otherwise, we will have a pointer to shared memory that
   // is no longer valid.
-  Drivetrain my_drivetrain_loop_;
+  DrivetrainQueue my_drivetrain_queue_;
 
   // Create a loop and simulation plant.
   DrivetrainLoop drivetrain_motor_;
   DrivetrainSimulation drivetrain_motor_plant_;
 
-  DrivetrainTest() : my_drivetrain_loop_(".frc971.control_loops.drivetrain",
+  DrivetrainTest() : my_drivetrain_queue_(".frc971.control_loops.drivetrain",
                                0x8a8dde77,
                                ".frc971.control_loops.drivetrain.goal",
                                ".frc971.control_loops.drivetrain.position",
                                ".frc971.control_loops.drivetrain.output",
                                ".frc971.control_loops.drivetrain.status"),
-                drivetrain_motor_(&my_drivetrain_loop_),
+                drivetrain_motor_(&my_drivetrain_queue_),
                 drivetrain_motor_plant_() {
     ::frc971::sensors::gyro_reading.Clear();
   }
 
   void VerifyNearGoal() {
-    my_drivetrain_loop_.goal.FetchLatest();
-    my_drivetrain_loop_.position.FetchLatest();
-    EXPECT_NEAR(my_drivetrain_loop_.goal->left_goal,
+    my_drivetrain_queue_.goal.FetchLatest();
+    my_drivetrain_queue_.position.FetchLatest();
+    EXPECT_NEAR(my_drivetrain_queue_.goal->left_goal,
                 drivetrain_motor_plant_.GetLeftPosition(),
                 1e-2);
-    EXPECT_NEAR(my_drivetrain_loop_.goal->right_goal,
+    EXPECT_NEAR(my_drivetrain_queue_.goal->right_goal,
                 drivetrain_motor_plant_.GetRightPosition(),
                 1e-2);
   }
@@ -140,7 +140,7 @@
 
 // Tests that the drivetrain converges on a goal.
 TEST_F(DrivetrainTest, ConvergesCorrectly) {
-  my_drivetrain_loop_.goal.MakeWithBuilder().control_loop_driving(true)
+  my_drivetrain_queue_.goal.MakeWithBuilder().control_loop_driving(true)
       .left_goal(-1.0)
       .right_goal(1.0).Send();
   for (int i = 0; i < 200; ++i) {
@@ -154,7 +154,7 @@
 
 // Tests that it survives disabling.
 TEST_F(DrivetrainTest, SurvivesDisabling) {
-  my_drivetrain_loop_.goal.MakeWithBuilder().control_loop_driving(true)
+  my_drivetrain_queue_.goal.MakeWithBuilder().control_loop_driving(true)
       .left_goal(-1.0)
       .right_goal(1.0).Send();
   for (int i = 0; i < 500; ++i) {