anchor.diff:                 ,(length definitions))))))))
   
   (defun expand-slot-to-layout (slot &optional type normalize)
  +  ;; if it one of the types in *cpu->gpu-vec-mappings* then it is one
  +  ;; where the gpu side type will be different from the cpu-side one
  +  ;; this means we cant rely on the varjo type introspection
  +  (if (and (not type) (assoc (s-type slot) *cpu->gpu-vec-mappings*))
  +      (expand-unmappable-slot-to-layout slot type normalize)
  +      (expand-mappable-slot-to-layout slot type normalize)))
  +
  +(defun expand-unmappable-slot-to-layout (slot type normalize)
  +  (assert (not type))
  +  (ecase (s-type slot)
  +    (:uint8-vec2 (list (list 2 :uint8 normalize :unsigned-byte)))
  +    (:uint8-vec3 (list (list 3 :uint8 normalize :unsigned-byte)))
  +    (:uint8-vec4 (list (list 4 :uint8 normalize :unsigned-byte)))))
  +
  +(defun expand-mappable-slot-to-layout (slot type normalize)
     (let ((type (or type (type-spec->type (s-type slot))))
           (normalize (or normalize (when slot (s-normalizedp slot)))))
  +    ;;
       (cond ((v-typep type 'v-matrix)
              (let ((v-type (type-spec->type
                             (kwd :vec (second (v-dimensions type))))))
                (setf (slot-value v-type 'varjo::element-type)
                      (type->spec (v-element-type type))) ;ugh
                (loop for i below (first (v-dimensions type))
  -                :append (expand-slot-to-layout nil v-type normalize))))
  +                :append (expand-mappable-slot-to-layout nil v-type normalize))))
  +          ;;
             ((v-typep type 'v-vector)
  -           `((,(apply #'* (v-dimensions type))
  -               ,(type->spec (v-element-type type))
  -               ,normalize)))
  +           (list (list (apply #'* (v-dimensions type))
  +                       (type->spec (v-element-type type))
  +                       normalize)))
  +          ;;
             ((v-typep type 'v-array)
              (loop for i below (apply #'* (v-dimensions type))
  -              :append (expand-slot-to-layout
  +              :append (expand-mappable-slot-to-layout
                          nil (v-element-type type) normalize)))
  +          ;;
             (t `((1 ,(type->spec type) ,normalize))))))
   
   ;;------------------------------------------------------------
  
positive.code: (in-package :cepl.types)
  
  (defgeneric s-arrayp (object))
  (defgeneric s-prim-p (object))
  
negative.code: ;;------------------------------------------------------------
  
  (defun buffer-stream-comptible-typep (slot)
    (let* ((type-spec (s-type slot)))
      (or (not (null (cdr (assoc type-spec *cpu->gpu-vec-mappings*))))
          (core-typep (type-spec->type type-spec)))))
  
  (defun make-struct-attrib-assigner (type-name slots)
    (when (every #'buffer-stream-comptible-typep slots)
  