diff --git a/Examples/BoneShaving/BoneShavingExample.cpp b/Examples/BoneShaving/BoneShavingExample.cpp
index 985c6600cfd4ed3ee3c5258ec9332f19c48bd304..94ad4f0410a72dfb728627b55a142c3471d18821 100644
--- a/Examples/BoneShaving/BoneShavingExample.cpp
+++ b/Examples/BoneShaving/BoneShavingExample.cpp
@@ -19,42 +19,36 @@
 
 =========================================================================*/
 
+#include "imstkLogger.h"
 #include "imstkMath.h"
-#include "imstkTimer.h"
-#include "imstkScene.h"
 #include "imstkNew.h"
-#include "imstkLogger.h"
+#include "imstkScene.h"
 #include "imstkSceneManager.h"
 #include "imstkVTKViewer.h"
-#include "imstkMouseSceneControl.h"
-#include "imstkKeyboardSceneControl.h"
 
 // Objects
+#include "imstkCamera.h"
 #include "imstkCollidingObject.h"
 #include "imstkLight.h"
-#include "imstkCamera.h"
 
 // Geometry
+#include "imstkMeshIO.h"
 #include "imstkSphere.h"
 #include "imstkTetrahedralMesh.h"
-#include "imstkSurfaceMesh.h"
-#include "imstkMeshIO.h"
 
 // Devices and controllers
 #include "imstkHapticDeviceClient.h"
 #include "imstkHapticDeviceManager.h"
+#include "imstkKeyboardSceneControl.h"
+#include "imstkMouseSceneControl.h"
 #include "imstkSceneObjectController.h"
 
 // Collisions
 #include "imstkCollisionGraph.h"
-#include "imstkInteractionPair.h"
-#include "imstkPointSetToSphereCD.h"
-#include "imstkVirtualCouplingCH.h"
-#include "imstkBoneDrillingCH.h"
 #include "imstkObjectInteractionFactory.h"
 
 // global variables
-const std::string phantomOmni1Name = "Phantom1";
+const std::string phantomOmni1Name = "Default Device";
 
 using namespace imstk;
 
@@ -71,55 +65,45 @@ main()
     // Create Scene
     imstkNew<Scene> scene("BoneDrilling");
 
-    // Add virtual coupling object in the scene.
-#ifdef iMSTK_USE_OPENHAPTICS
-
     // Device Server
-    auto server = std::make_shared<HapticDeviceManager>();
-    auto client = server->makeDeviceClient(phantomOmni1Name);
+    imstkNew<HapticDeviceManager>       server;
+    std::shared_ptr<HapticDeviceClient> client = server->makeDeviceClient(phantomOmni1Name);
 
     // Create bone scene object
     // Load the mesh
-    auto tetMesh = MeshIO::read(iMSTK_DATA_ROOT "/asianDragon/asianDragon.veg");
+    auto tetMesh = MeshIO::read<TetrahedralMesh>(iMSTK_DATA_ROOT "/asianDragon/asianDragon.veg");
     if (!tetMesh)
     {
         LOG(FATAL) << "Could not read mesh from file.";
         return 1;
     }
-    auto bone = std::make_shared<CollidingObject>("Bone");
+    imstkNew<CollidingObject> bone("Bone");
     bone->setCollidingGeometry(tetMesh);
     bone->setVisualGeometry(tetMesh);
     scene->addSceneObject(bone);
 
     // Create a virtual coupling object: Drill
-    auto drillVisualGeom = std::make_shared<Sphere>();
-    drillVisualGeom->setRadius(3.);
-    auto drillCollidingGeom = std::make_shared<Sphere>();
-    drillCollidingGeom->setRadius(3.);
-    auto drill = std::make_shared<CollidingObject>("Drill");
-    drill->setCollidingGeometry(drillCollidingGeom);
-    drill->setVisualGeometry(drillVisualGeom);
+    imstkNew<Sphere>          drillGeom(Vec3d(0.0, 0.0, 0.0), 3.0);
+    imstkNew<CollidingObject> drill("Drill");
+    drill->setCollidingGeometry(drillGeom);
+    drill->setVisualGeometry(drillGeom);
     scene->addSceneObject(drill);
 
     // Create and add virtual coupling object controller in the scene
-    auto objController = std::make_shared<SceneObjectController>(drill, client);
-    scene->addController(objController);
+    imstkNew<SceneObjectController> controller(drill, client);
+    scene->addController(controller);
 
     // Add interaction
     scene->getCollisionGraph()->addInteraction(makeObjectInteractionPair(bone, drill,
         InteractionType::CollidingObjToCollidingObjBoneDrilling, CollisionDetection::Type::PointSetToSphere));
 
-#endif
-
     // Light
-    auto light = std::make_shared<DirectionalLight>("light");
-    light->setFocalPoint(Vec3d(5, -8, -5));
-    light->setIntensity(1);
+    imstkNew<DirectionalLight> light("light");
+    light->setFocalPoint(Vec3d(5.0, -8.0, -5.0));
+    light->setIntensity(1.0);
     scene->addLight(light);
 
-    //Run
-    auto cam = scene->getActiveCamera();
-    cam->setPosition(Vec3d(0, 0, 15));
+    scene->getActiveCamera()->setPosition(Vec3d(0.0, 3.0, 25.0));
 
     //Run the simulation
     {
@@ -131,8 +115,7 @@ main()
         imstkNew<SceneManager> sceneManager("Scene Manager 1");
         sceneManager->setActiveScene(scene);
         viewer->addChildThread(sceneManager); // SceneManager will start/stop with viewer
-
-        viewer->addChildThread(server);
+        viewer->addChildThread(server);       // Server starts/stops with viewer
 
         // Add mouse and keyboard controls to the viewer
         {
diff --git a/Examples/CameraController/CameraControllerExample.cpp b/Examples/CameraController/CameraControllerExample.cpp
index 7012a5c3a6c8fa3e3aa913c3b7eec59e69cc34f1..5cb6ef3b6424a821f5c229d0ebc9bd9ecc889444 100644
--- a/Examples/CameraController/CameraControllerExample.cpp
+++ b/Examples/CameraController/CameraControllerExample.cpp
@@ -19,29 +19,24 @@
 
 =========================================================================*/
 
-#include "imstkSceneObject.h"
-#include "imstkLight.h"
 #include "imstkCamera.h"
+#include "imstkCameraController.h"
+#include "imstkHapticDeviceClient.h"
+#include "imstkHapticDeviceManager.h"
+#include "imstkKeyboardSceneControl.h"
+#include "imstkLight.h"
+#include "imstkLogger.h"
 #include "imstkMeshIO.h"
-#include "imstkScene.h"
+#include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
-#include "imstkLogger.h"
+#include "imstkPlane.h"
+#include "imstkScene.h"
 #include "imstkSceneManager.h"
-#include "imstkVTKViewer.h"
-#include "imstkMouseSceneControl.h"
-#include "imstkKeyboardSceneControl.h"
-
+#include "imstkSceneObject.h"
 #include "imstkSurfaceMesh.h"
+#include "imstkVTKViewer.h"
 
-// Devices and controllers
-#include "imstkHapticDeviceClient.h"
-#include "imstkHapticDeviceManager.h"
-#include "imstkCameraController.h"
-#include "imstkCollisionGraph.h"
-
-#include "imstkScene.h"
-
-const std::string phantomOmni1Name = "Phantom1";
+const std::string phantomOmni1Name = "Default Device";
 
 using namespace imstk;
 
@@ -55,50 +50,37 @@ main()
     // Setup logger (write to file and stdout)
     Logger::startLogger();
 
-    #ifndef iMSTK_USE_OPENHAPTICS
-    std::cout << "Audio not enabled at build time" << std::endl;
-    return 1;
-    #endif
-
     // Create Scene
     imstkNew<Scene> scene("CameraController");
 
-#ifdef iMSTK_USE_OPENHAPTICS
-
     // Device Server
-    auto server = std::make_shared<HapticDeviceManager>();
-    auto client = server->makeDeviceClient(phantomOmni1Name);
-
-#else
-    LOG(WARNING) << "Phantom device option not enabled during build!";
-#endif
+    imstkNew<HapticDeviceManager>       server;
+    std::shared_ptr<HapticDeviceClient> client = server->makeDeviceClient(phantomOmni1Name);
 
     // Load Mesh
-    auto mesh       = MeshIO::read(iMSTK_DATA_ROOT "/asianDragon/asianDragon.obj");
-    auto meshObject = std::make_shared<VisualObject>("meshObject");
+    auto                   mesh = MeshIO::read<SurfaceMesh>(iMSTK_DATA_ROOT "/asianDragon/asianDragon.obj");
+    imstkNew<VisualObject> meshObject("meshObject");
     meshObject->setVisualGeometry(mesh);
     scene->addSceneObject(meshObject);
 
-    // Update Camera position
-    auto camera = scene->getActiveCamera();
-    camera->setPosition(Vec3d(0, 0, 10));
-
-#ifdef iMSTK_USE_OPENHAPTICS
+    imstkNew<VisualObject> planeObject("Plane");
+    imstkNew<Plane>        plane(Vec3d(0.0, -2.0, 0.0));
+    plane->setWidth(1000.0);
+    planeObject->setVisualGeometry(plane);
+    scene->addSceneObject(planeObject);
 
-    auto camController = std::make_shared<CameraController>(camera, client);
+    // Update Camera position
+    scene->getActiveCamera()->setPosition(Vec3d(0.0, 0.0, 10.0));
 
+    imstkNew<CameraController> camController(scene->getActiveCamera(), client);
     //camController->setTranslationScaling(100);
     //LOG(INFO) << camController->getTranslationOffset(); // should be the same than initial cam position
-    camController->setInversionFlags(CameraController::InvertFlag::rotY |
-                                     CameraController::InvertFlag::rotZ);
-
     scene->addController(camController);
-#endif
 
     // Light
-    auto light = std::make_shared<DirectionalLight>("light");
-    light->setFocalPoint(Vec3d(5, -8, -5));
-    light->setIntensity(1);
+    imstkNew<DirectionalLight> light("light");
+    light->setFocalPoint(Vec3d(5.0, -8.0, -5.0));
+    light->setIntensity(1.0);
     scene->addLight(light);
 
     //Run the simulation
@@ -111,7 +93,6 @@ main()
         imstkNew<SceneManager> sceneManager("Scene Manager 1");
         sceneManager->setActiveScene(scene);
         viewer->addChildThread(sceneManager); // SceneManager will start/stop with viewer
-
         viewer->addChildThread(server);
 
         // attach the camera controller to the viewer
@@ -129,7 +110,7 @@ main()
             viewer->addControl(keyControl);
         }
 
-        // Start viewer running, scene as paused
+        // Start viewer and its children
         viewer->start();
     }
 
diff --git a/Examples/ObjectController/ObjectControllerExample.cpp b/Examples/ObjectController/ObjectControllerExample.cpp
index 8e3464b236d11a011c091b59ed2d5a2f64ee7a18..5d17119b8ac7785fe616a4625fdd22139ba7fdd0 100644
--- a/Examples/ObjectController/ObjectControllerExample.cpp
+++ b/Examples/ObjectController/ObjectControllerExample.cpp
@@ -19,25 +19,23 @@
 
 =========================================================================*/
 
-#include "imstkNew.h"
-#include "imstkLogger.h"
-#include "imstkSceneManager.h"
-#include "imstkVTKViewer.h"
-#include "imstkMouseSceneControl.h"
-#include "imstkKeyboardSceneControl.h"
-
-#include "imstkCube.h"
 #include "imstkCamera.h"
-#include "imstkLight.h"
 #include "imstkCollidingObject.h"
+#include "imstkCube.h"
 #include "imstkHapticDeviceClient.h"
 #include "imstkHapticDeviceManager.h"
-#include "imstkSceneObjectController.h"
-#include "imstkCollisionGraph.h"
+#include "imstkKeyboardSceneControl.h"
+#include "imstkLight.h"
+#include "imstkLogger.h"
+#include "imstkMouseSceneControl.h"
+#include "imstkNew.h"
 #include "imstkScene.h"
+#include "imstkSceneManager.h"
+#include "imstkSceneObjectController.h"
+#include "imstkVTKViewer.h"
 
 // global variables
-const std::string phantomOmni1Name = "Phantom1";
+const std::string phantomOmni1Name = "Default Device";
 
 using namespace imstk;
 
@@ -48,8 +46,6 @@ using namespace imstk;
 int
 main()
 {
-#ifdef iMSTK_USE_OPENHAPTICS
-
     // Setup logger (write to file and stdout)
     Logger::startLogger();
 
@@ -57,32 +53,29 @@ main()
     imstkNew<Scene> scene("ObjectController");
 
     // Device Server
-    auto server = std::make_shared<HapticDeviceManager>();
-    auto client = server->makeDeviceClient(phantomOmni1Name);
+    imstkNew<HapticDeviceManager>       server;
+    std::shared_ptr<HapticDeviceClient> client = server->makeDeviceClient(phantomOmni1Name);
 
     // Object
-    auto geom = std::make_shared<Cube>();
-    geom->setPosition(0, 1, 0);
-    geom->setWidth(2);
-
-    auto object = std::make_shared<CollidingObject>("VirtualObject");
+    imstkNew<Cube>            geom(Vec3d(0.0, 1.0, 0.0), 2.0);
+    imstkNew<CollidingObject> object("VirtualObject");
     object->setVisualGeometry(geom);
     object->setCollidingGeometry(geom);
     scene->addSceneObject(object);
 
-    auto controller = std::make_shared<SceneObjectController>(object, client);
+    imstkNew<SceneObjectController> controller(object, client);
     controller->setTranslationScaling(0.1);
     scene->addController(controller);
 
     // Update Camera position
-    auto cam = scene->getActiveCamera();
-    cam->setPosition(Vec3d(0, 0, 10));
+    std::shared_ptr<Camera> cam = scene->getActiveCamera();
+    cam->setPosition(Vec3d(0.0, 0.0, 10.0));
     cam->setFocalPoint(geom->getPosition());
 
     // Light
-    auto light = std::make_shared<DirectionalLight>("light");
-    light->setFocalPoint(Vec3d(5, -8, -5));
-    light->setIntensity(1);
+    imstkNew<DirectionalLight> light("light");
+    light->setFocalPoint(Vec3d(5.0, -8.0, -5.0));
+    light->setIntensity(1.0);
     scene->addLight(light);
 
     //Run the simulation
@@ -110,9 +103,8 @@ main()
             viewer->addControl(keyControl);
         }
 
-        // Start viewer running, scene as paused
+        // Start the viewer and its children
         viewer->start();
     }
-#endif
     return 0;
 }
diff --git a/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp b/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp
index 0dac696ba0d1b2e4153cc8a9da49c36616dbec08..ed6df35219da121c25c5dd32e838fb06fb7114e3 100644
--- a/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp
+++ b/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp
@@ -19,35 +19,29 @@
 
 =========================================================================*/
 
-#include "imstkNew.h"
-#include "imstkLogger.h"
-#include "imstkSceneManager.h"
-#include "imstkVTKViewer.h"
-#include "imstkMouseSceneControl.h"
-#include "imstkKeyboardSceneControl.h"
-
-#include "imstkSceneManager.h"
-#include "imstkSceneObject.h"
-#include "imstkTetrahedralMesh.h"
-#include "imstkVirtualCouplingCH.h"
-#include "imstkHapticDeviceManager.h"
-#include "imstkHapticDeviceClient.h"
-#include "imstkSceneObjectController.h"
-#include "imstkPlane.h"
-#include "imstkSphere.h"
-#include "imstkRigidObject.h"
-#include "imstkRigidBodyModel.h"
-#include "imstkMeshIO.h"
+#include "imstkCamera.h"
 #include "imstkCube.h"
+#include "imstkHapticDeviceClient.h"
+#include "imstkHapticDeviceManager.h"
 #include "imstkIsometricMap.h"
+#include "imstkKeyboardSceneControl.h"
 #include "imstkLight.h"
-#include "imstkCamera.h"
+#include "imstkLogger.h"
+#include "imstkMeshIO.h"
+#include "imstkMouseSceneControl.h"
+#include "imstkNew.h"
+#include "imstkPlane.h"
+#include "imstkRenderMaterial.h"
 #include "imstkRigidBodyModel.h"
-#include "imstkCollisionGraph.h"
+#include "imstkRigidObject.h"
 #include "imstkScene.h"
-#include "imstkRenderMaterial.h"
+#include "imstkSceneManager.h"
+#include "imstkSceneObjectController.h"
+#include "imstkSphere.h"
 #include "imstkSurfaceMesh.h"
+#include "imstkTetrahedralMesh.h"
 #include "imstkVisualModel.h"
+#include "imstkVTKViewer.h"
 
 // global variables
 const std::string phantomOmni1Name = "Default Device";
@@ -55,145 +49,132 @@ const std::string phantomOmni1Name = "Default Device";
 using namespace imstk;
 
 std::shared_ptr<imstk::RigidObject>
-addMeshRigidObject(std::string& name, std::shared_ptr<Scene> scene, Vec3d pos)
+makeMeshRigidObject(const std::string& name, const Vec3d& pos)
 {
     // create cube object
-    auto meshObj = std::make_shared<RigidObject>(name);
+    imstkNew<RigidObject> meshObj("name");
 
     // Load a tetrahedral mesh
-    auto tetMesh = imstk::MeshIO::read(iMSTK_DATA_ROOT "/asianDragon/asianDragon.veg");
+    auto tetMesh = MeshIO::read<TetrahedralMesh>(iMSTK_DATA_ROOT "/asianDragon/asianDragon.veg");
     if (!tetMesh)
     {
         LOG(FATAL) << "Could not read mesh from file.";
     }
 
     // Extract the surface mesh
-    auto surfMesh   = std::make_shared<SurfaceMesh>();
-    auto volTetMesh = std::dynamic_pointer_cast<TetrahedralMesh>(tetMesh);
-    if (!volTetMesh)
-    {
-        LOG(FATAL) << "Dynamic pointer cast from PointSet to TetrahedralMesh failed!";
-    }
-    volTetMesh->scale(15., Geometry::TransformType::ApplyToData);
-    volTetMesh->translate(pos, Geometry::TransformType::ApplyToData);
-    volTetMesh->extractSurfaceMesh(surfMesh, true);
-
-    // add visual model
-    auto renderModel = std::make_shared<VisualModel>(surfMesh);
-    auto mat = std::make_shared<RenderMaterial>();
+    imstkNew<SurfaceMesh> surfMesh;
+    tetMesh->scale(15.0, Geometry::TransformType::ApplyToData);
+    tetMesh->translate(pos, Geometry::TransformType::ApplyToData);
+    tetMesh->extractSurfaceMesh(surfMesh, true);
+
+    // Add visual model
+    imstkNew<VisualModel>    renderModel(surfMesh.get());
+    imstkNew<RenderMaterial> mat;
     mat->setDisplayMode(RenderMaterial::DisplayMode::WireframeSurface);
-    mat->setLineWidth(2.);
+    mat->setLineWidth(2.0);
     mat->setColor(Color::Green);
     renderModel->setRenderMaterial(mat);
     meshObj->addVisualModel(renderModel);
 
     // add dynamic model
-    auto rigidModel = std::make_shared<RigidBodyModel>();
-    auto rigidProp  = std::make_shared<RigidBodyConfig>();
-    rigidProp->m_rigidBodyType = RigidBodyType::Kinematic;
-    rigidModel->configure(rigidProp);
+    imstkNew<RigidBodyModel>  rigidModel;
+    imstkNew<RigidBodyConfig> rigidConfig;
+    rigidConfig->m_rigidBodyType = RigidBodyType::Kinematic;
+    rigidModel->configure(rigidConfig);
     rigidModel->setModelGeometry(surfMesh);
     meshObj->setPhysicsGeometry(surfMesh);
     meshObj->setDynamicalModel(rigidModel);
 
-    // add cube to scene
-    scene->addSceneObject(meshObj);
     return meshObj;
 }
 
 std::shared_ptr<imstk::RigidObject>
-addCubeRigidObject(std::string& name, std::shared_ptr<Scene> scene, Vec3d pos, const bool isStatic = false)
+makeCubeRigidObject(const std::string& name, const Vec3d& pos, const bool isStatic)
 {
     // create cube object
-    auto cubeObj = std::make_shared<RigidObject>(name);
+    imstkNew<RigidObject> cubeObj(name);
 
     // Create Cube object
-    auto cubeGeom = std::make_shared<Cube>();
-    cubeGeom->setWidth(20.);
-    cubeGeom->translate(pos);
+    imstkNew<Cube> cubeGeom(pos, 20.0);
 
     // cube visual model
-    auto mesh = imstk::MeshIO::read(iMSTK_DATA_ROOT "/asianDragon/asianDragon.obj");
-    auto SurfaceMesh = std::dynamic_pointer_cast<imstk::SurfaceMesh>(mesh);
-    SurfaceMesh->scale(5., Geometry::TransformType::ApplyToData);
-    auto renderModel = std::make_shared<VisualModel>(cubeGeom);
-    auto mat = std::make_shared<RenderMaterial>();
+    auto surfMesh = MeshIO::read<SurfaceMesh>(iMSTK_DATA_ROOT "/asianDragon/asianDragon.obj");
+    surfMesh->scale(5., Geometry::TransformType::ApplyToData);
+    imstkNew<VisualModel>    renderModel(cubeGeom.get());
+    imstkNew<RenderMaterial> mat;
     mat->setDisplayMode(RenderMaterial::DisplayMode::Surface);
-    mat->setLineWidth(2.);
+    mat->setLineWidth(2.0);
     mat->setColor(Color::Orange);
     renderModel->setRenderMaterial(mat);
     cubeObj->addVisualModel(renderModel);
 
-    auto rigidMap = std::make_shared<IsometricMap>();
+    imstkNew<IsometricMap> rigidMap;
     rigidMap->setMaster(cubeGeom);
-    rigidMap->setSlave(SurfaceMesh);
+    rigidMap->setSlave(surfMesh);
 
     // cube dynamic model
-    auto rigidModel = std::make_shared<RigidBodyModel>();
-    auto rigidProp  = std::make_shared<RigidBodyConfig>();
-    rigidProp->m_rigidBodyType = RigidBodyType::Dynamic;
-    rigidModel->configure(rigidProp);
+    imstkNew<RigidBodyModel>  rigidModel;
+    imstkNew<RigidBodyConfig> rigidConfig;
+    rigidConfig->m_rigidBodyType = RigidBodyType::Dynamic;
+    rigidModel->configure(rigidConfig);
     rigidModel->setModelGeometry(cubeGeom);
     cubeObj->setDynamicalModel(rigidModel);
 
     cubeObj->setPhysicsToVisualMap(rigidMap);
 
-    // add cube to scene
-    scene->addSceneObject(cubeObj);
     return cubeObj;
 }
 
-void
-addPlaneRigidObject(std::shared_ptr<Scene> scene)
+std::shared_ptr<RigidObject>
+makePlaneRigidObject(const double width)
 {
     // create plane object
-    auto planeObj = std::make_shared<RigidObject>("Plane");
+    imstkNew<RigidObject> planeObj("Plane");
 
-    auto planeGeom = std::make_shared<Plane>();
-    planeGeom->setWidth(400.);
+    imstkNew<Plane> planeGeom;
+    planeGeom->setWidth(width);
 
     // visual model
-    auto renderModel2 = std::make_shared<VisualModel>(planeGeom);
-    renderModel2->setRenderMaterial(std::make_shared<RenderMaterial>());
-    planeObj->addVisualModel(renderModel2);
+    imstkNew<VisualModel> renderModel(planeGeom.get());
+    renderModel->setRenderMaterial(std::make_shared<RenderMaterial>());
+    planeObj->addVisualModel(renderModel);
 
     // dynamic model
-    auto rigidModel2 = std::make_shared<RigidBodyModel>();
-    auto rigidProp2  = std::make_shared<RigidBodyConfig>();
-    rigidProp2->m_rigidBodyType = RigidBodyType::Static;
-    rigidModel2->configure(rigidProp2);
-    rigidModel2->setModelGeometry(planeGeom);
-    planeObj->setDynamicalModel(rigidModel2);
-
-    scene->addSceneObject(planeObj);
+    imstkNew<RigidBodyModel>  rigidModel;
+    imstkNew<RigidBodyConfig> rigidConfig;
+    rigidConfig->m_rigidBodyType = RigidBodyType::Static;
+    rigidModel->configure(rigidConfig);
+    rigidModel->setModelGeometry(planeGeom);
+    planeObj->setDynamicalModel(rigidModel);
+
+    return planeObj;
 }
 
-void
-addSphereRigidObject(std::shared_ptr<Scene> scene, Vec3d t = Vec3d(0., 0., 0.))
+std::shared_ptr<RigidObject>
+makeSphereRigidObject(const Vec3d& t)
 {
     // create cube object
-    auto sphereObj = std::make_shared<RigidObject>("Sphere");
+    imstkNew<RigidObject> sphereObj("Sphere");
 
     // Create Cube object
-    auto sphereGeom = std::make_shared<Sphere>();
-    sphereGeom->setRadius(10.);
+    imstkNew<Sphere> sphereGeom;
+    sphereGeom->setRadius(10.0);
     sphereGeom->translate(t);
 
     // cube visual model
-    auto renderModel = std::make_shared<VisualModel>(sphereGeom);
+    imstkNew<VisualModel> renderModel(sphereGeom.get());
     renderModel->setRenderMaterial(std::make_shared<RenderMaterial>());
     sphereObj->addVisualModel(renderModel);
 
     // cube dynamic model
-    auto rigidModel3 = std::make_shared<RigidBodyModel>();
-    auto rigidProp   = std::make_shared<RigidBodyConfig>();
-    rigidProp->m_rigidBodyType = RigidBodyType::Dynamic;
-    rigidModel3->configure(rigidProp);
-    rigidModel3->setModelGeometry(sphereGeom);
-    sphereObj->setDynamicalModel(rigidModel3);
-
-    // add cube to scene
-    scene->addSceneObject(sphereObj);
+    imstkNew<RigidBodyModel>  rigidModel;
+    imstkNew<RigidBodyConfig> rigidConfig;
+    rigidConfig->m_rigidBodyType = RigidBodyType::Dynamic;
+    rigidModel->configure(rigidConfig);
+    rigidModel->setModelGeometry(sphereGeom);
+    sphereObj->setDynamicalModel(rigidModel);
+
+    return sphereObj;
 }
 
 int
@@ -205,52 +186,52 @@ main()
     // Create Scene
     imstkNew<Scene> scene("ControlRB");
 
-    auto cubeObj = addCubeRigidObject(std::string("cube"), scene, Vec3d(0., 0., 0.));
+    std::shared_ptr<RigidObject> cubeObj = makeCubeRigidObject("cube", Vec3d(0.0, 0.0, 0.0), false);
+    scene->addSceneObject(cubeObj);
+
+    std::shared_ptr<RigidObject> planeObj = makePlaneRigidObject(400.0);
+    scene->addSceneObject(planeObj);
+
+    //makeSphereRigidObject(Vec3d(0.0, 200.0, 0..0));
 
-    addPlaneRigidObject(scene);
-    //addSphereRigidObject(scene, Vec3d(0., 200, 0.));
-    auto rigidObj = addMeshRigidObject(std::string("dragon"), scene, Vec3d(0., 30., 0.));
+    std::shared_ptr<RigidObject> meshObj = makeMeshRigidObject("dragon", Vec3d(0.0, 30.0, 0.0));
+    scene->addSceneObject(meshObj);
 
     //-------------------------------------------------------------
 
     // Device Server
-    auto server = std::make_shared<HapticDeviceManager>();
-    auto client = server->makeDeviceClient(phantomOmni1Name);
+    imstkNew<HapticDeviceManager>       server;
+    std::shared_ptr<HapticDeviceClient> client = server->makeDeviceClient(phantomOmni1Name);
 
     // Create a virtual coupling object
-    auto visualGeom = std::make_shared<Sphere>();
-    visualGeom->setRadius(5.);
-    auto obj         = std::make_shared<VisualObject>("VirtualCouplingObject");
-    auto material    = std::make_shared<RenderMaterial>();
-    auto visualModel = std::make_shared<VisualModel>(visualGeom);
+    imstkNew<Sphere>         visualGeom(Vec3d(0.0, 0.0, 0.0), 5.0);
+    imstkNew<VisualObject>   obj("virtualCouplingObject");
+    imstkNew<RenderMaterial> material;
+    imstkNew<VisualModel>    visualModel(visualGeom.get());
     visualModel->setRenderMaterial(material);
     obj->addVisualModel(visualModel);
     scene->addSceneObject(obj);
 
     // Device tracker
-    auto objController = std::make_shared<imstk::SceneObjectController>(obj, client);
-    scene->addController(objController);
+    imstkNew<SceneObjectController> controller(obj, client);
+    scene->addController(controller);
 
     //-----------------------------------------------------------------
+    std::shared_ptr<RigidBodyModel> rbdModel = cubeObj->getRigidBodyModel();
 
-    auto rbModel = std::dynamic_pointer_cast<RigidBodyModel>(cubeObj->getDynamicalModel());
-
-    if (!rbModel)
+    if (!rbdModel.get())
     {
-        addCubeRigidObject(std::string("cube"), scene, Vec3d(0., 40., 0.));
+        std::shared_ptr<RigidObject> cubeObj2 = makeCubeRigidObject("cube", Vec3d(0.0, 40.0, 0.0), false);
+        scene->addSceneObject(cubeObj2);
         // throw error
     }
-    auto prevCubePos = rbModel->getModelGeometry()->getTranslation();
-
-    //-------------------------------------------------------------------
 
     // Set Camera configuration
-    auto cam = scene->getActiveCamera();
-    cam->setPosition(Vec3d(300, 300, 300));
+    scene->getActiveCamera()->setPosition(Vec3d(300.0, 300.0, 300.0));
 
     // Light
-    auto light = std::make_shared<DirectionalLight>("light");
-    light->setIntensity(1);
+    imstkNew<DirectionalLight> light("light");
+    light->setIntensity(1.0);
     scene->addLight(light);
 
     // Run
@@ -279,18 +260,19 @@ main()
             viewer->addControl(keyControl);
         }
 
+        Vec3d prevCubePos = rbdModel->getModelGeometry()->getTranslation();
         connect<Event>(sceneManager, EventType::PostUpdate,
             [&](Event*)
         {
-            const auto devPos = objController->getPosition();
-            const auto devQ   = objController->getRotation();
-            rbModel->getModelGeometry()->rotate(devQ);
-            auto cubeGeo      = std::dynamic_pointer_cast<Cube>(cubeObj->getPhysicsGeometry());
-            auto cubePos      = rbModel->getModelGeometry()->getTranslation();
-            auto cubeVelocity = (cubePos - prevCubePos) / 2;
-            auto damp  = -1000000 * cubeVelocity;
-            auto force = -1000 * (cubePos - devPos) + damp;
-            rbModel->addForce(force, Vec3d(0., 0., 0.));
+            const auto devPos = controller->getPosition();
+            const auto devQ   = controller->getRotation();
+            rbdModel->getModelGeometry()->rotate(devQ);
+            auto cubeGeo = std::dynamic_pointer_cast<Cube>(cubeObj->getPhysicsGeometry());
+            const Vec3d cubePos      = rbdModel->getModelGeometry()->getTranslation();
+            const Vec3d cubeVelocity = (cubePos - prevCubePos) / 2.0;
+            const Vec3d damp  = -1000000 * cubeVelocity;
+            const Vec3d force = -1000 * (cubePos - devPos) + damp;
+            rbdModel->addForce(force, Vec3d(0.0, 0.0, 0.0));
             prevCubePos = cubePos;
             });
 
diff --git a/Examples/VirtualCoupling/VirtualCouplingExample.cpp b/Examples/VirtualCoupling/VirtualCouplingExample.cpp
index edc3227360c7da52a244c82cc3c4a3d7bcb5a9d4..7d2253acb84c707cefc6c5211abb8503e9782786 100644
--- a/Examples/VirtualCoupling/VirtualCouplingExample.cpp
+++ b/Examples/VirtualCoupling/VirtualCouplingExample.cpp
@@ -19,32 +19,30 @@
 
 =========================================================================*/
 
-#include "imstkCollidingObject.h"
-#include "imstkObjectInteractionFactory.h"
-#include "imstkVirtualCouplingCH.h"
-#include "imstkHapticDeviceManager.h"
-#include "imstkHapticDeviceClient.h"
-#include "imstkSceneObjectController.h"
+#include "imstkCamera.h"
 #include "imstkCDObjectFactory.h"
-#include "imstkCollisionGraph.h"
-#include "imstkCollisionPair.h"
+#include "imstkCollidingObject.h"
 #include "imstkCollisionData.h"
-#include "imstkVisualModel.h"
-#include "imstkRenderMaterial.h"
 #include "imstkCollisionGraph.h"
+#include "imstkCollisionPair.h"
+#include "imstkHapticDeviceClient.h"
+#include "imstkHapticDeviceManager.h"
+#include "imstkKeyboardSceneControl.h"
 #include "imstkLight.h"
-#include "imstkCamera.h"
+#include "imstkMouseSceneControl.h"
+#include "imstkNew.h"
 #include "imstkPlane.h"
-#include "imstkSphere.h"
+#include "imstkRenderMaterial.h"
 #include "imstkScene.h"
-#include "imstkNew.h"
-#include "imstkVTKViewer.h"
 #include "imstkSceneManager.h"
-#include "imstkKeyboardSceneControl.h"
-#include "imstkMouseSceneControl.h"
+#include "imstkSceneObjectController.h"
+#include "imstkSphere.h"
+#include "imstkVirtualCouplingCH.h"
+#include "imstkVisualModel.h"
+#include "imstkVTKViewer.h"
 
 // global variables
-const std::string phantomOmni1Name = "Phantom1";
+const std::string phantomOmni1Name = "Default Device";
 
 using namespace imstk;
 
@@ -58,18 +56,14 @@ main()
     // Setup logger (write to file and stdout)
     Logger::startLogger();
 
-#ifndef iMSTK_USE_OPENHAPTICS
-    std::cout << "LaparoscopicToolController example needs haptic device to be enabled at build time" << std::endl;
-    return 1;
-#else if
     // Scene
     imstkNew<Scene> scene("VirtualCoupling");
 
     // Create a plane in the scene
-    auto planeGeom = std::make_shared<Plane>();
-    planeGeom->setWidth(400);
-    planeGeom->setPosition(0.0, -50, 0.0);
-    auto planeObj = std::make_shared<CollidingObject>("Plane");
+    auto            planeGeom = std::make_shared<Plane>();
+    imstkNew<Plane> plane(Vec3d(0.0, -50.0, 0.0));
+    planeGeom->setWidth(400.0);
+    imstkNew<CollidingObject> planeObj("Plane");
     planeObj->setVisualGeometry(planeGeom);
     planeObj->setCollidingGeometry(planeGeom);
     scene->addSceneObject(planeObj);
@@ -77,19 +71,17 @@ main()
     // Create the virtual coupling object controller
 
     // Device Server
-    auto server = std::make_shared<HapticDeviceManager>();
-    auto client = server->makeDeviceClient(phantomOmni1Name);
+    imstkNew<HapticDeviceManager>       server;
+    std::shared_ptr<HapticDeviceClient> client = server->makeDeviceClient(phantomOmni1Name);
 
     // Create a virtual coupling object
-    auto visualGeom = std::make_shared<Sphere>();
-    visualGeom->setRadius(20);
-    auto collidingGeom = std::make_shared<Sphere>();
-    collidingGeom->setRadius(20);
-    auto obj = std::make_shared<CollidingObject>("VirtualCouplingObject");
+    imstkNew<Sphere>          visualGeom(Vec3d(0.0, 0.0, 0.0), 20.0);
+    imstkNew<Sphere>          collidingGeom(Vec3d(0.0, 0.0, 0.0), 20.0);
+    imstkNew<CollidingObject> obj("VirtualCouplingObject");
     obj->setCollidingGeometry(collidingGeom);
 
-    auto material    = std::make_shared<RenderMaterial>();
-    auto visualModel = std::make_shared<VisualModel>(visualGeom);
+    imstkNew<RenderMaterial> material;
+    imstkNew<VisualModel>    visualModel(visualGeom.get());
     visualModel->setRenderMaterial(material);
     obj->addVisualModel(visualModel);
 
@@ -97,34 +89,33 @@ main()
     scene->addSceneObject(obj);
 
     // Create and add virtual coupling object controller in the scene
-    auto objController = std::make_shared<SceneObjectController>(obj, client);
-    scene->addController(objController);
+    imstkNew<SceneObjectController> controller(obj, client);
+    scene->addController(controller);
 
     {
         // Setup CD, and collision data
-        auto colData = std::make_shared<CollisionData>();
+        imstkNew<CollisionData> colData;
 
         std::shared_ptr<CollisionDetection> colDetect = makeCollisionDetectionObject(CollisionDetection::Type::UnidirectionalPlaneToSphere,
             planeObj->getCollidingGeometry(), obj->getCollidingGeometry(), colData);
 
         // Setup the handler
-        auto colHandler = std::make_shared<VirtualCouplingCH>(CollisionHandling::Side::B, colData, obj);
+        imstkNew<VirtualCouplingCH> colHandler(CollisionHandling::Side::B, colData, obj);
         colHandler->setStiffness(5e-01);
         colHandler->setDamping(0.005);
 
-        auto pair = std::make_shared<CollisionPair>(planeObj, obj, colDetect, nullptr, colHandler);
+        imstkNew<CollisionPair> pair(planeObj, obj, colDetect, nullptr, colHandler);
         scene->getCollisionGraph()->addInteraction(pair);
     }
 
     // Camera
-    auto cam = scene->getActiveCamera();
-    cam->setPosition(Vec3d(200, 200, 200));
-    cam->setFocalPoint(Vec3d(0, 0, 0));
+    scene->getActiveCamera()->setPosition(Vec3d(200, 200, 200));
+    scene->getActiveCamera()->setFocalPoint(Vec3d(0, 0, 0));
 
     // Light
-    auto light = std::make_shared<DirectionalLight>("light");
-    light->setFocalPoint(Vec3d(5, -8, -5));
-    light->setIntensity(1);
+    imstkNew<DirectionalLight> light("light");
+    light->setFocalPoint(Vec3d(5.0, -8.0, -5.0));
+    light->setIntensity(1.0);
     scene->addLight(light);
 
     //Run the simulation
@@ -158,5 +149,4 @@ main()
     }
 
     return 0;
-#endif
 }
diff --git a/Source/Controllers/imstkSceneObjectController.cpp b/Source/Controllers/imstkSceneObjectController.cpp
index 01e2513f212f51f0d5a9781ffd7f446f86d2e2d6..0913ff36e4e2538321b39e9ffa9f5f9ba99ecb87 100644
--- a/Source/Controllers/imstkSceneObjectController.cpp
+++ b/Source/Controllers/imstkSceneObjectController.cpp
@@ -46,6 +46,16 @@ SceneObjectController::updateControlledObjects()
         }
     }
 
+    if (m_sceneObject == nullptr)
+    {
+        return;
+    }
+
+    if (!m_deviceClient->getTrackingEnabled())
+    {
+        return;
+    }
+
     this->postEvent(Event(EventType::Modified));
 
     // Update geometry
diff --git a/Source/Devices/imstkHapticDeviceClient.cpp b/Source/Devices/imstkHapticDeviceClient.cpp
index 1025366d315d886132c61df87859a01487dff325..beac639ef00c9643ed2429d57fbe4669256eb366 100644
--- a/Source/Devices/imstkHapticDeviceClient.cpp
+++ b/Source/Devices/imstkHapticDeviceClient.cpp
@@ -20,11 +20,10 @@
 =========================================================================*/
 
 #include "imstkHapticDeviceClient.h"
+#include "imstkLogger.h"
 
-#include <HDU/hduVector.h>
 #include <HDU/hduError.h>
-
-#include "imstkLogger.h"
+#include <HDU/hduVector.h>
 
 namespace imstk
 {
@@ -70,9 +69,14 @@ HapticDeviceClient::disable()
 HDCallbackCode HDCALLBACK
 HapticDeviceClient::hapticCallback(void* pData)
 {
-    auto client = reinterpret_cast<HapticDeviceClient*>(pData);
-    auto handle = client->m_handle;
-    auto state  = client->m_state;
+    auto    client = static_cast<HapticDeviceClient*>(pData);
+    HHD     handle = client->m_handle;
+    HDstate state  = client->m_state;
+
+    if (handle == HD_BAD_HANDLE || handle == HD_INVALID_HANDLE)
+    {
+        return HD_CALLBACK_DONE;
+    }
 
     hdBeginFrame(handle);
 
@@ -93,6 +97,8 @@ HapticDeviceClient::hapticCallback(void* pData)
     client->m_buttons[2]  = state.buttons & HD_DEVICE_BUTTON_3;
     client->m_buttons[3]  = state.buttons & HD_DEVICE_BUTTON_4;
 
+    client->m_trackingEnabled = true;
+
     return HD_CALLBACK_DONE;
 }
 } // imstk
diff --git a/Source/Devices/imstkHapticDeviceClient.h b/Source/Devices/imstkHapticDeviceClient.h
index a3e964898fd583a082cc2a1358e98602f88208d7..ed9b11ff57fcc49d9d4e8e6c58eb671e5c702056 100644
--- a/Source/Devices/imstkHapticDeviceClient.h
+++ b/Source/Devices/imstkHapticDeviceClient.h
@@ -51,9 +51,9 @@ public:
 
 protected:
     ///
-    /// \brief Constructor/Destructor
+    /// \brief Constructor/Destructor, only the DeviceManager can construct
     ///
-    explicit HapticDeviceClient(const std::string& name) : DeviceClient(name, "localhost") {}
+    HapticDeviceClient(const std::string& name) : DeviceClient(name, "localhost"), m_handle(HD_INVALID_HANDLE) { }
 
     ///
     /// \brief Initialize the phantom omni device
diff --git a/Source/SceneEntities/Objects/imstkFeDeformableObject.cpp b/Source/SceneEntities/Objects/imstkFeDeformableObject.cpp
index d49510a0a844bf161759b65d0e48874f1c08a1db..ef34448492e5faed86276541a79eda0b5728d071 100644
--- a/Source/SceneEntities/Objects/imstkFeDeformableObject.cpp
+++ b/Source/SceneEntities/Objects/imstkFeDeformableObject.cpp
@@ -40,4 +40,11 @@ FeDeformableObject::initialize()
 
     return true;
 }
+
+std::shared_ptr<FEMDeformableBodyModel>
+FeDeformableObject::getFEMModel()
+{
+    m_femModel = std::dynamic_pointer_cast<FEMDeformableBodyModel>(m_dynamicalModel);
+    return m_femModel;
+}
 } // imstk
diff --git a/Source/SceneEntities/Objects/imstkFeDeformableObject.h b/Source/SceneEntities/Objects/imstkFeDeformableObject.h
index 429ca5d162a2c12a9d6ac24b2a56afb389be1d37..1cef4ac8e665a9428d971e9ed5862bde9eadfdcd 100644
--- a/Source/SceneEntities/Objects/imstkFeDeformableObject.h
+++ b/Source/SceneEntities/Objects/imstkFeDeformableObject.h
@@ -47,7 +47,7 @@ public:
     ///
     bool initialize() override;
 
-    std::shared_ptr<FEMDeformableBodyModel> getFEMModel() const { return m_femModel; }
+    std::shared_ptr<FEMDeformableBodyModel> getFEMModel();
 
 protected:
     std::shared_ptr<FEMDeformableBodyModel> m_femModel = nullptr;
diff --git a/Source/SceneEntities/Objects/imstkRigidObject.cpp b/Source/SceneEntities/Objects/imstkRigidObject.cpp
index fa2ebba781ae404919be4cf353ecb80b111c0cd0..887861a650ced49cbc5098fd463742d533222722 100644
--- a/Source/SceneEntities/Objects/imstkRigidObject.cpp
+++ b/Source/SceneEntities/Objects/imstkRigidObject.cpp
@@ -46,4 +46,11 @@ RigidObject::addForce(const Vec3d& force, const Vec3d& pos, bool wakeup)
 {
     m_rigidBodyModel->addForce(force, pos, wakeup);
 }
+
+std::shared_ptr<RigidBodyModel>
+RigidObject::getRigidBodyModel()
+{
+    m_rigidBodyModel = std::dynamic_pointer_cast<RigidBodyModel>(m_dynamicalModel);
+    return m_rigidBodyModel;
+}
 } // imstk
diff --git a/Source/SceneEntities/Objects/imstkRigidObject.h b/Source/SceneEntities/Objects/imstkRigidObject.h
index 6ca495fbc40185b7754c1b7ad9747c8a075328ff..8383495bfedcfbefe83a11972d1962be37cf6b32 100644
--- a/Source/SceneEntities/Objects/imstkRigidObject.h
+++ b/Source/SceneEntities/Objects/imstkRigidObject.h
@@ -53,7 +53,7 @@ public:
     ///
     void addForce(const Vec3d& force, const Vec3d& pos, bool wakeup = true);
 
-    std::shared_ptr<RigidBodyModel> getRigidBodyModel() const { return m_rigidBodyModel; }
+    std::shared_ptr<RigidBodyModel> getRigidBodyModel();
 
 protected:
     std::shared_ptr<RigidBodyModel> m_rigidBodyModel;
diff --git a/Source/SceneEntities/Objects/imstkRigidObject2.cpp b/Source/SceneEntities/Objects/imstkRigidObject2.cpp
index 3ffc0163b5b39c6c80560fcf4332ecb12666ed09..c907f9e6039090901c5b0c75506f94cf163e6f26 100644
--- a/Source/SceneEntities/Objects/imstkRigidObject2.cpp
+++ b/Source/SceneEntities/Objects/imstkRigidObject2.cpp
@@ -48,6 +48,13 @@ RigidObject2::initialize()
     return true;
 }
 
+std::shared_ptr<RigidBodyModel2>
+RigidObject2::getRigidBodyModel2()
+{
+    m_rigidBodyModel2 = std::dynamic_pointer_cast<RigidBodyModel2>(m_dynamicalModel);
+    return m_rigidBodyModel2;
+}
+
 void
 RigidObject2::setDynamicalModel(std::shared_ptr<AbstractDynamicalModel> dynaModel)
 {
diff --git a/Source/SceneEntities/Objects/imstkRigidObject2.h b/Source/SceneEntities/Objects/imstkRigidObject2.h
index 75866130ec5ffa4a69600fbf266024ae93ff6834..1a65255404a033e587fdc74827046cbc1dc70909 100644
--- a/Source/SceneEntities/Objects/imstkRigidObject2.h
+++ b/Source/SceneEntities/Objects/imstkRigidObject2.h
@@ -57,7 +57,7 @@ public:
     ///
     //void addForce(const Vec3d& force, const Vec3d& pos, bool wakeup = true);
 
-    std::shared_ptr<RigidBodyModel2> getRigidBodyModel2() const { return m_rigidBodyModel2; }
+    std::shared_ptr<RigidBodyModel2> getRigidBodyModel2();
 
     ///
     /// \brief Returns body in the model