diff --git a/y2014/control_loops/claw/claw.cc b/y2014/control_loops/claw/claw.cc
index 00c4341..7322b1e 100644
--- a/y2014/control_loops/claw/claw.cc
+++ b/y2014/control_loops/claw/claw.cc
@@ -364,8 +364,8 @@
   return false;
 }
 
-ClawMotor::ClawMotor(control_loops::ClawGroup *my_claw)
-    : aos::controls::ControlLoop<control_loops::ClawGroup>(my_claw),
+ClawMotor::ClawMotor(control_loops::ClawQueue *my_claw)
+    : aos::controls::ControlLoop<control_loops::ClawQueue>(my_claw),
       has_top_claw_goal_(false),
       top_claw_goal_(0.0),
       top_claw_(this),
@@ -609,10 +609,10 @@
 bool ClawMotor::is_zeroing() const { return !is_ready(); }
 
 // Positive angle is up, and positive power is up.
-void ClawMotor::RunIteration(const control_loops::ClawGroup::Goal *goal,
-                             const control_loops::ClawGroup::Position *position,
-                             control_loops::ClawGroup::Output *output,
-                             control_loops::ClawGroup::Status *status) {
+void ClawMotor::RunIteration(const control_loops::ClawQueue::Goal *goal,
+                             const control_loops::ClawQueue::Position *position,
+                             control_loops::ClawQueue::Output *output,
+                             control_loops::ClawQueue::Status *status) {
   constexpr double dt = 0.01;
 
   // Disable the motors now so that all early returns will return with the
diff --git a/y2014/control_loops/claw/claw.gyp b/y2014/control_loops/claw/claw.gyp
index 40315ff..8a6a7c5 100644
--- a/y2014/control_loops/claw/claw.gyp
+++ b/y2014/control_loops/claw/claw.gyp
@@ -16,7 +16,7 @@
       ],
     },
     {
-      'target_name': 'claw_loop',
+      'target_name': 'claw_queue',
       'type': 'static_library',
       'sources': ['claw.q'],
       'variables': {
@@ -40,7 +40,7 @@
         'claw_motor_plant.cc',
       ],
       'dependencies': [
-        'claw_loop',
+        'claw_queue',
         '<(AOS)/common/controls/controls.gyp:control_loop',
         '<(DEPTH)/y2014/y2014.gyp:constants',
         '<(DEPTH)/frc971/control_loops/control_loops.gyp:state_feedback_loop',
@@ -50,7 +50,7 @@
         '<(AOS)/common/logging/logging.gyp:matrix_logging',
       ],
       'export_dependent_settings': [
-        'claw_loop',
+        'claw_queue',
         '<(AOS)/common/controls/controls.gyp:control_loop',
         '<(DEPTH)/frc971/control_loops/control_loops.gyp:state_feedback_loop',
         '<(AOS)/common/controls/controls.gyp:polytope',
@@ -65,7 +65,7 @@
       ],
       'dependencies': [
         '<(EXTERNALS):gtest',
-        'claw_loop',
+        'claw_queue',
         'claw_lib',
         '<(DEPTH)/frc971/control_loops/control_loops.gyp:state_feedback_loop',
         '<(AOS)/common/controls/controls.gyp:control_loop_test',
@@ -79,7 +79,7 @@
       ],
       'dependencies': [
         '<(AOS)/linux_code/linux_code.gyp:init',
-        'claw_loop',
+        'claw_queue',
         '<(AOS)/common/controls/controls.gyp:control_loop',
         '<(DEPTH)/y2014/y2014.gyp:constants',
       ],
diff --git a/y2014/control_loops/claw/claw.h b/y2014/control_loops/claw/claw.h
index 86b9b6d..cdd3948 100644
--- a/y2014/control_loops/claw/claw.h
+++ b/y2014/control_loops/claw/claw.h
@@ -182,10 +182,10 @@
       const constants::Values::Claws::Claw &claw_values);
 };
 
-class ClawMotor : public aos::controls::ControlLoop<control_loops::ClawGroup> {
+class ClawMotor : public aos::controls::ControlLoop<control_loops::ClawQueue> {
  public:
-  explicit ClawMotor(control_loops::ClawGroup *my_claw =
-                         &control_loops::claw_queue_group);
+  explicit ClawMotor(control_loops::ClawQueue *my_claw =
+                         &control_loops::claw_queue);
 
   // True if the state machine is ready.
   bool capped_goal() const { return capped_goal_; }
@@ -215,10 +215,10 @@
   CalibrationMode mode() const { return mode_; }
 
  protected:
-  virtual void RunIteration(const control_loops::ClawGroup::Goal *goal,
-                            const control_loops::ClawGroup::Position *position,
-                            control_loops::ClawGroup::Output *output,
-                            control_loops::ClawGroup::Status *status);
+  virtual void RunIteration(const control_loops::ClawQueue::Goal *goal,
+                            const control_loops::ClawQueue::Position *position,
+                            control_loops::ClawQueue::Output *output,
+                            control_loops::ClawQueue::Status *status);
 
   double top_absolute_position() const {
     return claw_.X_hat(1, 0) + claw_.X_hat(0, 0);
diff --git a/y2014/control_loops/claw/claw.q b/y2014/control_loops/claw/claw.q
index 6c7dada..a116970 100644
--- a/y2014/control_loops/claw/claw.q
+++ b/y2014/control_loops/claw/claw.q
@@ -16,7 +16,7 @@
 };
 
 // All angles here are 0 vertical, positive "up" (aka backwards).
-queue_group ClawGroup {
+queue_group ClawQueue {
   implements aos.control_loops.ControlLoop;
 
   message Goal {
@@ -67,7 +67,7 @@
   queue Status status;
 };
 
-queue_group ClawGroup claw_queue_group;
+queue_group ClawQueue claw_queue;
 
 struct ClawPositionToLog {
 	double top;
diff --git a/y2014/control_loops/claw/claw_calibration.cc b/y2014/control_loops/claw/claw_calibration.cc
index 8d806d7..772a940 100644
--- a/y2014/control_loops/claw/claw_calibration.cc
+++ b/y2014/control_loops/claw/claw_calibration.cc
@@ -153,17 +153,17 @@
 };
 
 int Main() {
-  control_loops::claw_queue_group.position.FetchNextBlocking();
+  control_loops::claw_queue.position.FetchNextBlocking();
 
   const double top_start_position =
-      control_loops::claw_queue_group.position->top.position;
+      control_loops::claw_queue.position->top.position;
   const double bottom_start_position =
-      control_loops::claw_queue_group.position->bottom.position;
+      control_loops::claw_queue.position->bottom.position;
 
   ClawSensors top(top_start_position,
-                  control_loops::claw_queue_group.position->top);
+                  control_loops::claw_queue.position->top);
   ClawSensors bottom(bottom_start_position,
-                     control_loops::claw_queue_group.position->bottom);
+                     control_loops::claw_queue.position->bottom);
 
   Claws limits;
 
@@ -217,28 +217,28 @@
   limits.start_fine_tune_pos = -0.2;
   limits.max_zeroing_voltage = 4.0;
 
-  control_loops::ClawGroup::Position last_position =
-      *control_loops::claw_queue_group.position;
+  control_loops::ClawQueue::Position last_position =
+      *control_loops::claw_queue.position;
 
   while (true) {
-    control_loops::claw_queue_group.position.FetchNextBlocking();
+    control_loops::claw_queue.position.FetchNextBlocking();
     bool print = false;
-    if (top.GetPositionOfEdge(control_loops::claw_queue_group.position->top,
+    if (top.GetPositionOfEdge(control_loops::claw_queue.position->top,
                               &limits.upper_claw)) {
       print = true;
       printf("Got an edge on the upper claw\n");
     }
     if (bottom.GetPositionOfEdge(
-            control_loops::claw_queue_group.position->bottom,
+            control_loops::claw_queue.position->bottom,
             &limits.lower_claw)) {
       print = true;
       printf("Got an edge on the lower claw\n");
     }
     const double top_position =
-        control_loops::claw_queue_group.position->top.position -
+        control_loops::claw_queue.position->top.position -
         top_start_position;
     const double bottom_position =
-        control_loops::claw_queue_group.position->bottom.position -
+        control_loops::claw_queue.position->bottom.position -
         bottom_start_position;
     const double separation = top_position - bottom_position;
     if (separation > limits.claw_max_separation) {
@@ -300,7 +300,7 @@
       printf("}\n");
     }
 
-    last_position = *control_loops::claw_queue_group.position;
+    last_position = *control_loops::claw_queue.position;
   }
   return 0;
 }
diff --git a/y2014/control_loops/claw/claw_lib_test.cc b/y2014/control_loops/claw/claw_lib_test.cc
index 2137316..63383c7 100644
--- a/y2014/control_loops/claw/claw_lib_test.cc
+++ b/y2014/control_loops/claw/claw_lib_test.cc
@@ -42,11 +42,11 @@
   ClawMotorSimulation(double initial_top_position,
                       double initial_bottom_position)
       : claw_plant_(new StateFeedbackPlant<4, 2, 2>(MakeClawPlant())),
-        claw_queue_group(".frc971.control_loops.claw_queue_group", 0x9f1a99dd,
-                         ".frc971.control_loops.claw_queue_group.goal",
-                         ".frc971.control_loops.claw_queue_group.position",
-                         ".frc971.control_loops.claw_queue_group.output",
-                         ".frc971.control_loops.claw_queue_group.status") {
+        claw_queue(".frc971.control_loops.claw_queue", 0x9f1a99dd,
+                   ".frc971.control_loops.claw_queue.goal",
+                   ".frc971.control_loops.claw_queue.position",
+                   ".frc971.control_loops.claw_queue.output",
+                   ".frc971.control_loops.claw_queue.status") {
     Reinitialize(initial_top_position, initial_bottom_position);
   }
 
@@ -106,7 +106,7 @@
 
   // Sets the values of the physical sensors that can be directly observed
   // (encoder, hall effect).
-  void SetPhysicalSensors(control_loops::ClawGroup::Position *position) {
+  void SetPhysicalSensors(control_loops::ClawQueue::Position *position) {
     position->top.position = GetPosition(TOP_CLAW);
     position->bottom.position = GetPosition(BOTTOM_CLAW);
 
@@ -181,8 +181,8 @@
 
   // Sends out the position queue messages.
   void SendPositionMessage() {
-    ::aos::ScopedMessagePtr<control_loops::ClawGroup::Position> position =
-        claw_queue_group.position.MakeMessage();
+    ::aos::ScopedMessagePtr<control_loops::ClawQueue::Position> position =
+        claw_queue.position.MakeMessage();
 
     // Initialize all the counters to their previous values.
     *position = last_position_;
@@ -207,10 +207,10 @@
   // Simulates the claw moving for one timestep.
   void Simulate() {
     const frc971::constants::Values& v = constants::GetValues();
-    EXPECT_TRUE(claw_queue_group.output.FetchLatest());
+    EXPECT_TRUE(claw_queue.output.FetchLatest());
 
-    claw_plant_->mutable_U() << claw_queue_group.output->bottom_claw_voltage,
-        claw_queue_group.output->top_claw_voltage;
+    claw_plant_->mutable_U() << claw_queue.output->bottom_claw_voltage,
+        claw_queue.output->top_claw_voltage;
     claw_plant_->Update();
 
     // Check that the claw is within the limits.
@@ -234,10 +234,10 @@
     initial_position_[type] = initial_position;
   }
 
-  ClawGroup claw_queue_group;
+  ClawQueue claw_queue;
   double initial_position_[CLAW_COUNT];
 
-  control_loops::ClawGroup::Position last_position_;
+  control_loops::ClawQueue::Position last_position_;
 };
 
 
@@ -246,7 +246,7 @@
   // 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.
-  ClawGroup claw_queue_group;
+  ClawQueue claw_queue;
 
   // Create a loop and simulation plant.
   ClawMotor claw_motor_;
@@ -257,30 +257,29 @@
   double min_separation_;
 
   ClawTest()
-      : claw_queue_group(".frc971.control_loops.claw_queue_group", 0x9f1a99dd,
-                         ".frc971.control_loops.claw_queue_group.goal",
-                         ".frc971.control_loops.claw_queue_group.position",
-                         ".frc971.control_loops.claw_queue_group.output",
-                         ".frc971.control_loops.claw_queue_group.status"),
-        claw_motor_(&claw_queue_group),
+      : claw_queue(".frc971.control_loops.claw_queue", 0x9f1a99dd,
+                   ".frc971.control_loops.claw_queue.goal",
+                   ".frc971.control_loops.claw_queue.position",
+                   ".frc971.control_loops.claw_queue.output",
+                   ".frc971.control_loops.claw_queue.status"),
+        claw_motor_(&claw_queue),
         claw_motor_plant_(0.4, 0.2),
-        min_separation_(constants::GetValues().claw.claw_min_separation) {
-  }
+        min_separation_(constants::GetValues().claw.claw_min_separation) {}
 
   void VerifyNearGoal() {
-    claw_queue_group.goal.FetchLatest();
-    claw_queue_group.position.FetchLatest();
+    claw_queue.goal.FetchLatest();
+    claw_queue.position.FetchLatest();
     double bottom = claw_motor_plant_.GetAbsolutePosition(BOTTOM_CLAW);
     double separation =
         claw_motor_plant_.GetAbsolutePosition(TOP_CLAW) - bottom;
-    EXPECT_NEAR(claw_queue_group.goal->bottom_angle, bottom, 1e-4);
-    EXPECT_NEAR(claw_queue_group.goal->separation_angle, separation, 1e-4);
+    EXPECT_NEAR(claw_queue.goal->bottom_angle, bottom, 1e-4);
+    EXPECT_NEAR(claw_queue.goal->separation_angle, separation, 1e-4);
     EXPECT_LE(min_separation_, separation);
   }
 };
 
 TEST_F(ClawTest, HandlesNAN) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(::std::nan(""))
       .separation_angle(::std::nan(""))
       .Send();
@@ -294,7 +293,7 @@
 
 // Tests that the wrist zeros correctly and goes to a position.
 TEST_F(ClawTest, ZerosCorrectly) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -392,7 +391,7 @@
 TEST_P(ZeroingClawTest, ParameterizedZero) {
   claw_motor_plant_.Reinitialize(GetParam().first, GetParam().second);
 
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -410,7 +409,7 @@
 TEST_P(ZeroingClawTest, HandleMissingPosition) {
   claw_motor_plant_.Reinitialize(GetParam().first, GetParam().second);
 
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -453,7 +452,7 @@
 /*
 // Tests that loosing the encoder for a second triggers a re-zero.
 TEST_F(ClawTest, RezeroWithMissingPos) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -468,7 +467,7 @@
         // Should be re-zeroing now.
         EXPECT_TRUE(claw_motor_.is_uninitialized());
       }
-      claw_queue_group.goal.MakeWithBuilder()
+      claw_queue.goal.MakeWithBuilder()
           .bottom_angle(0.2)
           .separation_angle(0.2)
           .Send();
@@ -490,7 +489,7 @@
 // Tests that disabling while zeroing sends the state machine into the
 // uninitialized state.
 TEST_F(ClawTest, DisableGoesUninitialized) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -504,9 +503,9 @@
         // it is in the correct state.
         EXPECT_TRUE(claw_motor_.is_uninitialized());
         // When disabled, we should be applying 0 power.
-        EXPECT_TRUE(claw_queue_group.output.FetchLatest());
-        EXPECT_EQ(0, claw_queue_group.output->top_claw_voltage);
-        EXPECT_EQ(0, claw_queue_group.output->bottom_claw_voltage);
+        EXPECT_TRUE(claw_queue.output.FetchLatest());
+        EXPECT_EQ(0, claw_queue.output->top_claw_voltage);
+        EXPECT_EQ(0, claw_queue.output->bottom_claw_voltage);
       }
     } else {
       SimulateTimestep(true);
@@ -588,7 +587,7 @@
 // Tests that the wrist can't get too far away from the zeroing position if the
 // zeroing position is saturating the goal.
 TEST_F(WindupClawTest, NoWindupPositive) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -601,7 +600,7 @@
 // Tests that the wrist can't get too far away from the zeroing position if the
 // zeroing position is saturating the goal.
 TEST_F(WindupClawTest, NoWindupNegative) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();
@@ -614,7 +613,7 @@
 // Tests that the wrist can't get too far away from the zeroing position if the
 // zeroing position is saturating the goal.
 TEST_F(WindupClawTest, NoWindupNegativeFineTune) {
-  claw_queue_group.goal.MakeWithBuilder()
+  claw_queue.goal.MakeWithBuilder()
       .bottom_angle(0.1)
       .separation_angle(0.2)
       .Send();