anchor.diff:  
   (defun 0p (quat)
     (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
  -    (cl:= 0f0 (+ (* w w) (* x x) (* y y) (* z z)))))
  +    (cl:= 0f0 (cl:+ (cl:* w w) (cl:* x x) (cl:* y y) (cl:* z z)))))
   
   (defun unitp (quat)
     (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
  -    (cl:= 0f0 (- 1.0 (* w w) (* x x) (* y y) (* z z)))))
  +    (cl:= 0f0 (cl:- 1.0 (cl:* w w) (cl:* x x) (cl:* y y) (cl:* z z)))))
   
   (defun identity ()
     (q! 1.0 0.0 0.0 0.0))
   
   (defun identity-p (quat)
  -  (and (cl:= 0f0 (- 1.0 (w quat)))
  +  (and (cl:= 0f0 (cl:- 1.0 (w quat)))
          (cl:= 0f0 (x quat))
          (cl:= 0f0 (y quat))
          (cl:= 0f0 (z quat))))
  
positive.code: (defun from-look-at (from3 to3)
    (let* ((dir (v3:- from3 to3))
           (n-dir (v3:normalize dir))
           (right (v3:make (v:z n-dir) 0.0 (- (v:x n-dir))))
           (n-right (v3:normalize right))
           (up (v3:cross n-dir n-right)))
      (q:from-axies n-right up n-dir)))
  
negative.code: ;; [TODO] Look into assets (this should be a unit quaternion
  (defun rotate (vec3 quat)
    "Rotate vec3 by quaternion. Assumes quaternion is normalized."
    (let* ((v-mult (cl:* 2.0 (cl:+ (cl:* (x quat) (aref vec3 0))
  				 (cl:* (y quat) (aref vec3 1))
  				 (cl:* (z quat) (aref vec3 2)))))
           (cross-mult (cl:* 2.0 (w quat)))
           (p-mult (cl:- (cl:* cross-mult (w quat)) 1.0)))
      (v3:make (cl:+ (cl:* p-mult (aref vec3 0))
  		   (cl:* v-mult (x quat))
  		   (cl:* cross-mult
  			 (cl:- (cl:* (y quat) (aref vec3 2))
  			       (cl:* (z quat) (aref vec3 1)))))
  	     (cl:+ (cl:* p-mult (aref vec3 1))
  		   (cl:* v-mult (y quat))
  		   (cl:* cross-mult
  			 (cl:- (cl:* (z quat) (aref vec3 0))
  			       (cl:* (x quat) (aref vec3 2)))))
  	     (cl:+ (cl:* p-mult (aref vec3 2))
  		   (cl:* v-mult (z quat))
  		   (cl:* cross-mult
  			 (cl:- (cl:* (x quat) (aref vec3 1))
  			       (cl:* (y quat) (aref vec3 0))))))))
  
  ;; [TODO] Could be faster (see q+1 area)
  (defun lerp (start-quat end-quat pos)
  