diff --git a/scripts/system/assets/sounds/entitySnap.wav b/scripts/system/assets/sounds/entitySnap.wav
new file mode 100644
index 0000000000..4584f3dcaa
Binary files /dev/null and b/scripts/system/assets/sounds/entitySnap.wav differ
diff --git a/scripts/tutorials/entity_scripts/magneticBlock.js b/scripts/tutorials/entity_scripts/magneticBlock.js
index 6eb0900db5..73f317e3b2 100644
--- a/scripts/tutorials/entity_scripts/magneticBlock.js
+++ b/scripts/tutorials/entity_scripts/magneticBlock.js
@@ -1,30 +1,34 @@
 (function(){
 
+
+  const SNAPSOUND = SoundCache.getSound(Script.resolvePath("../../system/assets/sounds/entitySnap.wav?xrs"));
+  const RANGE_MULTIPLER = 1.5;
+
   // Helper for detecting nearby objects
   function findEntitiesInRange(releasedProperties) {
     var dimensions = releasedProperties.dimensions;
-    return Entities.findEntities(releasedProperties.position, ((dimensions.x + dimensions.y + dimensions.z) / 3) *1.5);
+    return Entities.findEntities(releasedProperties.position, ((dimensions.x + dimensions.y + dimensions.z) / 3) * RANGE_MULTIPLER);
   }
-  function getNearestValidEntityProperties(id) {
-    var releasedProperties = Entities.getEntityProperties(id,["position", "rotation", "dimensions"]);
+
+  function getNearestValidEntityProperties(releasedProperties) {
     var entities = findEntitiesInRange(releasedProperties);
     var nearestEntity = null;
-    var nearest = -1;
+    var nearest = 9999999999999;
     var releaseSize = Vec3.length(releasedProperties.dimensions);
     entities.forEach(function(entityId) {
-      print('ftest ' + entityId);
-      var entity = Entities.getEntityProperties(entityId, ['position', 'rotation', 'dimensions']);
-      var distance = Vec3.distance(releasedProperties.position, entity.position);
-      var scale = releaseSize/Vec3.length(entity.dimensions);
-      if ((nearest === -1 || distance < nearest && scale >= 0.5 && scale <= 2 ) && entity.id !== entityId) {
-        nearestEntity = entity;
-        dnearest = distance;
+      if(entityId !== releasedProperties.id) {
+        var entity = Entities.getEntityProperties(entityId, ['position', 'rotation', 'dimensions']);
+        var distance = Vec3.distance(releasedProperties.position, entity.position);
+        var scale = releaseSize/Vec3.length(entity.dimensions);
+
+        if (distance < nearest && (scale >= 0.5 && scale <= 2)) {
+          nearestEntity = entity;
+          nearest = distance;
+        }
       }
     })
     return nearestEntity;
-
   }
-
   // Create the 'class'
   function MagneticBlock () {  }
   // Bind pre-emptive events
@@ -52,13 +56,56 @@
       var t = this;
       this.callbacks = {};
       this.callbacks["releaseGrab"] = function () {
-        var nearest = getNearestValidEntityProperties(id);
+          var released = Entities.getEntityProperties(id,["position", "rotation", "dimensions"]);
+          var target = getNearestValidEntityProperties(released);
+          if (target !== null) {
+              // We found nearest, now lets do the snap calculations
+              // Plays the snap sound between the two objects.
+              Audio.playSound(SNAPSOUND, {
+                  volume: 1,
+                  position: Vec3.mix(target.position, released.position, 0.5)
+              });
+              // Check Nearest Axis
+              var difference = Vec3.subtract(released.position, target.position);
+              var relativeDifference = Vec3.multiplyQbyV(Quat.inverse(target.rotation), difference);
 
-        print(JSON.stringify(nearest));
+              var abs = {
+                  x: Math.abs(relativeDifference.x),
+                  y: Math.abs(relativeDifference.y),
+                  z: Math.abs(relativeDifference.z)
+              };
+
+              if (abs.x >= abs.y && abs.x >= abs.z) {
+                  relativeDifference.y = 0;
+                  relativeDifference.z = 0;
+                  if (relativeDifference.x > 0) {
+                      relativeDifference.x = target.dimensions.x / 2 + released.dimensions.x / 2;
+                  } else {
+                      relativeDifference.x = -target.dimensions.x / 2 - released.dimensions.x / 2;
+                  }
+              } else if (abs.y >= abs.x && abs.y >= abs.z) {
+                  relativeDifference.x = 0;
+                  relativeDifference.z = 0;
+                  if (relativeDifference.y > 0) {
+                      relativeDifference.y = target.dimensions.y / 2 + released.dimensions.y / 2;
+                  } else {
+                      relativeDifference.y = -target.dimensions.y / 2 - released.dimensions.y / 2;
+                  }
+              } else if (abs.z >= abs.x && abs.z >= abs.y ) {
+                  relativeDifference.x = 0;
+                  relativeDifference.y = 0;
+                  if (relativeDifference.z > 0) {
+                      relativeDifference.z = target.dimensions.z / 2 + released.dimensions.z / 2;
+                  } else {
+                      relativeDifference.z = -target.dimensions.z / 2 - released.dimensions.z / 2;
+                  }
+              }
+              var newPosition = Vec3.multiplyQbyV(target.rotation, relativeDifference);
+              Entities.editEntity(id, {rotation: target.rotation, position: Vec3.sum(target.position, newPosition)})
+          }
       }
 
       this.releaseGrab = this.callbacks["releaseGrab"];
-
       Script.scriptEnding.connect( function () {
         Script.removeEventHandler(id, "releaseGrab", this.callbacks["releaseGrab"]); //continueNearGrab
       })
diff --git a/scripts/tutorials/makeBlocks.js b/scripts/tutorials/makeBlocks.js
index e69de29bb2..6a8b95bb3f 100644
--- a/scripts/tutorials/makeBlocks.js
+++ b/scripts/tutorials/makeBlocks.js
@@ -0,0 +1,15 @@
+// Toy
+const MAX_RGB_COMPONENT_VALUE = 256 / 2; // Limit the values to half the maximum.
+const MIN_COLOR_VALUE = 127;
+function newColor() {
+  color = {
+    red: randomPastelRGBComponent(),
+    green: randomPastelRGBComponent(),
+    blue: randomPastelRGBComponent()
+  };
+  return color;
+  }
+// Helper functions.
+function randomPastelRGBComponent() {
+  return Math.floor(Math.random() * MAX_RGB_COMPONENT_VALUE) + MIN_COLOR_VALUE;
+}