anchor.diff:  
   (v-defspecial %multi-env-progn (&rest env-local-expessions)
     :args-valid t
  -  :return  
  -  (let* ((e (mapcar λ(multiple-value-list (varjo->glsl % env))
  -                    env-local-expessions))
  -         (code-objs (mapcar #'first e))
  -         (env-objs (mapcar #'second e))
  -         (merged-env (reduce λ(merge-env % %1) env-objs)))    
  -    (values
  -     (merge-obs code-objs
  -                 :type (type-spec->type 'v-none)
  -                 :current-line nil
  -                 :to-block (append (mapcan #'to-block code-objs)
  -                                   (mapcar λ(current-line (end-line %))
  -                                           code-objs))
  -                 :to-top (mapcan #'to-top code-objs))
  -     merged-env)))
  -
  -(v-defmacro :wip-let (bindings &body body)
  -  `(%clone-env-block
  -    (%multi-env-progn ,@(loop :for b :in bindings
  -                           :collect `(%glsl-let ,b t)))
  -    ,@body))
  -
  -;;{TODO} DEPRECATED - REMOVE ASAP
  -(v-defspecial :%env-multi-var-declare (forms &optional include-type-declarations
  -                                       arg-glsl-names)
  -  ;; This is the single ugliest thing in varjo (hopefully!)
  -  ;; it implements declarations of multiple values without letting
  -  ;; them share the environment.
  -  :args-valid t
  -  :return
  -  (labels ((validate-var-types (var-name type-spec code-obj)
  -             (when (and (null type-spec) (null code-obj))
  -               (error "Could not establish the type of the variable: ~s" var-name))
  -             (when (and code-obj type-spec (not (v-type-eq (code-type code-obj) type-spec)))
  -               (error "Type specified does not match the type of the form~%~s~%~s"
  -                      (code-type code-obj) type-spec))
  -             t))
  -    ;; compile vals
  -    (let* ((forms (remove nil forms))
  -           (env (clone-environment env))
  -           (var-specs (loop :for f :in forms :collect (listify (first f))))
  -           (c-objs (loop :for f in forms :collect
  -                      (when (> (length f) 1) (varjo->glsl (second f) env))))
  -           (glsl-names (or arg-glsl-names
  -                           (loop :for (name) :in var-specs
  -                              :do (when (> (count name var-specs :key #'first) 1)
  -                                    (error 'duplicate-name name))
  -                              :collect (safe-glsl-name-string (free-name name env)))))
  -           (decl-objs (loop :for (name type-spec qualifiers) :in var-specs
  -                         :for glsl-name :in glsl-names
  -                         :for code-obj :in c-objs :do
  -                         (validate-var-types name type-spec code-obj)
  -                         :collect
  -                         (let* ((type-spec (when type-spec (type-spec->type type-spec)))
  -                                (code (if code-obj
  -                                          `(setf (%make-var ,glsl-name ,(or type-spec (code-type code-obj))) ,code-obj)
  -                                          `(%make-var ,glsl-name ,type-spec))))
  -                           (if (eq include-type-declarations :env-and-set)
  -                               (varjo->glsl code env)
  -                               (varjo->glsl `(%typify ,code) env))))))
  -      ;;add-vars to env - this is destrucitvely modifying env
  -      (loop :for (name type-spec qualifiers) :in var-specs
  -         :for glsl-name :in glsl-names
  -         :for code-obj :in c-objs :do
  -         (let ((type-spec (when type-spec (type-spec->type type-spec))))
  -           (add-var name
  -                    (make-instance 'v-value :glsl-name glsl-name
  -                                   :type (set-place-t (or type-spec
  -                                                          (code-type code-obj))))
  -                    env t)))
  -      (values (if include-type-declarations
  -                  (merge-obs decl-objs
  -                             :type (type-spec->type 'v-none)
  -                             :current-line nil
  -                             :to-block (append (mapcan #'to-block decl-objs)
  -                                               (mapcar #'(lambda (x) (current-line (end-line x)))
  -                                                       decl-objs))
  -                             :to-top (mapcan #'to-top decl-objs))
  -                  (make-instance 'code :type 'v-none))
  -              env))))
  -
  -;; {TODO} is block the best term? is it a block in the code-obj sense?
  +  :return
  +  (if env-local-expessions
  +      (let* ((e (mapcar λ(multiple-value-list (varjo->glsl % env))
  +                        env-local-expessions))
  +             (code-objs (mapcar #'first e))
  +             (env-objs (mapcar #'second e))
  +             (merged-env (reduce λ(merge-env % %1) env-objs)))
  +        (values
  +         (merge-obs code-objs
  +                    :type (type-spec->type 'v-none)
  +                    :current-line nil
  +                    :to-block (append (mapcan #'to-block code-objs)
  +                                      (mapcar λ(current-line (end-line %))
  +                                              code-objs))
  +                    :to-top (mapcan #'to-top code-objs))
  +         merged-env))
  +      (make-instance 'code :type (type-spec->type :none) :current-line "")))
  +
   (v-defmacro :let (bindings &body body)
     `(%clone-env-block
  -    (%env-multi-var-declare ,bindings t)
  +    (%multi-env-progn
  +     ,@(loop :for b :in bindings :collect `(%glsl-let ,b t)))
       ,@body))
   
   (v-defmacro :let* (bindings &rest body)
  
positive.code:              (bindings (mapcar (lambda (x y) (list (list x) y))  names values))
               (result (varjo->glsl
                        `(%clone-env-block
                          (%env-multi-var-declare ,bindings :env-and-set ,glsl-names))
                        (clone-environment env))))
          (setf (multi-vals result)
                (loop :for o :in objs :for n in glsl-names :collect
  
negative.code:     (error "Code not ascertain the type of the stemcell used in the let form:~%(~a ~a)"
             (string-downcase var-name) (current-line code-obj)))
    (when (and (null type) (null code-obj))
      (error "Could not establish the type of the variable: ~s" var-name))
    (when (and code-obj type (not (v-type-eq (code-type code-obj) type)))
      (error "Type specified does not match the type of the form~%~s~%~s"
             (code-type code-obj) type))
  