anchor.diff:                                              (current-line w))
                         :to-block (mapcat #'to-block args)
                         :node-tree (ast-node!
  -                                  'sv!
  +                                  'v!
                                     (mapcar #'node-tree args)
                                     type
                                     env
  
positive.code: ~a
  and
  ~a" u-a u-b))))
  
negative.code:   (declare (ignore space body))
    (error "the 'in' macro can only be used inside shaders"))
  
  (v-defspecial get-transform ((space-a v-space) (space-b v-space))
    :return
    ;;
    ;; when we have to transform from *screen-space* or *ndc-space* we are in
    ;; a more tricky situation as the transform is a function of the vector,
    ;; a matrix alone cannot capture the transform.
    ;; To handle this situation (in a way that won't kill performace) we
    ;; require that the source space (screen or ndc) is explicit, in code, at
    ;; compile time.
    ;;
    (labels ((uname (s)
               (let ((id (flow-ids s)))
                 (first (find id (v-uniforms env) :test #'id=
                              :key λ(flow-ids (second _)))))))
      (let* ((from-name (or (uname space-a)
                            (error "get-transform: The first argument doesnt appear to be from a uniform")))
             (to-name (or (uname space-b)
                          (error "get-transform: The first argument doesnt appear to be from a uniform"))))
        (if (or (eq from-name '*screen-space*) (eq from-name '*ndc-space*))
            (error "CEPL: get-transform is not currently supported for transform from *screen-space* or *ndc-space*")
            (values (compile-implicit-mat4 from-name to-name env)
                    env)))))
  
  (v-defspecial space-boundary-convert ((form-obj v-type))
    :return
    (if (v-typep (code-type form-obj) 'v-svec)
        (if (variable-in-scope-p '*current-space* env)
            (let* ((inner-name (get-space-from-svec form-obj env))
                   (outer-name (get-current-space env)))
              (convert-between-spaces form-obj inner-name outer-name env))
            (values
             (let ((ast (node-tree form-obj)))
               (copy-code
                form-obj
                :node-tree (ast-node! 'space-boundary-convert
                                      (list ast)
                                      (ast-return-type ast)
                                      (ast-starting-env ast)
                                      (ast-ending-env ast))))
             env))
        (values form-obj env)))
  
  (defun convert-between-spaces (form-obj from-name to-name env)
    (vbind (obj env)
        (if (or (eq from-name '*screen-space*) (eq from-name '*ndc-space*))
            (inject-clip-or-ndc-reverse-transform form-obj from-name to-name env)
            (inject-regular-space-transform form-obj from-name to-name env))
      ;;
      (add-space-to-meta (flow-ids obj) (variable-type to-name env) env)
      ;;
      (values obj env)))
  
  (defun inject-regular-space-transform (form-obj from-name to-name  env)
    ;; we need to add the transform uniform and get it's name
    (let* ((injected (compile-implicit-mat4 from-name to-name env )))
      ;; and here is the replacement code for our crossing the spaces
      (compile-form `(svec-* ,form-obj ,injected) env)))
  
  (defun compile-implicit-mat4 (from-name to-name env)
    ;; Inject a conversion uniform
    (let ((implicit-uniform-name (symb from-name :-to- to-name :-mat4)))
      (inject-implicit-uniform
       implicit-uniform-name :mat4 env
       `(get-transform ,from-name ,to-name))))
  
  (defun inject-clip-or-ndc-reverse-transform (form-obj from-name to-name env)
    (cond
      ;; -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
      ;; The cases we dont yet handle
      ((eq from-name '*ndc-space*)
       (error 'from-ndc))
      ((eq to-name '*screen-space*)
       (error 'to-ndc-or-screen))
      ((eq to-name '*ndc-space*)
       (error 'to-ndc-or-screen))
      ;; -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
      ;; The case we do handle
      ((eq from-name '*screen-space*)
       (let* ((vpp-name 'viewport-params)
              (injected (inject-implicit-uniform
                         vpp-name :vec4 env `(viewport-params-to-vec4))))
         ;; lets make the code to transform to clip-space
         (let ((code `(screen-space-to-clip-space ,form-obj ,injected)))
           ;; now we have a transform to clip-space, but it is likely we need to
           ;; go further, if that might be the case then tell the next pass that
           ;; we are in clip-space and let the compiler take care of the rest
           (compile-form (if (eq to-name '*clip-space*)
                             `(sv! ,code)
                             `(in *clip-space* (sv! ,code)))
                         env))))
      (t (error "compile bug"))))
  
  
  ;; this func isn't in the ast, which means the build won't
  ;; stabilize. Add a copy-code and replace the svec-* ast-node
  (v-defun svec-* (a b) "(~a * ~a)" (v-mat4 v-svec) 1)
  (v-defun svec-* (a b) "(~a * ~a)" (v-svec v-mat4) 0)
  (v-defun svec-* (a b) "(~a * ~a)" (v-mat4 :vec4) 1)
  (v-defun svec-* (a b) "(~a * ~a)" (:vec4 v-mat4) 0)
  
  (defmethod combine-metadata ((meta-a space-meta)
                               (meta-b space-meta))
  