diff --git a/src/location/declarativemaps/qdeclarativecirclemapitem.cpp b/src/location/declarativemaps/qdeclarativecirclemapitem.cpp
index 68e61ee5a93e6a25ee07bad397ab9741e303fd36..e8b73ae5cf16a01611082d9e6e445548fc9009a1 100644
--- a/src/location/declarativemaps/qdeclarativecirclemapitem.cpp
+++ b/src/location/declarativemaps/qdeclarativecirclemapitem.cpp
@@ -501,7 +501,7 @@ void QDeclarativeCircleMapItem::updatePolish()
     QList<QDoubleVector2D> circlePath = circlePath_;
 
     int pathCount = circlePath.size();
-    bool preserve = preserveCircleGeometry(circlePath, circle_.center(), circle_.radius());
+    bool preserve = preserveCircleGeometry(circlePath, circle_.center(), circle_.radius(), p);
     // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft());
     // to fix QTBUG-62154
     geometry_.setPreserveGeometry(true, leftBound_); // to set the geoLeftBound_
@@ -623,11 +623,11 @@ void QDeclarativeCircleMapItem::geometryChanged(const QRectF &newGeometry, const
 }
 
 bool QDeclarativeCircleMapItem::preserveCircleGeometry (QList<QDoubleVector2D> &path,
-                                    const QGeoCoordinate &center, qreal distance)
+                                    const QGeoCoordinate &center, qreal distance, const QGeoProjectionWebMercator &p)
 {
     // if circle crosses north/south pole, then don't preserve circular shape,
     if ( crossEarthPole(center, distance)) {
-        updateCirclePathForRendering(path, center, distance);
+        updateCirclePathForRendering(path, center, distance, p);
         return false;
     }
     return true;
@@ -653,9 +653,8 @@ bool QDeclarativeCircleMapItem::preserveCircleGeometry (QList<QDoubleVector2D> &
  */
 void QDeclarativeCircleMapItem::updateCirclePathForRendering(QList<QDoubleVector2D> &path,
                                                              const QGeoCoordinate &center,
-                                                             qreal distance)
+                                                             qreal distance, const QGeoProjectionWebMercator &p)
 {
-    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map()->geoProjection());
     const qreal poleLat = 90;
     const qreal distanceToNorthPole = center.distanceTo(QGeoCoordinate(poleLat, 0));
     const qreal distanceToSouthPole = center.distanceTo(QGeoCoordinate(-poleLat, 0));
diff --git a/src/location/declarativemaps/qdeclarativecirclemapitem_p.h b/src/location/declarativemaps/qdeclarativecirclemapitem_p.h
index bb359ee31b981a5eccce55bfe21754f5d38df88d..2e8c56f8a499f1e4069ffb7e63d6f5a7d0bf07a5 100644
--- a/src/location/declarativemaps/qdeclarativecirclemapitem_p.h
+++ b/src/location/declarativemaps/qdeclarativecirclemapitem_p.h
@@ -58,7 +58,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class QGeoMapCircleGeometry : public QGeoMapPolygonGeometry
+class Q_LOCATION_PRIVATE_EXPORT QGeoMapCircleGeometry : public QGeoMapPolygonGeometry
 {
 public:
     QGeoMapCircleGeometry();
@@ -99,8 +99,10 @@ public:
     static bool crossEarthPole(const QGeoCoordinate &center, qreal distance);
     static void calculatePeripheralPoints(QList<QGeoCoordinate> &path, const QGeoCoordinate &center,
                                    qreal distance, int steps, QGeoCoordinate &leftBound);
-    bool preserveCircleGeometry(QList<QDoubleVector2D> &path, const QGeoCoordinate &center,
-                                qreal distance);
+    static bool preserveCircleGeometry(QList<QDoubleVector2D> &path, const QGeoCoordinate &center,
+                                qreal distance, const QGeoProjectionWebMercator &p);
+    static void updateCirclePathForRendering(QList<QDoubleVector2D> &path, const QGeoCoordinate &center,
+                                      qreal distance, const QGeoProjectionWebMercator &p);
 
 Q_SIGNALS:
     void centerChanged(const QGeoCoordinate &center);
@@ -117,8 +119,6 @@ protected Q_SLOTS:
 
 private:
     void updateCirclePath();
-    void updateCirclePathForRendering(QList<QDoubleVector2D> &path, const QGeoCoordinate &center,
-                                      qreal distance);
 
 private:
     QGeoCircle circle_;
diff --git a/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h b/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h
index 72bfd85646ba03d425f65b5a817046dbc8170fa4..1e2a91c9bc42d2cc639edf0a5459026a627b15ce 100644
--- a/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h
+++ b/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h
@@ -60,7 +60,7 @@ QT_BEGIN_NAMESPACE
 
 class MapPolygonNode;
 
-class QGeoMapPolygonGeometry : public QGeoMapItemGeometry
+class Q_LOCATION_PRIVATE_EXPORT QGeoMapPolygonGeometry : public QGeoMapItemGeometry
 {
 public:
     QGeoMapPolygonGeometry();
@@ -137,7 +137,7 @@ private:
 
 //////////////////////////////////////////////////////////////////////
 
-class MapPolygonNode : public QSGGeometryNode
+class Q_LOCATION_PRIVATE_EXPORT MapPolygonNode : public QSGGeometryNode
 {
 
 public:
diff --git a/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp b/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp
index 3b004dce619684ac58016716aab9dd040e6215a0..632f71d7a8a010d77328e0fad9daaf776fb1953f 100644
--- a/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp
+++ b/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp
@@ -410,6 +410,12 @@ void QGeoMapPolylineGeometry::updateScreenPoints(const QGeoMap &map,
     this->translate( -1 * sourceBounds_.topLeft());
 }
 
+void QGeoMapPolylineGeometry::clearSource()
+{
+    srcPoints_.clear();
+    srcPointTypes_.clear();
+}
+
 QDeclarativePolylineMapItem::QDeclarativePolylineMapItem(QQuickItem *parent)
 :   QDeclarativeGeoMapItemBase(parent), line_(this), dirtyMaterial_(true), updatingGeometry_(false)
 {
diff --git a/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h b/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h
index 03fba63657479392d93b17c597b1564ff35eec25..61439097ba26d06749200336d254c8b1faedca63 100644
--- a/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h
+++ b/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h
@@ -85,7 +85,7 @@ private:
     QColor color_;
 };
 
-class QGeoMapPolylineGeometry : public QGeoMapItemGeometry
+class Q_LOCATION_PRIVATE_EXPORT QGeoMapPolylineGeometry : public QGeoMapItemGeometry
 {
 public:
     QGeoMapPolylineGeometry();
@@ -97,7 +97,8 @@ public:
     void updateScreenPoints(const QGeoMap &map,
                             qreal strokeWidth);
 
-protected:
+    void clearSource();
+
     QList<QList<QDoubleVector2D> > clipPath(const QGeoMap &map,
                     const QList<QDoubleVector2D> &path,
                     QDoubleVector2D &leftBoundWrapped);
@@ -177,7 +178,7 @@ private:
 
 //////////////////////////////////////////////////////////////////////
 
-class MapPolylineNode : public QSGGeometryNode
+class Q_LOCATION_PRIVATE_EXPORT MapPolylineNode : public QSGGeometryNode
 {
 
 public:
diff --git a/src/location/declarativemaps/qgeomapitemgeometry_p.h b/src/location/declarativemaps/qgeomapitemgeometry_p.h
index 595107ae2f97765c8222dbca3bebf9ce82943ac0..5149a7c08f42ff7b8d4da8b4a6a26d9bab4460ea 100644
--- a/src/location/declarativemaps/qgeomapitemgeometry_p.h
+++ b/src/location/declarativemaps/qgeomapitemgeometry_p.h
@@ -63,7 +63,7 @@ QT_BEGIN_NAMESPACE
 class QSGGeometry;
 class QGeoMap;
 
-class QGeoMapItemGeometry
+class Q_LOCATION_PRIVATE_EXPORT QGeoMapItemGeometry
 {
 public:
     QGeoMapItemGeometry();
@@ -124,6 +124,9 @@ public:
 
     static QRectF translateToCommonOrigin(const QList<QGeoMapItemGeometry *> &geoms);
 
+private:
+    QGeoMapItemGeometry(const QGeoMapItemGeometry &other); // Or else it may crash on copy
+    QGeoMapItemGeometry &operator= (const QGeoMapItemGeometry & other); // Or else it may crash on copy
 
 protected:
     bool sourceDirty_;
diff --git a/src/location/declarativemaps/qgeomapobject.cpp b/src/location/declarativemaps/qgeomapobject.cpp
index 2e81afa9d55972536479cb798432ffb4fd7b5265..d1d78b666ca7677b368dcf2740b6964d72e6762e 100644
--- a/src/location/declarativemaps/qgeomapobject.cpp
+++ b/src/location/declarativemaps/qgeomapobject.cpp
@@ -185,7 +185,7 @@ void QGeoMapObject::setMap(QGeoMap *map)
         d_ptr->m_componentCompleted = oldCmponentCompleted;
         d_ptr->setVisible(oldVisible);
     }
-    d_ptr->m_map = map;
+    d_ptr->setMap(map);
 
     const QList<QGeoMapObject *> kids = geoMapObjectChildren();
     for (auto kid : kids)
@@ -269,4 +269,9 @@ void QGeoMapObjectPrivate::setVisible(bool visible)
     m_visible = visible;
 }
 
+void QGeoMapObjectPrivate::setMap(QGeoMap *map)
+{
+    m_map = map;
+}
+
 QT_END_NAMESPACE
diff --git a/src/location/declarativemaps/qgeomapobject_p_p.h b/src/location/declarativemaps/qgeomapobject_p_p.h
index 000a992de611b4c8fa8d29189b7163d0ee0d6fe3..fa788b00971240d9651595da8620306af6f5f795 100644
--- a/src/location/declarativemaps/qgeomapobject_p_p.h
+++ b/src/location/declarativemaps/qgeomapobject_p_p.h
@@ -72,6 +72,7 @@ public:
     virtual QGeoMapObject::Type type() const;
     virtual bool visible() const;
     virtual void setVisible(bool visible);
+    virtual void setMap(QGeoMap *map);
     virtual QGeoMapObjectPrivate *clone() = 0; // to allow proper detaching
 
     QGeoMapObject *q = nullptr;
diff --git a/src/location/labs/labs.pri b/src/location/labs/labs.pri
index de2fd8202a7f0d98e56c207bc4d479e22d0fec2c..2da5e90d569201b6bab7546b7bbddb929ad4aec0 100644
--- a/src/location/labs/labs.pri
+++ b/src/location/labs/labs.pri
@@ -1,4 +1,4 @@
 INCLUDEPATH += labs
 
-PRIVATE_HEADERS += $$files($$PWD/*.h)
-SOURCES += $$files($$PWD/*.cpp)
+PRIVATE_HEADERS += $$files($$PWD/*.h) $$files($$PWD/qsg/*.h)
+SOURCES += $$files($$PWD/*.cpp) $$files($$PWD/qsg/*.cpp)
diff --git a/src/location/labs/qgeotiledmaplabs.cpp b/src/location/labs/qgeotiledmaplabs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e4b2c16f2bc9c4e5ce2d08da03b9135a27702fe
--- /dev/null
+++ b/src/location/labs/qgeotiledmaplabs.cpp
@@ -0,0 +1,295 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgeotiledmaplabs_p.h"
+#include <QtLocation/private/qgeotiledmap_p_p.h>
+#include <QtLocation/private/qgeomapobject_p.h>
+#include <QtLocation/private/qmappolylineobjectqsg_p_p.h>
+#include <QtLocation/private/qmappolygonobjectqsg_p_p.h>
+#include <QtLocation/private/qmapcircleobjectqsg_p_p.h>
+#include <QtLocation/private/qmaprouteobjectqsg_p_p.h>
+#include <QtLocation/private/qmapiconobjectqsg_p_p.h>
+
+QT_BEGIN_NAMESPACE
+
+struct MapObject {
+    MapObject(QPointer<QGeoMapObject> &o, QQSGMapObject *sgo)
+        : object(o), sgObject(sgo) {}
+    QPointer<QGeoMapObject> object;
+    QQSGMapObject *sgObject = nullptr;
+};
+
+class QGeoTiledMapLabsPrivate : public QGeoTiledMapPrivate
+{
+    Q_DECLARE_PUBLIC(QGeoTiledMapLabs)
+public:
+    QGeoTiledMapLabsPrivate(QGeoTiledMappingManagerEngine *engine);
+    virtual ~QGeoTiledMapLabsPrivate();
+
+    QGeoMapObjectPrivate *createMapObjectImplementation(QGeoMapObject *obj) override;
+    virtual QList<QGeoMapObject *> mapObjects() const override;
+    static int findMapObject(QGeoMapObject *o, const QList<MapObject> &list);
+    void removeMapObject(QGeoMapObject *obj);
+
+    void updateMapObjects(QSGNode *root, QQuickWindow *window);
+    void updateObjectsGeometry();
+
+protected:
+    void changeViewportSize(const QSize &size) override;
+    void changeCameraData(const QGeoCameraData &oldCameraData) override;
+    void changeActiveMapType(const QGeoMapType mapType) override;
+
+    QList<MapObject> m_mapObjects;
+    QList<MapObject> m_pendingMapObjects;
+};
+
+QGeoTiledMapLabsPrivate::QGeoTiledMapLabsPrivate(QGeoTiledMappingManagerEngine *engine)
+    : QGeoTiledMapPrivate(engine)
+{
+
+}
+
+QGeoTiledMapLabsPrivate::~QGeoTiledMapLabsPrivate()
+{
+
+}
+
+QGeoMapObjectPrivate *QGeoTiledMapLabsPrivate::createMapObjectImplementation(QGeoMapObject *obj)
+{
+    switch (obj->type()) {
+        case QGeoMapObject::PolylineType: {
+            QMapPolylineObjectPrivate &oldImpl = static_cast<QMapPolylineObjectPrivate &>(*obj->implementation());
+            QMapPolylineObjectPrivateQSG *pimpl =
+                    new QMapPolylineObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::PolygonType: {
+            QMapPolygonObjectPrivate &oldImpl = static_cast<QMapPolygonObjectPrivate &>(*obj->implementation());
+            QMapPolygonObjectPrivateQSG *pimpl =
+                    new QMapPolygonObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::CircleType: {
+            QMapCircleObjectPrivate &oldImpl = static_cast<QMapCircleObjectPrivate &>(*obj->implementation());
+            QMapCircleObjectPrivateQSG *pimpl =
+                    new QMapCircleObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::RouteType: {
+            QMapRouteObjectPrivate &oldImpl = static_cast<QMapRouteObjectPrivate &>(*obj->implementation());
+            QMapRouteObjectPrivateQSG *pimpl =
+                    new QMapRouteObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::IconType: {
+            QMapIconObjectPrivate &oldImpl = static_cast<QMapIconObjectPrivate &>(*obj->implementation());
+            QMapIconObjectPrivateQSG *pimpl =
+                    new QMapIconObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        default:
+            qWarning() << "Unsupported object type: " << obj->type();
+            break;
+    }
+    return nullptr;
+}
+
+QList<QGeoMapObject *> QGeoTiledMapLabsPrivate::mapObjects() const
+{
+    return QList<QGeoMapObject *>();
+}
+
+int QGeoTiledMapLabsPrivate::findMapObject(QGeoMapObject *o, const QList<MapObject> &list)
+{
+    for (int i = 0; i < list.size(); ++i)
+    {
+        if (list.at(i).object.data() == o)
+            return i;
+    }
+    return -1;
+}
+
+void QGeoTiledMapLabsPrivate::removeMapObject(QGeoMapObject *obj)
+{
+    int idx = findMapObject(obj, m_mapObjects);
+    if (idx >= 0) {
+        m_mapObjects.removeAt(idx);
+    } else {
+        idx = findMapObject(obj, m_pendingMapObjects);
+        if (idx >= 0) {
+            m_pendingMapObjects.removeAt(idx);
+        } else {
+            // obj not here.
+        }
+    }
+}
+
+void QGeoTiledMapLabsPrivate::updateMapObjects(QSGNode *root, QQuickWindow *window)
+{
+    for (int i = 0; i < m_mapObjects.size(); ++i) {
+        // already added as node
+        if (!m_mapObjects.at(i).object) {
+            qWarning() << "m_mapObjects at "<<i<< " NULLed!!";
+            continue;
+        }
+
+        QQSGMapObject *sgo = m_mapObjects.at(i).sgObject;
+        QSGNode *oldNode = sgo->node;
+        sgo->node = sgo->updateMapObjectNode(oldNode, root, window);
+    }
+
+    QList<int> toRemove;
+    for (int i = 0; i < m_pendingMapObjects.size(); ++i) {
+        // already added as node
+        QQSGMapObject *sgo = m_pendingMapObjects.at(i).sgObject;
+        QSGNode *oldNode = sgo->node;
+        sgo->updateGeometry(); // or subtree will be blocked
+        sgo->node = sgo->updateMapObjectNode(oldNode, root, window);
+        if (sgo->node) {
+            m_mapObjects << m_pendingMapObjects.at(i);
+            toRemove.push_front(i);
+        } else {
+            // leave it to be processed
+        }
+    }
+
+    for (int i: qAsConst(toRemove))
+        m_pendingMapObjects.removeAt(i);
+}
+
+void QGeoTiledMapLabsPrivate::updateObjectsGeometry()
+{
+    Q_Q(QGeoTiledMapLabs);
+    for (int i = 0; i < m_mapObjects.size(); ++i) {
+        // already added as node
+        if (!m_mapObjects.at(i).object) {
+            qWarning() << "m_mapObjects at "<<i<< " NULLed!!";
+            continue;
+        }
+
+        QQSGMapObject *sgo = m_mapObjects.at(i).sgObject;
+        sgo->updateGeometry();
+    }
+    emit q->sgNodeChanged();
+}
+
+void QGeoTiledMapLabsPrivate::changeViewportSize(const QSize &size)
+{
+    updateObjectsGeometry();
+    QGeoTiledMapPrivate::changeViewportSize(size);
+}
+
+void QGeoTiledMapLabsPrivate::changeCameraData(const QGeoCameraData &oldCameraData)
+{
+    updateObjectsGeometry();
+    QGeoTiledMapPrivate::changeCameraData(oldCameraData);
+}
+
+void QGeoTiledMapLabsPrivate::changeActiveMapType(const QGeoMapType mapType)
+{
+    updateObjectsGeometry();
+    QGeoTiledMapPrivate::changeActiveMapType(mapType);
+}
+
+
+/*
+    QGeoTiledMapLabs
+*/
+
+
+
+QGeoTiledMapLabs::QGeoTiledMapLabs(QGeoTiledMappingManagerEngine *engine, QObject *parent)
+    : QGeoTiledMap(*new QGeoTiledMapLabsPrivate(engine), engine, parent)
+{
+
+}
+
+QGeoTiledMapLabs::~QGeoTiledMapLabs()
+{
+
+}
+
+bool QGeoTiledMapLabs::createMapObjectImplementation(QGeoMapObject *obj)
+{
+    Q_D(QGeoTiledMapLabs);
+    QExplicitlySharedDataPointer<QGeoMapObjectPrivate> pimpl =
+            QExplicitlySharedDataPointer<QGeoMapObjectPrivate>(d->createMapObjectImplementation(obj));
+    if (pimpl.constData()) {
+        bool res = obj->setImplementation(pimpl);
+        if (res)
+            emit sgNodeChanged();
+        return res;
+    }
+    return false;
+}
+
+QSGNode *QGeoTiledMapLabs::updateSceneGraph(QSGNode *node, QQuickWindow *window)
+{
+    Q_D(QGeoTiledMapLabs);
+    QSGNode *root = QGeoTiledMap::updateSceneGraph(node, window);
+    d->updateMapObjects(root, window);
+    return root;
+}
+
+void QGeoTiledMapLabs::removeMapObject(QGeoMapObject *obj)
+{
+    Q_D(QGeoTiledMapLabs);
+    d->removeMapObject(obj);
+}
+
+QGeoTiledMapLabs::QGeoTiledMapLabs(QGeoTiledMapLabsPrivate &dd, QGeoTiledMappingManagerEngine *engine, QObject *parent)
+    : QGeoTiledMap(dd, engine, parent)
+{
+
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/location/labs/qgeotiledmaplabs_p.h b/src/location/labs/qgeotiledmaplabs_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..f64997849e9d54caa67a9065cc51016038bd9721
--- /dev/null
+++ b/src/location/labs/qgeotiledmaplabs_p.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGEOTILEDMAPLABS_P_H
+#define QGEOTILEDMAPLABS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtQml/qqml.h>
+#include <QPointer>
+#include <QtLocation/private/qgeotiledmap_p.h>
+#include <QtQuick/qsgsimplerectnode.h>
+#include <QtLocation/private/qqsgmapobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDeclarativeGeoServiceProvider;
+class QDeclarativeGeoMap;
+class QMapRouteObject;
+class QNavigationManager;
+class QGeoTiledMapLabsPrivate;
+class Q_LOCATION_PRIVATE_EXPORT QGeoTiledMapLabs : public QGeoTiledMap
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QGeoTiledMapLabs)
+public:
+    QGeoTiledMapLabs(QGeoTiledMappingManagerEngine *engine, QObject *parent);
+    virtual ~QGeoTiledMapLabs();
+
+    bool createMapObjectImplementation(QGeoMapObject *obj) override;
+
+protected:
+    QSGNode *updateSceneGraph(QSGNode *node, QQuickWindow *window) override;
+    void removeMapObject(QGeoMapObject *obj) override;
+
+    QSGClipNode *m_clip = nullptr;
+    QSGSimpleRectNode *m_simpleRectNode = nullptr;
+
+    // From QGeoTiledMap
+    QGeoTiledMapLabs(QGeoTiledMapLabsPrivate &dd, QGeoTiledMappingManagerEngine *engine, QObject *parent);
+private:
+    Q_DISABLE_COPY(QGeoTiledMapLabs)
+};
+
+QT_END_NAMESPACE
+
+#endif // QGEOTILEDMAPLABS_P_H
diff --git a/src/location/labs/qsg/qmapcircleobjectqsg.cpp b/src/location/labs/qsg/qmapcircleobjectqsg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10110eab4bd4254d8eab6481f7d1913abf643562
--- /dev/null
+++ b/src/location/labs/qsg/qmapcircleobjectqsg.cpp
@@ -0,0 +1,218 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmapcircleobjectqsg_p_p.h"
+
+QT_BEGIN_NAMESPACE
+
+static const int CircleSamples = 128;
+
+QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(QGeoMapObject *q)
+    : QMapCircleObjectPrivateDefault(q)
+{
+
+}
+
+QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(const QMapCircleObjectPrivate &other)
+    : QMapCircleObjectPrivateDefault(other)
+{
+    // Data already cloned by the *Default copy constructor, but necessary
+    // update operations triggered by setters overrides
+    setCenter(center());
+    setRadius(radius());
+    setColor(color());
+    setBorderColor(borderColor());
+    setBorderWidth(borderWidth());
+}
+
+QMapCircleObjectPrivateQSG::~QMapCircleObjectPrivateQSG()
+{
+
+}
+
+void QMapCircleObjectPrivateQSG::updateCirclePath()
+{
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+    QList<QGeoCoordinate> path;
+    QDeclarativeCircleMapItem::calculatePeripheralPoints(path, center(), radius(), CircleSamples, m_leftBound);
+    m_circlePath.clear();
+    for (const QGeoCoordinate &c : path)
+        m_circlePath << p.geoToMapProjection(c);
+}
+
+void QMapCircleObjectPrivateQSG::updateGeometry()
+{
+    if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator
+            || !qIsFinite(m_radius) || !m_center.isValid())
+        return;
+
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+    QScopedValueRollback<bool> rollback(m_updatingGeometry);
+    m_updatingGeometry = true;
+
+    updateCirclePath();
+    QList<QDoubleVector2D> circlePath = m_circlePath;
+
+    int pathCount = circlePath.size();
+    bool preserve = QDeclarativeCircleMapItem::preserveCircleGeometry(circlePath, center(), radius(), p);
+    // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft());
+    // to fix QTBUG-62154
+    m_geometry.markSourceDirty();
+    m_geometry.setPreserveGeometry(true, m_leftBound); // to set the geoLeftBound_
+    m_geometry.setPreserveGeometry(preserve, m_leftBound);
+
+    bool invertedCircle = false;
+    if (QDeclarativeCircleMapItem::crossEarthPole(center(), radius()) && circlePath.size() == pathCount) {
+        m_geometry.updateScreenPointsInvert(circlePath, *m_map); // invert fill area for really huge circles
+        invertedCircle = true;
+    } else {
+        m_geometry.updateSourcePoints(*m_map, circlePath);
+        m_geometry.updateScreenPoints(*m_map);
+    }
+
+    m_borderGeometry.clear();
+
+    //if (borderColor() != Qt::transparent && borderWidth() > 0)
+    {
+        QList<QDoubleVector2D> closedPath = circlePath;
+        closedPath << closedPath.first();
+
+        if (invertedCircle) {
+            closedPath = m_circlePath;
+            closedPath << closedPath.first();
+            std::reverse(closedPath.begin(), closedPath.end());
+        }
+
+        m_borderGeometry.markSourceDirty();
+        m_borderGeometry.setPreserveGeometry(true, m_leftBound);
+        m_borderGeometry.setPreserveGeometry(preserve, m_leftBound);
+
+        // Use srcOrigin_ from fill geometry after clipping to ensure that translateToCommonOrigin won't fail.
+        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+
+        m_borderGeometry.clearSource();
+
+        QDoubleVector2D borderLeftBoundWrapped;
+        QList<QList<QDoubleVector2D > > clippedPaths =
+                m_borderGeometry.clipPath(*m_map, closedPath, borderLeftBoundWrapped);
+        if (clippedPaths.size()) {
+            borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
+            m_borderGeometry.pathToScreen(*m_map, clippedPaths, borderLeftBoundWrapped);
+            m_borderGeometry.updateScreenPoints(*m_map, borderWidth());
+        } else {
+            m_borderGeometry.clear();
+        }
+    }
+
+    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF();
+    m_geometry.translate(origin - m_geometry.firstPointOffset());
+    m_borderGeometry.translate(origin - m_borderGeometry.firstPointOffset());
+}
+
+QGeoMapObjectPrivate *QMapCircleObjectPrivateQSG::clone()
+{
+    return new QMapCircleObjectPrivateQSG(static_cast<QMapCircleObjectPrivate &>(*this));
+}
+
+QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * /*window*/)
+{
+    MapPolygonNode *node = static_cast<MapPolygonNode *>(oldNode);
+
+    bool created = false;
+    if (!node) {
+        node = new MapPolygonNode();
+        created = true;
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty() || !m_borderGeometry.isScreenDirty() || !oldNode || created) {
+        //QMapPolygonObject *p = static_cast<QMapPolygonObject *>(q);
+        node->update(color(), borderColor(), &m_geometry, &m_borderGeometry);
+        m_geometry.setPreserveGeometry(false);
+        m_borderGeometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+        m_borderGeometry.markClean();
+    }
+
+    if (created)
+        root->appendChildNode(node);
+
+    return node;
+}
+
+
+void QMapCircleObjectPrivateQSG::setCenter(const QGeoCoordinate &center)
+{
+    m_center = center;
+    updateGeometry();
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapCircleObjectPrivateQSG::setRadius(qreal radius)
+{
+    m_radius = radius;
+    updateGeometry();
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapCircleObjectPrivateQSG::setColor(const QColor &color)
+{
+    m_fillColor = color;
+    updateGeometry();
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapCircleObjectPrivateQSG::setBorderColor(const QColor &color)
+{
+    m_borderColor = color;
+    updateGeometry();
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapCircleObjectPrivateQSG::setBorderWidth(qreal width)
+{
+    m_borderWidth = width;
+    updateGeometry();
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/location/labs/qsg/qmapcircleobjectqsg_p_p.h b/src/location/labs/qsg/qmapcircleobjectqsg_p_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..17d8568ad0abf045a3090baca99a54ebbc7398e3
--- /dev/null
+++ b/src/location/labs/qsg/qmapcircleobjectqsg_p_p.h
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMAPCIRCLEOBJECTQSG_P_H
+#define QMAPCIRCLEOBJECTQSG_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtLocation/private/qgeomapobject_p_p.h>
+#include <QtLocation/private/qdeclarativecirclemapitem_p.h>
+#include <QtLocation/private/qdeclarativepolygonmapitem_p.h>
+#include <QtLocation/private/qmapcircleobject_p.h>
+#include <QtLocation/private/qmapcircleobject_p_p.h>
+#include <QtLocation/private/qqsgmapobject_p.h>
+#include <QtCore/qscopedvaluerollback.h>
+#include <QGeoCoordinate>
+#include <QColor>
+
+QT_BEGIN_NAMESPACE
+
+class Q_LOCATION_PRIVATE_EXPORT QMapCircleObjectPrivateQSG : public QMapCircleObjectPrivateDefault, public QQSGMapObject
+{
+public:
+    QMapCircleObjectPrivateQSG(QGeoMapObject *q);
+    QMapCircleObjectPrivateQSG(const QMapCircleObjectPrivate &other);
+    ~QMapCircleObjectPrivateQSG() override;
+
+    void updateCirclePath();
+
+    // QQSGMapObject
+    void updateGeometry() override;
+    QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override;
+
+    // QGeoMapCirclePrivate interface
+    void setCenter(const QGeoCoordinate &center) override;
+    void setRadius(qreal radius) override;
+    void setColor(const QColor &color) override;
+    void setBorderColor(const QColor &color) override;
+    void setBorderWidth(qreal width) override;
+
+    // QGeoMapObjectPrivate
+    QGeoMapObjectPrivate *clone() override;
+
+public:
+    // Data Members
+    QList<QDoubleVector2D> m_circlePath;
+    QGeoCoordinate m_leftBound;
+    QGeoMapCircleGeometry m_geometry;
+    QGeoMapPolylineGeometry m_borderGeometry;
+    bool m_updatingGeometry = false;
+};
+
+QT_END_NAMESPACE
+
+#endif // QMAPCIRCLEOBJECT_P_P_H
diff --git a/src/location/labs/qsg/qmapiconobjectqsg.cpp b/src/location/labs/qsg/qmapiconobjectqsg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53d161799c017b0b98fc666d646954e1a8cd5f48
--- /dev/null
+++ b/src/location/labs/qsg/qmapiconobjectqsg.cpp
@@ -0,0 +1,226 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmapiconobjectqsg_p_p.h"
+#include <QtQuick/qsgimagenode.h>
+#include <QtQuick/qsgnode.h>
+#include <QtQuick/private/qquickimage_p.h>
+#include <QtQuick/qquickimageprovider.h>
+#include <QtQuick/qquickwindow.h>
+#include <QtQml/qqmlengine.h>
+#include <QtQml/qqml.h>
+#include <QtNetwork/qnetworkaccessmanager.h>
+
+QT_BEGIN_NAMESPACE
+
+class RootNode : public QSGTransformNode
+{
+public:
+    RootNode() : QSGTransformNode()
+    { }
+
+    bool isSubtreeBlocked() const override
+    {
+        return m_blocked;
+    }
+
+    void setSubtreeBlocked(bool blocked)
+    {
+        m_blocked = blocked;
+    }
+
+    bool m_blocked = false;
+};
+
+QMapIconObjectPrivateQSG::QMapIconObjectPrivateQSG(QGeoMapObject *q)
+    : QMapIconObjectPrivateDefault(q)
+{
+
+}
+
+QMapIconObjectPrivateQSG::QMapIconObjectPrivateQSG(const QMapIconObjectPrivate &other)
+    : QMapIconObjectPrivateDefault(other)
+{
+    setContent(content());
+    setCoordinate(coordinate());
+}
+
+QMapIconObjectPrivateQSG::~QMapIconObjectPrivateQSG()
+{
+
+}
+
+void QMapIconObjectPrivateQSG::updateGeometry()
+{
+    if (!m_map)
+        return;
+
+    m_geometryDirty = true;
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+
+    m_itemPosition = p.coordinateToItemPosition(coordinate());
+    if (m_itemPosition.isFinite()) {
+        m_transformation.setToIdentity();
+        m_transformation.translate(QVector3D(m_itemPosition.x(), m_itemPosition.y(), 0));
+    }
+
+    // TODO: support and test for zoomLevel
+}
+
+QSGNode *QMapIconObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode * root, QQuickWindow *window)
+{
+    bool created = false;
+    RootNode *node = static_cast<RootNode *>(oldNode);
+    if (!node) {
+        node = new RootNode();
+        m_imageNode = window->createImageNode();
+        m_imageNode->setOwnsTexture(true);
+        node->appendChildNode(m_imageNode);
+        created = true;
+    }
+
+    if (m_imageDirty) {
+        m_imageDirty = false;
+        m_imageNode->setTexture(window->createTextureFromImage(m_image));
+        QRect rect = m_image.rect();
+        m_imageNode->setSourceRect(rect);
+        m_imageNode->setRect(QRectF(QPointF(0,0), m_size));
+    }
+
+    if (m_geometryDirty) {
+        m_geometryDirty = false;
+        if (!m_itemPosition.isFinite()) {
+            node->setSubtreeBlocked(true);
+        } else {
+            node->setSubtreeBlocked(false);
+            node->setMatrix(m_transformation);
+        }
+    }
+
+    if (created)
+        root->appendChildNode(node);
+
+    return node;
+}
+
+void QMapIconObjectPrivateQSG::setCoordinate(const QGeoCoordinate &coordinate)
+{
+    QMapIconObjectPrivateDefault::setCoordinate(coordinate);
+    updateGeometry();
+}
+
+template<typename T>
+static T *getContent(const QVariant &content)
+{
+    QObject *obj = qvariant_cast<QObject *>(content);
+    return qobject_cast<T *>(obj);
+}
+
+static inline QString imageId(const QUrl &url)
+{
+    return url.toString(QUrl::RemoveScheme | QUrl::RemoveAuthority).mid(1);
+}
+
+void QMapIconObjectPrivateQSG::clearContent()
+{
+    m_image = QImage();
+}
+
+void QMapIconObjectPrivateQSG::setContent(const QVariant &content)
+{
+    // First reset all local containers
+    clearContent();
+    QQmlEngine *engine = qmlEngine(q);
+
+    // Then pull the new content
+    QMapIconObjectPrivateDefault::setContent(content);
+    switch (content.type()) {
+        case QVariant::UserType: {
+            // TODO: Handle QObject subclasses -- first decide which ones
+            break;
+        }
+        case QVariant::String:
+        case QVariant::Url: {
+            // URL, including image/texture providers
+            // Supporting only image providers for now
+            const QUrl url = content.toUrl();
+            if (!url.isValid()) {
+                m_image = QImage(content.toString());
+                m_imageDirty = true;
+                updateGeometry();
+            } else if (url.scheme().isEmpty() || url.scheme() == QLatin1String("file")) {
+                m_image = QImage(url.toString(QUrl::RemoveScheme));
+                m_imageDirty = true;
+                updateGeometry();
+            } else if (url.scheme() == QLatin1String("image")) {
+                QQuickImageProvider *provider = static_cast<QQuickImageProvider *>(engine->imageProvider(url.host()));
+                QSize outSize;
+                m_image = provider->requestImage(imageId(url), &outSize, QSize());
+                if (outSize.isEmpty())
+                    break;
+                m_imageDirty = true;
+                updateGeometry();
+            } else { // ToDo: Use QNAM
+
+            }
+
+            break;
+        }
+        case QVariant::ByteArray: {
+            // ToDo: Build the image from bytearray
+            break;
+        }
+        default:
+            qWarning() << "Unsupported parameter type: " << content.type();
+            break;
+    }
+
+    if (m_map && m_imageDirty)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapIconObjectPrivateQSG::setSize(const QSizeF &size)
+{
+    QMapIconObjectPrivateDefault::setSize(size);
+    updateGeometry();
+}
+
+QGeoMapObjectPrivate *QMapIconObjectPrivateQSG::clone()
+{
+    return new QMapIconObjectPrivateQSG(static_cast<QMapIconObjectPrivate &>(*this));
+}
+
+QT_END_NAMESPACE
diff --git a/src/location/labs/qsg/qmapiconobjectqsg_p_p.h b/src/location/labs/qsg/qmapiconobjectqsg_p_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2f7cf4077c3ee913e6370622d67d9a12c31f78a
--- /dev/null
+++ b/src/location/labs/qsg/qmapiconobjectqsg_p_p.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMAPICONOBJECTQSG_P_P_H
+#define QMAPICONOBJECTQSG_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtLocation/private/qmapiconobject_p.h>
+#include <QtLocation/private/qmapiconobject_p_p.h>
+#include <QtLocation/private/qqsgmapobject_p.h>
+#include <QtCore/qscopedvaluerollback.h>
+#include <QtGui/qimage.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSGImageNode;
+class Q_LOCATION_PRIVATE_EXPORT QMapIconObjectPrivateQSG : public QMapIconObjectPrivateDefault, public QQSGMapObject
+{
+public:
+    QMapIconObjectPrivateQSG(QGeoMapObject *q);
+    QMapIconObjectPrivateQSG(const QMapIconObjectPrivate &other);
+    ~QMapIconObjectPrivateQSG() override;
+
+    void clearContent();
+
+    // QQSGMapObject
+    void updateGeometry() override;
+    QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override;
+
+    // QGeoMapIconPrivate interface
+    void setCoordinate(const QGeoCoordinate &coordinate) override;
+    void setContent(const QVariant &content) override;
+    void setSize(const QSizeF &size) override;
+
+    // QGeoMapObjectPrivate
+    QGeoMapObjectPrivate *clone() override;
+
+public:
+    // Data Members
+    bool m_imageDirty = false;
+    bool m_geometryDirty = false;
+    QImage m_image;
+    QSGImageNode *m_imageNode = nullptr;
+    QDoubleVector2D m_itemPosition;
+    QMatrix4x4 m_transformation;
+};
+
+QT_END_NAMESPACE
+
+#endif // QMAPICONOBJECTQSG_P_P_H
diff --git a/src/location/labs/qsg/qmappolygonobjectqsg.cpp b/src/location/labs/qsg/qmappolygonobjectqsg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4000c08f7038612a8b6c339a4836c409e2aeb5bb
--- /dev/null
+++ b/src/location/labs/qsg/qmappolygonobjectqsg.cpp
@@ -0,0 +1,212 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmappolygonobjectqsg_p_p.h"
+#include <QtQuick/qsgnode.h>
+#include <QtQuick/qsgsimplerectnode.h>
+
+QT_BEGIN_NAMESPACE
+
+QMapPolygonObjectPrivateQSG::QMapPolygonObjectPrivateQSG(QGeoMapObject *q)
+    : QMapPolygonObjectPrivate(q)
+{
+
+}
+
+QMapPolygonObjectPrivateQSG::QMapPolygonObjectPrivateQSG(const QMapPolygonObjectPrivate &other)
+    : QMapPolygonObjectPrivate(other.q)
+{
+    setPath(other.path());
+    setFillColor(other.fillColor());
+    setBorderColor(other.borderColor());
+    setBorderWidth(other.borderWidth());
+}
+
+QMapPolygonObjectPrivateQSG::~QMapPolygonObjectPrivateQSG()
+{
+
+}
+
+QList<QDoubleVector2D> QMapPolygonObjectPrivateQSG::projectPath()
+{
+    QList<QDoubleVector2D> geopathProjected_;
+    if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return geopathProjected_;
+
+    const QGeoProjectionWebMercator &p =
+            static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+    geopathProjected_.reserve(m_geoPath.path().size());
+    for (const QGeoCoordinate &c : m_geoPath.path())
+        geopathProjected_ << p.geoToMapProjection(c);
+    return geopathProjected_;
+}
+
+QSGNode *QMapPolygonObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * /*window*/)
+{
+    MapPolygonNode *node = static_cast<MapPolygonNode *>(oldNode);
+
+    bool created = false;
+    if (!node) {
+        node = new MapPolygonNode();
+        created = true;
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty() || !m_borderGeometry.isScreenDirty() || !oldNode || created) {
+        node->update(fillColor(), borderColor(), &m_geometry, &m_borderGeometry);
+        m_geometry.setPreserveGeometry(false);
+        m_borderGeometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+        m_borderGeometry.markClean();
+    }
+
+    if (created)
+        root->appendChildNode(node);
+
+    return node;
+}
+
+QList<QGeoCoordinate> QMapPolygonObjectPrivateQSG::path() const
+{
+    return m_geoPath.path();
+}
+
+QColor QMapPolygonObjectPrivateQSG::fillColor() const
+{
+    return m_fillColor;
+}
+
+QColor QMapPolygonObjectPrivateQSG::borderColor() const
+{
+    return m_borderColor;
+}
+
+qreal QMapPolygonObjectPrivateQSG::borderWidth() const
+{
+    return m_borderWidth;
+}
+
+void QMapPolygonObjectPrivateQSG::setPath(const QList<QGeoCoordinate> &path)
+{
+    m_geoPath.setPath(path);
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapPolygonObjectPrivateQSG::setFillColor(const QColor &color)
+{
+    m_fillColor = color;
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapPolygonObjectPrivateQSG::setBorderColor(const QColor &color)
+{
+    m_borderColor = color;
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapPolygonObjectPrivateQSG::setBorderWidth(qreal width)
+{
+    m_borderWidth = width;
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+QGeoMapObjectPrivate *QMapPolygonObjectPrivateQSG::clone()
+{
+    return new QMapPolygonObjectPrivateQSG(static_cast<QMapPolygonObjectPrivate &>(*this));
+}
+
+void QMapPolygonObjectPrivateQSG::updateGeometry()
+{
+    if (!m_map || m_geoPath.path().length() == 0
+            || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return;
+
+    QScopedValueRollback<bool> rollback(m_updatingGeometry);
+    m_updatingGeometry = true;
+
+    const QList<QDoubleVector2D> &geopathProjected = projectPath();
+
+    m_geometry.markSourceDirty();
+    m_geometry.setPreserveGeometry(true, m_geoPath.boundingGeoRectangle().topLeft());
+    m_geometry.updateSourcePoints(*m_map, geopathProjected);
+    m_geometry.updateScreenPoints(*m_map);
+
+    m_borderGeometry.clear();
+
+    //if (border_.color() != Qt::transparent && border_.width() > 0)
+    {
+        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+        QList<QDoubleVector2D> closedPath = geopathProjected;
+        closedPath << closedPath.first();
+
+        m_borderGeometry.markSourceDirty();
+        m_borderGeometry.setPreserveGeometry(true, m_geoPath.boundingGeoRectangle().topLeft());
+
+        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+
+        m_borderGeometry.clearSource();
+
+        QDoubleVector2D borderLeftBoundWrapped;
+        QList<QList<QDoubleVector2D > > clippedPaths =
+                m_borderGeometry.clipPath(*m_map.data(), closedPath, borderLeftBoundWrapped);
+
+        if (clippedPaths.size()) {
+            borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
+            m_borderGeometry.pathToScreen(*m_map.data(), clippedPaths, borderLeftBoundWrapped);
+            m_borderGeometry.updateScreenPoints(*m_map.data(), borderWidth());
+        } else {
+            m_borderGeometry.clear();
+        }
+    }
+
+    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF();
+    m_geometry.translate(origin - m_geometry.firstPointOffset());
+    m_borderGeometry.translate(origin - m_borderGeometry.firstPointOffset());
+}
+
+QT_END_NAMESPACE
diff --git a/src/location/labs/qsg/qmappolygonobjectqsg_p_p.h b/src/location/labs/qsg/qmappolygonobjectqsg_p_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd5efcffaa015729211c8bc1495e4d90b25b8fa1
--- /dev/null
+++ b/src/location/labs/qsg/qmappolygonobjectqsg_p_p.h
@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMAPPOLYGONOBJECTQSG_P_P_H
+#define QMAPPOLYGONOBJECTQSG_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtLocation/private/qmappolygonobject_p.h>
+#include <QtLocation/private/qmappolygonobject_p_p.h>
+#include <QtLocation/private/qqsgmapobject_p.h>
+#include <QtLocation/private/qdeclarativepolygonmapitem_p.h>
+#include <QtCore/qscopedvaluerollback.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_LOCATION_PRIVATE_EXPORT QMapPolygonObjectPrivateQSG : public QMapPolygonObjectPrivate, public QQSGMapObject
+{
+public:
+    QMapPolygonObjectPrivateQSG(QGeoMapObject *q);
+    QMapPolygonObjectPrivateQSG(const QMapPolygonObjectPrivate &other);
+    ~QMapPolygonObjectPrivateQSG() override;
+
+    QList<QDoubleVector2D> projectPath();
+
+    // QQSGMapObject
+    void updateGeometry() override;
+    QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override;
+
+    // QGeoMapPolylinePrivate interface
+    QList<QGeoCoordinate> path() const override;
+    QColor fillColor() const override;
+    QColor borderColor() const override;
+    qreal borderWidth() const override;
+
+    void setPath(const QList<QGeoCoordinate> &path) override;
+    void setFillColor(const QColor &color) override;
+    void setBorderColor(const QColor &color) override;
+    void setBorderWidth(qreal width) override;
+
+    // QGeoMapObjectPrivate
+    QGeoMapObjectPrivate *clone() override;
+
+    // Data Members
+    QGeoMapPolygonGeometry m_geometry;
+    QGeoMapPolylineGeometry m_borderGeometry;
+    QGeoPath m_geoPath;
+
+    QColor m_fillColor;
+    QColor m_borderColor;
+    qreal m_borderWidth = 0;
+    bool m_updatingGeometry = false;
+};
+
+QT_END_NAMESPACE
+
+#endif // QMAPPOLYGONOBJECTQSG_P_P_H
diff --git a/src/location/labs/qsg/qmappolylineobjectqsg.cpp b/src/location/labs/qsg/qmappolylineobjectqsg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe6fbec643d6050c45e8c0c852c361637732e5d3
--- /dev/null
+++ b/src/location/labs/qsg/qmappolylineobjectqsg.cpp
@@ -0,0 +1,160 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmappolylineobjectqsg_p_p.h"
+#include <QtQuick/qsgnode.h>
+#include <QtQuick/qsgsimplerectnode.h>
+
+QT_BEGIN_NAMESPACE
+
+/*
+    Note: never use q, since this class is also used inside QMapRouteObjectPrivateQSG!
+*/
+
+QMapPolylineObjectPrivateQSG::QMapPolylineObjectPrivateQSG(QGeoMapObject *q)
+    : QMapPolylineObjectPrivate(q)
+{
+
+}
+
+QMapPolylineObjectPrivateQSG::QMapPolylineObjectPrivateQSG(const QMapPolylineObjectPrivate &other)
+    : QMapPolylineObjectPrivate(other.q)
+{
+    // do the appropriate internal update and trigger map repaint
+    setPath(other.path());
+    setColor(other.color());
+    setWidth(other.width());
+}
+
+QMapPolylineObjectPrivateQSG::~QMapPolylineObjectPrivateQSG()
+{
+
+}
+
+QList<QDoubleVector2D> QMapPolylineObjectPrivateQSG::projectPath()
+{
+    QList<QDoubleVector2D> geopathProjected_;
+    if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return geopathProjected_;
+
+    const QGeoProjectionWebMercator &p =
+            static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+    geopathProjected_.reserve(m_geoPath.path().size());
+    for (const QGeoCoordinate &c : m_geoPath.path())
+        geopathProjected_ << p.geoToMapProjection(c);
+    return geopathProjected_;
+}
+
+void QMapPolylineObjectPrivateQSG::updateGeometry()
+{
+    if (!m_map || m_geoPath.path().length() == 0
+            || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return;
+
+    QScopedValueRollback<bool> rollback(m_updatingGeometry);
+    m_updatingGeometry = true;
+    m_geometry.markSourceDirty();
+    const QList<QDoubleVector2D> &geopathProjected = projectPath();
+    m_geometry.setPreserveGeometry(true, m_geoPath.boundingGeoRectangle().topLeft());
+    m_geometry.updateSourcePoints(*m_map.data(), geopathProjected, m_geoPath.boundingGeoRectangle().topLeft());
+    m_geometry.updateScreenPoints(*m_map.data(), width());
+
+    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF();
+    m_geometry.translate(origin - m_geometry.firstPointOffset());
+}
+
+QSGNode *QMapPolylineObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * /*window*/)
+{
+    MapPolylineNode *node = static_cast<MapPolylineNode *>(oldNode);
+
+    bool created = false;
+    if (!node) {
+        node = new MapPolylineNode();
+        created = true;
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty() || !oldNode || created) {
+        node->update(color(), &m_geometry);
+        m_geometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+    }
+
+    if (created)
+        root->appendChildNode(node);
+
+    return node;
+}
+
+QList<QGeoCoordinate> QMapPolylineObjectPrivateQSG::path() const { return m_geoPath.path(); }
+
+QColor QMapPolylineObjectPrivateQSG::color() const { return m_color; }
+
+qreal QMapPolylineObjectPrivateQSG::width() const { return m_width; }
+
+void QMapPolylineObjectPrivateQSG::setPath(const QList<QGeoCoordinate> &path)
+{
+    m_geoPath.setPath(path);
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapPolylineObjectPrivateQSG::setColor(const QColor &color)
+{
+    m_color = color;
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+void QMapPolylineObjectPrivateQSG::setWidth(qreal width)
+{
+    m_width = width;
+    updateGeometry();
+
+    if (m_map)
+        emit m_map->sgNodeChanged();
+}
+
+QGeoMapObjectPrivate *QMapPolylineObjectPrivateQSG::clone()
+{
+    return new QMapPolylineObjectPrivateQSG(static_cast<QMapPolylineObjectPrivate &>(*this));
+}
+
+QT_END_NAMESPACE
diff --git a/src/location/labs/qsg/qmappolylineobjectqsg_p_p.h b/src/location/labs/qsg/qmappolylineobjectqsg_p_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..52b5e89a84becb93cfcf6d859902279a996dc37d
--- /dev/null
+++ b/src/location/labs/qsg/qmappolylineobjectqsg_p_p.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMAPPOLYLINEOBJECTOBJECTSOVERLAY_H
+#define QMAPPOLYLINEOBJECTOBJECTSOVERLAY_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtLocation/private/qmappolylineobject_p_p.h>
+#include <QtLocation/private/qdeclarativepolylinemapitem_p.h>
+#include <QtLocation/private/qmappolylineobject_p.h>
+#include <QtLocation/private/qqsgmapobject_p.h>
+#include <QtCore/qscopedvaluerollback.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_LOCATION_PRIVATE_EXPORT QMapPolylineObjectPrivateQSG : public QMapPolylineObjectPrivate, public QQSGMapObject
+{
+public:
+    QMapPolylineObjectPrivateQSG(QGeoMapObject *q);
+    QMapPolylineObjectPrivateQSG(const QMapPolylineObjectPrivate &other);
+    ~QMapPolylineObjectPrivateQSG() override;
+
+    QList<QDoubleVector2D> projectPath();
+
+    // QQSGMapObject
+    void updateGeometry() override;
+    QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override;
+
+    // QGeoMapPolylinePrivate interface
+    QList<QGeoCoordinate> path() const override;
+    QColor color() const override;
+    qreal width() const override;
+
+    void setPath(const QList<QGeoCoordinate> &path) override;
+    void setColor(const QColor &color) override;
+    void setWidth(qreal width) override;
+
+    // QGeoMapObjectPrivate
+    QGeoMapObjectPrivate *clone() override;
+
+    // Data Members
+    QGeoMapPolylineGeometry m_geometry;
+    QGeoPath m_geoPath;
+
+    QColor m_color;
+    qreal m_width = 0;
+    bool m_updatingGeometry = false;
+};
+
+QT_END_NAMESPACE
+
+#endif // QMAPPOLYLINEOBJECTOBJECTSOVERLAY_H
diff --git a/src/location/labs/qsg/qmaprouteobjectqsg.cpp b/src/location/labs/qsg/qmaprouteobjectqsg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8728e08272b5b8744a6dd977e9211bcf8734156
--- /dev/null
+++ b/src/location/labs/qsg/qmaprouteobjectqsg.cpp
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmaprouteobjectqsg_p_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QMapRouteObjectPrivateQSG::QMapRouteObjectPrivateQSG(QGeoMapObject *q)
+    : QMapRouteObjectPrivate(q)
+{
+    QScopedPointer<QMapPolylineObjectPrivateQSG> poly(new QMapPolylineObjectPrivateQSG(q));
+    m_polyline.swap(poly);
+    m_polyline->m_componentCompleted = true;
+}
+
+QMapRouteObjectPrivateQSG::QMapRouteObjectPrivateQSG(const QMapRouteObjectPrivate &other)
+    : QMapRouteObjectPrivate(other)
+{
+    QScopedPointer<QMapPolylineObjectPrivateQSG> poly(new QMapPolylineObjectPrivateQSG(other.q));
+    m_polyline.swap(poly);
+    m_polyline->m_componentCompleted = true;
+    setRoute(other.declarativeGeoRoute());
+}
+
+QMapRouteObjectPrivateQSG::~QMapRouteObjectPrivateQSG()
+{
+
+}
+
+void QMapRouteObjectPrivateQSG::updateGeometry()
+{
+    m_polyline->updateGeometry();
+}
+
+QSGNode *QMapRouteObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * window)
+{
+    return m_polyline->updateMapObjectNode(oldNode, root, window);
+}
+
+void QMapRouteObjectPrivateQSG::setRoute(const QDeclarativeGeoRoute *route)
+{
+    const QList<QGeoCoordinate> &path = route->route().path();
+    m_polyline->setColor(QColor("deepskyblue")); // ToDo: support MapParameters for this
+    m_polyline->setWidth(4);
+    m_polyline->setPath(path); // SGNodeChanged emitted by m_polyline
+}
+
+QGeoMapObjectPrivate *QMapRouteObjectPrivateQSG::clone()
+{
+    return new QMapRouteObjectPrivateQSG(static_cast<QMapRouteObjectPrivate &>(*this));
+}
+
+void QMapRouteObjectPrivateQSG::setMap(QGeoMap *map)
+{
+    QGeoMapObjectPrivate::setMap(map);
+    m_polyline->setMap(map);
+}
+
+
+void QMapRouteObjectPrivateQSG::setVisible(bool visible)
+{
+    m_visible = visible;
+    m_polyline->setVisible(visible);
+}
+
+QT_END_NAMESPACE
diff --git a/src/location/labs/qsg/qmaprouteobjectqsg_p_p.h b/src/location/labs/qsg/qmaprouteobjectqsg_p_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..1c612532f81c6020ca92facda2bb549f1e5251ac
--- /dev/null
+++ b/src/location/labs/qsg/qmaprouteobjectqsg_p_p.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMAPROUTEOBJECTQSG_P_P_H
+#define QMAPROUTEOBJECTQSG_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtLocation/private/qmappolylineobjectqsg_p_p.h>
+#include <QtLocation/private/qmaprouteobject_p_p.h>
+#include <QtLocation/private/qdeclarativegeoroute_p.h>
+#include <QtLocation/private/qmaprouteobject_p.h>
+#include <QtLocation/private/qqsgmapobject_p.h>
+#include <QtCore/qscopedvaluerollback.h>
+#include <QtCore/qscopedpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_LOCATION_PRIVATE_EXPORT QMapRouteObjectPrivateQSG : public QMapRouteObjectPrivate, public QQSGMapObject
+{
+public:
+    QMapRouteObjectPrivateQSG(QGeoMapObject *q);
+    QMapRouteObjectPrivateQSG(const QMapRouteObjectPrivate &other);
+    ~QMapRouteObjectPrivateQSG() override;
+
+    // QQSGMapObject
+    void updateGeometry() override;
+    QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override;
+
+    // QMapRouteObjectPrivate interface
+    void setRoute(const QDeclarativeGeoRoute *route) override;
+
+    // QGeoMapObjectPrivate interface
+    QGeoMapObjectPrivate *clone() override;
+    void setMap(QGeoMap *map) override;
+    void setVisible(bool visible) override;
+
+    // Data Members
+    QScopedPointer<QMapPolylineObjectPrivateQSG> m_polyline;
+};
+
+QT_END_NAMESPACE
+
+#endif // QMAPROUTEOBJECTQSG_P_P_H
diff --git a/src/location/labs/qsg/qqsgmapobject.cpp b/src/location/labs/qsg/qqsgmapobject.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b4f7dbf7584cb80ead607021c1de71927e0959b
--- /dev/null
+++ b/src/location/labs/qsg/qqsgmapobject.cpp
@@ -0,0 +1,64 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqsgmapobject_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QQSGMapObject::QQSGMapObject()
+{
+
+}
+
+QQSGMapObject::~QQSGMapObject()
+{
+
+}
+
+QSGNode *QQSGMapObject::updateMapObjectNode(QSGNode *oldNode, QSGNode * /*root*/, QQuickWindow * /*window*/)
+{
+    delete oldNode;
+    return 0;
+}
+
+void QQSGMapObject::updateGeometry()
+{
+
+}
+
+QT_END_NAMESPACE
+
+
diff --git a/src/location/labs/qsg/qqsgmapobject_p.h b/src/location/labs/qsg/qqsgmapobject_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..d3e54a68cb89c5be946f5d2f3ee6df612d7359c8
--- /dev/null
+++ b/src/location/labs/qsg/qqsgmapobject_p.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQSGMAPOBJECT_H
+#define QQSGMAPOBJECT_H
+
+#include <QtLocation/private/qlocationglobal_p.h>
+#include <QtQuick/QSGOpacityNode>
+#include <QtLocation/private/qgeomapobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickWindow;
+class Q_LOCATION_PRIVATE_EXPORT QQSGMapObject
+{
+public:
+    QQSGMapObject();
+    virtual ~QQSGMapObject();
+
+    virtual QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window);
+    virtual void updateGeometry();
+
+    QSGNode *node = nullptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQSGMAPOBJECT_H
diff --git a/src/plugins/geoservices/esri/esri.pro b/src/plugins/geoservices/esri/esri.pro
index 3642ddafee2d856bb8f46e1dc94029e29391bf4f..3a4da208651963892b08855f8fb583f7351683ed 100644
--- a/src/plugins/geoservices/esri/esri.pro
+++ b/src/plugins/geoservices/esri/esri.pro
@@ -2,6 +2,9 @@ TARGET = qtgeoservices_esri
 
 QT += location-private positioning-private network
 
+QT_FOR_CONFIG += location-private
+qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS
+
 HEADERS += \
     geocodereply_esri.h \
     geocodingmanagerengine_esri.h \
diff --git a/src/plugins/geoservices/esri/geotiledmap_esri.cpp b/src/plugins/geoservices/esri/geotiledmap_esri.cpp
index 9171fc2bc8af375f7b5d8e521dc4811aa0f8fd35..8feb9615d89ee0507c7c71ec9694d4158e5ac3fd 100644
--- a/src/plugins/geoservices/esri/geotiledmap_esri.cpp
+++ b/src/plugins/geoservices/esri/geotiledmap_esri.cpp
@@ -45,7 +45,7 @@
 QT_BEGIN_NAMESPACE
 
 GeoTiledMapEsri::GeoTiledMapEsri(GeoTiledMappingManagerEngineEsri *engine, QObject *parent) :
-    QGeoTiledMap(engine, parent), m_engine(engine), m_mapId(-1)
+    Map(engine, parent), m_engine(engine), m_mapId(-1)
 {
 }
 
diff --git a/src/plugins/geoservices/esri/geotiledmap_esri.h b/src/plugins/geoservices/esri/geotiledmap_esri.h
index e8b26152a683d1ecfb395b32bf4053b9c52a8c63..7a21af9aaca5062aeb43e5b8ee8d94d3fc8a7c24 100644
--- a/src/plugins/geoservices/esri/geotiledmap_esri.h
+++ b/src/plugins/geoservices/esri/geotiledmap_esri.h
@@ -41,12 +41,18 @@
 #define GEOTILEDMAPESRI_H
 
 #include <QtLocation/private/qgeotiledmap_p.h>
+#ifdef LOCATIONLABS
+#include <QtLocation/private/qgeotiledmaplabs_p.h>
+typedef QGeoTiledMapLabs Map;
+#else
+typedef QGeoTiledMap Map;
+#endif
 
 QT_BEGIN_NAMESPACE
 
 class GeoTiledMappingManagerEngineEsri;
 
-class GeoTiledMapEsri: public QGeoTiledMap
+class GeoTiledMapEsri: public Map
 {
     Q_OBJECT
 
diff --git a/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro b/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro
index 1f45de97f52ef519ed806bb66c4572cf152f6882..486ed97aee5aa50380ee252ad5f3d3bc24976a13 100644
--- a/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro
+++ b/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro
@@ -2,6 +2,9 @@ TARGET = qtgeoservices_itemsoverlay
 
 QT += location-private positioning-private
 
+QT_FOR_CONFIG += location-private
+qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS
+
 HEADERS += \
     qgeomapitemsoverlay.h \
     qgeomappingmanagerengineitemsoverlay.h \
diff --git a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp
index 29b844087304c37d6275a7cd04806fb1024ab5ea..99146801802fbb58453e255419c4a97235ab109b 100644
--- a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp
+++ b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp
@@ -38,6 +38,22 @@
 #include "qgeomappingmanagerengineitemsoverlay.h"
 #include <QtLocation/private/qgeomap_p_p.h>
 #include <QtQuick/qsgnode.h>
+#include <QtQuick/qsgrectanglenode.h>
+#include <QtQuick/qquickwindow.h>
+
+#ifdef LOCATIONLABS
+#include <QtLocation/private/qmappolylineobjectqsg_p_p.h>
+#include <QtLocation/private/qmappolygonobjectqsg_p_p.h>
+#include <QtLocation/private/qmapcircleobjectqsg_p_p.h>
+#include <QtLocation/private/qmaprouteobjectqsg_p_p.h>
+#include <QtLocation/private/qmapiconobjectqsg_p_p.h>
+struct MapObject {
+    MapObject(QPointer<QGeoMapObject> &o, QQSGMapObject *sgo)
+        : object(o), sgObject(sgo) {}
+    QPointer<QGeoMapObject> object;
+    QQSGMapObject *sgObject = nullptr;
+};
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -46,9 +62,20 @@ class QGeoMapItemsOverlayPrivate : public QGeoMapPrivate
     Q_DECLARE_PUBLIC(QGeoMapItemsOverlay)
 public:
     QGeoMapItemsOverlayPrivate(QGeoMappingManagerEngineItemsOverlay *engine);
-
     virtual ~QGeoMapItemsOverlayPrivate();
 
+#ifdef LOCATIONLABS
+    QGeoMapObjectPrivate *createMapObjectImplementation(QGeoMapObject *obj) override;
+    virtual QList<QGeoMapObject *> mapObjects() const override;
+    static int findMapObject(QGeoMapObject *o, const QList<MapObject> &list);
+    void removeMapObject(QGeoMapObject *obj);
+    void updateMapObjects(QSGNode *root, QQuickWindow *window);
+
+    QList<MapObject> m_mapObjects;
+    QList<MapObject> m_pendingMapObjects;
+#endif
+
+    void updateObjectsGeometry();
 protected:
     void changeViewportSize(const QSize &size) override;
     void changeCameraData(const QGeoCameraData &oldCameraData) override;
@@ -65,10 +92,31 @@ QGeoMapItemsOverlay::~QGeoMapItemsOverlay()
 {
 }
 
+QGeoMap::Capabilities QGeoMapItemsOverlay::capabilities() const
+{
+    return Capabilities(SupportsVisibleRegion
+                        | SupportsSetBearing
+                        | SupportsAnchoringCoordinate);
+}
+
 QSGNode *QGeoMapItemsOverlay::updateSceneGraph(QSGNode *node, QQuickWindow *window)
 {
+#ifndef LOCATIONLABS
     Q_UNUSED(window)
     return node;
+#else
+    Q_D(QGeoMapItemsOverlay);
+
+    QSGRectangleNode *mapRoot = static_cast<QSGRectangleNode *>(node);
+    if (!mapRoot)
+        mapRoot = window->createRectangleNode();
+
+    mapRoot->setRect(QRect(0, 0, viewportWidth(), viewportHeight()));
+    mapRoot->setColor(QColor(0,0,0,0));
+
+    d->updateMapObjects(mapRoot, window);
+    return mapRoot;
+#endif
 }
 
 QGeoMapItemsOverlayPrivate::QGeoMapItemsOverlayPrivate(QGeoMappingManagerEngineItemsOverlay *engine)
@@ -80,19 +128,157 @@ QGeoMapItemsOverlayPrivate::~QGeoMapItemsOverlayPrivate()
 {
 }
 
-void QGeoMapItemsOverlayPrivate::changeViewportSize(const QSize &size)
+#ifdef LOCATIONLABS
+QGeoMapObjectPrivate *QGeoMapItemsOverlayPrivate::createMapObjectImplementation(QGeoMapObject *obj)
+{
+    switch (obj->type()) {
+        case QGeoMapObject::PolylineType: {
+            QMapPolylineObjectPrivate &oldImpl = static_cast<QMapPolylineObjectPrivate &>(*obj->implementation());
+            QMapPolylineObjectPrivateQSG *pimpl =
+                    new QMapPolylineObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::PolygonType: {
+            QMapPolygonObjectPrivate &oldImpl = static_cast<QMapPolygonObjectPrivate &>(*obj->implementation());
+            QMapPolygonObjectPrivateQSG *pimpl =
+                    new QMapPolygonObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::CircleType: {
+            QMapCircleObjectPrivate &oldImpl = static_cast<QMapCircleObjectPrivate &>(*obj->implementation());
+            QMapCircleObjectPrivateQSG *pimpl =
+                    new QMapCircleObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::RouteType: {
+            QMapRouteObjectPrivate &oldImpl = static_cast<QMapRouteObjectPrivate &>(*obj->implementation());
+            QMapRouteObjectPrivateQSG *pimpl =
+                    new QMapRouteObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        case QGeoMapObject::IconType: {
+            QMapIconObjectPrivate &oldImpl = static_cast<QMapIconObjectPrivate &>(*obj->implementation());
+            QMapIconObjectPrivateQSG *pimpl =
+                    new QMapIconObjectPrivateQSG(oldImpl);
+            QPointer<QGeoMapObject> p(obj);
+            MapObject mo(p, pimpl);
+            m_pendingMapObjects << mo;
+            return pimpl;
+        }
+        default:
+            qWarning() << "Unsupported object type: " << obj->type();
+            break;
+    }
+    return nullptr;
+}
+
+QList<QGeoMapObject *> QGeoMapItemsOverlayPrivate::mapObjects() const
+{
+    return QList<QGeoMapObject *>();
+}
+
+int QGeoMapItemsOverlayPrivate::findMapObject(QGeoMapObject *o, const QList<MapObject> &list)
+{
+    for (int i = 0; i < list.size(); ++i)
+    {
+        if (list.at(i).object.data() == o)
+            return i;
+    }
+    return -1;
+}
+
+void QGeoMapItemsOverlayPrivate::removeMapObject(QGeoMapObject *obj)
+{
+    int idx = findMapObject(obj, m_mapObjects);
+    if (idx >= 0) {
+        m_mapObjects.removeAt(idx);
+    } else {
+        idx = findMapObject(obj, m_pendingMapObjects);
+        if (idx >= 0) {
+            m_pendingMapObjects.removeAt(idx);
+        } else {
+            // obj not here.
+        }
+    }
+}
+
+void QGeoMapItemsOverlayPrivate::updateMapObjects(QSGNode *root, QQuickWindow *window)
+{
+    for (int i = 0; i < m_mapObjects.size(); ++i) {
+        // already added as node
+        if (!m_mapObjects.at(i).object) {
+            qWarning() << "m_mapObjects at "<<i<< " NULLed!!";
+            continue;
+        }
+
+        QQSGMapObject *sgo = m_mapObjects.at(i).sgObject;
+        QSGNode *oldNode = sgo->node;
+        sgo->node = sgo->updateMapObjectNode(oldNode, root, window);
+    }
+
+    QList<int> toRemove;
+    for (int i = 0; i < m_pendingMapObjects.size(); ++i) {
+        // already added as node
+        QQSGMapObject *sgo = m_pendingMapObjects.at(i).sgObject;
+        QSGNode *oldNode = sgo->node;
+        sgo->updateGeometry(); // or subtree will be blocked
+        sgo->node = sgo->updateMapObjectNode(oldNode, root, window);
+        if (sgo->node) {
+            m_mapObjects << m_pendingMapObjects.at(i);
+            toRemove.push_front(i);
+        } else {
+            // leave it to be processed
+        }
+    }
+
+    for (int i: qAsConst(toRemove))
+        m_pendingMapObjects.removeAt(i);
+}
+#endif
+
+void QGeoMapItemsOverlayPrivate::updateObjectsGeometry()
+{
+#ifdef LOCATIONLABS
+    Q_Q(QGeoMapItemsOverlay);
+    for (int i = 0; i < m_mapObjects.size(); ++i) {
+        // already added as node
+        if (!m_mapObjects.at(i).object) {
+            qWarning() << "m_mapObjects at "<<i<< " NULLed!!";
+            continue;
+        }
+
+        QQSGMapObject *sgo = m_mapObjects.at(i).sgObject;
+        sgo->updateGeometry();
+    }
+    emit q->sgNodeChanged();
+#endif
+}
+
+void QGeoMapItemsOverlayPrivate::changeViewportSize(const QSize &/*size*/)
 {
-    Q_UNUSED(size)
+    updateObjectsGeometry();
 }
 
-void QGeoMapItemsOverlayPrivate::changeCameraData(const QGeoCameraData &oldCameraData)
+void QGeoMapItemsOverlayPrivate::changeCameraData(const QGeoCameraData &/*oldCameraData*/)
 {
-    Q_UNUSED(oldCameraData)
+    updateObjectsGeometry();
 }
 
-void QGeoMapItemsOverlayPrivate::changeActiveMapType(const QGeoMapType mapType)
+void QGeoMapItemsOverlayPrivate::changeActiveMapType(const QGeoMapType /*mapType*/)
 {
-    Q_UNUSED(mapType)
+    updateObjectsGeometry();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h
index 4724924054c8e9457faf0b52b591b39c7393874d..42a59f06e5aecefa21005597d9190943be9ed1e0 100644
--- a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h
+++ b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h
@@ -51,8 +51,10 @@ class QGeoMapItemsOverlay: public QGeoMap
     Q_DECLARE_PRIVATE(QGeoMapItemsOverlay)
 public:
     QGeoMapItemsOverlay(QGeoMappingManagerEngineItemsOverlay *engine, QObject *parent);
-
     virtual ~QGeoMapItemsOverlay();
+
+    QGeoMap::Capabilities capabilities() const override;
+
 protected:
     QSGNode *updateSceneGraph(QSGNode *node, QQuickWindow *window) override;
 
diff --git a/src/plugins/geoservices/mapbox/mapbox.pro b/src/plugins/geoservices/mapbox/mapbox.pro
index 25a12795cbf9de91be5acf83f9e67e8e7edbcdf4..c4e7f6719a3c09554a4e45d390063c623944b5fc 100644
--- a/src/plugins/geoservices/mapbox/mapbox.pro
+++ b/src/plugins/geoservices/mapbox/mapbox.pro
@@ -2,6 +2,9 @@ TARGET = qtgeoservices_mapbox
 
 QT += location-private positioning-private network
 
+QT_FOR_CONFIG += location-private
+qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS
+
 HEADERS += \
     qgeoserviceproviderpluginmapbox.h \
     qgeotiledmappingmanagerenginemapbox.h \
diff --git a/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp b/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp
index 632b22866db7396409bf0d14eb24fc9a06949a2d..f2595d03073637c3eb829668f193527e5ed20017 100644
--- a/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp
+++ b/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp
@@ -41,6 +41,12 @@
 #include <QtLocation/private/qgeomaptype_p.h>
 #include <QtLocation/private/qgeotiledmap_p.h>
 #include "qgeofiletilecachemapbox.h"
+#ifdef LOCATIONLABS
+#include <QtLocation/private/qgeotiledmaplabs_p.h>
+typedef QGeoTiledMapLabs Map;
+#else
+typedef QGeoTiledMap Map;
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -246,7 +252,7 @@ QGeoTiledMappingManagerEngineMapbox::~QGeoTiledMappingManagerEngineMapbox()
 
 QGeoMap *QGeoTiledMappingManagerEngineMapbox::createMap()
 {
-    QGeoTiledMap *map = new QGeoTiledMap(this, 0);
+    QGeoTiledMap *map = new Map(this, 0);
     map->setPrefetchStyle(m_prefetchStyle);
     return map;
 }
diff --git a/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp b/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp
index 4835c20154efc592903f1188bf3297161bbc4b93..4dae68260db8e536523b3a27f701b1a797d91054 100644
--- a/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp
+++ b/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp
@@ -97,7 +97,7 @@ QMapbox::Feature featureFromMapCircle(QDeclarativeCircleMapItem *mapItem)
     for (const QGeoCoordinate &c : qAsConst(path))
         pathProjected << p.geoToMapProjection(c);
     if (QDeclarativeCircleMapItem::crossEarthPole(mapItem->center(), mapItem->radius()))
-        mapItem->preserveCircleGeometry(pathProjected, mapItem->center(), mapItem->radius());
+        mapItem->preserveCircleGeometry(pathProjected, mapItem->center(), mapItem->radius(), p);
     path.clear();
     for (const QDoubleVector2D &c : qAsConst(pathProjected))
         path << p.mapProjectionToGeo(c);
diff --git a/src/plugins/geoservices/nokia/nokia.pro b/src/plugins/geoservices/nokia/nokia.pro
index c6dadd86c989c6dee806a765d011be0278cefd84..86a0665c6c67c1e67aeebbc114e4a30c616fb0dc 100644
--- a/src/plugins/geoservices/nokia/nokia.pro
+++ b/src/plugins/geoservices/nokia/nokia.pro
@@ -2,6 +2,9 @@ TARGET = qtgeoservices_nokia
 
 QT += location-private positioning-private network
 
+QT_FOR_CONFIG += location-private
+qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS
+
 HEADERS += \
             qgeocodereply_nokia.h \
             qgeocodejsonparser.h \
diff --git a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp
index 90be0ae91a7c27bf83d07d73da45f257db3c1cd1..a09899d3d869f33a66aab12faf75fe529790fb8f 100644
--- a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp
@@ -54,7 +54,7 @@ QT_BEGIN_NAMESPACE
  \a geoMap and makes use of the functionality provided by \a engine.
  */
 QGeoTiledMapNokia::QGeoTiledMapNokia(QGeoTiledMappingManagerEngineNokia *engine, QObject *parent /*= 0*/) :
-    QGeoTiledMap(engine, parent),
+    Map(engine, parent),
     m_logo(":/nokia/logo.png"), // HERE logo image
     m_engine(engine)
 {}
diff --git a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h
index 9651cc80d060fd3fadda9afd5eb91339a922bf55..487f6f4947d5dc319b9e459c8c7150368d78404b 100644
--- a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h
@@ -40,12 +40,18 @@
 #include "qgeotiledmap_p.h"
 #include <QtGui/QImage>
 #include <QtCore/QPointer>
+#ifdef LOCATIONLABS
+#include <QtLocation/private/qgeotiledmaplabs_p.h>
+typedef QGeoTiledMapLabs Map;
+#else
+typedef QGeoTiledMap Map;
+#endif
 
 QT_BEGIN_NAMESPACE
 
 class QGeoTiledMappingManagerEngineNokia;
 
-class QGeoTiledMapNokia: public QGeoTiledMap
+class QGeoTiledMapNokia: public Map
 {
 Q_OBJECT
 public:
diff --git a/src/plugins/geoservices/osm/osm.pro b/src/plugins/geoservices/osm/osm.pro
index 86a62744f90610c28276c0858ec8648242c45448..74e27dc9a199eb49c1d395cdb165e144dcc2d87f 100644
--- a/src/plugins/geoservices/osm/osm.pro
+++ b/src/plugins/geoservices/osm/osm.pro
@@ -2,6 +2,9 @@ TARGET = qtgeoservices_osm
 
 QT += location-private positioning-private network concurrent
 
+QT_FOR_CONFIG += location-private
+qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS
+
 HEADERS += \
     qgeoserviceproviderpluginosm.h \
     qgeotiledmappingmanagerengineosm.h \
diff --git a/src/plugins/geoservices/osm/qgeotiledmaposm.cpp b/src/plugins/geoservices/osm/qgeotiledmaposm.cpp
index 16799dc214d18891039fa06a4fb03d4573625b1d..372d1a31966fc548d8a7550d571078bc39628e76 100644
--- a/src/plugins/geoservices/osm/qgeotiledmaposm.cpp
+++ b/src/plugins/geoservices/osm/qgeotiledmaposm.cpp
@@ -46,7 +46,7 @@
 QT_BEGIN_NAMESPACE
 
 QGeoTiledMapOsm::QGeoTiledMapOsm(QGeoTiledMappingManagerEngineOsm *engine, QObject *parent)
-:   QGeoTiledMap(engine, parent), m_mapId(-1), m_engine(engine)
+:   Map(engine, parent), m_mapId(-1), m_engine(engine)
 {
     // Needed because evaluateCopyrights() is only triggered if visible tiles change in the map.
     // It fails the first time it gets called if providers aren't resolved, and subsequent calls
diff --git a/src/plugins/geoservices/osm/qgeotiledmaposm.h b/src/plugins/geoservices/osm/qgeotiledmaposm.h
index b2af5d893b2d1c0dce77927c57b9f7cde0089eec..cc349793336f45bb5dd224cbab1e7f5b72a46a77 100644
--- a/src/plugins/geoservices/osm/qgeotiledmaposm.h
+++ b/src/plugins/geoservices/osm/qgeotiledmaposm.h
@@ -43,11 +43,17 @@
 #include "qgeotileproviderosm.h"
 
 #include <QtLocation/private/qgeotiledmap_p.h>
+#ifdef LOCATIONLABS
+#include <QtLocation/private/qgeotiledmaplabs_p.h>
+typedef QGeoTiledMapLabs Map;
+#else
+typedef QGeoTiledMap Map;
+#endif
 
 QT_BEGIN_NAMESPACE
 
 class QGeoTiledMappingManagerEngineOsm;
-class QGeoTiledMapOsm: public QGeoTiledMap
+class QGeoTiledMapOsm: public Map
 {
     Q_OBJECT
 
diff --git a/src/positioning/qdoublevector2d_p.h b/src/positioning/qdoublevector2d_p.h
index e944d2f4cb1a3e42426e200c4bd1bf89240c5ee5..92ccfe8572f125b0a2b214d7446f6c50598d8682 100644
--- a/src/positioning/qdoublevector2d_p.h
+++ b/src/positioning/qdoublevector2d_p.h
@@ -73,6 +73,7 @@ public:
 
     Q_DECL_CONSTEXPR inline double manhattanLength() const;
     inline bool isNull() const;
+    inline bool isFinite() const;
 
     Q_DECL_CONSTEXPR inline double x() const;
     Q_DECL_CONSTEXPR inline double y() const;
@@ -136,6 +137,11 @@ inline bool QDoubleVector2D::isNull() const
     return qIsNull(xp) && qIsNull(yp);
 }
 
+inline bool QDoubleVector2D::isFinite() const
+{
+    return qIsFinite(xp) && qIsFinite(yp);
+}
+
 Q_DECL_CONSTEXPR inline double QDoubleVector2D::x() const { return xp; }
 Q_DECL_CONSTEXPR inline double QDoubleVector2D::y() const { return yp; }