diff --git a/sdk/core/qtutils.h b/sdk/core/qtutils.h
index 4333cba..96d6316 100644
--- a/sdk/core/qtutils.h
+++ b/sdk/core/qtutils.h
@@ -63,14 +63,6 @@ namespace QtUtils
     bool runRScript(const QString &file);
     bool runDot(const QString &file);
     void showFile(const QString &file);
-
-    /**** Thread Utilities ****/
-    template <typename T>
-    static inline void waitForFinished(const QList< QFuture<T> > &futures)
-    {
-        foreach (QFuture<T> future, futures)
-            future.waitForFinished();
-    }
 }
 
 #endif // __QTUTILS_H
diff --git a/sdk/openbr_plugin.cpp b/sdk/openbr_plugin.cpp
index 9f5445e..309acee 100644
--- a/sdk/openbr_plugin.cpp
+++ b/sdk/openbr_plugin.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+#include <QFutureSynchronizer>
 #include <QMetaProperty>
 #include <QPointF>
 #include <QRect>
@@ -1162,12 +1163,12 @@ private:
         for (int i=0; i<templatesList.size(); i++)
             templatesList[i] = Downsample(templatesList[i], transforms[i]);
 
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<templatesList.size(); i++) {
-            if (Globals->parallelism) futures.append(QtConcurrent::run(_train, transforms[i], &templatesList[i]));
-            else                                                       _train (transforms[i], &templatesList[i]);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_train, transforms[i], &templatesList[i]));
+            else                                                          _train (transforms[i], &templatesList[i]);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
     }
 
     void project(const Template &src, Template &dst) const
@@ -1306,11 +1307,11 @@ void Transform::backProject(const TemplateList &dst, TemplateList &src) const
     src.reserve(dst.size());
     for (int i=0; i<dst.size(); i++) src.append(Template());
 
-    QList< QFuture<void> > futures;
+    QFutureSynchronizer<void> futures;
     for (int i=0; i<dst.size(); i++)
-        if (Globals->parallelism) futures.append(QtConcurrent::run(_backProject, this, &dst[i], &src[i]));
-        else                                                       _backProject (this, &dst[i], &src[i]);
-    QtUtils::waitForFinished(futures);
+        if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_backProject, this, &dst[i], &src[i]));
+        else                                                          _backProject (this, &dst[i], &src[i]);
+    futures.waitForFinished();
 }
 
 /* Distance - public methods */
@@ -1338,16 +1339,16 @@ void Distance::compare(const TemplateList &target, const TemplateList &query, Ou
     const bool stepTarget = target.size() > query.size();
     const int totalSize = std::max(target.size(), query.size());
     int stepSize = ceil(float(totalSize) / float(std::max(1, abs(Globals->parallelism))));
-    QList< QFuture<void> > futures; futures.reserve(ceil(float(totalSize)/float(stepSize)));
+    QFutureSynchronizer<void> futures;
     for (int i=0; i<totalSize; i+=stepSize) {
         const TemplateList &targets(stepTarget ? TemplateList(target.mid(i, stepSize)) : target);
         const TemplateList &queries(stepTarget ? query : TemplateList(query.mid(i, stepSize)));
         const int targetOffset = stepTarget ? i : 0;
         const int queryOffset = stepTarget ? 0 : i;
-        if (Globals->parallelism) futures.append(QtConcurrent::run(this, &Distance::compareBlock, targets, queries, output, targetOffset, queryOffset));
-        else                                                                        compareBlock (targets, queries, output, targetOffset, queryOffset);
+        if (Globals->parallelism) futures.addFuture(QtConcurrent::run(this, &Distance::compareBlock, targets, queries, output, targetOffset, queryOffset));
+        else                                                                           compareBlock (targets, queries, output, targetOffset, queryOffset);
     }
-    QtUtils::waitForFinished(futures);
+    futures.waitForFinished();
 }
 
 QList<float> Distance::compare(const TemplateList &targets, const Template &query) const
diff --git a/sdk/plugins/distance.cpp b/sdk/plugins/distance.cpp
index 4781f04..5df5bdc 100644
--- a/sdk/plugins/distance.cpp
+++ b/sdk/plugins/distance.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <opencv2/imgproc/imgproc.hpp>
 #include <openbr_plugin.h>
@@ -155,11 +156,11 @@ class PipeDistance : public Distance
 
     void train(const TemplateList &data)
     {
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         foreach (br::Distance *distance, distances)
-            if (Globals->parallelism) futures.append(QtConcurrent::run(distance, &Distance::train, data));
-            else                      distance->train(data);
-        QtUtils::waitForFinished(futures);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(distance, &Distance::train, data));
+            else                                                          distance->train(data);
+        futures.waitForFinished();
     }
 
     float compare(const Template &a, const Template &b) const
diff --git a/sdk/plugins/meta.cpp b/sdk/plugins/meta.cpp
index c693452..dd11ca5 100644
--- a/sdk/plugins/meta.cpp
+++ b/sdk/plugins/meta.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <openbr_plugin.h>
 
@@ -284,12 +285,12 @@ class ForkTransform : public CompositeTransform
 
     void train(const TemplateList &data)
     {
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<transforms.size(); i++) {
-            if (Globals->parallelism) futures.append(QtConcurrent::run(_train, transforms[i], &data));
-            else                                                       _train (transforms[i], &data);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_train, transforms[i], &data));
+            else                                                          _train (transforms[i], &data);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
     }
 
     void backProject(const Template &dst, Template &src) const {Transform::backProject(dst, src);}
@@ -634,16 +635,13 @@ public:
             output_buffer.append(TemplateList());
         }
 
-        QList< QFuture<void> > futures;
-        futures.reserve(src.size());
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<src.size(); i++) {
             input_buffer[i].append(src[i]);
-            if (Globals->parallelism)
-                futures.append(QtConcurrent::run(_projectList, transform, &input_buffer[i], &output_buffer[i]));
-            else
-                _projectList(transform, &input_buffer[i], &output_buffer[i]);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_projectList, transform, &input_buffer[i], &output_buffer[i]));
+            else                                                          _projectList( transform, &input_buffer[i], &output_buffer[i]);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
 
         for (int i=0; i<src.size(); i++) dst.append(output_buffer[i]);
     }
diff --git a/sdk/plugins/normalize.cpp b/sdk/plugins/normalize.cpp
index 86ebcd7..208ae11 100644
--- a/sdk/plugins/normalize.cpp
+++ b/sdk/plugins/normalize.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
@@ -120,16 +121,16 @@ private:
             bv.push_back(Mat(1, dims, CV_64FC1));
         }
 
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         const bool parallel = (data.size() > 1000) && Globals->parallelism;
         for (size_t c = 0; c < mv.size(); c++) {
             for (int i=0; i<dims; i++)
-                if (parallel) futures.append(QtConcurrent::run(_train, method, mv[c], &av[c], &bv[c], i));
-                else                                           _train (method, mv[c], &av[c], &bv[c], i);
+                if (parallel) futures.addFuture(QtConcurrent::run(_train, method, mv[c], &av[c], &bv[c], i));
+                else                                              _train (method, mv[c], &av[c], &bv[c], i);
             av[c] = av[c].reshape(1, data.first().m().rows);
             bv[c] = bv[c].reshape(1, data.first().m().rows);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
 
         merge(av, a);
         merge(bv, b);
diff --git a/sdk/plugins/validate.cpp b/sdk/plugins/validate.cpp
index 80a5b70..819fd79 100644
--- a/sdk/plugins/validate.cpp
+++ b/sdk/plugins/validate.cpp
@@ -1,8 +1,7 @@
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <openbr_plugin.h>
 
-#include "core/qtutils.h"
-
 namespace br
 {
 
@@ -36,16 +35,16 @@ class CrossValidateTransform : public MetaTransform
             return;
         }
 
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<numPartitions; i++) {
             TemplateList partitionedData = data;
             for (int j=partitionedData.size()-1; j>=0; j--)
                 if (partitions[j] == i)
                     partitionedData.removeAt(j);
-            if (Globals->parallelism) futures.append(QtConcurrent::run(transforms[i], &Transform::train, partitionedData));
-            else                                                       transforms[i]->train(partitionedData);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(transforms[i], &Transform::train, partitionedData));
+            else                                                          transforms[i]->train(partitionedData);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
     }
 
     void project(const Template &src, Template &dst) const