diff --git a/src/cgmath/rotation.rs b/src/cgmath/rotation.rs
index 699a43b..28dc015 100644
--- a/src/cgmath/rotation.rs
+++ b/src/cgmath/rotation.rs
@@ -30,7 +30,7 @@ pub trait Rotation2
 :   Eq
 +   ApproxEq<S>
 +   ToMat2<S>
-+   ToRot2<S>
++   ToBasis2<S>
 {
     fn rotate_point2(&self, point: &Point2<S>) -> Point2<S>;
     fn rotate_vec2(&self, vec: &Vec2<S>) -> Vec2<S>;
@@ -49,7 +49,7 @@ pub trait Rotation3
 :   Eq
 +   ApproxEq<S>
 +   ToMat3<S>
-+   ToRot3<S>
++   ToBasis3<S>
 +   ToQuat<S>
 {
     fn rotate_point3(&self, point: &Point3<S>) -> Point3<S>;
@@ -68,30 +68,30 @@ pub trait Rotation3
 /// enforce orthogonality at the type level the operations have been restricted
 /// to a subeset of those implemented on `Mat2`.
 #[deriving(Eq, Clone)]
-pub struct Rot2<S> {
+pub struct Basis2<S> {
     priv mat: Mat2<S>
 }
 
-impl<S: Float> Rot2<S> {
+impl<S: Float> Basis2<S> {
     #[inline]
     pub fn as_mat2<'a>(&'a self) -> &'a Mat2<S> { &'a self.mat }
 }
 
-pub trait ToRot2<S: Float> {
-    fn to_rot2(&self) -> Rot2<S>;
+pub trait ToBasis2<S: Float> {
+    fn to_rot2(&self) -> Basis2<S>;
 }
 
-impl<S: Float> ToRot2<S> for Rot2<S> {
+impl<S: Float> ToBasis2<S> for Basis2<S> {
     #[inline]
-    fn to_rot2(&self) -> Rot2<S> { self.clone() }
+    fn to_rot2(&self) -> Basis2<S> { self.clone() }
 }
 
-impl<S: Float> ToMat2<S> for Rot2<S> {
+impl<S: Float> ToMat2<S> for Basis2<S> {
     #[inline]
     fn to_mat2(&self) -> Mat2<S> { self.mat.clone() }
 }
 
-impl<S: Float> Rotation2<S> for Rot2<S> {
+impl<S: Float> Rotation2<S> for Basis2<S> {
     #[inline]
     fn rotate_point2(&self, _point: &Point2<S>) -> Point2<S> { fail!("Not yet implemented") }
 
@@ -102,15 +102,15 @@ impl<S: Float> Rotation2<S> for Rot2<S> {
     fn rotate_ray2(&self, _ray: &Ray2<S>) -> Ray2<S> { fail!("Not yet implemented") }
 
     #[inline]
-    fn concat(&self, other: &Rot2<S>) -> Rot2<S> { Rot2 { mat: self.mat.mul_m(&other.mat) } }
+    fn concat(&self, other: &Basis2<S>) -> Basis2<S> { Basis2 { mat: self.mat.mul_m(&other.mat) } }
 
     #[inline]
-    fn concat_self(&mut self, other: &Rot2<S>) { self.mat.mul_self_m(&other.mat); }
+    fn concat_self(&mut self, other: &Basis2<S>) { self.mat.mul_self_m(&other.mat); }
 
     // TODO: we know the matrix is orthogonal, so this could be re-written
     // to be faster
     #[inline]
-    fn invert(&self) -> Rot2<S> { Rot2 { mat: self.mat.invert().unwrap() } }
+    fn invert(&self) -> Basis2<S> { Basis2 { mat: self.mat.invert().unwrap() } }
 
     // TODO: we know the matrix is orthogonal, so this could be re-written
     // to be faster
@@ -118,7 +118,7 @@ impl<S: Float> Rotation2<S> for Rot2<S> {
     fn invert_self(&mut self) { self.mat.invert_self(); }
 }
 
-impl<S: Float> ApproxEq<S> for Rot2<S> {
+impl<S: Float> ApproxEq<S> for Basis2<S> {
     #[inline]
     fn approx_epsilon() -> S {
         // TODO: fix this after static methods are fixed in rustc
@@ -126,12 +126,12 @@ impl<S: Float> ApproxEq<S> for Rot2<S> {
     }
 
     #[inline]
-    fn approx_eq(&self, other: &Rot2<S>) -> bool {
+    fn approx_eq(&self, other: &Basis2<S>) -> bool {
         self.mat.approx_eq(&other.mat)
     }
 
     #[inline]
-    fn approx_eq_eps(&self, other: &Rot2<S>, approx_epsilon: &S) -> bool {
+    fn approx_eq_eps(&self, other: &Basis2<S>, approx_epsilon: &S) -> bool {
         self.mat.approx_eq_eps(&other.mat, approx_epsilon)
     }
 }
@@ -143,29 +143,29 @@ impl<S: Float> ApproxEq<S> for Rot2<S> {
 /// `math::Mat3`. To ensure orthogonality is maintained, the operations have
 /// been restricted to a subeset of those implemented on `Mat3`.
 #[deriving(Eq, Clone)]
-pub struct Rot3<S> {
+pub struct Basis3<S> {
     priv mat: Mat3<S>
 }
 
-impl<S: Float> Rot3<S> {
+impl<S: Float> Basis3<S> {
     #[inline]
-    pub fn look_at(dir: &Vec3<S>, up: &Vec3<S>) -> Rot3<S> {
-        Rot3 { mat: Mat3::look_at(dir, up) }
+    pub fn look_at(dir: &Vec3<S>, up: &Vec3<S>) -> Basis3<S> {
+        Basis3 { mat: Mat3::look_at(dir, up) }
     }
 
     /// Create a rotation matrix from a rotation around the `x` axis (pitch).
-    pub fn from_angle_x(theta: Rad<S>) -> Rot3<S> {
-        Rot3 { mat: Mat3::from_angle_x(theta) }
+    pub fn from_angle_x(theta: Rad<S>) -> Basis3<S> {
+        Basis3 { mat: Mat3::from_angle_x(theta) }
     }
 
     /// Create a rotation matrix from a rotation around the `y` axis (yaw).
-    pub fn from_angle_y(theta: Rad<S>) -> Rot3<S> {
-        Rot3 { mat: Mat3::from_angle_y(theta) }
+    pub fn from_angle_y(theta: Rad<S>) -> Basis3<S> {
+        Basis3 { mat: Mat3::from_angle_y(theta) }
     }
 
     /// Create a rotation matrix from a rotation around the `z` axis (roll).
-    pub fn from_angle_z(theta: Rad<S>) -> Rot3<S> {
-        Rot3 { mat: Mat3::from_angle_z(theta) }
+    pub fn from_angle_z(theta: Rad<S>) -> Basis3<S> {
+        Basis3 { mat: Mat3::from_angle_z(theta) }
     }
 
     /// Create a rotation matrix from a set of euler angles.
@@ -175,39 +175,39 @@ impl<S: Float> Rot3<S> {
     /// - `x`: the angular rotation around the `x` axis (pitch).
     /// - `y`: the angular rotation around the `y` axis (yaw).
     /// - `z`: the angular rotation around the `z` axis (roll).
-    pub fn from_euler(x: Rad<S>, y: Rad<S>, z: Rad<S>) -> Rot3<S> {
-        Rot3 { mat: Mat3::from_euler(x, y ,z) }
+    pub fn from_euler(x: Rad<S>, y: Rad<S>, z: Rad<S>) -> Basis3<S> {
+        Basis3 { mat: Mat3::from_euler(x, y ,z) }
     }
 
     /// Create a rotation matrix from a rotation around an arbitrary axis.
-    pub fn from_axis_angle(axis: &Vec3<S>, angle: Rad<S>) -> Rot3<S> {
-        Rot3 { mat: Mat3::from_axis_angle(axis, angle) }
+    pub fn from_axis_angle(axis: &Vec3<S>, angle: Rad<S>) -> Basis3<S> {
+        Basis3 { mat: Mat3::from_axis_angle(axis, angle) }
     }
 
     #[inline]
     pub fn as_mat3<'a>(&'a self) -> &'a Mat3<S> { &'a self.mat }
 }
 
-pub trait ToRot3<S: Float> {
-    fn to_rot3(&self) -> Rot3<S>;
+pub trait ToBasis3<S: Float> {
+    fn to_rot3(&self) -> Basis3<S>;
 }
 
-impl<S: Float> ToRot3<S> for Rot3<S> {
+impl<S: Float> ToBasis3<S> for Basis3<S> {
     #[inline]
-    fn to_rot3(&self) -> Rot3<S> { self.clone() }
+    fn to_rot3(&self) -> Basis3<S> { self.clone() }
 }
 
-impl<S: Float> ToMat3<S> for Rot3<S> {
+impl<S: Float> ToMat3<S> for Basis3<S> {
     #[inline]
     fn to_mat3(&self) -> Mat3<S> { self.mat.clone() }
 }
 
-impl<S: Float> ToQuat<S> for Rot3<S> {
+impl<S: Float> ToQuat<S> for Basis3<S> {
     #[inline]
     fn to_quat(&self) -> Quat<S> { self.mat.to_quat() }
 }
 
-impl<S: Float> Rotation3<S> for Rot3<S> {
+impl<S: Float> Rotation3<S> for Basis3<S> {
     #[inline]
     fn rotate_point3(&self, _point: &Point3<S>) -> Point3<S> { fail!("Not yet implemented") }
 
@@ -218,15 +218,15 @@ impl<S: Float> Rotation3<S> for Rot3<S> {
     fn rotate_ray3(&self, _ray: &Ray3<S>) -> Ray3<S> { fail!("Not yet implemented") }
 
     #[inline]
-    fn concat(&self, other: &Rot3<S>) -> Rot3<S> { Rot3 { mat: self.mat.mul_m(&other.mat) } }
+    fn concat(&self, other: &Basis3<S>) -> Basis3<S> { Basis3 { mat: self.mat.mul_m(&other.mat) } }
 
     #[inline]
-    fn concat_self(&mut self, other: &Rot3<S>) { self.mat.mul_self_m(&other.mat); }
+    fn concat_self(&mut self, other: &Basis3<S>) { self.mat.mul_self_m(&other.mat); }
 
     // TODO: we know the matrix is orthogonal, so this could be re-written
     // to be faster
     #[inline]
-    fn invert(&self) -> Rot3<S> { Rot3 { mat: self.mat.invert().unwrap() } }
+    fn invert(&self) -> Basis3<S> { Basis3 { mat: self.mat.invert().unwrap() } }
 
     // TODO: we know the matrix is orthogonal, so this could be re-written
     // to be faster
@@ -234,7 +234,7 @@ impl<S: Float> Rotation3<S> for Rot3<S> {
     fn invert_self(&mut self) { self.mat.invert_self(); }
 }
 
-impl<S: Float> ApproxEq<S> for Rot3<S> {
+impl<S: Float> ApproxEq<S> for Basis3<S> {
     #[inline]
     fn approx_epsilon() -> S {
         // TODO: fix this after static methods are fixed in rustc
@@ -242,21 +242,21 @@ impl<S: Float> ApproxEq<S> for Rot3<S> {
     }
 
     #[inline]
-    fn approx_eq(&self, other: &Rot3<S>) -> bool {
+    fn approx_eq(&self, other: &Basis3<S>) -> bool {
         self.mat.approx_eq(&other.mat)
     }
 
     #[inline]
-    fn approx_eq_eps(&self, other: &Rot3<S>, approx_epsilon: &S) -> bool {
+    fn approx_eq_eps(&self, other: &Basis3<S>, approx_epsilon: &S) -> bool {
         self.mat.approx_eq_eps(&other.mat, approx_epsilon)
     }
 }
 
 // Quaternion Rotation impls
 
-impl<S: Float> ToRot3<S> for Quat<S> {
+impl<S: Float> ToBasis3<S> for Quat<S> {
     #[inline]
-    fn to_rot3(&self) -> Rot3<S> { Rot3 { mat: self.to_mat3() } }
+    fn to_rot3(&self) -> Basis3<S> { Basis3 { mat: self.to_mat3() } }
 }
 
 impl<S: Float> ToQuat<S> for Quat<S> {