anchor.diff:                         (nth 2 quant)
                          0))
              (time (+ (or (raw-event-value item :latency) *latency*)
  -                    (or (timestamp-to-cl-collider (raw-event-value item :timestamp-at-start)) (sc:now))
  +                    (or (timestamp-to-cl-collider (raw-event-value item :timestamp-at-start)) (cl-collider:now))
                       (time-dur (or (raw-event-value item :timing-offset) 0) (tempo *clock*))
                       offset))
              (params (supercollider-make-synth-args-list inst item)))
         (if (or (eql (event-value item :type) :mono)
  -              (typep inst 'sc::node))
  -          (let ((node (sc:at time
  +              (typep inst 'cl-collider::node))
  +          (let ((node (cl-collider:at time
                           (let ((nodes (task-nodes task *supercollider-node-map*)))
                             (cond ((not (null nodes))
  -                                 (apply #'sc:ctrl (car nodes) params))
  -                                ((typep inst 'sc::node)
  +                                 (apply #'cl-collider:ctrl (car nodes) params))
  +                                ((typep inst 'cl-collider::node)
                                    ;; redefining a proxy changes its Node's ID.
                                    ;; thus if the user redefines a proxy, the Node object previously provided to the pbind will become inaccurate.
                                    ;; thus we look up the proxy in the node-proxy-table to ensure we always have the correct ID.
                                    (let ((node (or (get-proxys-node-id inst)
                                                    inst)))
  -                                   (apply #'sc:ctrl node params)))
  +                                   (apply #'cl-collider:ctrl node params)))
                                   (t
  -                                 (apply #'sc:synth inst params)))))))
  -            (unless (or (typep inst 'sc::node)
  +                                 (apply #'cl-collider:synth inst params)))))))
  +            (unless (or (typep inst 'cl-collider::node)
                           (not (has-gate-p inst :supercollider)))
                 (if (< (legato item) 1)
  -                  (sc:at (+ time (dur-time (sustain item)))
  +                  (cl-collider:at (+ time (dur-time (sustain item)))
                       (setf (task-nodes task *supercollider-node-map*) nil)
  -                    (sc:release node))
  +                    (cl-collider:release node))
                     (setf (task-nodes task *supercollider-node-map*) (list node)))))
  -          (let ((node (sc:at time
  -                        (apply #'sc:synth inst params))))
  +          (let ((node (cl-collider:at time
  +                        (apply #'cl-collider:synth inst params))))
               (when (has-gate-p node :supercollider)
  -              (sc:at (+ time (dur-time (sustain item)))
  -                (sc:release node))))))))
  +              (cl-collider:at (+ time (dur-time (sustain item)))
  +                (cl-collider:release node))))))))
   
   (defmethod backend-task-removed (task (backend (eql :supercollider)))
     (let ((item (slot-value task 'item)))
       (unless (typep item 'event)
         (let ((last-output (last-output item)))
           (dolist (node (task-nodes task *supercollider-node-map*))
  -          (sc:at (timestamp-to-cl-collider
  -                  (absolute-beats-to-timestamp (+ (slot-value task 'start-beat) (beat last-output) (sustain last-output))
  -                                               (slot-value task 'clock)))
  -            (sc:release node))))))
  +          (cl-collider:at (timestamp-to-cl-collider
  +                           (absolute-beats-to-timestamp (+ (slot-value task 'start-beat) (beat last-output) (sustain last-output))
  +                                                        (slot-value task 'clock)))
  +            (cl-collider:release node))))))
     (setf (task-nodes task *supercollider-node-map*) nil))
   
   ;;; convenience methods
   
  -(defmethod play ((object sc::node))
  +(defmethod play ((object cl-collider::node))
     t)
   
  -(defmethod stop ((object sc::node))
  -  (sc:stop object))
  +(defmethod stop ((object cl-collider::node))
  +  (cl-collider:stop object))
   
  -(defmethod end ((object sc::node))
  -  (sc:release object))
  +(defmethod end ((object cl-collider::node))
  +  (cl-collider:release object))
   
  -(defmethod playing-p ((node sc::node) &optional (server sc:*s*))
  -  (when (position (sc::node-watcher server) (sc::id node))
  +(defmethod playing-p ((node cl-collider::node) &optional (server cl-collider:*s*))
  +  (when (position (cl-collider::node-watcher server) (cl-collider::id node))
       t))
   
   (register-backend :supercollider)
  
positive.code: 
  (defun get-proxys-node-id (name)
    "Get the current node ID of the proxy NAME, or NIL if it doesn't exist in cl-collider's node-proxy-table."
    (if (typep name 'sc::node)
        (get-proxys-node-id (alexandria:make-keyword (string-upcase (slot-value name 'sc::name))))
        (alexandria:when-let ((val (gethash name (sc::node-proxy-table sc::*s*))))
          (sc::id val))))
  
  (defgeneric supercollider-convert-object (object key)
    (:documentation "Method used to convert objects in events to values the SuperCollider server can understand. For example, any `cl-collider::buffer' objects are converted to their bufnum."))
  
negative.code:   (declare (ignore key))
    object)
  
  (defmethod supercollider-convert-object ((object cl-collider::buffer) key)
    (declare (ignore key))
    (cl-collider:bufnum object))
  
  (defmethod supercollider-convert-object ((object cl-collider::bus) key)
    (declare (ignore key))
    (cl-collider:busnum object))
  
  (defmethod supercollider-convert-object ((object cl-collider::node) key)
    (let ((bus (if (eql key :out)
                   (cl-collider:get-synthdef-metadata object :input-bus)
                   (or (cl-collider:get-synthdef-metadata object :output-bus)
                       (cl-collider:get-synthdef-metadata object :input-bus)))))
      (if bus
          (cl-collider:busnum bus)
          object)))
  
  (defmethod supercollider-convert-object ((object cl-collider::group) key)
    (declare (ignore key))
    (cl-collider::id object))
  
  (defvar *supercollider-node-map* (make-node-map)
    "Hash mapping cl-patterns tasks to SuperCollider nodes.")
  