anchor.diff:  
   ;;--------------------------------------------------
   
  -(defun %def-gpu-function (name in-args uniforms context body instancing
  -                          equivalent-inargs equivalent-uniforms
  +(defun %def-gpu-function (name in-args uniforms body instancing
                             doc-string declarations)
     "This is the meat of defun-g. it is broken down as follows:
   
      [0] makes a gpu-func-spec that will be populated a stored later.
   
  -   [1] turn this function definiton into a macro that injects a labels form
  -       containing the function body and whos body is a call to that local
  -       function. This may seem like madness but it will make sense soon.
  -       So now this means that wherever you call the function in shader code
  -       there will be a local function and call.
  -
  -       One of the optimizations that varjo does is find all functions that are
  -       identical and merge them.
  -       This works as there are no local functions in glsl, they are all moved to
  -       shader-global scope.
  +   [1] Adds a external function definition to varjo
   
      [2] %test-&-update-spec compiles the code to check for errors and log
          dependencies. (this is called at runtime)
  
positive.code:        one of its missing dependencies and calls %test-&-update-spec on them.
         Note that this will (possibly) update the spec but will not trigger a
         recompile in the pipelines."
    (let ((spec (%make-gpu-func-spec name in-args uniforms context body instancing
                                     equivalent-inargs equivalent-uniforms nil nil
                                     doc-string declarations nil))) ;;[0]
      ;; this gets the functions used in the body of this function
      ;; it is *not* recursive
      (let* ((in-arg-names (mapcar #'first in-args))
  	   (uniform-names (mapcar #'first uniforms))
  	   (macro-func-name (gensym (symbol-name name)))
  	   (fbody `(list 'varjo-lang:labels-no-implicit ;;[1]
  			 '((,macro-func-name (,@in-args ,@uniforms) ,@body))
  			 (list ',macro-func-name
  			       ,@in-arg-names ,@uniform-names)))
  	   (to-compile `(lambda (,@in-arg-names ,@uniform-names) ;;[1]
  			  ,fbody)))
        (%update-gpu-function-data spec nil nil)
        (varjo::add-macro name (compile nil to-compile)
  			context varjo::*global-env*);;[1]
        `(progn
           (%test-&-update-spec ,(%serialize-gpu-func-spec spec));;[2]
           ,(%make-stand-in-lisp-func spec);;[3]
           (%recompile-gpu-function-and-pipelines ',name);;[4]
  	 (update-specs-with-missing-dependencies);;[5]
  	 ',name))))
  
  (defvar *warn-when-cant-test-compile* t)
  
  
negative.code:       ;; check the arguments are sanely formatted
        (mapcar #'(lambda (x) (assert-arg-format name x)) in-args)
        (mapcar #'(lambda (x) (assert-arg-format name x)) uniforms)
        (assert (null context))
        ;; now the meat
        (%def-gpu-function name in-args uniforms body instancing
                           doc-string declarations))))
  
  (defun assert-arg-format (gfunc-name x)
    (unless (listp x)
  