anchor.diff:        ;; 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)
  -      ;; equivalent types need to be swapped out
  -      (let* ((in-args in-args)
  -	     (uniforms uniforms))
  -	;; now the meat
  -        (%def-gpu-function name in-args uniforms context body instancing
  -                           nil nil doc-string declarations)))))
  +      (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)
  
positive.code: 
  ;;--------------------------------------------------
  
  (defun %def-gpu-function (name in-args uniforms context body instancing
                            equivalent-inargs equivalent-uniforms
                            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.
  
     [2] %test-&-update-spec compiles the code to check for errors and log
         dependencies. (this is called at runtime)
  
negative.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 nil body instancing
                                     nil nil nil nil doc-string declarations
                                     nil)));;[0]
      ;; this gets the functions used in the body of this function
      ;; it is *not* recursive
      (%update-gpu-function-data spec nil nil)
      (varjo::add-external-function name in-args uniforms body);;[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)
  
  