anchor.diff:  				  (mods-group *compositor*)))))
   
   (defmethod first-commit ((mode default-mode) surface)
  -  (start-animation (animation
  -		    :target surface
  -		    :property 'opacity
  -		    :from 0.0 :to 1.0
  -		    :duration 250
  -		    :easing-fn 'easing:linear)))
  +  (let ((animation (sequential-animation (lambda ()
  +					   (setf (origin-x surface) 0.0)
  +					   (setf (origin-y surface) 0.0))
  +					 (animation :target surface
  +						    :property 'scale-x
  +						    :easing-fn 'easing:out-exp
  +						    :from 0
  +						    :to 1.0
  +						    :duration 500)
  +					 (animation :target surface
  +						    :property 'scale-y
  +						    :easing-fn 'easing:out-exp
  +						    :to 1.0
  +						    :duration 500))))
  +    (setf (origin-x surface) (/ (width surface) 2))
  +    (setf (origin-y surface) (/ (height surface) 2))
  +    (setf (scale-y surface) (/ 6 (height surface)))
  +    (start-animation animation)))
  +
  +(defun-g default-mode-vertex-shader ((vert g-pt) &uniform (ortho :mat4) (origin :mat4) (origin-inverse :mat4) (surface-scale :mat4) (surface-translate :mat4))
  +  (values (* ortho surface-translate origin-inverse surface-scale origin (v! (pos vert) 1))
  +	  (:smooth (tex vert))))
   
   (def-g-> default-pipeline ()
  -  #'default-vertex-shader #'default-fragment-shader)
  +  #'default-mode-vertex-shader #'default-fragment-shader)
   
   (defmethod render ((mode default-mode))
     (apply #'gl:clear-color (clear-color mode))
  
positive.code:   (map-g #'default-pipeline nil)
    (setf (render-needed *compositor*) t))
  
  (defmethod mouse-motion-handler ((mode default-mode) time delta-x delta-y)
    ;; Update the pointer location
    (incf (pointer-x *compositor*) delta-x)
    (incf (pointer-y *compositor*) delta-y)
    (let ((x (pointer-x *compositor*))
  	(y (pointer-y *compositor*)))
      (when (cursor-surface *compositor*)
        (setf (render-needed *compositor*) t))
      (cond
        ((moving-surface *compositor*) ;; 1. If we are dragging a window...
         (progn
  	 (incf (x (moving-surface *compositor*)) delta-x) ;;... update its location
  	 (incf (y (moving-surface *compositor*)) delta-y)
  	 (setf (render-needed *compositor*) t)))
        ((resizing-surface *compositor*)
         (let* ((saved-width (resize-op-surface-width (resizing-surface *compositor*)))
  	      (saved-height (resize-op-surface-height (resizing-surface *compositor*)))
  	      (saved-pointer-x (resize-op-pointer-x (resizing-surface *compositor*)))
  	      (saved-pointer-y (resize-op-pointer-y (resizing-surface *compositor*)))
  	      (delta-x (- x saved-pointer-x))
  	      (delta-y (- y saved-pointer-y)))
  	 (resize-surface-absolute (resize-op-surface (resizing-surface *compositor*)) (+ saved-width delta-x) (+ saved-height delta-y))))
        ;; 2. The pointer has left the current surface
        ((not (equalp (pointer-surface *compositor*) (surface-under-pointer x y *compositor*)))
         (progn
  	 (setf (cursor-surface *compositor*) nil)
  	 (when (focus-follows-mouse mode)
  	   (deactivate-surface (pointer-surface *compositor*)))
  	 (when (accepts-pointer-events? (pointer-surface *compositor*))
  	   (wl-pointer-send-leave (->pointer (client (pointer-surface *compositor*)))
  				  0
  				  (->surface (pointer-surface *compositor*))))
  	 (setf (pointer-surface *compositor*) (surface-under-pointer x y *compositor*))
  	 (when (focus-follows-mouse mode)
  	   (activate-surface (pointer-surface *compositor*)))
  	 (when (accepts-pointer-events? (pointer-surface *compositor*))
  	   (wl-pointer-send-enter (->pointer (client (pointer-surface *compositor*)))
  				  0
  				  (->surface (pointer-surface *compositor*))
  				  (round (* 256 (- x (x (pointer-surface *compositor*)))))
  				  (round (* 256 (- y (y (pointer-surface *compositor*)))))))))
        ;; 3. Pointer is over previous surface
        ((equalp (pointer-surface *compositor*) (surface-under-pointer x y *compositor*))
         (when (accepts-pointer-events? (pointer-surface *compositor*))
  	 (wl-pointer-send-motion (->pointer (client (pointer-surface *compositor*)))
  				 time
  				 (round (* 256 (- x (x (pointer-surface *compositor*)))))
  				 (round (* 256 (- y (y (pointer-surface *compositor*))))))
  	 (wl-pointer-send-frame (->pointer (client (pointer-surface *compositor*))))
  	 )))))
  
  (defun pulse-animation (surface)
    (sequential-animation nil
     (parallel-animation nil
      (animation :duration 100 :easing-fn 'easing:linear :to 1.05 :target surface :property 'scale-x)
      (animation :duration 100 :easing-fn 'easing:linear :to 1.05 :target surface :property 'scale-y)
      (animation :duration 100 :easing-fn 'easing:linear :to (+ (x surface) (- (* (width surface) 0.05 0.5))) :target surface :property 'x)
      (animation :duration 100 :easing-fn 'easing:linear :to (+ (y surface) (- (* (height surface) 0.05  0.5))) :target surface :property 'y))
     (parallel-animation nil
      (animation :duration 100 :easing-fn 'easing:linear :to 1.0 :target surface :property 'scale-x)
      (animation :duration 100 :easing-fn 'easing:linear :to 1.0 :target surface :property 'scale-y)
      (animation :duration 100 :easing-fn 'easing:linear :to (x surface) :target surface :property 'x)
      (animation :duration 100 :easing-fn 'easing:linear :to (y surface) :target surface :property 'y))))
  
  (defmethod mouse-button-handler ((mode default-mode) time button state)
    ;; 1. Change (possibly) the active surface
  
negative.code:   ;; 2. Send active surface mouse button
    (when (surface-under-pointer (pointer-x *compositor*)
  			       (pointer-y *compositor*)
  			       *compositor*) 
      (let ((surface (surface-under-pointer (pointer-x *compositor*)
  			       (pointer-y *compositor*)
  			       *compositor*) ))
  