anchor.diff:  
     phase.add(MakeStarScene(cgl, perspective, 2000));
   
  -  Material mat = Material("mat");
  -  Math.Random rng = Math.Random();
  +  final Material mat = Material("mat");
  +  final Math.Random rng = Math.Random();
  +  final VM.Quaternion start = VM.Quaternion.identity();
  +  final VM.Quaternion end = VM.Quaternion.identity();
  +  final VM.Vector3 axis = VM.Vector3(0.0, 0.0, 1.0);
  +  final Node node = Node.Container("wrapper");
  +  scene.add(node);
  +  node.lookAt(VM.Vector3(100.0, 0.0, -100.0));
   
  -  List<Future<Object>> futures = [
  -    LoadRaw(modelFile),
  -  ];
   
  -  Future.wait(futures).then((List list) {
  -    // Setup Mesh
  -    GeometryBuilder ctLogo = ImportGeometryFromWavefront(list[0]);
  -    MeshData md = GeometryBuilderToMeshData("", scene.program, ctLogo);
  -    Node mesh = Node(md.name, md, mat)
  -      ..rotX(3.14 / 2)
  -      ..rotZ(3.14);
  -    Node node = Node.Container("wrapper", mesh);
  -    //n.invert = true;
  -    node.lookAt(VM.Vector3(100.0, 0.0, -100.0));
  -    //n.matrix.scale(0.02);
  +  var future = LoadRaw(modelFile)
  +    ..then((String content) {
  +      final GeometryBuilder gb = ImportGeometryFromWavefront(content);
  +      final MeshData ctLogo = GeometryBuilderToMeshData("", scene.program, gb);
  +      final Node mesh = Node(ctLogo.name, ctLogo, mat)
  +        ..rotX(3.14 / 2)
  +        ..rotZ(3.14);
   
  -    VM.Vector3 axis = VM.Vector3(0.0, 0.0, 1.0);
  -    VM.Quaternion start = VM.Quaternion.identity();
  -    start.setFromRotation(node.transform.getRotation());
  -    VM.Quaternion end = VM.Quaternion.identity();
  -    end.setAxisAngle(axis, 3.14);
  -    double time = 0.0;
  +      //n.invert = true;
  +      //n.matrix.scale(0.02);
   
  -    void animateNode(double elapsedMs) {
  -      if (time < 1.0) {
  -        VM.Quaternion work = slerp(start, end, time += 0.2 * elapsedMs / 1000);
  -        VM.Matrix3 rm = work.asRotationMatrix();
  -        node.transform.setRotation(rm);
  -        return;
  +      start.setFromRotation(node.transform.getRotation());
  +      end.setAxisAngle(axis, 3.14);
  +      node.add(mesh);
  +    });
  +  gLoadables.add(future);
  +
  +  double time = 0.0;
  +  void animateNode(double elapsedMs) {
  +    if (time < 1.0) {
  +      VM.Quaternion work = slerp(start, end, time += 0.2 * elapsedMs / 1000);
  +      VM.Matrix3 rm = work.asRotationMatrix();
  +      node.transform.setRotation(rm);
  +      return;
  +    } else {
  +      print("new rotation");
  +      time = 0.0;
  +      double angle;
  +      if (rng.nextBool()) {
  +        axis..setValues(rng.nextDouble(), rng.nextDouble(), rng.nextDouble());
  +        axis.normalize();
  +        angle = 2 * Math.pi * rng.nextDouble();
         } else {
  -        print("new rotation");
  -        time = 0.0;
  -        double angle;
  -        if (rng.nextBool()) {
  -          axis..setValues(rng.nextDouble(), rng.nextDouble(), rng.nextDouble());
  -          axis.normalize();
  -          angle = 2 * Math.pi * rng.nextDouble();
  -        } else {
  -          // TODO(rhulha): the original value was all zero which caused the animation to stop.
  -          axis.setValues(1.0, 0.0, 0.0);
  -          angle = 0.0;
  -        }
  -        print("new rotation axis: " + axis.toString());
  -        start.setFromRotation(node.transform.getRotation());
  -        end.setAxisAngle(axis, angle);
  +        // TODO(rhulha): the original value was all zero which caused the animation to stop.
  +        axis.setValues(1.0, 0.0, 0.0);
  +        angle = 0.0;
         }
  +      print("new rotation axis: " + axis.toString());
  +      start.setFromRotation(node.transform.getRotation());
  +      end.setAxisAngle(axis, angle);
       }
  +  }
   
  -    scene.add(node);
  +  double _lastTimeMs = 0.0;
  +  void animate(num timeMs) {
  +    double elapsed = timeMs - _lastTimeMs;
  +    _lastTimeMs = timeMs + 0.0;
  +    orbit.azimuth += 0.001;
  +    orbit.animate(elapsed);
  +    animateNode(elapsed);
   
  -    double _lastTimeMs = 0.0;
  -    void animate(num timeMs) {
  -      double elapsed = timeMs - _lastTimeMs;
  -      _lastTimeMs = timeMs + 0.0;
  -      orbit.azimuth += 0.001;
  -      orbit.animate(elapsed);
  -      animateNode(elapsed);
  +    phase.Draw();
  +    HTML.window.animationFrame.then(animate);
  +  }
   
  -      phase.Draw();
  -      HTML.window.animationFrame.then(animate);
  -    }
  -
  +  Future.wait(gLoadables).then((List list) {
       animate(0.0);
     });
   }
  
positive.code: 
  const String modelFile = "../ct_logo.obj";
  
  void main() {
    HTML.CanvasElement canvas = HTML.document.querySelector('#webgl-canvas');
    ChronosGL cgl = ChronosGL(canvas);
    OrbitCamera orbit = OrbitCamera(15.0, -45.0, 0.3, canvas);
    Perspective perspective = Perspective(orbit, 1.0, 1000.0);
    final RenderPhaseResizeAware phase =
        RenderPhaseResizeAware("main", cgl, canvas, perspective);
  
    Scene scene = Scene(
        "demo",
        RenderProgram("demo", cgl, demoVertexShader, demoFragmentShader),
        [perspective]);
  
negative.code: }
  
  VM.Quaternion slerp(VM.Quaternion a, VM.Quaternion b, double t) {
    double ax = a[0],
        ay = a[1],
        az = a[2],
        aw = a[3];
    double bx = b[0],
        by = b[1],
        bz = b[2],
        bw = b[3];
    double omega, cosom, sinom, scale0, scale1;
  
    // calc cosine
  