diff --git a/CMakeLists.txt b/CMakeLists.txt
index c57bea20d8..173c6b0040 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,12 +40,21 @@ CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
 
 if (COMPILER_SUPPORTS_CXX11)
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+  
+  if (APPLE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+  endif ()
 elseif(COMPILER_SUPPORTS_CXX0X)
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
 else()
   message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
 endif()
 
+if (APPLE) 
+  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++0x")
+  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+endif ()
+
 if (ANDROID)
   if (NOT ANDROID_QT_CMAKE_PREFIX_PATH)
     set(QT_CMAKE_PREFIX_PATH $ENV{HIFI_ANDROID}/qt/5.3/android_armv7/lib/cmake)
diff --git a/assignment-client/src/audio/AudioMixer.cpp b/assignment-client/src/audio/AudioMixer.cpp
index 4173cacfc7..f8143f5198 100644
--- a/assignment-client/src/audio/AudioMixer.cpp
+++ b/assignment-client/src/audio/AudioMixer.cpp
@@ -439,12 +439,13 @@ int AudioMixer::prepareMixForListeningNode(Node* node) {
 
     // loop through all other nodes that have sufficient audio to mix
     int streamsMixed = 0;
-    foreach (const SharedNodePointer& otherNode, NodeList::getInstance()->getNodeHash()) {
+    
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& otherNode){
         if (otherNode->getLinkedData()) {
             AudioMixerClientData* otherNodeClientData = (AudioMixerClientData*) otherNode->getLinkedData();
-
+            
             // enumerate the ARBs attached to the otherNode and add all that should be added to mix
-
+            
             const QHash<QUuid, PositionalAudioStream*>& otherNodeAudioStreams = otherNodeClientData->getAudioStreams();
             QHash<QUuid, PositionalAudioStream*>::ConstIterator i;
             for (i = otherNodeAudioStreams.constBegin(); i != otherNodeAudioStreams.constEnd(); i++) {
@@ -454,14 +455,15 @@ int AudioMixer::prepareMixForListeningNode(Node* node) {
                 if (otherNodeStream->getType() == PositionalAudioStream::Microphone) {
                     streamUUID = otherNode->getUUID();
                 }
-                 
+                
                 if (*otherNode != *node || otherNodeStream->shouldLoopbackForNode()) {
-                    streamsMixed += addStreamToMixForListeningNodeWithStream(listenerNodeData, streamUUID, 
-                                                                                otherNodeStream, nodeAudioStream);
+                    streamsMixed += addStreamToMixForListeningNodeWithStream(listenerNodeData, streamUUID,
+                                                                             otherNodeStream, nodeAudioStream);
                 }
             }
         }
-    }
+    });
+    
     return streamsMixed;
 }
 
@@ -539,12 +541,11 @@ void AudioMixer::readPendingDatagram(const QByteArray& receivedPacket, const Hif
             QByteArray packet = receivedPacket;
             populatePacketHeader(packet, PacketTypeMuteEnvironment);
             
-            foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+            nodeList->eachNode([&](const SharedNodePointer& node){
                 if (node->getType() == NodeType::Agent && node->getActiveSocket() && node->getLinkedData() && node != nodeList->sendingNodeForPacket(receivedPacket)) {
                     nodeList->writeDatagram(packet, packet.size(), node);
                 }
-            }
-            
+            });
         } else {
             // let processNodeData handle it.
             nodeList->processNodeData(senderSockAddr, receivedPacket);
@@ -607,8 +608,9 @@ void AudioMixer::sendStatsPacket() {
     
     NodeList* nodeList = NodeList::getInstance();
     int clientNumber = 0;
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
-
+    
+    
+    nodeList->eachNode([&](const SharedNodePointer& node) {
         // if we're too large, send the packet
         if (sizeOfStats > TOO_BIG_FOR_MTU) {
             nodeList->sendStatsToDomainServer(statsObject2);
@@ -626,7 +628,7 @@ void AudioMixer::sendStatsPacket() {
             somethingToSend = true;
             sizeOfStats += property.size() + value.size();
         }
-    }
+    });
 
     if (somethingToSend) {
         nodeList->sendStatsToDomainServer(statsObject2);
@@ -764,7 +766,8 @@ void AudioMixer::run() {
             _lastPerSecondCallbackTime = now;
         }
         
-        foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+        nodeList->eachNode([&](const SharedNodePointer& node) {
+            
             if (node->getLinkedData()) {
                 AudioMixerClientData* nodeData = (AudioMixerClientData*)node->getLinkedData();
 
@@ -847,7 +850,7 @@ void AudioMixer::run() {
                     ++_sumListeners;
                 }
             }
-        }
+        });
         
         ++_numStatFrames;
         
@@ -905,7 +908,7 @@ void AudioMixer::perSecondActions() {
             _timeSpentPerHashMatchCallStats.getWindowSum() / WINDOW_LENGTH_USECS * 100.0,
             _timeSpentPerHashMatchCallStats.getCurrentIntervalSum() / USECS_PER_SECOND * 100.0);
 
-        foreach(const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+        NodeList::getInstance()->eachNode([](const SharedNodePointer& node) {
             if (node->getLinkedData()) {
                 AudioMixerClientData* nodeData = (AudioMixerClientData*)node->getLinkedData();
 
@@ -915,7 +918,7 @@ void AudioMixer::perSecondActions() {
                     nodeData->printUpstreamDownstreamStats();
                 }
             }
-        }
+        });
     }
 
     _datagramsReadPerCallStats.currentIntervalComplete();
diff --git a/assignment-client/src/avatars/AvatarMixer.cpp b/assignment-client/src/avatars/AvatarMixer.cpp
index 3ec7c5cfbf..107ce29ac9 100644
--- a/assignment-client/src/avatars/AvatarMixer.cpp
+++ b/assignment-client/src/avatars/AvatarMixer.cpp
@@ -122,7 +122,7 @@ void AvatarMixer::broadcastAvatarData() {
     AvatarMixerClientData* nodeData = NULL;
     AvatarMixerClientData* otherNodeData = NULL;
     
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    nodeList->eachNode([&](const SharedNodePointer& node) {
         if (node->getLinkedData() && node->getType() == NodeType::Agent && node->getActiveSocket()
             && (nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData()))->getMutex().tryLock()) {
             ++_sumListeners;
@@ -135,7 +135,7 @@ void AvatarMixer::broadcastAvatarData() {
             
             // this is an AGENT we have received head data from
             // send back a packet with other active node data to this node
-            foreach (const SharedNodePointer& otherNode, nodeList->getNodeHash()) {
+            nodeList->eachNode([&](const SharedNodePointer& otherNode) {
                 if (otherNode->getLinkedData() && otherNode->getUUID() != node->getUUID()
                     && (otherNodeData = reinterpret_cast<AvatarMixerClientData*>(otherNode->getLinkedData()))->getMutex().tryLock()) {
                     
@@ -203,13 +203,13 @@ void AvatarMixer::broadcastAvatarData() {
                 
                     otherNodeData->getMutex().unlock();
                 }
-            }
+            });
             
             nodeList->writeDatagram(mixedAvatarByteArray, node);
             
             nodeData->getMutex().unlock();
         }
-    }
+    });
     
     _lastFrameTimestamp = QDateTime::currentMSecsSinceEpoch();
 }
diff --git a/assignment-client/src/entities/EntityServer.cpp b/assignment-client/src/entities/EntityServer.cpp
index 2b7d6873cc..a39e7acbf4 100644
--- a/assignment-client/src/entities/EntityServer.cpp
+++ b/assignment-client/src/entities/EntityServer.cpp
@@ -123,15 +123,17 @@ void EntityServer::pruneDeletedEntities() {
     if (tree->hasAnyDeletedEntities()) {
 
         quint64 earliestLastDeletedEntitiesSent = usecTimestampNow() + 1; // in the future
-        foreach (const SharedNodePointer& otherNode, NodeList::getInstance()->getNodeHash()) {
-            if (otherNode->getLinkedData()) {
-                EntityNodeData* nodeData = static_cast<EntityNodeData*>(otherNode->getLinkedData());
+        
+        NodeList::getInstance()->eachNode([&earliestLastDeletedEntitiesSent](const SharedNodePointer& node) {
+            if (node->getLinkedData()) {
+                EntityNodeData* nodeData = static_cast<EntityNodeData*>(node->getLinkedData());
                 quint64 nodeLastDeletedEntitiesSentAt = nodeData->getLastDeletedEntitiesSentAt();
                 if (nodeLastDeletedEntitiesSentAt < earliestLastDeletedEntitiesSent) {
                     earliestLastDeletedEntitiesSent = nodeLastDeletedEntitiesSentAt;
                 }
             }
-        }
+        });
+        
         tree->forgetEntitiesDeletedBefore(earliestLastDeletedEntitiesSent);
     }
 }
diff --git a/assignment-client/src/octree/OctreeInboundPacketProcessor.cpp b/assignment-client/src/octree/OctreeInboundPacketProcessor.cpp
index b9bde8d544..e880615b71 100644
--- a/assignment-client/src/octree/OctreeInboundPacketProcessor.cpp
+++ b/assignment-client/src/octree/OctreeInboundPacketProcessor.cpp
@@ -261,7 +261,7 @@ int OctreeInboundPacketProcessor::sendNackPackets() {
             continue;
         }
 
-        const SharedNodePointer& destinationNode = NodeList::getInstance()->getNodeHash().value(nodeUUID);
+        const SharedNodePointer& destinationNode = NodeList::getInstance()->nodeWithUUID(nodeUUID);
 
         // retrieve sequence number stats of node, prune its missing set
         SequenceNumberStats& sequenceNumberStats = nodeStats.getIncomingEditSequenceNumberStats();
diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp
index 26cf94269b..4c5f4865ef 100644
--- a/assignment-client/src/octree/OctreeServer.cpp
+++ b/assignment-client/src/octree/OctreeServer.cpp
@@ -1193,10 +1193,12 @@ void OctreeServer::aboutToFinish() {
     qDebug() << qPrintable(_safeServerName) << "server STARTING about to finish...";
     qDebug() << qPrintable(_safeServerName) << "inform Octree Inbound Packet Processor that we are shutting down...";
     _octreeInboundPacketProcessor->shuttingDown();
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    
+    NodeList::getInstance()->eachNode([this](const SharedNodePointer& node) {
         qDebug() << qPrintable(_safeServerName) << "server about to finish while node still connected node:" << *node;
         forceNodeShutdown(node);
-    }
+    });
+    
     qDebug() << qPrintable(_safeServerName) << "server ENDING about to finish...";
 }
 
diff --git a/cmake/macros/LinkHifiLibraries.cmake b/cmake/macros/LinkHifiLibraries.cmake
index 9d73963fea..a46023fe9a 100644
--- a/cmake/macros/LinkHifiLibraries.cmake
+++ b/cmake/macros/LinkHifiLibraries.cmake
@@ -29,6 +29,10 @@ macro(LINK_HIFI_LIBRARIES)
     get_target_property(LINKED_TARGET_DEPENDENCY_LIBRARIES ${HIFI_LIBRARY} DEPENDENCY_LIBRARIES)
     list(APPEND ${TARGET_NAME}_LIBRARIES_TO_LINK ${LINKED_TARGET_DEPENDENCY_LIBRARIES})
     
+    # ask the library what its include dependencies are and link them
+    get_target_property(LINKED_TARGET_DEPENDENCY_INCLUDES ${HIFI_LIBRARY} DEPENDENCY_INCLUDES)
+    list(APPEND ${TARGET_NAME}_DEPENDENCY_INCLUDES ${LINKED_TARGET_DEPENDENCY_INCLUDES})
+    
   endforeach()
   
 endmacro(LINK_HIFI_LIBRARIES)
\ No newline at end of file
diff --git a/cmake/macros/LinkSharedDependencies.cmake b/cmake/macros/LinkSharedDependencies.cmake
index ae478ca530..a73f57dc1d 100644
--- a/cmake/macros/LinkSharedDependencies.cmake
+++ b/cmake/macros/LinkSharedDependencies.cmake
@@ -17,9 +17,17 @@ macro(LINK_SHARED_DEPENDENCIES)
     target_link_libraries(${TARGET_NAME} ${${TARGET_NAME}_LIBRARIES_TO_LINK})
   endif ()
   
+  if (${TARGET_NAME}_DEPENDENCY_INCLUDES)
+    list(REMOVE_DUPLICATES ${TARGET_NAME}_DEPENDENCY_INCLUDES)
+    
+    # include those in our own target
+    include_directories(SYSTEM ${${TARGET_NAME}_DEPENDENCY_INCLUDES})
+  endif ()
+  
   # we've already linked our Qt modules, but we need to bubble them up to parents
   list(APPEND ${TARGET_NAME}_LIBRARIES_TO_LINK "${${TARGET}_QT_MODULES_TO_LINK}")
   
   # set the property on this target so it can be retreived by targets linking to us
-  set_target_properties(${TARGET_NAME} PROPERTIES DEPENDENCY_LIBRARIES "${${TARGET}_LIBRARIES_TO_LINK}")
+  set_target_properties(${TARGET_NAME} PROPERTIES DEPENDENCY_LIBRARIES "${${TARGET_NAME}_LIBRARIES_TO_LINK}")
+  set_target_properties(${TARGET_NAME} PROPERTIES DEPENDENCY_INCLUDES "${${TARGET_NAME}_DEPENDENCY_INCLUDES}")
 endmacro(LINK_SHARED_DEPENDENCIES)
\ No newline at end of file
diff --git a/cmake/modules/FindTBB.cmake b/cmake/modules/FindTBB.cmake
new file mode 100644
index 0000000000..e5ca100391
--- /dev/null
+++ b/cmake/modules/FindTBB.cmake
@@ -0,0 +1,283 @@
+# Locate Intel Threading Building Blocks include paths and libraries
+# FindTBB.cmake can be found at https://code.google.com/p/findtbb/
+# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de>
+# Improvements by Gino van den Bergen <gino _at_ dtecta.com>,
+#   Florian Uhlig <F.Uhlig _at_ gsi.de>,
+#   Jiri Marsik <jiri.marsik89 _at_ gmail.com>
+
+# The MIT License
+#
+# Copyright (c) 2011 Hannes Hofmann
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.
+#   e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21"
+#   TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found
+#   in the TBB installation directory (TBB_INSTALL_DIR).
+#
+# GvdB: Mac OS X distribution places libraries directly in lib directory.
+#
+# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.
+# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]
+#   which architecture to use
+# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9
+#   which compiler to use (detected automatically on Windows)
+
+# This module respects
+# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}
+
+# This module defines
+# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.
+# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc
+# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug
+# TBB_INSTALL_DIR, the base TBB install directory
+# TBB_LIBRARIES, the libraries to link against to use TBB.
+# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.
+# TBB_FOUND, If false, don't try to use TBB.
+# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h
+
+
+if (WIN32)
+    # has em64t/vc8 em64t/vc9
+    # has ia32/vc7.1 ia32/vc8 ia32/vc9
+    set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB")
+    set(_TBB_LIB_NAME "tbb")
+    set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+    set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+    set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+    if (MSVC71)
+        set (_TBB_COMPILER "vc7.1")
+    endif(MSVC71)
+    if (MSVC80)
+        set(_TBB_COMPILER "vc8")
+    endif(MSVC80)
+    if (MSVC90)
+        set(_TBB_COMPILER "vc9")
+    endif(MSVC90)
+    if(MSVC10)
+        set(_TBB_COMPILER "vc10")
+    endif(MSVC10)
+    # Todo: add other Windows compilers such as ICL.
+    set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+endif (WIN32)
+
+if (UNIX)
+    if (APPLE)
+        # MAC
+        set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions")
+        # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug
+        set(_TBB_LIB_NAME "tbb")
+        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+        # default flavor on apple: ia32/cc4.0.1_os10.4.9
+        # Jiri: There is no reason to presume there is only one flavor and
+        #       that user's setting of variables should be ignored.
+        if(NOT TBB_COMPILER)
+            set(_TBB_COMPILER "cc4.0.1_os10.4.9")
+        elseif (NOT TBB_COMPILER)
+            set(_TBB_COMPILER ${TBB_COMPILER})
+        endif(NOT TBB_COMPILER)
+        if(NOT TBB_ARCHITECTURE)
+            set(_TBB_ARCHITECTURE "ia32")
+        elseif(NOT TBB_ARCHITECTURE)
+            set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+        endif(NOT TBB_ARCHITECTURE)
+    else (APPLE)
+        # LINUX
+        set(_TBB_DEFAULT_INSTALL_DIR "/opt/intel/tbb" "/usr/local/include" "/usr/include")
+        set(_TBB_LIB_NAME "tbb")
+        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+        # has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21
+        # has ia32/*
+        # has itanium/*
+        set(_TBB_COMPILER ${TBB_COMPILER})
+        set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+    endif (APPLE)
+endif (UNIX)
+
+if (CMAKE_SYSTEM MATCHES "SunOS.*")
+# SUN
+# not yet supported
+# has em64t/cc3.4.3_kernel5.10
+# has ia32/*
+endif (CMAKE_SYSTEM MATCHES "SunOS.*")
+
+
+#-- Clear the public variables
+set (TBB_FOUND "NO")
+
+
+#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}
+# first: use CMake variable TBB_INSTALL_DIR
+if (TBB_INSTALL_DIR)
+    set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})
+endif (TBB_INSTALL_DIR)
+# second: use environment variable
+if (NOT _TBB_INSTALL_DIR)
+    if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})
+    endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
+    # Intel recommends setting TBB21_INSTALL_DIR
+    if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})
+    endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
+    if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})
+    endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
+    if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})
+    endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
+endif (NOT _TBB_INSTALL_DIR)
+# third: try to find path automatically
+if (NOT _TBB_INSTALL_DIR)
+    if (_TBB_DEFAULT_INSTALL_DIR)
+        set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})
+    endif (_TBB_DEFAULT_INSTALL_DIR)
+endif (NOT _TBB_INSTALL_DIR)
+# sanity check
+if (NOT _TBB_INSTALL_DIR)
+    message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}")
+else (NOT _TBB_INSTALL_DIR)
+# finally: set the cached CMake variable TBB_INSTALL_DIR
+if (NOT TBB_INSTALL_DIR)
+    set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory")
+    mark_as_advanced(TBB_INSTALL_DIR)
+endif (NOT TBB_INSTALL_DIR)
+
+
+#-- A macro to rewrite the paths of the library. This is necessary, because
+#   find_library() always found the em64t/vc9 version of the TBB libs
+macro(TBB_CORRECT_LIB_DIR var_name)
+#    if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
+        string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
+#    endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
+    string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
+    string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+endmacro(TBB_CORRECT_LIB_DIR var_content)
+
+
+#-- Look for include directory and set ${TBB_INCLUDE_DIR}
+set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)
+# Jiri: tbbvars now sets the CPATH environment variable to the directory
+#       containing the headers.
+find_path(TBB_INCLUDE_DIR
+    tbb/task_scheduler_init.h
+    PATHS ${TBB_INC_SEARCH_DIR} ENV CPATH
+)
+mark_as_advanced(TBB_INCLUDE_DIR)
+
+
+#-- Look for libraries
+# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]
+if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
+    set (_TBB_LIBRARY_DIR 
+         ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}
+         ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib
+        )
+endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
+# Jiri: This block isn't mutually exclusive with the previous one
+#       (hence no else), instead I test if the user really specified
+#       the variables in question.
+if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
+    # HH: deprecated
+    message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).")
+    # Jiri: It doesn't hurt to look in more places, so I store the hints from
+    #       ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER
+    #       variables and search them both.
+    set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR})
+endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
+
+# GvdB: Mac OS X distribution places libraries directly in lib directory.
+list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)
+
+# Jiri: No reason not to check the default paths. From recent versions,
+#       tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH
+#       variables, which now point to the directories of the lib files.
+#       It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS
+#       argument instead of the implicit PATHS as it isn't hard-coded
+#       but computed by system introspection. Searching the LIBRARY_PATH
+#       and LD_LIBRARY_PATH environment variables is now even more important
+#       that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates
+#       the use of TBB built from sources.
+find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+
+#Extract path from TBB_LIBRARY name
+get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)
+
+#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)
+#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)
+mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)
+
+#-- Look for debug libraries
+# Jiri: Changed the same way as for the release libraries.
+find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+
+# Jiri: Self-built TBB stores the debug libraries in a separate directory.
+#       Extract path from TBB_LIBRARY_DEBUG name
+get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)
+
+#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)
+#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)
+mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)
+
+
+if (TBB_INCLUDE_DIR)
+    if (TBB_LIBRARY)
+        set (TBB_FOUND "YES")
+        set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})
+        set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})
+        set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE)
+        set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE)
+        # Jiri: Self-built TBB stores the debug libraries in a separate directory.
+        set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE)
+        mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)
+        message(STATUS "Found Intel TBB")
+    endif (TBB_LIBRARY)
+endif (TBB_INCLUDE_DIR)
+
+if (NOT TBB_FOUND)
+    message("ERROR: Intel TBB NOT found!")
+    message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}")
+    # do only throw fatal, if this pkg is REQUIRED
+    if (TBB_FIND_REQUIRED)
+        message(FATAL_ERROR "Could NOT find TBB library.")
+    endif (TBB_FIND_REQUIRED)
+endif (NOT TBB_FOUND)
+
+endif (NOT _TBB_INSTALL_DIR)
+
+if (TBB_FOUND)
+	set(TBB_INTERFACE_VERSION 0)
+	FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
+	STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
+	set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
+endif (TBB_FOUND)
diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index dbaaca43fa..153fbae0c9 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -821,49 +821,48 @@ void DomainServer::sendDomainListToNode(const SharedNodePointer& node, const Hif
 
         if (nodeData->isAuthenticated()) {
             // if this authenticated node has any interest types, send back those nodes as well
-            foreach (const SharedNodePointer& otherNode, nodeList->getNodeHash()) {
-
+            nodeList->eachNode([&](const SharedNodePointer& otherNode){
                 // reset our nodeByteArray and nodeDataStream
                 QByteArray nodeByteArray;
                 QDataStream nodeDataStream(&nodeByteArray, QIODevice::Append);
-
+                
                 if (otherNode->getUUID() != node->getUUID() && nodeInterestList.contains(otherNode->getType())) {
-
+                    
                     // don't send avatar nodes to other avatars, that will come from avatar mixer
                     nodeDataStream << *otherNode.data();
-
+                    
                     // pack the secret that these two nodes will use to communicate with each other
                     QUuid secretUUID = nodeData->getSessionSecretHash().value(otherNode->getUUID());
                     if (secretUUID.isNull()) {
                         // generate a new secret UUID these two nodes can use
                         secretUUID = QUuid::createUuid();
-
+                        
                         // set that on the current Node's sessionSecretHash
                         nodeData->getSessionSecretHash().insert(otherNode->getUUID(), secretUUID);
-
+                        
                         // set it on the other Node's sessionSecretHash
                         reinterpret_cast<DomainServerNodeData*>(otherNode->getLinkedData())
                         ->getSessionSecretHash().insert(node->getUUID(), secretUUID);
-
+                        
                     }
-
+                    
                     nodeDataStream << secretUUID;
-
+                    
                     if (broadcastPacket.size() +  nodeByteArray.size() > dataMTU) {
                         // we need to break here and start a new packet
                         // so send the current one
-
+                        
                         nodeList->writeDatagram(broadcastPacket, node, senderSockAddr);
-
+                        
                         // reset the broadcastPacket structure
                         broadcastPacket.resize(numBroadcastPacketLeadBytes);
                         broadcastDataStream.device()->seek(numBroadcastPacketLeadBytes);
                     }
-
+                    
                     // append the nodeByteArray to the current state of broadcastDataStream
                     broadcastPacket.append(nodeByteArray);
                 }
-            }
+            });
         }
 
         // always write the last broadcastPacket
@@ -960,14 +959,14 @@ void DomainServer::readAvailableDatagrams() {
 
 void DomainServer::setupPendingAssignmentCredits() {
     // enumerate the NodeList to find the assigned nodes
-    foreach (const SharedNodePointer& node, LimitedNodeList::getInstance()->getNodeHash()) {
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node){
         DomainServerNodeData* nodeData = reinterpret_cast<DomainServerNodeData*>(node->getLinkedData());
-
+        
         if (!nodeData->getAssignmentUUID().isNull() && !nodeData->getWalletUUID().isNull()) {
             // check if we have a non-finalized transaction for this node to add this amount to
             TransactionHash::iterator i = _pendingAssignmentCredits.find(nodeData->getWalletUUID());
             WalletTransaction* existingTransaction = NULL;
-
+            
             while (i != _pendingAssignmentCredits.end() && i.key() == nodeData->getWalletUUID()) {
                 if (!i.value()->isFinalized()) {
                     existingTransaction = i.value();
@@ -976,16 +975,16 @@ void DomainServer::setupPendingAssignmentCredits() {
                     ++i;
                 }
             }
-
+            
             qint64 elapsedMsecsSinceLastPayment = nodeData->getPaymentIntervalTimer().elapsed();
             nodeData->getPaymentIntervalTimer().restart();
-
+            
             const float CREDITS_PER_HOUR = 0.10f;
             const float CREDITS_PER_MSEC = CREDITS_PER_HOUR / (60 * 60 * 1000);
             const int SATOSHIS_PER_MSEC = CREDITS_PER_MSEC * SATOSHIS_PER_CREDIT;
-
+            
             float pendingCredits = elapsedMsecsSinceLastPayment * SATOSHIS_PER_MSEC;
-
+            
             if (existingTransaction) {
                 existingTransaction->incrementAmount(pendingCredits);
             } else {
@@ -994,7 +993,7 @@ void DomainServer::setupPendingAssignmentCredits() {
                 _pendingAssignmentCredits.insert(nodeData->getWalletUUID(), freshTransaction);
             }
         }
-    }
+    });
 }
 
 void DomainServer::sendPendingTransactionsToServer() {
@@ -1119,11 +1118,12 @@ void DomainServer::sendHeartbeatToDataServer(const QString& networkAddress) {
     
     // add the number of currently connected agent users
     int numConnectedAuthedUsers = 0;
-    foreach(const SharedNodePointer& node, LimitedNodeList::getInstance()->getNodeHash()) {
+    
+    NodeList::getInstance()->eachNode([&numConnectedAuthedUsers](const SharedNodePointer& node){
         if (node->getLinkedData() && !static_cast<DomainServerNodeData*>(node->getLinkedData())->getUsername().isEmpty()) {
             ++numConnectedAuthedUsers;
         }
-    }
+    });
     
     const QString DOMAIN_HEARTBEAT_KEY = "heartbeat";
     const QString HEARTBEAT_NUM_USERS_KEY = "num_users";
@@ -1242,8 +1242,9 @@ void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiS
                     parseNodeDataFromByteArray(packetStream, throwawayNodeType, nodePublicAddress, nodeLocalAddress,
                                                senderSockAddr);
                     
-                    SharedNodePointer checkInNode = nodeList->updateSocketsForNode(nodeUUID,
-                                                                                   nodePublicAddress, nodeLocalAddress);
+                    SharedNodePointer checkInNode = nodeList->nodeWithUUID(nodeUUID);
+                    checkInNode->setPublicSocket(nodePublicAddress);
+                    checkInNode->setLocalSocket(nodeLocalAddress);
                     
                     // update last receive to now
                     quint64 timeNow = usecTimestampNow();
@@ -1425,15 +1426,15 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
             QJsonObject assignedNodesJSON;
 
             // enumerate the NodeList to find the assigned nodes
-            foreach (const SharedNodePointer& node, LimitedNodeList::getInstance()->getNodeHash()) {
+            NodeList::getInstance()->eachNode([this, &assignedNodesJSON](const SharedNodePointer& node){
                 DomainServerNodeData* nodeData = reinterpret_cast<DomainServerNodeData*>(node->getLinkedData());
-
+                
                 if (!nodeData->getAssignmentUUID().isNull()) {
                     // add the node using the UUID as the key
                     QString uuidString = uuidStringWithoutCurlyBraces(nodeData->getAssignmentUUID());
                     assignedNodesJSON[uuidString] = jsonObjectForNode(node);
                 }
-            }
+            });
 
             assignmentJSON["fulfilled"] = assignedNodesJSON;
 
@@ -1487,12 +1488,10 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
             QJsonArray nodesJSONArray;
 
             // enumerate the NodeList to find the assigned nodes
-            LimitedNodeList* nodeList = LimitedNodeList::getInstance();
-
-            foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+            LimitedNodeList::getInstance()->eachNode([this, &nodesJSONArray](const SharedNodePointer& node){
                 // add the node using the UUID as the key
                 nodesJSONArray.append(jsonObjectForNode(node));
-            }
+            });
 
             rootJSON["nodes"] = nodesJSONArray;
 
@@ -2020,16 +2019,9 @@ void DomainServer::addStaticAssignmentsToQueue() {
     QHash<QUuid, SharedAssignmentPointer>::iterator staticAssignment = staticHashCopy.begin();
     while (staticAssignment != staticHashCopy.end()) {
         // add any of the un-matched static assignments to the queue
-        bool foundMatchingAssignment = false;
-
+        
         // enumerate the nodes and check if there is one with an attached assignment with matching UUID
-        foreach (const SharedNodePointer& node, LimitedNodeList::getInstance()->getNodeHash()) {
-            if (node->getUUID() == staticAssignment->data()->getUUID()) {
-                foundMatchingAssignment = true;
-            }
-        }
-
-        if (!foundMatchingAssignment) {
+        if (!NodeList::getInstance()->nodeWithUUID(staticAssignment->data()->getUUID())) {
             // this assignment has not been fulfilled - reset the UUID and add it to the assignment queue
             refreshStaticAssignmentAndAddToQueue(*staticAssignment);
         }
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index f11ac14d40..f6f7d37f6a 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -2414,72 +2414,73 @@ int Application::sendNackPackets() {
     char packet[MAX_PACKET_SIZE];
 
     // iterates thru all nodes in NodeList
-    foreach(const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    NodeList* nodeList = NodeList::getInstance();
+    
+    nodeList->eachNode([&](const SharedNodePointer& node){
         
-        if (node->getActiveSocket() &&
-            ( node->getType() == NodeType::VoxelServer
-            || node->getType() == NodeType::EntityServer)
-            ) {
-
+        if (node->getActiveSocket()
+            && (node->getType() == NodeType::VoxelServer || node->getType() == NodeType::EntityServer)) {
+            
             QUuid nodeUUID = node->getUUID();
-
+            
             // if there are octree packets from this node that are waiting to be processed,
             // don't send a NACK since the missing packets may be among those waiting packets.
             if (_octreeProcessor.hasPacketsToProcessFrom(nodeUUID)) {
-                continue;
+                return;
             }
             
             _octreeSceneStatsLock.lockForRead();
-
+            
             // retreive octree scene stats of this node
             if (_octreeServerSceneStats.find(nodeUUID) == _octreeServerSceneStats.end()) {
                 _octreeSceneStatsLock.unlock();
-                continue;
+                return;
             }
-
+            
             // get sequence number stats of node, prune its missing set, and make a copy of the missing set
             SequenceNumberStats& sequenceNumberStats = _octreeServerSceneStats[nodeUUID].getIncomingOctreeSequenceNumberStats();
             sequenceNumberStats.pruneMissingSet();
             const QSet<OCTREE_PACKET_SEQUENCE> missingSequenceNumbers = sequenceNumberStats.getMissingSet();
-
+            
             _octreeSceneStatsLock.unlock();
-
+            
             // construct nack packet(s) for this node
             int numSequenceNumbersAvailable = missingSequenceNumbers.size();
             QSet<OCTREE_PACKET_SEQUENCE>::const_iterator missingSequenceNumbersIterator = missingSequenceNumbers.constBegin();
             while (numSequenceNumbersAvailable > 0) {
-
+                
                 char* dataAt = packet;
                 int bytesRemaining = MAX_PACKET_SIZE;
-
+                
                 // pack header
                 int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack);
                 dataAt += numBytesPacketHeader;
                 bytesRemaining -= numBytesPacketHeader;
-
+                
                 // calculate and pack the number of sequence numbers
                 int numSequenceNumbersRoomFor = (bytesRemaining - sizeof(uint16_t)) / sizeof(OCTREE_PACKET_SEQUENCE);
                 uint16_t numSequenceNumbers = min(numSequenceNumbersAvailable, numSequenceNumbersRoomFor);
                 uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt;
                 *numSequenceNumbersAt = numSequenceNumbers;
                 dataAt += sizeof(uint16_t);
-
+                
                 // pack sequence numbers
                 for (int i = 0; i < numSequenceNumbers; i++) {
                     OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt;
                     *sequenceNumberAt = *missingSequenceNumbersIterator;
                     dataAt += sizeof(OCTREE_PACKET_SEQUENCE);
-
+                    
                     missingSequenceNumbersIterator++;
                 }
                 numSequenceNumbersAvailable -= numSequenceNumbers;
-
+                
                 // send it
-                NodeList::getInstance()->writeUnverifiedDatagram(packet, dataAt - packet, node);
+                nodeList->writeUnverifiedDatagram(packet, dataAt - packet, node);
                 packetsSent++;
             }
         }
-    }
+    });
+
     return packetsSent;
 }
 
@@ -2512,7 +2513,9 @@ void Application::queryOctree(NodeType_t serverType, PacketType packetType, Node
     int inViewServers = 0;
     int unknownJurisdictionServers = 0;
 
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    NodeList* nodeList = NodeList::getInstance();
+    
+    nodeList->eachNode([&](const SharedNodePointer& node) {
         // only send to the NodeTypes that are serverType
         if (node->getActiveSocket() && node->getType() == serverType) {
             totalServers++;
@@ -2543,7 +2546,7 @@ void Application::queryOctree(NodeType_t serverType, PacketType packetType, Node
                 }
             }
         }
-    }
+    });
 
     if (wantExtraDebugging) {
         qDebug("Servers: total %d, in view %d, unknown jurisdiction %d",
@@ -2569,20 +2572,18 @@ void Application::queryOctree(NodeType_t serverType, PacketType packetType, Node
     if (wantExtraDebugging) {
         qDebug("perServerPPS: %d perUnknownServer: %d", perServerPPS, perUnknownServer);
     }
-
-    NodeList* nodeList = NodeList::getInstance();
-
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    
+    nodeList->eachNode([&](const SharedNodePointer& node){
         // only send to the NodeTypes that are serverType
         if (node->getActiveSocket() && node->getType() == serverType) {
-
-
+            
+            
             // get the server bounds for this server
             QUuid nodeUUID = node->getUUID();
-
+            
             bool inView = false;
             bool unknownView = false;
-
+            
             // if we haven't heard from this voxel server, go ahead and send it a query, so we
             // can get the jurisdiction...
             if (jurisdictions.find(nodeUUID) == jurisdictions.end()) {
@@ -2592,15 +2593,15 @@ void Application::queryOctree(NodeType_t serverType, PacketType packetType, Node
                 }
             } else {
                 const JurisdictionMap& map = (jurisdictions)[nodeUUID];
-
+                
                 unsigned char* rootCode = map.getRootOctalCode();
-
+                
                 if (rootCode) {
                     VoxelPositionSize rootDetails;
                     voxelDetailsForCode(rootCode, rootDetails);
                     AACube serverBounds(glm::vec3(rootDetails.x, rootDetails.y, rootDetails.z), rootDetails.s);
                     serverBounds.scale(TREE_SCALE);
-
+                    
                     ViewFrustum::location serverFrustumLocation = _viewFrustum.cubeInFrustum(serverBounds);
                     if (serverFrustumLocation != ViewFrustum::OUTSIDE) {
                         inView = true;
@@ -2613,15 +2614,15 @@ void Application::queryOctree(NodeType_t serverType, PacketType packetType, Node
                     }
                 }
             }
-
+            
             if (inView) {
                 _octreeQuery.setMaxOctreePacketsPerSecond(perServerPPS);
             } else if (unknownView) {
                 if (wantExtraDebugging) {
                     qDebug() << "no known jurisdiction for node " << *node << ", give it budget of "
-                            << perUnknownServer << " to send us jurisdiction.";
+                    << perUnknownServer << " to send us jurisdiction.";
                 }
-
+                
                 // set the query's position/orientation to be degenerate in a manner that will get the scene quickly
                 // If there's only one server, then don't do this, and just let the normal voxel query pass through
                 // as expected... this way, we will actually get a valid scene if there is one to be seen
@@ -2645,22 +2646,22 @@ void Application::queryOctree(NodeType_t serverType, PacketType packetType, Node
             }
             // set up the packet for sending...
             unsigned char* endOfQueryPacket = queryPacket;
-
+            
             // insert packet type/version and node UUID
             endOfQueryPacket += populatePacketHeader(reinterpret_cast<char*>(endOfQueryPacket), packetType);
-
+            
             // encode the query data...
             endOfQueryPacket += _octreeQuery.getBroadcastData(endOfQueryPacket);
-
+            
             int packetLength = endOfQueryPacket - queryPacket;
-
+            
             // make sure we still have an active socket
             nodeList->writeUnverifiedDatagram(reinterpret_cast<const char*>(queryPacket), packetLength, node);
-
+            
             // Feed number of bytes to corresponding channel of the bandwidth meter
             _bandwidthMeter.outputStream(BandwidthMeter::VOXELS).updateValue(packetLength);
         }
-    }
+    });
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
diff --git a/interface/src/MetavoxelSystem.cpp b/interface/src/MetavoxelSystem.cpp
index 4c0acc553a..2ca17e32c1 100644
--- a/interface/src/MetavoxelSystem.cpp
+++ b/interface/src/MetavoxelSystem.cpp
@@ -163,7 +163,7 @@ void MetavoxelSystem::render() {
 }
 
 void MetavoxelSystem::refreshVoxelData() {
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    NodeList::getInstance()->eachNode([](const SharedNodePointer& node){
         if (node->getType() == NodeType::MetavoxelServer) {
             QMutexLocker locker(&node->getMutex());
             MetavoxelSystemClient* client = static_cast<MetavoxelSystemClient*>(node->getLinkedData());
@@ -171,7 +171,7 @@ void MetavoxelSystem::refreshVoxelData() {
                 QMetaObject::invokeMethod(client, "refreshVoxelData");
             }
         }
-    }
+    });
 }
 
 class RayHeightfieldIntersectionVisitor : public RayIntersectionVisitor {
@@ -685,7 +685,7 @@ MetavoxelClient* MetavoxelSystem::createClient(const SharedNodePointer& node) {
 }
 
 void MetavoxelSystem::guideToAugmented(MetavoxelVisitor& visitor, bool render) {
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    NodeList::getInstance()->eachNode([&visitor, &render](const SharedNodePointer& node) {
         if (node->getType() == NodeType::MetavoxelServer) {
             QMutexLocker locker(&node->getMutex());
             MetavoxelSystemClient* client = static_cast<MetavoxelSystemClient*>(node->getLinkedData());
@@ -699,7 +699,7 @@ void MetavoxelSystem::guideToAugmented(MetavoxelVisitor& visitor, bool render) {
                 }
             }
         }
-    }
+    });
 }
 
 Throttle::Throttle() :
diff --git a/interface/src/ui/NodeBounds.cpp b/interface/src/ui/NodeBounds.cpp
index 49509cc9cf..dedc687cc2 100644
--- a/interface/src/ui/NodeBounds.cpp
+++ b/interface/src/ui/NodeBounds.cpp
@@ -53,62 +53,61 @@ void NodeBounds::draw() {
     float selectedScale = 0;
 
     NodeList* nodeList = NodeList::getInstance();
-
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    nodeList->eachNode([&](const SharedNodePointer& node){
         NodeType_t nodeType = node->getType();
-
+        
         if (nodeType == NodeType::VoxelServer && _showVoxelNodes) {
             serverJurisdictions = &voxelServerJurisdictions;
         } else if (nodeType == NodeType::EntityServer && _showEntityNodes) {
             serverJurisdictions = &entityServerJurisdictions;
         } else {
-            continue;
+            return;
         }
-
+        
         QUuid nodeUUID = node->getUUID();
         serverJurisdictions->lockForRead();
         if (serverJurisdictions->find(nodeUUID) != serverJurisdictions->end()) {
             const JurisdictionMap& map = (*serverJurisdictions)[nodeUUID];
-
+            
             unsigned char* rootCode = map.getRootOctalCode();
-
+            
             if (rootCode) {
                 VoxelPositionSize rootDetails;
                 voxelDetailsForCode(rootCode, rootDetails);
                 serverJurisdictions->unlock();
                 glm::vec3 location(rootDetails.x, rootDetails.y, rootDetails.z);
                 location *= (float)TREE_SCALE;
-
+                
                 AACube serverBounds(location, rootDetails.s * TREE_SCALE);
-
+                
                 glm::vec3 center = serverBounds.getVertex(BOTTOM_RIGHT_NEAR)
-                    + ((serverBounds.getVertex(TOP_LEFT_FAR) - serverBounds.getVertex(BOTTOM_RIGHT_NEAR)) / 2.0f);
-
+                + ((serverBounds.getVertex(TOP_LEFT_FAR) - serverBounds.getVertex(BOTTOM_RIGHT_NEAR)) / 2.0f);
+                
                 const float VOXEL_NODE_SCALE = 1.00f;
                 const float ENTITY_NODE_SCALE = 0.99f;
-
+                
                 float scaleFactor = rootDetails.s * TREE_SCALE;
-
+                
                 // Scale by 0.92 - 1.00 depending on the scale of the node.  This allows smaller nodes to scale in
                 // a bit and not overlap larger nodes.
                 scaleFactor *= 0.92 + (rootDetails.s * 0.08);
-
+                
                 // Scale different node types slightly differently because it's common for them to overlap.
                 if (nodeType == NodeType::VoxelServer) {
                     scaleFactor *= VOXEL_NODE_SCALE;
                 } else if (nodeType == NodeType::EntityServer) {
                     scaleFactor *= ENTITY_NODE_SCALE;
                 }
-
+                
                 float red, green, blue;
                 getColorForNodeType(nodeType, red, green, blue);
                 drawNodeBorder(center, scaleFactor, red, green, blue);
-
+                
                 float distance;
                 BoxFace face;
                 bool inside = serverBounds.contains(mouseRayOrigin);
                 bool colliding = serverBounds.findRayIntersection(mouseRayOrigin, mouseRayDirection, distance, face);
-
+                
                 // If the camera is inside a node it will be "selected" if you don't have your cursor over another node
                 // that you aren't inside.
                 if (colliding && (!selectedNode || (!inside && (distance < selectedDistance || selectedIsInside)))) {
@@ -124,7 +123,7 @@ void NodeBounds::draw() {
         } else {
             serverJurisdictions->unlock();
         }
-    }
+    });
 
     if (selectedNode) {
         glPushMatrix();
diff --git a/interface/src/ui/OctreeStatsDialog.cpp b/interface/src/ui/OctreeStatsDialog.cpp
index e51b9b1f42..14da45e1d1 100644
--- a/interface/src/ui/OctreeStatsDialog.cpp
+++ b/interface/src/ui/OctreeStatsDialog.cpp
@@ -248,8 +248,8 @@ void OctreeStatsDialog::showOctreeServersOfType(int& serverCount, NodeType_t ser
     QLocale locale(QLocale::English);
     
     NodeList* nodeList = NodeList::getInstance();
-
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    nodeList->eachNode([&](const SharedNodePointer& node){
+        
         // only send to the NodeTypes that are NodeType_t_VOXEL_SERVER
         if (node->getType() == serverType) {
             serverCount++;
@@ -420,7 +420,7 @@ void OctreeStatsDialog::showOctreeServersOfType(int& serverCount, NodeType_t ser
             serverDetails << linkDetails.str();
             _labels[_voxelServerLables[serverCount - 1]]->setText(serverDetails.str().c_str());
         } // is VOXEL_SERVER
-    }
+    });
 }
 
 void OctreeStatsDialog::reject() {
diff --git a/interface/src/ui/Stats.cpp b/interface/src/ui/Stats.cpp
index 9bad475838..08eaac9334 100644
--- a/interface/src/ui/Stats.cpp
+++ b/interface/src/ui/Stats.cpp
@@ -328,8 +328,8 @@ void Stats::display(
         // Now handle voxel servers, since there could be more than one, we average their ping times
         unsigned long totalPingVoxel = 0;
         int voxelServerCount = 0;
-
-        foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+        
+        nodeList->eachNode([&totalPingVoxel, &pingVoxelMax, &voxelServerCount](const SharedNodePointer& node){
             // TODO: this should also support entities
             if (node->getType() == NodeType::VoxelServer) {
                 totalPingVoxel += node->getPingMs();
@@ -338,7 +338,7 @@ void Stats::display(
                     pingVoxelMax = node->getPingMs();
                 }
             }
-        }
+        });
 
         if (voxelServerCount) {
             pingVoxel = totalPingVoxel/voxelServerCount;
diff --git a/libraries/metavoxels/src/MetavoxelClientManager.cpp b/libraries/metavoxels/src/MetavoxelClientManager.cpp
index f1c086da67..3148f870c2 100644
--- a/libraries/metavoxels/src/MetavoxelClientManager.cpp
+++ b/libraries/metavoxels/src/MetavoxelClientManager.cpp
@@ -42,21 +42,23 @@ SharedObjectPointer MetavoxelClientManager::findFirstRaySpannerIntersection(cons
         const glm::vec3& direction, const AttributePointer& attribute, float& distance) {
     SharedObjectPointer closestSpanner;
     float closestDistance = FLT_MAX;
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node){
         if (node->getType() == NodeType::MetavoxelServer) {
             QMutexLocker locker(&node->getMutex());
             MetavoxelClient* client = static_cast<MetavoxelClient*>(node->getLinkedData());
             if (client) {
                 float clientDistance;
                 SharedObjectPointer clientSpanner = client->getDataCopy().findFirstRaySpannerIntersection(
-                    origin, direction, attribute, clientDistance);
+                                                                                                          origin, direction, attribute, clientDistance);
                 if (clientSpanner && clientDistance < closestDistance) {
                     closestSpanner = clientSpanner;
                     closestDistance = clientDistance;
                 }
             }
         }
-    }
+    });
+    
     if (closestSpanner) {
         distance = closestDistance;
     }
@@ -115,7 +117,7 @@ MetavoxelClient* MetavoxelClientManager::createClient(const SharedNodePointer& n
 }
 
 void MetavoxelClientManager::guide(MetavoxelVisitor& visitor) {
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    NodeList::getInstance()->eachNode([&visitor](const SharedNodePointer& node){
         if (node->getType() == NodeType::MetavoxelServer) {
             QMutexLocker locker(&node->getMutex());
             MetavoxelClient* client = static_cast<MetavoxelClient*>(node->getLinkedData());
@@ -123,7 +125,7 @@ void MetavoxelClientManager::guide(MetavoxelVisitor& visitor) {
                 client->getDataCopy().guide(visitor);
             }
         }
-    }
+    });
 }
 
 MetavoxelUpdater::MetavoxelUpdater(MetavoxelClientManager* clientManager) :
diff --git a/libraries/networking/CMakeLists.txt b/libraries/networking/CMakeLists.txt
index 50f41fe643..7c8b628183 100644
--- a/libraries/networking/CMakeLists.txt
+++ b/libraries/networking/CMakeLists.txt
@@ -10,8 +10,9 @@ if (WIN32)
   target_link_libraries(${TARGET_NAME} ws2_32.lib)
 endif ()
 
-# find OpenSSL
+# find required dependencies
 find_package(OpenSSL REQUIRED)
+find_package(TBB REQUIRED)
 
 if (APPLE AND ${OPENSSL_INCLUDE_DIR} STREQUAL "/usr/include")
   # this is a user on OS X using system OpenSSL, which is going to throw warnings since they're deprecating for their common crypto
@@ -22,7 +23,10 @@ endif ()
 include_directories(SYSTEM "${OPENSSL_INCLUDE_DIR}")
 
 # append OpenSSL to our list of libraries to link
-list(APPEND ${TARGET_NAME}_LIBRARIES_TO_LINK "${OPENSSL_LIBRARIES}")
+list(APPEND ${TARGET_NAME}_LIBRARIES_TO_LINK "${OPENSSL_LIBRARIES}" "${TBB_LIBRARIES}")
+
+# append libcuckoo includes to our list of includes to bubble
+list(APPEND ${TARGET_NAME}_DEPENDENCY_INCLUDES "${TBB_INCLUDE_DIRS}")
 
 # call macro to link our dependencies and bubble them up via a property on our target
 link_shared_dependencies()
\ No newline at end of file
diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp
index fd034ab285..bce1572587 100644
--- a/libraries/networking/src/LimitedNodeList.cpp
+++ b/libraries/networking/src/LimitedNodeList.cpp
@@ -21,6 +21,8 @@
 
 #include <LogHandler.h>
 
+#include <tbb/parallel_for.h>
+
 #include "AccountManager.h"
 #include "Assignment.h"
 #include "HifiSockAddr.h"
@@ -68,7 +70,6 @@ LimitedNodeList* LimitedNodeList::getInstance() {
 LimitedNodeList::LimitedNodeList(unsigned short socketListenPort, unsigned short dtlsListenPort) :
     _sessionUUID(),
     _nodeHash(),
-    _nodeHashMutex(QMutex::Recursive),
     _nodeSocket(this),
     _dtlsSocket(NULL),
     _localSockAddr(),
@@ -328,19 +329,9 @@ int LimitedNodeList::findNodeAndUpdateWithDataFromPacket(const QByteArray& packe
     return 0;
 }
 
-SharedNodePointer LimitedNodeList::nodeWithUUID(const QUuid& nodeUUID, bool blockingLock) {
-    const int WAIT_TIME = 10; // wait up to 10ms in the try lock case
-    SharedNodePointer node;
-    // if caller wants us to block and guarantee the correct answer, then honor that request
-    if (blockingLock) {
-        // this will block till we can get access
-        QMutexLocker locker(&_nodeHashMutex);
-        node = _nodeHash.value(nodeUUID);
-    } else if (_nodeHashMutex.tryLock(WAIT_TIME)) { // some callers are willing to get wrong answers but not block
-        node = _nodeHash.value(nodeUUID);
-        _nodeHashMutex.unlock();
-    }
-    return node;
+SharedNodePointer LimitedNodeList::nodeWithUUID(const QUuid& nodeUUID) {
+    NodeHash::const_iterator it = _nodeHash.find(nodeUUID);
+    return it == _nodeHash.cend() ? SharedNodePointer() : it->second;
  }
 
 SharedNodePointer LimitedNodeList::sendingNodeForPacket(const QByteArray& packet) {
@@ -350,21 +341,21 @@ SharedNodePointer LimitedNodeList::sendingNodeForPacket(const QByteArray& packet
     return nodeWithUUID(nodeUUID);
 }
 
-NodeHash LimitedNodeList::getNodeHash() {
-    QMutexLocker locker(&_nodeHashMutex);
-    return NodeHash(_nodeHash);
-}
-
 void LimitedNodeList::eraseAllNodes() {
     qDebug() << "Clearing the NodeList. Deleting all nodes in list.";
     
-    QMutexLocker locker(&_nodeHashMutex);
-
-    NodeHash::iterator nodeItem = _nodeHash.begin();
-
-    // iterate the nodes in the list
-    while (nodeItem != _nodeHash.end()) {
-        nodeItem = killNodeAtHashIterator(nodeItem);
+    QSet<SharedNodePointer> killedNodes;
+    eachNode([&killedNodes](const SharedNodePointer& node){
+        killedNodes.insert(node);
+    });
+    
+    // iterate the current nodes, emit that they are dying and remove them from the hash
+    _nodeMutex.lockForWrite();
+    _nodeHash.clear();
+    _nodeMutex.unlock();
+    
+    foreach(const SharedNodePointer& killedNode, killedNodes) {
+        handleNodeKill(killedNode);
     }
 }
 
@@ -373,20 +364,17 @@ void LimitedNodeList::reset() {
 }
 
 void LimitedNodeList::killNodeWithUUID(const QUuid& nodeUUID) {
-    QMutexLocker locker(&_nodeHashMutex);
-    
-    NodeHash::iterator nodeItemToKill = _nodeHash.find(nodeUUID);
-    if (nodeItemToKill != _nodeHash.end()) {
-        killNodeAtHashIterator(nodeItemToKill);
+    NodeHash::iterator it = _nodeHash.find(nodeUUID);
+    if (it != _nodeHash.end()) {
+        SharedNodePointer matchingNode = it->second;
+        
+        QWriteLocker writeLocker(&_nodeMutex);
+        _nodeHash.unsafe_erase(it);
+        
+        handleNodeKill(matchingNode);
     }
 }
 
-NodeHash::iterator LimitedNodeList::killNodeAtHashIterator(NodeHash::iterator& nodeItemToKill) {
-    qDebug() << "Killed" << *nodeItemToKill.value();
-    emit nodeKilled(nodeItemToKill.value());
-    return _nodeHash.erase(nodeItemToKill);
-}
-
 void LimitedNodeList::processKillNode(const QByteArray& dataByteArray) {
     // read the node id
     QUuid nodeUUID = QUuid::fromRfc4122(dataByteArray.mid(numBytesForPacketHeader(dataByteArray), NUM_BYTES_RFC4122_UUID));
@@ -395,66 +383,44 @@ void LimitedNodeList::processKillNode(const QByteArray& dataByteArray) {
     killNodeWithUUID(nodeUUID);
 }
 
+void LimitedNodeList::handleNodeKill(const SharedNodePointer& node) {
+    qDebug() << "Killed" << *node;
+    emit nodeKilled(node);
+}
+
 SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
-                                            const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket) {
-    _nodeHashMutex.lock();
-    
-    if (!_nodeHash.contains(uuid)) {
+                                                   const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket) {
+    try {
+        SharedNodePointer matchingNode = _nodeHash.at(uuid);
         
+        matchingNode->setPublicSocket(publicSocket);
+        matchingNode->setLocalSocket(localSocket);
+        
+        return matchingNode;
+    } catch (std::out_of_range) {
         // we didn't have this node, so add them
         Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket);
         SharedNodePointer newNodeSharedPointer(newNode, &QObject::deleteLater);
         
-        _nodeHash.insert(newNode->getUUID(), newNodeSharedPointer);
-        
-        _nodeHashMutex.unlock();
+        _nodeHash.insert(UUIDNodePair(newNode->getUUID(), newNodeSharedPointer));
         
         qDebug() << "Added" << *newNode;
-
+        
         emit nodeAdded(newNodeSharedPointer);
-
+        
         return newNodeSharedPointer;
-    } else {
-        _nodeHashMutex.unlock();
-        
-        return updateSocketsForNode(uuid, publicSocket, localSocket);
     }
 }
 
-SharedNodePointer LimitedNodeList::updateSocketsForNode(const QUuid& uuid,
-                                                 const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket) {
-
-    SharedNodePointer matchingNode = nodeWithUUID(uuid);
-    
-    if (matchingNode) {
-        // perform appropriate updates to this node
-        QMutexLocker locker(&matchingNode->getMutex());
-        
-        // check if we need to change this node's public or local sockets
-        if (publicSocket != matchingNode->getPublicSocket()) {
-            matchingNode->setPublicSocket(publicSocket);
-            qDebug() << "Public socket change for node" << *matchingNode;
-        }
-        
-        if (localSocket != matchingNode->getLocalSocket()) {
-            matchingNode->setLocalSocket(localSocket);
-            qDebug() << "Local socket change for node" << *matchingNode;
-        }
-    }
-    
-    return matchingNode;
-}
-
 unsigned LimitedNodeList::broadcastToNodes(const QByteArray& packet, const NodeSet& destinationNodeTypes) {
     unsigned n = 0;
-
-    foreach (const SharedNodePointer& node, getNodeHash()) {
-        // only send to the NodeTypes we are asked to send to.
+    
+    eachNode([&](const SharedNodePointer& node){
         if (destinationNodeTypes.contains(node->getType())) {
             writeDatagram(packet, node);
             ++n;
         }
-    }
+    });
 
     return n;
 }
@@ -493,15 +459,9 @@ QByteArray LimitedNodeList::constructPingReplyPacket(const QByteArray& pingPacke
 }
 
 SharedNodePointer LimitedNodeList::soloNodeOfType(char nodeType) {
-
-    if (memchr(SOLO_NODE_TYPES, nodeType, sizeof(SOLO_NODE_TYPES))) {
-        foreach (const SharedNodePointer& node, getNodeHash()) {
-            if (node->getType() == nodeType) {
-                return node;
-            }
-        }
-    }
-    return SharedNodePointer();
+    return nodeMatchingPredicate([&](const SharedNodePointer& node){
+        return node->getType() == nodeType;
+    });
 }
 
 void LimitedNodeList::getPacketStats(float& packetsPerSecond, float& bytesPerSecond) {
@@ -516,28 +476,28 @@ void LimitedNodeList::resetPacketStats() {
 }
 
 void LimitedNodeList::removeSilentNodes() {
-
-    _nodeHashMutex.lock();
+    QSet<SharedNodePointer> killedNodes;
     
-    NodeHash::iterator nodeItem = _nodeHash.begin();
-
-    while (nodeItem != _nodeHash.end()) {
-        SharedNodePointer node = nodeItem.value();
-
+    eachNodeHashIterator([&](NodeHash::iterator& it){
+        SharedNodePointer node = it->second;
         node->getMutex().lock();
-
+        
         if ((usecTimestampNow() - node->getLastHeardMicrostamp()) > (NODE_SILENCE_THRESHOLD_MSECS * 1000)) {
-            // call our private method to kill this node (removes it and emits the right signal)
-            nodeItem = killNodeAtHashIterator(nodeItem);
+            // call the NodeHash erase to get rid of this node
+            it = _nodeHash.unsafe_erase(it);
+            
+            killedNodes.insert(node);
         } else {
-            // we didn't kill this node, push the iterator forwards
-            ++nodeItem;
+            // we didn't erase this node, push the iterator forwards
+            ++it;
         }
         
         node->getMutex().unlock();
-    }
+    });
     
-    _nodeHashMutex.unlock();
+    foreach(const SharedNodePointer& killedNode, killedNodes) {
+        handleNodeKill(killedNode);
+    }
 }
 
 const uint32_t RFC_5389_MAGIC_COOKIE = 0x2112A442;
diff --git a/libraries/networking/src/LimitedNodeList.h b/libraries/networking/src/LimitedNodeList.h
index 64495fbd34..d713f69d29 100644
--- a/libraries/networking/src/LimitedNodeList.h
+++ b/libraries/networking/src/LimitedNodeList.h
@@ -20,16 +20,18 @@
 #include <unistd.h> // not on windows, not needed for mac or windows
 #endif
 
-#include <QtCore/QElapsedTimer>
-#include <QtCore/QMutex>
-#include <QtCore/QSet>
-#include <QtCore/QSettings>
-#include <QtCore/QSharedPointer>
-#include <QtNetwork/QHostAddress>
-#include <QtNetwork/QUdpSocket>
+#include <qelapsedtimer.h>
+#include <qreadwritelock.h>
+#include <qset.h>
+#include <qsharedpointer.h>
+#include <QtNetwork/qudpsocket.h>
+#include <QtNetwork/qhostaddress.h>
+
+#include <tbb/concurrent_unordered_map.h>
 
 #include "DomainHandler.h"
 #include "Node.h"
+#include "UUIDHasher.h"
 
 const int MAX_PACKET_SIZE = 1500;
 
@@ -49,9 +51,12 @@ class HifiSockAddr;
 typedef QSet<NodeType_t> NodeSet;
 
 typedef QSharedPointer<Node> SharedNodePointer;
-typedef QHash<QUuid, SharedNodePointer> NodeHash;
 Q_DECLARE_METATYPE(SharedNodePointer)
 
+using namespace tbb;
+typedef std::pair<QUuid, SharedNodePointer> UUIDNodePair;
+typedef concurrent_unordered_map<QUuid, SharedNodePointer, UUIDHasher> NodeHash;
+
 typedef quint8 PingType_t;
 namespace PingType {
     const PingType_t Agnostic = 0;
@@ -69,7 +74,6 @@ public:
     const QUuid& getSessionUUID() const { return _sessionUUID; }
     void setSessionUUID(const QUuid& sessionUUID);
     
-    
     void rebindNodeSocket();
     QUdpSocket& getNodeSocket() { return _nodeSocket; }
     QUdpSocket& getDTLSSocket();
@@ -90,17 +94,14 @@ public:
                          const HifiSockAddr& overridenSockAddr = HifiSockAddr());
 
     void(*linkedDataCreateCallback)(Node *);
-
-    NodeHash getNodeHash();
+    
     int size() const { return _nodeHash.size(); }
 
-    SharedNodePointer nodeWithUUID(const QUuid& nodeUUID, bool blockingLock = true);
+    SharedNodePointer nodeWithUUID(const QUuid& nodeUUID);
     SharedNodePointer sendingNodeForPacket(const QByteArray& packet);
     
     SharedNodePointer addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
                                       const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket);
-    SharedNodePointer updateSocketsForNode(const QUuid& uuid,
-                                           const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket);
     
     const HifiSockAddr& getLocalSockAddr() const { return _localSockAddr; }
 
@@ -125,6 +126,40 @@ public:
     
     void sendHeartbeatToIceServer(const HifiSockAddr& iceServerSockAddr,
                                   QUuid headerID = QUuid(), const QUuid& connectRequestID = QUuid());
+    
+    template<typename NodeLambda>
+    void eachNode(NodeLambda functor) {
+        QReadLocker readLock(&_nodeMutex);
+        
+        for (NodeHash::const_iterator it = _nodeHash.cbegin(); it != _nodeHash.cend(); ++it) {
+            functor(it->second);
+        }
+    }
+    
+    template<typename BreakableNodeLambda>
+    void eachNodeBreakable(BreakableNodeLambda functor) {
+        QReadLocker readLock(&_nodeMutex);
+        
+        for (NodeHash::const_iterator it = _nodeHash.cbegin(); it != _nodeHash.cend(); ++it) {
+            if (!functor(it->second)) {
+                break;
+            }
+        }
+    }
+    
+    template<typename PredLambda>
+    SharedNodePointer nodeMatchingPredicate(const PredLambda predicate) {
+        QReadLocker readLock(&_nodeMutex);
+        
+        for (NodeHash::const_iterator it = _nodeHash.cbegin(); it != _nodeHash.cend(); ++it) {
+            if (predicate(it->second)) {
+                return it->second;
+            }
+        }
+        
+        return SharedNodePointer();
+    }
+    
 public slots:
     void reset();
     void eraseAllNodes();
@@ -150,15 +185,14 @@ protected:
     
     qint64 writeDatagram(const QByteArray& datagram, const HifiSockAddr& destinationSockAddr,
                          const QUuid& connectionSecret);
-
-    NodeHash::iterator killNodeAtHashIterator(NodeHash::iterator& nodeItemToKill);
-
     
     void changeSocketBufferSizes(int numBytes);
+    
+    void handleNodeKill(const SharedNodePointer& node);
 
     QUuid _sessionUUID;
     NodeHash _nodeHash;
-    QMutex _nodeHashMutex;
+    QReadWriteLock _nodeMutex;
     QUdpSocket _nodeSocket;
     QUdpSocket* _dtlsSocket;
     HifiSockAddr _localSockAddr;
@@ -167,6 +201,17 @@ protected:
     int _numCollectedPackets;
     int _numCollectedBytes;
     QElapsedTimer _packetStatTimer;
+    
+    template<typename IteratorLambda>
+    void eachNodeHashIterator(IteratorLambda functor) {
+        QWriteLocker writeLock(&_nodeMutex);
+        NodeHash::iterator it = _nodeHash.begin();
+        
+        while (it != _nodeHash.end()) {
+            functor(it);
+        }
+    }
+    
 };
 
 #endif // hifi_LimitedNodeList_h
diff --git a/libraries/networking/src/Node.cpp b/libraries/networking/src/Node.cpp
index c2b35d3b7d..de82dde7f0 100644
--- a/libraries/networking/src/Node.cpp
+++ b/libraries/networking/src/Node.cpp
@@ -94,30 +94,48 @@ void Node::updateClockSkewUsec(int clockSkewSample) {
 }
 
 void Node::setPublicSocket(const HifiSockAddr& publicSocket) {
-    if (_activeSocket == &_publicSocket) {
-        // if the active socket was the public socket then reset it to NULL
-        _activeSocket = NULL;
+    if (publicSocket != _publicSocket) {
+        if (_activeSocket == &_publicSocket) {
+            // if the active socket was the public socket then reset it to NULL
+            _activeSocket = NULL;
+        }
+        
+        if (!_publicSocket.isNull()) {
+            qDebug() << "Public socket change for node" << *this;
+        }
+        
+        _publicSocket = publicSocket;
     }
-    
-    _publicSocket = publicSocket;
 }
 
 void Node::setLocalSocket(const HifiSockAddr& localSocket) {
-    if (_activeSocket == &_localSocket) {
-        // if the active socket was the local socket then reset it to NULL
-        _activeSocket = NULL;
+    if (localSocket != _localSocket) {
+        if (_activeSocket == &_localSocket) {
+            // if the active socket was the local socket then reset it to NULL
+            _activeSocket = NULL;
+        }
+        
+        if (!_localSocket.isNull()) {
+            qDebug() << "Local socket change for node" << *this;
+        }
+        
+        _localSocket = localSocket;
     }
-    
-    _localSocket = localSocket;
 }
 
 void Node::setSymmetricSocket(const HifiSockAddr& symmetricSocket) {
-    if (_activeSocket == &_symmetricSocket) {
-        // if the active socket was the symmetric socket then reset it to NULL
-        _activeSocket = NULL;
+    if (symmetricSocket != _symmetricSocket) {
+        if (_activeSocket == &_symmetricSocket) {
+            // if the active socket was the symmetric socket then reset it to NULL
+            _activeSocket = NULL;
+        }
+        
+        if (!_symmetricSocket.isNull()) {
+            qDebug() << "Symmetric socket change for node" << *this;
+        }
+        
+        _symmetricSocket = symmetricSocket;
     }
-    
-    _symmetricSocket = symmetricSocket;
 }
 
 void Node::activateLocalSocket() {
diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp
index ff3b86880d..bf992e7b88 100644
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@@ -449,12 +449,12 @@ void NodeList::pingPunchForInactiveNode(const SharedNodePointer& node) {
 }
 
 void NodeList::pingInactiveNodes() {
-    foreach (const SharedNodePointer& node, getNodeHash()) {
+    eachNode([this](const SharedNodePointer& node){
         if (!node->getActiveSocket()) {
             // we don't have an active link to this node, ping it to set that up
             pingPunchForInactiveNode(node);
         }
-    }
+    });
 }
 
 void NodeList::activateSocketFromNodeCommunication(const QByteArray& packet, const SharedNodePointer& sendingNode) {
diff --git a/libraries/networking/src/SequenceNumberStats.cpp b/libraries/networking/src/SequenceNumberStats.cpp
index f472159164..58c684e16b 100644
--- a/libraries/networking/src/SequenceNumberStats.cpp
+++ b/libraries/networking/src/SequenceNumberStats.cpp
@@ -68,7 +68,7 @@ SequenceNumberStats::ArrivalInfo SequenceNumberStats::sequenceNumberReceived(qui
         int expectedInt = (int)expected;
 
         // check if the gap between incoming and expected is reasonable, taking possible rollover into consideration
-        int absGap = std::abs(incomingInt - expectedInt);
+        int absGap = abs(incomingInt - expectedInt);
         if (absGap >= UINT16_RANGE - MAX_REASONABLE_SEQUENCE_GAP) {
             // rollover likely occurred between incoming and expected.
             // correct the larger of the two so that it's within [-UINT16_RANGE, -1] while the other remains within [0, UINT16_RANGE-1]
diff --git a/libraries/networking/src/UUIDHasher.h b/libraries/networking/src/UUIDHasher.h
new file mode 100644
index 0000000000..d5d16e21e9
--- /dev/null
+++ b/libraries/networking/src/UUIDHasher.h
@@ -0,0 +1,26 @@
+//
+//  UUIDHasher.h
+//  libraries/networking/src
+//
+//  Created by Stephen Birarda on 2014-11-05.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_UUIDHasher_h
+#define hifi_UUIDHasher_h
+
+#include "UUID.h"
+
+class UUIDHasher {
+public:
+    size_t operator()(const QUuid& uuid) const {
+        return uuid.data1 ^ uuid.data2 ^ (uuid.data3 << 16)
+            ^ ((uuid.data4[0] << 24) | (uuid.data4[1] << 16) | (uuid.data4[2] << 8) | uuid.data4[3])
+            ^ ((uuid.data4[4] << 24) | (uuid.data4[5] << 16) | (uuid.data4[6] << 8) | uuid.data4[7]);
+    }
+};
+
+#endif // hifi_UUIDHasher_h
\ No newline at end of file
diff --git a/libraries/octree/src/JurisdictionListener.cpp b/libraries/octree/src/JurisdictionListener.cpp
index f3d9e31acc..bcd5e9ac1c 100644
--- a/libraries/octree/src/JurisdictionListener.cpp
+++ b/libraries/octree/src/JurisdictionListener.cpp
@@ -38,14 +38,12 @@ bool JurisdictionListener::queueJurisdictionRequest() {
     int sizeOut = populatePacketHeader(reinterpret_cast<char*>(bufferOut), PacketTypeJurisdictionRequest);
     int nodeCount = 0;
 
-    NodeList* nodeList = NodeList::getInstance();
-    
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node) {
         if (node->getType() == getNodeType() && node->getActiveSocket()) {
             _packetSender.queuePacketForSending(node, QByteArray(reinterpret_cast<char*>(bufferOut), sizeOut));
             nodeCount++;
         }
-    }
+    });
 
     if (nodeCount > 0){
         _packetSender.setPacketsPerSecond(nodeCount);
diff --git a/libraries/octree/src/OctreeEditPacketSender.cpp b/libraries/octree/src/OctreeEditPacketSender.cpp
index df52e85c5e..cae8919a64 100644
--- a/libraries/octree/src/OctreeEditPacketSender.cpp
+++ b/libraries/octree/src/OctreeEditPacketSender.cpp
@@ -51,13 +51,10 @@ OctreeEditPacketSender::~OctreeEditPacketSender() {
 bool OctreeEditPacketSender::serversExist() const {
     bool hasServers = false;
     bool atLeastOneJurisdictionMissing = false; // assume the best
-    NodeList* nodeList = NodeList::getInstance();
-
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
-
-        // only send to the NodeTypes that are getMyNodeType()
+    
+    NodeList::getInstance()->eachNodeBreakable([&](const SharedNodePointer& node){
         if (node->getType() == getMyNodeType() && node->getActiveSocket()) {
-
+            
             QUuid nodeUUID = node->getUUID();
             // If we've got Jurisdictions set, then check to see if we know the jurisdiction for this server
             if (_serverJurisdictions) {
@@ -71,10 +68,13 @@ bool OctreeEditPacketSender::serversExist() const {
             }
             hasServers = true;
         }
+        
         if (atLeastOneJurisdictionMissing) {
-            break; // no point in looking further...
+            return false; // no point in looking further - return false from anonymous function
+        } else {
+            return true;
         }
-    }
+    });
 
     return (hasServers && !atLeastOneJurisdictionMissing);
 }
@@ -85,51 +85,48 @@ void OctreeEditPacketSender::queuePacketToNode(const QUuid& nodeUUID, unsigned c
                                                size_t length, qint64 satoshiCost) {
 
     bool wantDebug = false;
-    NodeList* nodeList = NodeList::getInstance();
-
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node){
         // only send to the NodeTypes that are getMyNodeType()
-        if (node->getType() == getMyNodeType() &&
-            ((node->getUUID() == nodeUUID) || (nodeUUID.isNull()))) {
-            if (node->getActiveSocket()) {
-
-                // pack sequence number
-                int numBytesPacketHeader = numBytesForPacketHeader(reinterpret_cast<char*>(buffer));
-                unsigned char* sequenceAt = buffer + numBytesPacketHeader;
-                quint16 sequence = _outgoingSequenceNumbers[nodeUUID]++;
-                memcpy(sequenceAt, &sequence, sizeof(quint16));
+        if (node->getType() == getMyNodeType()
+            && ((node->getUUID() == nodeUUID) || (nodeUUID.isNull()))
+            && node->getActiveSocket()) {
+            
+            // pack sequence number
+            int numBytesPacketHeader = numBytesForPacketHeader(reinterpret_cast<char*>(buffer));
+            unsigned char* sequenceAt = buffer + numBytesPacketHeader;
+            quint16 sequence = _outgoingSequenceNumbers[nodeUUID]++;
+            memcpy(sequenceAt, &sequence, sizeof(quint16));
+            
+            // send packet
+            QByteArray packet(reinterpret_cast<const char*>(buffer), length);
+            
+            queuePacketForSending(node, packet);
+            
+            if (hasDestinationWalletUUID() && satoshiCost > 0) {
+                // if we have a destination wallet UUID and a cost associated with this packet, signal that it
+                // needs to be sent
+                emit octreePaymentRequired(satoshiCost, nodeUUID, _destinationWalletUUID);
+            }
+            
+            // add packet to history
+            _sentPacketHistories[nodeUUID].packetSent(sequence, packet);
+            
+            // debugging output...
+            if (wantDebug) {
+                int numBytesPacketHeader = numBytesForPacketHeader(reinterpret_cast<const char*>(buffer));
+                unsigned short int sequence = (*((unsigned short int*)(buffer + numBytesPacketHeader)));
+                quint64 createdAt = (*((quint64*)(buffer + numBytesPacketHeader + sizeof(sequence))));
+                quint64 queuedAt = usecTimestampNow();
+                quint64 transitTime = queuedAt - createdAt;
                 
-                // send packet
-                QByteArray packet(reinterpret_cast<const char*>(buffer), length);
-
-                queuePacketForSending(node, packet);
-                
-                if (hasDestinationWalletUUID() && satoshiCost > 0) {
-                    // if we have a destination wallet UUID and a cost associated with this packet, signal that it
-                    // needs to be sent
-                    emit octreePaymentRequired(satoshiCost, nodeUUID, _destinationWalletUUID);
-                }
-
-                // add packet to history
-                _sentPacketHistories[nodeUUID].packetSent(sequence, packet);
-
-                // debugging output...
-                if (wantDebug) {
-                    int numBytesPacketHeader = numBytesForPacketHeader(reinterpret_cast<const char*>(buffer));
-                    unsigned short int sequence = (*((unsigned short int*)(buffer + numBytesPacketHeader)));
-                    quint64 createdAt = (*((quint64*)(buffer + numBytesPacketHeader + sizeof(sequence))));
-                    quint64 queuedAt = usecTimestampNow();
-                    quint64 transitTime = queuedAt - createdAt;
-
-                    qDebug() << "OctreeEditPacketSender::queuePacketToNode() queued " << buffer[0] <<
-                            " - command to node bytes=" << length <<
-                            " satoshiCost=" << satoshiCost <<
-                            " sequence=" << sequence <<
-                            " transitTimeSoFar=" << transitTime << " usecs";
-                }
+                qDebug() << "OctreeEditPacketSender::queuePacketToNode() queued " << buffer[0] <<
+                " - command to node bytes=" << length <<
+                " satoshiCost=" << satoshiCost <<
+                " sequence=" << sequence <<
+                " transitTimeSoFar=" << transitTime << " usecs";
             }
         }
-    }
+    });
 }
 
 void OctreeEditPacketSender::processPreServerExistsPackets() {
@@ -194,8 +191,8 @@ void OctreeEditPacketSender::queuePacketToNodes(unsigned char* buffer, size_t le
     // But we can't really do that with a packed message, since each edit message could be destined
     // for a different server... So we need to actually manage multiple queued packets... one
     // for each server
-
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node){
         // only send to the NodeTypes that are getMyNodeType()
         if (node->getActiveSocket() && node->getType() == getMyNodeType()) {
             QUuid nodeUUID = node->getUUID();
@@ -210,7 +207,7 @@ void OctreeEditPacketSender::queuePacketToNodes(unsigned char* buffer, size_t le
                 queuePacketToNode(nodeUUID, buffer, length, satoshiCost);
             }
         }
-    }
+    });
 }
 
 
@@ -247,7 +244,8 @@ void OctreeEditPacketSender::queueOctreeEditMessage(PacketType type, unsigned ch
     // for a different server... So we need to actually manage multiple queued packets... one
     // for each server
     _packetsQueueLock.lock();
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node){
         // only send to the NodeTypes that are getMyNodeType()
         if (node->getActiveSocket() && node->getType() == getMyNodeType()) {
             QUuid nodeUUID = node->getUUID();
@@ -270,19 +268,19 @@ void OctreeEditPacketSender::queueOctreeEditMessage(PacketType type, unsigned ch
             if (isMyJurisdiction) {
                 EditPacketBuffer& packetBuffer = _pendingEditPackets[nodeUUID];
                 packetBuffer._nodeUUID = nodeUUID;
-
+                
                 // If we're switching type, then we send the last one and start over
                 if ((type != packetBuffer._currentType && packetBuffer._currentSize > 0) ||
                     (packetBuffer._currentSize + length >= (size_t)_maxPacketSize)) {
                     releaseQueuedPacket(packetBuffer);
                     initializePacket(packetBuffer, type, node->getClockSkewUsec());
                 }
-
+                
                 // If the buffer is empty and not correctly initialized for our type...
                 if (type != packetBuffer._currentType && packetBuffer._currentSize == 0) {
                     initializePacket(packetBuffer, type, node->getClockSkewUsec());
                 }
-
+                
                 // This is really the first time we know which server/node this particular edit message
                 // is going to, so we couldn't adjust for clock skew till now. But here's our chance.
                 // We call this virtual function that allows our specific type of EditPacketSender to
@@ -290,13 +288,13 @@ void OctreeEditPacketSender::queueOctreeEditMessage(PacketType type, unsigned ch
                 if (node->getClockSkewUsec() != 0) {
                     adjustEditPacketForClockSkew(type, editPacketBuffer, length, node->getClockSkewUsec());
                 }
-
+                
                 memcpy(&packetBuffer._currentBuffer[packetBuffer._currentSize], editPacketBuffer, length);
                 packetBuffer._currentSize += length;
                 packetBuffer._satoshiCost += satoshiCost;
             }
         }
-    }
+    });
 
     _packetsQueueLock.unlock();
 
@@ -382,7 +380,7 @@ void OctreeEditPacketSender::processNackPacket(const QByteArray& packet) {
         // retrieve packet from history
         const QByteArray* packet = sentPacketHistory.getPacket(sequenceNumber);
         if (packet) {
-            const SharedNodePointer& node = NodeList::getInstance()->getNodeHash().value(sendingNodeUUID);
+            const SharedNodePointer& node = NodeList::getInstance()->nodeWithUUID(sendingNodeUUID);
             queuePacketForSending(node, *packet);
         }
     }
diff --git a/libraries/octree/src/OctreeHeadlessViewer.cpp b/libraries/octree/src/OctreeHeadlessViewer.cpp
index 2f21c7a899..e0ca22e4e8 100644
--- a/libraries/octree/src/OctreeHeadlessViewer.cpp
+++ b/libraries/octree/src/OctreeHeadlessViewer.cpp
@@ -76,15 +76,15 @@ void OctreeHeadlessViewer::queryOctree() {
     int totalServers = 0;
     int inViewServers = 0;
     int unknownJurisdictionServers = 0;
-
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+    
+    NodeList::getInstance()->eachNode([&](const SharedNodePointer& node){
         // only send to the NodeTypes that are serverType
         if (node->getActiveSocket() && node->getType() == serverType) {
             totalServers++;
-
+            
             // get the server bounds for this server
             QUuid nodeUUID = node->getUUID();
-
+            
             // if we haven't heard from this voxel server, go ahead and send it a query, so we
             // can get the jurisdiction...
             jurisdictions.lockForRead();
@@ -93,18 +93,18 @@ void OctreeHeadlessViewer::queryOctree() {
                 unknownJurisdictionServers++;
             } else {
                 const JurisdictionMap& map = (jurisdictions)[nodeUUID];
-
+                
                 unsigned char* rootCode = map.getRootOctalCode();
-
+                
                 if (rootCode) {
                     VoxelPositionSize rootDetails;
                     voxelDetailsForCode(rootCode, rootDetails);
                     jurisdictions.unlock();
                     AACube serverBounds(glm::vec3(rootDetails.x, rootDetails.y, rootDetails.z), rootDetails.s);
                     serverBounds.scale(TREE_SCALE);
-
+                    
                     ViewFrustum::location serverFrustumLocation = _viewFrustum.cubeInFrustum(serverBounds);
-
+                    
                     if (serverFrustumLocation != ViewFrustum::OUTSIDE) {
                         inViewServers++;
                     }
@@ -113,7 +113,7 @@ void OctreeHeadlessViewer::queryOctree() {
                 }
             }
         }
-    }
+    });
 
     if (wantExtraDebugging) {
         qDebug("Servers: total %d, in view %d, unknown jurisdiction %d",
@@ -141,18 +141,16 @@ void OctreeHeadlessViewer::queryOctree() {
     }
 
     NodeList* nodeList = NodeList::getInstance();
-
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+    nodeList->eachNode([&](const SharedNodePointer& node){
         // only send to the NodeTypes that are serverType
         if (node->getActiveSocket() && node->getType() == serverType) {
-
-
+            
             // get the server bounds for this server
             QUuid nodeUUID = node->getUUID();
-
+            
             bool inView = false;
             bool unknownView = false;
-
+            
             // if we haven't heard from this voxel server, go ahead and send it a query, so we
             // can get the jurisdiction...
             jurisdictions.lockForRead();
@@ -164,16 +162,16 @@ void OctreeHeadlessViewer::queryOctree() {
                 }
             } else {
                 const JurisdictionMap& map = (jurisdictions)[nodeUUID];
-
+                
                 unsigned char* rootCode = map.getRootOctalCode();
-
+                
                 if (rootCode) {
                     VoxelPositionSize rootDetails;
                     voxelDetailsForCode(rootCode, rootDetails);
                     jurisdictions.unlock();
                     AACube serverBounds(glm::vec3(rootDetails.x, rootDetails.y, rootDetails.z), rootDetails.s);
                     serverBounds.scale(TREE_SCALE);
-
+                    
                     ViewFrustum::location serverFrustumLocation = _viewFrustum.cubeInFrustum(serverBounds);
                     if (serverFrustumLocation != ViewFrustum::OUTSIDE) {
                         inView = true;
@@ -187,7 +185,7 @@ void OctreeHeadlessViewer::queryOctree() {
                     }
                 }
             }
-
+            
             if (inView) {
                 _octreeQuery.setMaxOctreePacketsPerSecond(perServerPPS);
                 if (wantExtraDebugging) {
@@ -196,9 +194,9 @@ void OctreeHeadlessViewer::queryOctree() {
             } else if (unknownView) {
                 if (wantExtraDebugging) {
                     qDebug() << "no known jurisdiction for node " << *node << ", give it budget of "
-                            << perUnknownServer << " to send us jurisdiction.";
+                    << perUnknownServer << " to send us jurisdiction.";
                 }
-
+                
                 // set the query's position/orientation to be degenerate in a manner that will get the scene quickly
                 // If there's only one server, then don't do this, and just let the normal voxel query pass through
                 // as expected... this way, we will actually get a valid scene if there is one to be seen
@@ -222,19 +220,19 @@ void OctreeHeadlessViewer::queryOctree() {
             }
             // set up the packet for sending...
             unsigned char* endOfQueryPacket = queryPacket;
-
+            
             // insert packet type/version and node UUID
             endOfQueryPacket += populatePacketHeader(reinterpret_cast<char*>(endOfQueryPacket), packetType);
-
+            
             // encode the query data...
             endOfQueryPacket += _octreeQuery.getBroadcastData(endOfQueryPacket);
-
+            
             int packetLength = endOfQueryPacket - queryPacket;
-
+            
             // make sure we still have an active socket
             nodeList->writeUnverifiedDatagram(reinterpret_cast<const char*>(queryPacket), packetLength, node);
         }
-    }
+    });
 }
 
 
diff --git a/libraries/script-engine/src/ScriptEngine.cpp b/libraries/script-engine/src/ScriptEngine.cpp
index 2691b10273..5dda0918c4 100644
--- a/libraries/script-engine/src/ScriptEngine.cpp
+++ b/libraries/script-engine/src/ScriptEngine.cpp
@@ -514,17 +514,17 @@ void ScriptEngine::run() {
                 
                 // write audio packet to AudioMixer nodes
                 NodeList* nodeList = NodeList::getInstance();
-                foreach(const SharedNodePointer& node, nodeList->getNodeHash()) {
+                nodeList->eachNode([this, &nodeList, &audioPacket, &numPreSequenceNumberBytes](const SharedNodePointer& node){
                     // only send to nodes of type AudioMixer
                     if (node->getType() == NodeType::AudioMixer) {
                         // pack sequence number
                         quint16 sequence = _outgoingScriptAudioSequenceNumbers[node->getUUID()]++;
                         memcpy(audioPacket.data() + numPreSequenceNumberBytes, &sequence, sizeof(quint16));
-
+                        
                         // send audio packet
                         nodeList->writeDatagram(audioPacket, node);
                     }
-                }
+                });
             }
         }
 
diff --git a/libraries/shared/src/LogHandler.cpp b/libraries/shared/src/LogHandler.cpp
index a13f3a9dad..6abfd9e787 100644
--- a/libraries/shared/src/LogHandler.cpp
+++ b/libraries/shared/src/LogHandler.cpp
@@ -12,15 +12,7 @@
 
 #include <time.h>
 
-#ifdef _WIN32
-#include <process.h>
-#define getpid _getpid
-#define getppid _getpid // hack to build
-#define pid_t int // hack to build
-#elif __linux__
-#include <unistd.h> // for getpid() on linux
-#endif
-
+#include <qcoreapplication.h>
 #include <qdebug.h>
 #include <qtimer.h>
 
@@ -122,14 +114,8 @@ QString LogHandler::printMessage(LogMsgType type, const QMessageLogContext& cont
     prefixString.append(QString(" [%1]").arg(dateString));
     
     if (_shouldOutputPID) {
-        prefixString.append(QString(" [%1").arg(getpid()));
+        prefixString.append(QString(" [%1]").arg(QCoreApplication::instance()->applicationPid()));
         
-        pid_t parentProcessID = getppid();
-        if (parentProcessID != 0) {
-            prefixString.append(QString(":%1]").arg(parentProcessID));
-        } else {
-            prefixString.append("]");
-        }
     }
     
     if (!_targetName.isEmpty()) {