anchor.diff:    (cluster-scale  1.56  :read-only t)
     (velocity-scale 2.64  :read-only t))
   
  -(defun init-body-sysmem (num-bodies gpu-p)
  +(defun init-body-system (num-bodies &key (gpu t) (interop nil))
  +  (when (and (null gpu) interop)
  +    (error "Interoperability is available only on GPU"))
     (let ((system (make-body-system)))
       (setf (num-bodies system) num-bodies)
  -    (init-cuda-context 0)
  -    (init-memory-blocks system gpu-p)
  +    (init-cuda-context 0 :interop t)
  +    (init-memory-blocks system gpu interop)
       (reset-body-system system)
  -    (when gpu-p
  +    (when gpu
         (memcpy-array-host-to-device (old-pos system))
         (memcpy-array-host-to-device (vel system)))
       system))
   
  -(defun init-memory-blocks (system gpu-p)
  +(defun lookup-array-type (gpu interop)
  +  (if gpu
  +      (if interop
  +          :gpu/interop
  +          :gpu)
  +      (if interop
  +          (error "Interoperability is available only on GPU")
  +          :cpu)))
  +
  +(defun init-memory-blocks (system gpu interop)
     (symbol-macrolet ((new-pos    (new-pos system))
                       (old-pos    (old-pos system))
                       (vel        (vel system))
                       (num-bodies (num-bodies system)))
  -    (setf new-pos (alloc-array num-bodies gpu-p)
  -          old-pos (alloc-array num-bodies gpu-p)
  -          vel     (alloc-array num-bodies gpu-p))))
  +    (let ((array-type (lookup-array-type gpu interop)))
  +      (setf new-pos (alloc-array num-bodies array-type)
  +            old-pos (alloc-array num-bodies array-type)
  +            vel     (alloc-array num-bodies array-type)))))
   
   (defun release-body-system (system)
     (release-memory-blocks system)
  
positive.code: 
  (defun update-body-system (system)
    (symbol-macrolet ((new-pos    (new-pos system))
                      (old-pos    (old-pos system))
                      (vel        (vel system))
                      (delta-time (delta-time system))
                      (damping    (damping system))
                      (num-bodies (num-bodies system))
                      (p          (p system)))
      (ecase (array-type new-pos)
        (:cpu (integrate-nbody-system-cpu new-pos old-pos vel delta-time damping num-bodies))
        (:gpu (integrate-nbody-system-gpu new-pos old-pos vel delta-time damping num-bodies p)))
      (rotatef new-pos old-pos)))
  
  
  ;;;
  
negative.code:   (destructuring-bind (x y z w) val
      (destructuring-bind (type raw-ary) ary
        (ecase type
          ((:gpu :gpu/interop)
                (setf (mem-aref raw-ary i) (make-float4 x y z w)))
          (:cpu (setf (vec3-aref raw-ary i :x) x
                      (vec3-aref raw-ary i :y) y
                      (vec3-aref raw-ary i :z) z))))))
  