diff --git a/libs/ui/opengl/kis_opengl.cpp b/libs/ui/opengl/kis_opengl.cpp
index 18578809eb..79d032db6e 100644
--- a/libs/ui/opengl/kis_opengl.cpp
+++ b/libs/ui/opengl/kis_opengl.cpp
@@ -1,225 +1,234 @@
 /*
  *  Copyright (c) 2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "opengl/kis_opengl.h"
 
 #include <QOpenGLContext>
 #include <QOpenGLFunctions>
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmapCache>
 
 #include <QDir>
 #include <QFile>
 #include <QDesktopServices>
 #include <QMessageBox>
 #include <QWindow>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 namespace
 {
     bool initialized = false;
     bool NeedsFenceWorkaround = false;
     bool NeedsPixmapCacheWorkaround = false;
     int glMajorVersion = 0;
     int glMinorVersion = 0;
     bool supportsDeprecatedFunctions = false;
+    bool isOpenGLES = false;
 
     QString Renderer;
 }
 
 void KisOpenGL::initialize()
 {
     if (initialized) return;
 
     setDefaultFormat();
 
     // we need a QSurface active to get our GL functions from the context
     QWindow  surface;
     surface.setSurfaceType( QSurface::OpenGLSurface );
     surface.create();
 
     QOpenGLContext context;
     context.create();
     if (!context.isValid()) return;
 
     context.makeCurrent( &surface );
 
     QOpenGLFunctions  *funcs = context.functions();
     funcs->initializeOpenGLFunctions();
 
 #ifndef GL_RENDERER
 #  define GL_RENDERER 0x1F01
 #endif
     Renderer = QString((const char*)funcs->glGetString(GL_RENDERER));
     /**
      * Warn about Intel's broken video drivers
      */
 #if defined Q_OS_WIN
     KisConfig cfg;
     if (cfg.useOpenGL() && Renderer.startsWith("Intel") && !cfg.readEntry("WarnedAboutIntel", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You have an Intel(R) HD Graphics video adapter.\n"
                                       "If you experience problems like a crash, a black or blank screen,"
                                       "please update your display driver to the latest version.\n\n"
                                       "If Krita crashes, it will disable OpenGL rendering. Please restart Krita in that case.\n After updating your drivers you can re-enable OpenGL in Krita's Settings.\n"));
         cfg.writeEntry("WarnedAboutIntel", true);
     }
 #endif
     qDebug() << "OpenGL Info";
     qDebug() << "  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
     qDebug() << "  Renderer: " << Renderer;
     qDebug() << "  Version: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION));
     qDebug() << "  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
     qDebug() << "  Requested format: " << QSurfaceFormat::defaultFormat();
     qDebug() << "  Current format:   " << context.format();
     
     glMajorVersion = context.format().majorVersion();
     glMinorVersion = context.format().minorVersion();
     supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions);
+    isOpenGLES = context.isOpenGLES();
 
     qDebug() << "     Version:" << glMajorVersion << "." << glMinorVersion;
     qDebug() << "     Supports deprecated functions" << supportsDeprecatedFunctions;
+    qDebug() << "     is OpenGL ES:" << isOpenGLES;
 
     initialized = true;
 }
 
 void KisOpenGL::initializeContext(QOpenGLContext *ctx)
 {
     KisConfig cfg;
     initialize();
 
     dbgUI << "OpenGL: Opening new context";
 
     // Double check we were given the version we requested
     QSurfaceFormat format = ctx->format();
     QOpenGLFunctions *f = ctx->functions();
     f->initializeOpenGLFunctions();
 
     QFile log(QDesktopServices::storageLocation(QDesktopServices::TempLocation) + "/krita-opengl.txt");
     log.open(QFile::WriteOnly);
     QString vendor((const char*)f->glGetString(GL_VENDOR));
     log.write(vendor.toLatin1());
     log.write(", ");
     log.write(Renderer.toLatin1());
     log.write(", ");
     QString version((const char*)f->glGetString(GL_VERSION));
     log.write(version.toLatin1());
     log.close();
 
     // Check if we have a bugged driver that needs fence workaround
     bool isOnX11 = false;
 #ifdef HAVE_X11
     isOnX11 = true;
 #endif
     
     if ((isOnX11 && Renderer.startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
         NeedsFenceWorkaround = true;
     }
 
 
     /**
      * NVidia + Qt's openGL don't play well together and one cannot
      * draw a pixmap on a widget more than once in one rendering cycle.
      *
      * It can be workarounded by drawing strictly via QPixmapCache and
      * only when the pixmap size in bigger than doubled size of the
      * display framebuffer. That is for 8-bit HD display, you should have
      * a cache bigger than 16 MiB. Don't ask me why. (DK)
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=361709
      *
      * TODO: check if this workaround is still needed after merging
      *       Qt5+openGL3 branch.
      */
 
     if (vendor.toUpper().contains("NVIDIA")) {
         NeedsPixmapCacheWorkaround = true;
 
         const QRect screenSize = QApplication::desktop()->screenGeometry();
         const int minCacheSize = 20 * 1024;
         const int cacheSize = 2048 + 2 * 4 * screenSize.width() * screenSize.height() / 1024; //KiB
 
         QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
     }
 
 
 }
 
 // XXX Temporary function to allow LoD on OpenGL3 without triggering
 // all of the other 3.2 functionality, can be removed once we move to Qt5.7
 bool KisOpenGL::supportsLoD()
 {
     initialize();
     return (glMajorVersion * 100 + glMinorVersion) >= 300;
 }
 
 bool KisOpenGL::hasOpenGL3()
 {
     initialize();
     return (glMajorVersion * 100 + glMinorVersion) >= 302;
 }
 
+bool KisOpenGL::hasOpenGLES()
+{
+    initialize();
+    return isOpenGLES;
+}
+
 bool KisOpenGL::supportsFenceSync()
 {
     initialize();
     return glMajorVersion >= 3;
 }
 
 bool KisOpenGL::needsFenceWorkaround()
 {
     initialize();
     return NeedsFenceWorkaround;
 }
 
 bool KisOpenGL::needsPixmapCacheWorkaround()
 {
     initialize();
     return NeedsPixmapCacheWorkaround;
 }
 
 void KisOpenGL::setDefaultFormat()
 {
     QSurfaceFormat format;
 #ifdef Q_OS_OSX
     format.setVersion(3, 2);
     format.setProfile(QSurfaceFormat::CoreProfile);
 #else
     // XXX This can be removed once we move to Qt5.7
     format.setVersion(3, 0);
     format.setProfile(QSurfaceFormat::CompatibilityProfile);
     format.setOptions(QSurfaceFormat::DeprecatedFunctions);
 #endif
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
     format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
     format.setSwapInterval(0); // Disable vertical refresh syncing
     QSurfaceFormat::setDefaultFormat(format);
 }
 
 bool KisOpenGL::hasOpenGL()
 {
     return ((glMajorVersion * 100 + glMinorVersion) >= 201);
     //return (glMajorVersion >= 3 && supportsDeprecatedFunctions);
 }
diff --git a/libs/ui/opengl/kis_opengl.h b/libs/ui/opengl/kis_opengl.h
index 4885026374..530d857bbc 100644
--- a/libs/ui/opengl/kis_opengl.h
+++ b/libs/ui/opengl/kis_opengl.h
@@ -1,85 +1,86 @@
 /*
  *  Copyright (c) 2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_OPENGL_H_
 #define KIS_OPENGL_H_
 
 /** @file */
 
 #include <KoConfig.h>
 
 #include <QtGlobal>
 class QOpenGLContext;
 
 #include "kritaui_export.h"
 
 
 /**
  * This class manages a shared OpenGL context and provides utility
  * functions for checking capabilities and error reporting.
  */
 class KRITAUI_EXPORT KisOpenGL
 {
 public:
     enum FilterMode {
         NearestFilterMode,  // nearest
         BilinearFilterMode, // linear, no mipmap
         TrilinearFilterMode, // LINEAR_MIPMAP_LINEAR
         HighQualityFiltering // Mipmaps + custom shader
     };
 public:
 
     /// Request OpenGL version 3.2
     static void initialize();
 
     /// Initialize shared OpenGL context
     static void initializeContext(QOpenGLContext *ctx);
 
     static bool supportsLoD();
     static bool hasOpenGL3();
+    static bool hasOpenGLES();
 
     /// Check for OpenGL
     static bool hasOpenGL();
 
     /**
      * @brief supportsFilter
      * @return True if OpenGL provides fence sync methods.
      */
     static bool supportsFenceSync();
 
     /**
      * Returns true if we have a driver that has bugged support to sync objects (a fence)
      * and false otherwise.
      */
     static bool needsFenceWorkaround();
 
     /**
      * @see a comment in initializeContext()
      */
     static bool needsPixmapCacheWorkaround();
 
     static void setDefaultFormat();
 
 private:
 
 
     KisOpenGL();
 
 
 };
 
 #endif // KIS_OPENGL_H_
diff --git a/libs/ui/opengl/kis_opengl_shader_loader.cpp b/libs/ui/opengl/kis_opengl_shader_loader.cpp
index a3b2623be3..4964df8b25 100644
--- a/libs/ui/opengl/kis_opengl_shader_loader.cpp
+++ b/libs/ui/opengl/kis_opengl_shader_loader.cpp
@@ -1,190 +1,198 @@
 /* This file is part of the KDE project
  * Copyright (C) Julian Thijssen <julianthijssen@gmail.com>, (C) 2016
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_opengl_shader_loader.h"
 
 #include "opengl/kis_opengl.h"
 #include "kis_config.h"
 
 #include <QFile>
 #include <QMessageBox>
 #include <KLocalizedString>
 
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 #define PROGRAM_TEXCOORD_ATTRIBUTE 1
 
 // Mapping of uniforms to uniform names
 std::map<Uniform, const char *> KisShaderProgram::names = {
    {ModelViewProjection, "modelViewProjection"},
    {TextureMatrix, "textureMatrix"},
    {ViewportScale, "viewportScale"},
    {TexelSize, "texelSize"},
    {Texture0, "texture0"},
    {Texture1, "texture1"},
    {FixedLodLevel, "fixedLodLevel"},
    {FragmentColor, "fragColor"}
 };
 
 /**
  * Generic shader loading function that will compile a shader program given
  * a vertex shader and fragment shader resource path. Extra code can be prepended
  * to each shader respectively using the header parameters.
  *
  * @param vertPath Resource path to a vertex shader
  * @param fragPath Resource path to a fragment shader
  * @param vertHeader Extra code which will be prepended to the vertex shader
  * @param fragHeader Extra code which will be prepended to the fragment shader
  */
 KisShaderProgram *KisOpenGLShaderLoader::loadShader(QString vertPath, QString fragPath,
                                                     QByteArray vertHeader, QByteArray fragHeader)
 {
     bool result;
 
     KisShaderProgram *shader = new KisShaderProgram();
 
     // Load vertex shader
     QByteArray vertSource;
 
 // XXX Check can be removed and set to the MAC version after we move to Qt5.7
 #ifdef Q_OS_OSX
     vertSource.append(KisOpenGL::hasOpenGL3() ? "#version 150 core\n" : "#version 120\n");
 #else
-    vertSource.append(KisOpenGL::supportsLoD() ? "#version 130\n" : "#version 120\n");
+    if (KisOpenGL::hasOpenGLES()) {
+        vertSource.append("#version 300 es\n");
+    } else {
+        vertSource.append(KisOpenGL::supportsLoD() ? "#version 130\n" : "#version 120\n");
+    }
 #endif
     vertSource.append(vertHeader);
     QFile vertexShaderFile(":/" + vertPath);
     vertexShaderFile.open(QIODevice::ReadOnly);
     vertSource.append(vertexShaderFile.readAll());
 
     result = shader->addShaderFromSourceCode(QOpenGLShader::Vertex, vertSource);
     if (!result)
         throw ShaderLoaderException(QString("%1: %2 - Cause: %3").arg("Failed to add vertex shader source from file", vertPath, shader->log()));
 
     // Load fragment shader
     QByteArray fragSource;
 
 // XXX Check can be removed and set to the MAC version after we move to Qt5.7
 #ifdef Q_OS_OSX
     fragSource.append(KisOpenGL::hasOpenGL3() ? "#version 150 core\n" : "#version 120\n");
 #else
-    fragSource.append(KisOpenGL::supportsLoD() ? "#version 130\n" : "#version 120\n");
+    if (KisOpenGL::hasOpenGLES()) {
+        fragSource.append("#version 300 es\nprecision mediump float;\n");
+    } else {
+        fragSource.append(KisOpenGL::supportsLoD() ? "#version 130\n" : "#version 120\n");
+    }
 #endif
     fragSource.append(fragHeader);
     QFile fragmentShaderFile(":/" + fragPath);
     fragmentShaderFile.open(QIODevice::ReadOnly);
     fragSource.append(fragmentShaderFile.readAll());
 
     result = shader->addShaderFromSourceCode(QOpenGLShader::Fragment, fragSource);
     if (!result)
         throw ShaderLoaderException(QString("%1: %2 - Cause: %3").arg("Failed to add fragment shader source from file", fragPath, shader->log()));
 
     // Bind attributes
     shader->bindAttributeLocation("a_vertexPosition", PROGRAM_VERTEX_ATTRIBUTE);
     shader->bindAttributeLocation("a_textureCoordinate", PROGRAM_TEXCOORD_ATTRIBUTE);
 
     // Link
     result = shader->link();
     if (!result)
         throw ShaderLoaderException(QString("Failed to link shader: ").append(vertPath));
 
     Q_ASSERT(shader->isLinked());
 
     return shader;
 }
 
 /**
  * Specific display shader loading function. It adds the appropriate extra code
  * to the fragment shader depending on what is available on the target machine.
  * Additionally, it picks the appropriate shader files depending on the availability
  * of OpenGL3.
  */
 KisShaderProgram *KisOpenGLShaderLoader::loadDisplayShader(QSharedPointer<KisDisplayFilter> displayFilter, bool useHiQualityFiltering)
 {
     QByteArray fragHeader;
 
     if (KisOpenGL::supportsLoD()) {
         fragHeader.append("#define DIRECT_LOD_FETCH\n");
         if (useHiQualityFiltering) {
             fragHeader.append("#define HIGHQ_SCALING\n");
         }
     }
 
     // If we have an OCIO display filter and it contains a function we add
     // it to our shader header which will sit on top of the fragment code.
     bool haveDisplayFilter = displayFilter && !displayFilter->program().isEmpty();
     if (haveDisplayFilter) {
         fragHeader.append("#define USE_OCIO\n");
         fragHeader.append(displayFilter->program().toLatin1());
     }
 
     QString vertPath, fragPath;
     // Select appropriate shader files
     if (KisOpenGL::supportsLoD()) {
         vertPath = "matrix_transform.vert";
         fragPath = "highq_downscale.frag";
     } else {
         vertPath = "matrix_transform_legacy.vert";
         fragPath = "simple_texture_legacy.frag";
     }
 
     KisShaderProgram *shader = loadShader(vertPath, fragPath, QByteArray(), fragHeader);
 
     return shader;
 }
 
 /**
  * Specific checker shader loading function. It picks the appropriate shader
  * files depending on the availability of OpenGL3 on the target machine.
  */
 KisShaderProgram *KisOpenGLShaderLoader::loadCheckerShader()
 {
     QString vertPath, fragPath;
     // Select appropriate shader files
     if (KisOpenGL::supportsLoD()) {
         vertPath = "matrix_transform.vert";
         fragPath = "simple_texture.frag";
     } else {
         vertPath = "matrix_transform_legacy.vert";
         fragPath = "simple_texture_legacy.frag";
     }
 
     KisShaderProgram *shader = loadShader(vertPath, fragPath, QByteArray(), QByteArray());
 
     return shader;
 }
 
 /**
  * Specific uniform shader loading function. It picks the appropriate shader
  * files depending on the availability of OpenGL3 on the target machine.
  */
 KisShaderProgram *KisOpenGLShaderLoader::loadSolidColorShader()
 {
     QString vertPath, fragPath;
     // Select appropriate shader files
     if (KisOpenGL::supportsLoD()) {
         vertPath = "matrix_transform.vert";
         fragPath = "solid_color.frag";
     } else {
         vertPath = "matrix_transform_legacy.vert";
         fragPath = "solid_color_legacy.frag";
     }
 
     KisShaderProgram *shader = loadShader(vertPath, fragPath, QByteArray(), QByteArray());
 
     return shader;
 }