diff --git a/cmake/CompilerWarnings.cmake b/cmake/CompilerWarnings.cmake
index 05b0334c..b6c95bb6 100644
--- a/cmake/CompilerWarnings.cmake
+++ b/cmake/CompilerWarnings.cmake
@@ -31,37 +31,60 @@ function(set_file_warnings)
 
         # Disables, remove when appropriate
         /wd4996 # disable warnings about deprecated functions
+        /wd4068 # disable warnings about unknown pragmas (e.g. #pragma GCC)
+        /wd4505 # disable warnings about unused functions that might be platform-specific
+        /wd4800 # disable warnings regarding implicit conversions to bool
     )
 
-    set(CLANG_WARNINGS
+    # some warnings are not supported on older NDK versions used for CI
+    if (ANDROID)
+        set(NON_ANDROID_CLANG_AND_GCC_WARNINGS "")
+        set(NON_ANDROID_GCC_WARNINGS "")
+    else()
+        set(NON_ANDROID_CLANG_AND_GCC_WARNINGS
+            -Wnull-dereference # warn if a null dereference is detected
+            -Wold-style-cast # warn for c-style casts
+            -Wpedantic # warn if non-standard C++ is used
+        )
+
+        set(NON_ANDROID_GCC_WARNINGS
+            -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist
+            -Wduplicated-cond # warn if if / else chain has duplicated conditions
+        )
+    endif()
+
+    set(CLANG_AND_GCC_WARNINGS
         -Wall
         -Wextra # reasonable and standard
         -Wshadow # warn the user if a variable declaration shadows one from a parent context
         -Wnon-virtual-dtor # warn the user if a class with virtual functions has a non-virtual destructor. This helps catch hard to track down memory errors
-        -Wold-style-cast # warn for c-style casts
         -Wcast-align # warn for potential performance problem casts
         -Wunused # warn on anything being unused
         -Woverloaded-virtual # warn if you overload (not override) a virtual function
-        -Wpedantic # warn if non-standard C++ is used
         -Wconversion # warn on type conversions that may lose data
         -Wsign-conversion # warn on sign conversions
-        -Wnull-dereference # warn if a null dereference is detected
         -Wdouble-promotion # warn if float is implicit promoted to double
         -Wformat=2 # warn on security issues around functions that format output (ie printf)
-        # -Wimplicit-fallthrough # warn when a missing break causes control flow to continue at the next case in a switch statement. Disabled until better compiler support for explicit fallthrough is available.
+        # -Wimplicit-fallthrough # warn when a missing break causes control flow to continue at the next case in a switch statement (disabled until better compiler support for explicit fallthrough is available)
+        ${NON_ANDROID_CLANG_AND_GCC_WARNINGS}
+    )
+
+
+    set(CLANG_WARNINGS
+        ${CLANG_AND_GCC_WARNINGS}
+        -Wno-unknown-warning-option # do not warn on GCC-specific warning diagnostic pragmas
     )
 
     if(WARNINGS_AS_ERRORS)
-        set(CLANG_WARNINGS ${CLANG_WARNINGS} -Werror)
+        set(CLANG_AND_GCC_WARNINGS ${CLANG_AND_GCC_WARNINGS} -Werror)
         set(MSVC_WARNINGS ${MSVC_WARNINGS} /WX)
     endif()
 
     set(GCC_WARNINGS
-        ${CLANG_WARNINGS}
-        -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist
-        -Wduplicated-cond # warn if if / else chain has duplicated conditions
+        ${CLANG_AND_GCC_WARNINGS}
+        ${NON_ANDROID_GCC_WARNINGS}
         -Wlogical-op # warn about logical operations being used where bitwise were probably wanted
-        -Wuseless-cast # warn if you perform a cast to the same type
+        # -Wuseless-cast # warn if you perform a cast to the same type (disabled because it is not portable as some typedefs might vary between platforms)
     )
 
     # Don't enable -Wduplicated-branches for GCC < 8.1 since it will lead to false positives
diff --git a/examples/island/Island.cpp b/examples/island/Island.cpp
index d0165f10..1ec46cb3 100644
--- a/examples/island/Island.cpp
+++ b/examples/island/Island.cpp
@@ -322,16 +322,23 @@ float getMoisture(unsigned int x, unsigned int y)
 /// Get the lowlands terrain color for the given moisture.
 ///
 ////////////////////////////////////////////////////////////
+sf::Color colorFromFloats(float r, float g, float b)
+{
+    return sf::Color(static_cast<sf::Uint8>(r),
+                     static_cast<sf::Uint8>(g),
+                     static_cast<sf::Uint8>(b));
+}
+
 sf::Color getLowlandsTerrainColor(float moisture)
 {
     sf::Color color =
-        moisture < 0.27f ? sf::Color(240, 240, 180) :
-        moisture < 0.3f ? sf::Color(240 - static_cast<sf::Uint8>(240 * (moisture - 0.27f) / 0.03f), 240 - static_cast<sf::Uint8>(40 * (moisture - 0.27f) / 0.03f), 180 - static_cast<sf::Uint8>(180 * (moisture - 0.27f) / 0.03f)) :
-        moisture < 0.4f ? sf::Color(0, 200, 0) :
-        moisture < 0.48f ? sf::Color(0, 200 - static_cast<sf::Uint8>(40 * (moisture - 0.4f) / 0.08f), 0) :
-        moisture < 0.6f ? sf::Color(0, 160, 0) :
-        moisture < 0.7f ? sf::Color(static_cast<sf::Uint8>(34 * (moisture - 0.6f) / 0.1f), 160 - static_cast<sf::Uint8>(60 * (moisture - 0.6f) / 0.1f), static_cast<sf::Uint8>(34 * (moisture - 0.6f) / 0.1f)) :
-        sf::Color(34, 100, 34);
+        moisture < 0.27f ? colorFromFloats(240, 240, 180) :
+        moisture < 0.3f ? colorFromFloats(240 - (240 * (moisture - 0.27f) / 0.03f), 240 - (40 * (moisture - 0.27f) / 0.03f), 180 - (180 * (moisture - 0.27f) / 0.03f)) :
+        moisture < 0.4f ? colorFromFloats(0, 200, 0) :
+        moisture < 0.48f ? colorFromFloats(0, 200 - (40 * (moisture - 0.4f) / 0.08f), 0) :
+        moisture < 0.6f ? colorFromFloats(0, 160, 0) :
+        moisture < 0.7f ? colorFromFloats((34 * (moisture - 0.6f) / 0.1f), 160 - (60 * (moisture - 0.6f) / 0.1f), (34 * (moisture - 0.6f) / 0.1f)) :
+        colorFromFloats(34, 100, 34);
 
     return color;
 }
@@ -348,7 +355,7 @@ sf::Color getHighlandsTerrainColor(float elevation, float moisture)
 
     sf::Color color =
         moisture < 0.6f ? sf::Color(112, 128, 144) :
-        sf::Color(112 + static_cast<sf::Uint8>(110 * (moisture - 0.6f) / 0.4f), 128 + static_cast<sf::Uint8>(56 * (moisture - 0.6f) / 0.4f), 144 - static_cast<sf::Uint8>(9 * (moisture - 0.6f) / 0.4f));
+        colorFromFloats(112 + (110 * (moisture - 0.6f) / 0.4f), 128 + (56 * (moisture - 0.6f) / 0.4f), 144 - (9 * (moisture - 0.6f) / 0.4f));
 
     float factor = std::min((elevation - 0.4f) / 0.1f, 1.f);
 
diff --git a/examples/tennis/Tennis.cpp b/examples/tennis/Tennis.cpp
index ca4e2847..bc80bf5e 100644
--- a/examples/tennis/Tennis.cpp
+++ b/examples/tennis/Tennis.cpp
@@ -33,13 +33,13 @@ int main()
 
     // Define some constants
     const float pi = 3.14159f;
-    const int gameWidth = 800;
-    const int gameHeight = 600;
+    const float gameWidth = 800;
+    const float gameHeight = 600;
     sf::Vector2f paddleSize(25, 100);
     float ballRadius = 10.f;
 
     // Create the window of the application
-    sf::RenderWindow window(sf::VideoMode(gameWidth, gameHeight, 32), "SFML Tennis",
+    sf::RenderWindow window(sf::VideoMode(static_cast<unsigned int>(gameWidth), static_cast<unsigned int>(gameHeight), 32), "SFML Tennis",
                             sf::Style::Titlebar | sf::Style::Close);
     window.setVerticalSyncEnabled(true);
 
@@ -134,26 +134,26 @@ int main()
                     clock.restart();
 
                     // Reset the position of the paddles and ball
-                    leftPaddle.setPosition(10 + paddleSize.x / 2, gameHeight / 2);
-                    rightPaddle.setPosition(gameWidth - 10 - paddleSize.x / 2, gameHeight / 2);
-                    ball.setPosition(gameWidth / 2, gameHeight / 2);
+                    leftPaddle.setPosition(10.f + paddleSize.x / 2.f, gameHeight / 2.f);
+                    rightPaddle.setPosition(gameWidth - 10.f - paddleSize.x / 2.f, gameHeight / 2.f);
+                    ball.setPosition(gameWidth / 2.f, gameHeight / 2.f);
 
                     // Reset the ball angle
                     do
                     {
                         // Make sure the ball initial angle is not too much vertical
-                        ballAngle = static_cast<float>(std::rand() % 360) * 2 * pi / 360;
+                        ballAngle = static_cast<float>(std::rand() % 360) * 2.f * pi / 360.f;
                     }
                     while (std::abs(std::cos(ballAngle)) < 0.7f);
                 }
             }
-            
+
             // Window size changed, adjust view appropriately
             if (event.type == sf::Event::Resized)
             {
                 sf::View view;
                 view.setSize(gameWidth, gameHeight);
-                view.setCenter(gameWidth/2.f, gameHeight/2.f);
+                view.setCenter(gameWidth / 2.f, gameHeight  /2.f);
                 window.setView(view);
             }
         }
@@ -173,7 +173,7 @@ int main()
             {
                 leftPaddle.move(0.f, paddleSpeed * deltaTime);
             }
-            
+
             if (sf::Touch::isDown(0))
             {
                 sf::Vector2i pos = sf::Touch::getPosition(0);
@@ -209,7 +209,7 @@ int main()
             #else
             const std::string inputString = "Press space to restart or\nescape to exit.";
             #endif
-            
+
             // Check collisions between the ball and the screen
             if (ball.getPosition().x - ballRadius < 0.f)
             {
diff --git a/examples/voip/Server.cpp b/examples/voip/Server.cpp
index e0e1ee45..12f0f979 100644
--- a/examples/voip/Server.cpp
+++ b/examples/voip/Server.cpp
@@ -4,6 +4,7 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio.hpp>
 #include <SFML/Network.hpp>
+#include <cstring>
 #include <iomanip>
 #include <iostream>
 #include <iterator>
@@ -126,14 +127,15 @@ private:
             if (id == serverAudioData)
             {
                 // Extract audio samples from the packet, and append it to our samples buffer
-                const sf::Int16* samples     = reinterpret_cast<const sf::Int16*>(static_cast<const char*>(packet.getData()) + 1);
-                std::size_t      sampleCount = (packet.getDataSize() - 1) / sizeof(sf::Int16);
+                std::size_t sampleCount = (packet.getDataSize() - 1) / sizeof(sf::Int16);
 
                 // Don't forget that the other thread can access the sample array at any time
                 // (so we protect any operation on it with the mutex)
                 {
                     sf::Lock lock(m_mutex);
-                    std::copy(samples, samples + sampleCount, std::back_inserter(m_samples));
+                    std::size_t oldSize = m_samples.size();
+                    m_samples.resize(oldSize + sampleCount);
+                    std::memcpy(&(m_samples[oldSize]), static_cast<const char*>(packet.getData()) + 1, sampleCount * sizeof(sf::Int16));
                 }
             }
             else if (id == serverEndOfStream)
diff --git a/examples/vulkan/Vulkan.cpp b/examples/vulkan/Vulkan.cpp
index 72ad3df5..ade2d14f 100644
--- a/examples/vulkan/Vulkan.cpp
+++ b/examples/vulkan/Vulkan.cpp
@@ -894,7 +894,7 @@ public:
                 return;
             }
 
-            std::vector<char> buffer(static_cast<std::size_t>(file.getSize()));
+            std::vector<uint32_t> buffer(static_cast<std::size_t>(file.getSize()) / sizeof(uint32_t));
 
             if (file.read(&buffer[0], file.getSize()) != file.getSize())
             {
@@ -902,8 +902,8 @@ public:
                 return;
             }
 
-            shaderModuleCreateInfo.codeSize = buffer.size();
-            shaderModuleCreateInfo.pCode = reinterpret_cast<const uint32_t*>(&buffer[0]);
+            shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t);
+            shaderModuleCreateInfo.pCode = &buffer[0];
 
             if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &vertexShaderModule) != VK_SUCCESS)
             {
@@ -922,7 +922,7 @@ public:
                 return;
             }
 
-            std::vector<char> buffer(static_cast<std::size_t>(file.getSize()));
+            std::vector<uint32_t> buffer(static_cast<std::size_t>(file.getSize()) / sizeof(uint32_t));
 
             if (file.read(&buffer[0], file.getSize()) != file.getSize())
             {
@@ -930,8 +930,8 @@ public:
                 return;
             }
 
-            shaderModuleCreateInfo.codeSize = buffer.size();
-            shaderModuleCreateInfo.pCode = reinterpret_cast<const uint32_t*>(&buffer[0]);
+            shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t);
+            shaderModuleCreateInfo.pCode = &buffer[0];
 
             if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &fragmentShaderModule) != VK_SUCCESS)
             {
@@ -1277,7 +1277,7 @@ public:
 
         for (; memoryType < memoryProperties.memoryTypeCount; memoryType++)
         {
-            if ((memoryRequirements.memoryTypeBits & (1 << memoryType)) &&
+            if ((memoryRequirements.memoryTypeBits & static_cast<unsigned int>(1 << memoryType)) &&
                 ((memoryProperties.memoryTypes[memoryType].propertyFlags & properties) == properties))
                 break;
         }
@@ -1599,7 +1599,7 @@ public:
 
         for (; memoryType < memoryProperties.memoryTypeCount; memoryType++)
         {
-            if ((memoryRequirements.memoryTypeBits & (1 << memoryType)) &&
+            if ((memoryRequirements.memoryTypeBits & static_cast<unsigned int>(1 << memoryType)) &&
                 ((memoryProperties.memoryTypes[memoryType].propertyFlags & properties) == properties))
                 break;
         }
@@ -1777,7 +1777,7 @@ public:
         }
 
         // Copy the image data into the buffer
-        std::memcpy(ptr, imageData.getPixelsPtr(), imageSize);
+        std::memcpy(ptr, imageData.getPixelsPtr(), static_cast<std::size_t>(imageSize));
 
         // Unmap the buffer
         vkUnmapMemory(device, stagingBufferMemory);
diff --git a/extlibs/headers/glad/include/glad/gl.h b/extlibs/headers/glad/include/glad/gl.h
index 9394a0a4..6d568509 100644
--- a/extlibs/headers/glad/include/glad/gl.h
+++ b/extlibs/headers/glad/include/glad/gl.h
@@ -10128,6 +10128,153 @@ static void sf_glad_gl_load_GL_VERSION_4_6( GLADuserptrloadfunc load, void* user
     sf_glad_glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC) load(userptr, "glPolygonOffsetClamp");
     sf_glad_glSpecializeShader = (PFNGLSPECIALIZESHADERPROC) load(userptr, "glSpecializeShader");
 }
+static void sf_glad_gl_load_GL_VERSION_ES_CM_1_0( GLADuserptrloadfunc load, void* userptr) {
+    if(!SF_GLAD_GL_VERSION_ES_CM_1_0) return;
+    sf_glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture");
+    sf_glad_glAlphaFunc = (PFNGLALPHAFUNCPROC) load(userptr, "glAlphaFunc");
+    sf_glad_glAlphaFuncx = (PFNGLALPHAFUNCXPROC) load(userptr, "glAlphaFuncx");
+    sf_glad_glBindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer");
+    sf_glad_glBindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture");
+    sf_glad_glBlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc");
+    sf_glad_glBufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData");
+    sf_glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData");
+    sf_glad_glClear = (PFNGLCLEARPROC) load(userptr, "glClear");
+    sf_glad_glClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor");
+    sf_glad_glClearColorx = (PFNGLCLEARCOLORXPROC) load(userptr, "glClearColorx");
+    sf_glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf");
+    sf_glad_glClearDepthx = (PFNGLCLEARDEPTHXPROC) load(userptr, "glClearDepthx");
+    sf_glad_glClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil");
+    sf_glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC) load(userptr, "glClientActiveTexture");
+    sf_glad_glClipPlanef = (PFNGLCLIPPLANEFPROC) load(userptr, "glClipPlanef");
+    sf_glad_glClipPlanex = (PFNGLCLIPPLANEXPROC) load(userptr, "glClipPlanex");
+    sf_glad_glColor4f = (PFNGLCOLOR4FPROC) load(userptr, "glColor4f");
+    sf_glad_glColor4ub = (PFNGLCOLOR4UBPROC) load(userptr, "glColor4ub");
+    sf_glad_glColor4x = (PFNGLCOLOR4XPROC) load(userptr, "glColor4x");
+    sf_glad_glColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask");
+    sf_glad_glColorPointer = (PFNGLCOLORPOINTERPROC) load(userptr, "glColorPointer");
+    sf_glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D");
+    sf_glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D");
+    sf_glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D");
+    sf_glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D");
+    sf_glad_glCullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace");
+    sf_glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers");
+    sf_glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures");
+    sf_glad_glDepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc");
+    sf_glad_glDepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask");
+    sf_glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC) load(userptr, "glDepthRangef");
+    sf_glad_glDepthRangex = (PFNGLDEPTHRANGEXPROC) load(userptr, "glDepthRangex");
+    sf_glad_glDisable = (PFNGLDISABLEPROC) load(userptr, "glDisable");
+    sf_glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC) load(userptr, "glDisableClientState");
+    sf_glad_glDrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays");
+    sf_glad_glDrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements");
+    sf_glad_glEnable = (PFNGLENABLEPROC) load(userptr, "glEnable");
+    sf_glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC) load(userptr, "glEnableClientState");
+    sf_glad_glFinish = (PFNGLFINISHPROC) load(userptr, "glFinish");
+    sf_glad_glFlush = (PFNGLFLUSHPROC) load(userptr, "glFlush");
+    sf_glad_glFogf = (PFNGLFOGFPROC) load(userptr, "glFogf");
+    sf_glad_glFogfv = (PFNGLFOGFVPROC) load(userptr, "glFogfv");
+    sf_glad_glFogx = (PFNGLFOGXPROC) load(userptr, "glFogx");
+    sf_glad_glFogxv = (PFNGLFOGXVPROC) load(userptr, "glFogxv");
+    sf_glad_glFrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace");
+    sf_glad_glFrustumf = (PFNGLFRUSTUMFPROC) load(userptr, "glFrustumf");
+    sf_glad_glFrustumx = (PFNGLFRUSTUMXPROC) load(userptr, "glFrustumx");
+    sf_glad_glGenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers");
+    sf_glad_glGenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures");
+    sf_glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv");
+    sf_glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv");
+    sf_glad_glGetClipPlanef = (PFNGLGETCLIPPLANEFPROC) load(userptr, "glGetClipPlanef");
+    sf_glad_glGetClipPlanex = (PFNGLGETCLIPPLANEXPROC) load(userptr, "glGetClipPlanex");
+    sf_glad_glGetError = (PFNGLGETERRORPROC) load(userptr, "glGetError");
+    sf_glad_glGetFixedv = (PFNGLGETFIXEDVPROC) load(userptr, "glGetFixedv");
+    sf_glad_glGetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv");
+    sf_glad_glGetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv");
+    sf_glad_glGetLightfv = (PFNGLGETLIGHTFVPROC) load(userptr, "glGetLightfv");
+    sf_glad_glGetLightxv = (PFNGLGETLIGHTXVPROC) load(userptr, "glGetLightxv");
+    sf_glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC) load(userptr, "glGetMaterialfv");
+    sf_glad_glGetMaterialxv = (PFNGLGETMATERIALXVPROC) load(userptr, "glGetMaterialxv");
+    sf_glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv");
+    sf_glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
+    sf_glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC) load(userptr, "glGetTexEnvfv");
+    sf_glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC) load(userptr, "glGetTexEnviv");
+    sf_glad_glGetTexEnvxv = (PFNGLGETTEXENVXVPROC) load(userptr, "glGetTexEnvxv");
+    sf_glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv");
+    sf_glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv");
+    sf_glad_glGetTexParameterxv = (PFNGLGETTEXPARAMETERXVPROC) load(userptr, "glGetTexParameterxv");
+    sf_glad_glHint = (PFNGLHINTPROC) load(userptr, "glHint");
+    sf_glad_glIsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer");
+    sf_glad_glIsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled");
+    sf_glad_glIsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture");
+    sf_glad_glLightModelf = (PFNGLLIGHTMODELFPROC) load(userptr, "glLightModelf");
+    sf_glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC) load(userptr, "glLightModelfv");
+    sf_glad_glLightModelx = (PFNGLLIGHTMODELXPROC) load(userptr, "glLightModelx");
+    sf_glad_glLightModelxv = (PFNGLLIGHTMODELXVPROC) load(userptr, "glLightModelxv");
+    sf_glad_glLightf = (PFNGLLIGHTFPROC) load(userptr, "glLightf");
+    sf_glad_glLightfv = (PFNGLLIGHTFVPROC) load(userptr, "glLightfv");
+    sf_glad_glLightx = (PFNGLLIGHTXPROC) load(userptr, "glLightx");
+    sf_glad_glLightxv = (PFNGLLIGHTXVPROC) load(userptr, "glLightxv");
+    sf_glad_glLineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth");
+    sf_glad_glLineWidthx = (PFNGLLINEWIDTHXPROC) load(userptr, "glLineWidthx");
+    sf_glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC) load(userptr, "glLoadIdentity");
+    sf_glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC) load(userptr, "glLoadMatrixf");
+    sf_glad_glLoadMatrixx = (PFNGLLOADMATRIXXPROC) load(userptr, "glLoadMatrixx");
+    sf_glad_glLogicOp = (PFNGLLOGICOPPROC) load(userptr, "glLogicOp");
+    sf_glad_glMaterialf = (PFNGLMATERIALFPROC) load(userptr, "glMaterialf");
+    sf_glad_glMaterialfv = (PFNGLMATERIALFVPROC) load(userptr, "glMaterialfv");
+    sf_glad_glMaterialx = (PFNGLMATERIALXPROC) load(userptr, "glMaterialx");
+    sf_glad_glMaterialxv = (PFNGLMATERIALXVPROC) load(userptr, "glMaterialxv");
+    sf_glad_glMatrixMode = (PFNGLMATRIXMODEPROC) load(userptr, "glMatrixMode");
+    sf_glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC) load(userptr, "glMultMatrixf");
+    sf_glad_glMultMatrixx = (PFNGLMULTMATRIXXPROC) load(userptr, "glMultMatrixx");
+    sf_glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC) load(userptr, "glMultiTexCoord4f");
+    sf_glad_glMultiTexCoord4x = (PFNGLMULTITEXCOORD4XPROC) load(userptr, "glMultiTexCoord4x");
+    sf_glad_glNormal3f = (PFNGLNORMAL3FPROC) load(userptr, "glNormal3f");
+    sf_glad_glNormal3x = (PFNGLNORMAL3XPROC) load(userptr, "glNormal3x");
+    sf_glad_glNormalPointer = (PFNGLNORMALPOINTERPROC) load(userptr, "glNormalPointer");
+    sf_glad_glOrthof = (PFNGLORTHOFPROC) load(userptr, "glOrthof");
+    sf_glad_glOrthox = (PFNGLORTHOXPROC) load(userptr, "glOrthox");
+    sf_glad_glPixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei");
+    sf_glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC) load(userptr, "glPointParameterf");
+    sf_glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC) load(userptr, "glPointParameterfv");
+    sf_glad_glPointParameterx = (PFNGLPOINTPARAMETERXPROC) load(userptr, "glPointParameterx");
+    sf_glad_glPointParameterxv = (PFNGLPOINTPARAMETERXVPROC) load(userptr, "glPointParameterxv");
+    sf_glad_glPointSize = (PFNGLPOINTSIZEPROC) load(userptr, "glPointSize");
+    sf_glad_glPointSizex = (PFNGLPOINTSIZEXPROC) load(userptr, "glPointSizex");
+    sf_glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset");
+    sf_glad_glPolygonOffsetx = (PFNGLPOLYGONOFFSETXPROC) load(userptr, "glPolygonOffsetx");
+    sf_glad_glPopMatrix = (PFNGLPOPMATRIXPROC) load(userptr, "glPopMatrix");
+    sf_glad_glPushMatrix = (PFNGLPUSHMATRIXPROC) load(userptr, "glPushMatrix");
+    sf_glad_glReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels");
+    sf_glad_glRotatef = (PFNGLROTATEFPROC) load(userptr, "glRotatef");
+    sf_glad_glRotatex = (PFNGLROTATEXPROC) load(userptr, "glRotatex");
+    sf_glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage");
+    sf_glad_glSampleCoveragex = (PFNGLSAMPLECOVERAGEXPROC) load(userptr, "glSampleCoveragex");
+    sf_glad_glScalef = (PFNGLSCALEFPROC) load(userptr, "glScalef");
+    sf_glad_glScalex = (PFNGLSCALEXPROC) load(userptr, "glScalex");
+    sf_glad_glScissor = (PFNGLSCISSORPROC) load(userptr, "glScissor");
+    sf_glad_glShadeModel = (PFNGLSHADEMODELPROC) load(userptr, "glShadeModel");
+    sf_glad_glStencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc");
+    sf_glad_glStencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask");
+    sf_glad_glStencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp");
+    sf_glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC) load(userptr, "glTexCoordPointer");
+    sf_glad_glTexEnvf = (PFNGLTEXENVFPROC) load(userptr, "glTexEnvf");
+    sf_glad_glTexEnvfv = (PFNGLTEXENVFVPROC) load(userptr, "glTexEnvfv");
+    sf_glad_glTexEnvi = (PFNGLTEXENVIPROC) load(userptr, "glTexEnvi");
+    sf_glad_glTexEnviv = (PFNGLTEXENVIVPROC) load(userptr, "glTexEnviv");
+    sf_glad_glTexEnvx = (PFNGLTEXENVXPROC) load(userptr, "glTexEnvx");
+    sf_glad_glTexEnvxv = (PFNGLTEXENVXVPROC) load(userptr, "glTexEnvxv");
+    sf_glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D");
+    sf_glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf");
+    sf_glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv");
+    sf_glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri");
+    sf_glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv");
+    sf_glad_glTexParameterx = (PFNGLTEXPARAMETERXPROC) load(userptr, "glTexParameterx");
+    sf_glad_glTexParameterxv = (PFNGLTEXPARAMETERXVPROC) load(userptr, "glTexParameterxv");
+    sf_glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D");
+    sf_glad_glTranslatef = (PFNGLTRANSLATEFPROC) load(userptr, "glTranslatef");
+    sf_glad_glTranslatex = (PFNGLTRANSLATEXPROC) load(userptr, "glTranslatex");
+    sf_glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC) load(userptr, "glVertexPointer");
+    sf_glad_glViewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport");
+}
 static void sf_glad_gl_load_GL_ARB_ES2_compatibility( GLADuserptrloadfunc load, void* userptr) {
     if(!SF_GLAD_GL_ARB_ES2_compatibility) return;
     sf_glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf");
@@ -11147,6 +11294,36 @@ static void sf_glad_gl_load_GL_OES_single_precision( GLADuserptrloadfunc load, v
     sf_glad_glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC) load(userptr, "glGetClipPlanefOES");
     sf_glad_glOrthofOES = (PFNGLORTHOFOESPROC) load(userptr, "glOrthofOES");
 }
+static void sf_glad_gl_load_GL_OES_blend_equation_separate( GLADuserptrloadfunc load, void* userptr) {
+    if(!SF_GLAD_GL_OES_blend_equation_separate) return;
+    sf_glad_glBlendEquationSeparateOES = (PFNGLBLENDEQUATIONSEPARATEOESPROC) load(userptr, "glBlendEquationSeparateOES");
+}
+static void sf_glad_gl_load_GL_OES_blend_func_separate( GLADuserptrloadfunc load, void* userptr) {
+    if(!SF_GLAD_GL_OES_blend_func_separate) return;
+    sf_glad_glBlendFuncSeparateOES = (PFNGLBLENDFUNCSEPARATEOESPROC) load(userptr, "glBlendFuncSeparateOES");
+}
+static void sf_glad_gl_load_GL_OES_blend_subtract( GLADuserptrloadfunc load, void* userptr) {
+    if(!SF_GLAD_GL_OES_blend_subtract) return;
+    sf_glad_glBlendEquationOES = (PFNGLBLENDEQUATIONOESPROC) load(userptr, "glBlendEquationOES");
+}
+static void sf_glad_gl_load_GL_OES_framebuffer_object( GLADuserptrloadfunc load, void* userptr) {
+    if(!SF_GLAD_GL_OES_framebuffer_object) return;
+    sf_glad_glBindFramebufferOES = (PFNGLBINDFRAMEBUFFEROESPROC) load(userptr, "glBindFramebufferOES");
+    sf_glad_glBindRenderbufferOES = (PFNGLBINDRENDERBUFFEROESPROC) load(userptr, "glBindRenderbufferOES");
+    sf_glad_glCheckFramebufferStatusOES = (PFNGLCHECKFRAMEBUFFERSTATUSOESPROC) load(userptr, "glCheckFramebufferStatusOES");
+    sf_glad_glDeleteFramebuffersOES = (PFNGLDELETEFRAMEBUFFERSOESPROC) load(userptr, "glDeleteFramebuffersOES");
+    sf_glad_glDeleteRenderbuffersOES = (PFNGLDELETERENDERBUFFERSOESPROC) load(userptr, "glDeleteRenderbuffersOES");
+    sf_glad_glFramebufferRenderbufferOES = (PFNGLFRAMEBUFFERRENDERBUFFEROESPROC) load(userptr, "glFramebufferRenderbufferOES");
+    sf_glad_glFramebufferTexture2DOES = (PFNGLFRAMEBUFFERTEXTURE2DOESPROC) load(userptr, "glFramebufferTexture2DOES");
+    sf_glad_glGenFramebuffersOES = (PFNGLGENFRAMEBUFFERSOESPROC) load(userptr, "glGenFramebuffersOES");
+    sf_glad_glGenRenderbuffersOES = (PFNGLGENRENDERBUFFERSOESPROC) load(userptr, "glGenRenderbuffersOES");
+    sf_glad_glGenerateMipmapOES = (PFNGLGENERATEMIPMAPOESPROC) load(userptr, "glGenerateMipmapOES");
+    sf_glad_glGetFramebufferAttachmentParameterivOES = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC) load(userptr, "glGetFramebufferAttachmentParameterivOES");
+    sf_glad_glGetRenderbufferParameterivOES = (PFNGLGETRENDERBUFFERPARAMETERIVOESPROC) load(userptr, "glGetRenderbufferParameterivOES");
+    sf_glad_glIsFramebufferOES = (PFNGLISFRAMEBUFFEROESPROC) load(userptr, "glIsFramebufferOES");
+    sf_glad_glIsRenderbufferOES = (PFNGLISRENDERBUFFEROESPROC) load(userptr, "glIsRenderbufferOES");
+    sf_glad_glRenderbufferStorageOES = (PFNGLRENDERBUFFERSTORAGEOESPROC) load(userptr, "glRenderbufferStorageOES");
+}
 
 
 static void sf_glad_gl_resolve_aliases(void) {
@@ -11978,6 +12155,91 @@ static int gladLoadGL( GLADloadfunc load) {
     return gladLoadGLUserPtr( sf_glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
 }
 
+static int sf_glad_gl_find_extensions_gles1( int version) {
+    const char *exts = NULL;
+    unsigned int num_exts_i = 0;
+    char **exts_i = NULL;
+    if (!sf_glad_gl_get_extensions(version, &exts, &num_exts_i, &exts_i)) return 0;
+
+    SF_GLAD_GL_EXT_blend_minmax = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_blend_minmax");
+    SF_GLAD_GL_KHR_debug = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_KHR_debug");
+    SF_GLAD_GL_OES_single_precision = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_single_precision");
+    SF_GLAD_GL_EXT_sRGB = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_sRGB");
+    SF_GLAD_GL_OES_blend_equation_separate = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_blend_equation_separate");
+    SF_GLAD_GL_OES_blend_func_separate = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_blend_func_separate");
+    SF_GLAD_GL_OES_blend_subtract = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_blend_subtract");
+    SF_GLAD_GL_OES_depth24 = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_depth24");
+    SF_GLAD_GL_OES_depth32 = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_depth32");
+    SF_GLAD_GL_OES_framebuffer_object = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_framebuffer_object");
+    SF_GLAD_GL_OES_packed_depth_stencil = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_packed_depth_stencil");
+    SF_GLAD_GL_OES_texture_npot = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_texture_npot");
+
+    sf_glad_gl_free_extensions(exts_i, num_exts_i);
+
+    return 1;
+}
+
+static int sf_glad_gl_find_core_gles1(void) {
+    int i, major, minor;
+    const char* version;
+    const char* prefixes[] = {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        NULL
+    };
+    version = (const char*) sf_glad_glGetString(GL_VERSION);
+    if (!version) return 0;
+    for (i = 0;  prefixes[i];  i++) {
+        const size_t length = strlen(prefixes[i]);
+        if (strncmp(version, prefixes[i], length) == 0) {
+            version += length;
+            break;
+        }
+    }
+
+    GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
+
+    SF_GLAD_GL_VERSION_ES_CM_1_0 = (major == 1 && minor >= 0) || major > 1;
+
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+static int gladLoadGLES1UserPtr( GLADuserptrloadfunc load, void *userptr) {
+    int version;
+
+    sf_glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
+    if(sf_glad_glGetString == NULL) return 0;
+    if(sf_glad_glGetString(GL_VERSION) == NULL) return 0;
+    version = sf_glad_gl_find_core_gles1();
+
+    sf_glad_gl_load_GL_VERSION_ES_CM_1_0(load, userptr);
+
+    if (!sf_glad_gl_find_extensions_gles1(version)) return 0;
+    sf_glad_gl_load_GL_EXT_blend_minmax(load, userptr);
+    sf_glad_gl_load_GL_KHR_debug(load, userptr);
+    sf_glad_gl_load_GL_OES_single_precision(load, userptr);
+    sf_glad_gl_load_GL_OES_blend_equation_separate(load, userptr);
+    sf_glad_gl_load_GL_OES_blend_func_separate(load, userptr);
+    sf_glad_gl_load_GL_OES_blend_subtract(load, userptr);
+    sf_glad_gl_load_GL_OES_framebuffer_object(load, userptr);
+
+
+    sf_glad_gl_resolve_aliases();
+
+    return version;
+}
+
+
+static int gladLoadGLES1( GLADloadfunc load) {
+    return gladLoadGLES1UserPtr( sf_glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+
+
+
+ 
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/SFML/Audio/SoundFileReaderWav.cpp b/src/SFML/Audio/SoundFileReaderWav.cpp
index f67b7440..28dfc4e4 100644
--- a/src/SFML/Audio/SoundFileReaderWav.cpp
+++ b/src/SFML/Audio/SoundFileReaderWav.cpp
@@ -41,13 +41,13 @@ namespace
 
     bool decode(sf::InputStream& stream, sf::Uint8& value)
     {
-         return stream.read(&value, sizeof(value)) == sizeof(value);
+         return static_cast<std::size_t>(stream.read(&value, sizeof(value))) == sizeof(value);
     }
 
     bool decode(sf::InputStream& stream, sf::Int16& value)
     {
         unsigned char bytes[sizeof(value)];
-        if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes))
+        if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes))
             return false;
 
         value = static_cast<sf::Uint8>(bytes[0] | (bytes[1] << 8));
@@ -58,7 +58,7 @@ namespace
     bool decode(sf::InputStream& stream, sf::Uint16& value)
     {
         unsigned char bytes[sizeof(value)];
-        if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes))
+        if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes))
             return false;
 
         value = static_cast<sf::Uint16>(bytes[0] | (bytes[1] << 8));
@@ -69,7 +69,7 @@ namespace
     bool decode24bit(sf::InputStream& stream, sf::Uint32& value)
     {
         unsigned char bytes[3];
-        if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes))
+        if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes))
             return false;
 
         value = static_cast<sf::Uint32>(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16));
@@ -80,7 +80,7 @@ namespace
     bool decode(sf::InputStream& stream, sf::Uint32& value)
     {
         unsigned char bytes[sizeof(value)];
-        if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes))
+        if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes))
             return false;
 
         value = static_cast<sf::Uint32>(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24));
@@ -225,7 +225,7 @@ bool SoundFileReaderWav::parseHeader(Info& info)
     // If we are here, it means that the first part of the header
     // (the format) has already been checked
     char mainChunk[mainChunkSize];
-    if (m_stream->read(mainChunk, sizeof(mainChunk)) != sizeof(mainChunk))
+    if (static_cast<std::size_t>(m_stream->read(mainChunk, static_cast<Int64>(sizeof(mainChunk)))) != sizeof(mainChunk))
         return false;
 
     // Parse all the sub-chunks
@@ -234,7 +234,7 @@ bool SoundFileReaderWav::parseHeader(Info& info)
     {
         // Parse the sub-chunk id and size
         char subChunkId[4];
-        if (m_stream->read(subChunkId, sizeof(subChunkId)) != sizeof(subChunkId))
+        if (static_cast<std::size_t>(m_stream->read(subChunkId, static_cast<Int64>(sizeof(subChunkId)))) != sizeof(subChunkId))
             return false;
         Uint32 subChunkSize = 0;
         if (!decode(*m_stream, subChunkSize))
@@ -307,7 +307,7 @@ bool SoundFileReaderWav::parseHeader(Info& info)
 
                 // Subformat
                 char subformat[16];
-                if (m_stream->read(subformat, sizeof(subformat)) != sizeof(subformat))
+                if (static_cast<std::size_t>(m_stream->read(subformat, static_cast<Int64>(sizeof(subformat)))) != sizeof(subformat))
                     return false;
 
                 if (std::memcmp(subformat, waveSubformatPcm, sizeof(subformat)) != 0)
diff --git a/src/SFML/Audio/SoundFileWriterOgg.cpp b/src/SFML/Audio/SoundFileWriterOgg.cpp
index 4f2daba6..4ecc4656 100644
--- a/src/SFML/Audio/SoundFileWriterOgg.cpp
+++ b/src/SFML/Audio/SoundFileWriterOgg.cpp
@@ -85,7 +85,7 @@ bool SoundFileWriterOgg::open(const std::string& filename, unsigned int sampleRa
 
     // Setup the encoder: VBR, automatic bitrate management
     // Quality is in range [-1 .. 1], 0.4 gives ~128 kbps for a 44 KHz stereo sound
-    int status = vorbis_encode_init_vbr(&m_vorbis, channelCount, sampleRate, 0.4f);
+    int status = vorbis_encode_init_vbr(&m_vorbis, static_cast<long>(channelCount), static_cast<long>(sampleRate), 0.4f);
     if (status < 0)
     {
         err() << "Failed to write ogg/vorbis file \"" << filename << "\" (unsupported bitrate)" << std::endl;
diff --git a/src/SFML/Graphics/Font.cpp b/src/SFML/Graphics/Font.cpp
index 27cd90e2..40c17a3c 100644
--- a/src/SFML/Graphics/Font.cpp
+++ b/src/SFML/Graphics/Font.cpp
@@ -131,7 +131,7 @@ Font::~Font()
     #ifdef SFML_SYSTEM_ANDROID
 
     if (m_stream)
-        delete (priv::ResourceStream*)m_stream;
+        delete static_cast<priv::ResourceStream*>(m_stream);
 
     #endif
 }
@@ -195,10 +195,10 @@ bool Font::loadFromFile(const std::string& filename)
     #else
 
     if (m_stream)
-        delete (priv::ResourceStream*)m_stream;
+        delete static_cast<priv::ResourceStream*>(m_stream);
 
     m_stream = new priv::ResourceStream(filename);
-    return loadFromStream(*(priv::ResourceStream*)m_stream);
+    return loadFromStream(*static_cast<priv::ResourceStream*>(m_stream));
 
     #endif
 }
@@ -659,16 +659,16 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, f
 
         // Make sure the texture data is positioned in the center
         // of the allocated texture rectangle
-        glyph.textureRect.left += static_cast<int>(padding);
-        glyph.textureRect.top  += static_cast<int>(padding);
+        glyph.textureRect.left   += static_cast<int>(padding);
+        glyph.textureRect.top    += static_cast<int>(padding);
         glyph.textureRect.width  -= static_cast<int>(2 * padding);
         glyph.textureRect.height -= static_cast<int>(2 * padding);
 
         // Compute the glyph's bounding box
-        glyph.bounds.left   =  bitmapGlyph->left;
-        glyph.bounds.top    = -bitmapGlyph->top;
-        glyph.bounds.width  =  bitmap.width;
-        glyph.bounds.height =  bitmap.rows;
+        glyph.bounds.left   = static_cast<float>( bitmapGlyph->left);
+        glyph.bounds.top    = static_cast<float>(-bitmapGlyph->top);
+        glyph.bounds.width  = static_cast<float>( bitmap.width);
+        glyph.bounds.height = static_cast<float>( bitmap.rows);
 
         // Resize the pixel buffer to the new size and fill it with transparent white pixels
         m_pixelBuffer.resize(width * height * 4);
diff --git a/src/SFML/Graphics/Shader.cpp b/src/SFML/Graphics/Shader.cpp
index e5b26593..90856b00 100644
--- a/src/SFML/Graphics/Shader.cpp
+++ b/src/SFML/Graphics/Shader.cpp
@@ -68,14 +68,14 @@ namespace
     }
 
     // Retrieve the maximum number of texture units available
-    GLint getMaxTextureUnits()
+    std::size_t getMaxTextureUnits()
     {
         // TODO: Remove this lock when it becomes unnecessary in C++11
         sf::Lock lock(maxTextureUnitsMutex);
 
         static GLint maxUnits = checkMaxTextureUnits();
 
-        return maxUnits;
+        return static_cast<std::size_t>(maxUnits);
     }
 
     // Read the contents of a file into an array of char
@@ -85,12 +85,12 @@ namespace
         if (file)
         {
             file.seekg(0, std::ios_base::end);
-            std::streamsize size = file.tellg();
+            std::ifstream::pos_type size = file.tellg();
             if (size > 0)
             {
                 file.seekg(0, std::ios_base::beg);
                 buffer.resize(static_cast<std::size_t>(size));
-                file.read(&buffer[0], size);
+                file.read(&buffer[0], static_cast<std::streamsize>(size));
             }
             buffer.push_back('\0');
             return true;
@@ -556,8 +556,7 @@ void Shader::setUniform(const std::string& name, const Texture& texture)
             if (it == m_textures.end())
             {
                 // New entry, make sure there are enough texture units
-                GLint maxUnits = getMaxTextureUnits();
-                if (m_textures.size() + 1 >= static_cast<std::size_t>(maxUnits))
+                if (m_textures.size() + 1 >= getMaxTextureUnits())
                 {
                     err() << "Impossible to use texture \"" << name << "\" for shader: all available texture units are used" << std::endl;
                     return;
diff --git a/src/SFML/Graphics/Texture.cpp b/src/SFML/Graphics/Texture.cpp
index bf546ccf..f462f263 100644
--- a/src/SFML/Graphics/Texture.cpp
+++ b/src/SFML/Graphics/Texture.cpp
@@ -36,6 +36,7 @@
 #include <SFML/System/Err.hpp>
 #include <cassert>
 #include <cstring>
+#include <climits>
 
 
 namespace
@@ -378,7 +379,7 @@ Image Texture::copyToImage() const
         if (m_pixelsFlipped)
         {
             src += srcPitch * (m_size.y - 1);
-            srcPitch = -srcPitch;
+            srcPitch = UINT_MAX - srcPitch + 1;
         }
 
         for (unsigned int i = 0; i < m_size.y; ++i)
diff --git a/src/SFML/Graphics/VertexBuffer.cpp b/src/SFML/Graphics/VertexBuffer.cpp
index d70fef1b..3c09716c 100644
--- a/src/SFML/Graphics/VertexBuffer.cpp
+++ b/src/SFML/Graphics/VertexBuffer.cpp
@@ -195,7 +195,7 @@ bool VertexBuffer::update(const Vertex* vertices, std::size_t vertexCount, unsig
         m_size = vertexCount;
     }
 
-    glCheck(GLEXT_glBufferSubData(GLEXT_GL_ARRAY_BUFFER, sizeof(Vertex) * offset, static_cast<GLsizeiptrARB>(sizeof(Vertex) * vertexCount), vertices));
+    glCheck(GLEXT_glBufferSubData(GLEXT_GL_ARRAY_BUFFER, static_cast<GLintptrARB>(sizeof(Vertex) * offset), static_cast<GLsizeiptrARB>(sizeof(Vertex) * vertexCount), vertices));
 
     glCheck(GLEXT_glBindBuffer(GLEXT_GL_ARRAY_BUFFER, 0));
 
diff --git a/src/SFML/Main/CMakeLists.txt b/src/SFML/Main/CMakeLists.txt
index 9344ada1..babd2b32 100644
--- a/src/SFML/Main/CMakeLists.txt
+++ b/src/SFML/Main/CMakeLists.txt
@@ -18,7 +18,7 @@ sfml_add_library(sfml-main STATIC SOURCES ${SRC})
 
 if(SFML_OS_ANDROID)
     # glad sources
-    target_include_directories(sfml-main PRIVATE "${PROJECT_SOURCE_DIR}/extlibs/headers/glad/include")
+    target_include_directories(sfml-main SYSTEM PRIVATE "${PROJECT_SOURCE_DIR}/extlibs/headers/glad/include")
 endif()
 
 # overwrite sfml-main suffix for backward compatibility with FindSFML.cmake
diff --git a/src/SFML/Main/MainAndroid.cpp b/src/SFML/Main/MainAndroid.cpp
index f217493b..9fbd586a 100644
--- a/src/SFML/Main/MainAndroid.cpp
+++ b/src/SFML/Main/MainAndroid.cpp
@@ -161,7 +161,6 @@ void goToFullscreenMode(ANativeActivity* activity)
         AWINDOW_FLAG_FULLSCREEN);
 
     // Hide the navigation bar
-    JavaVM* lJavaVM = activity->vm;
     JNIEnv* lJNIEnv = activity->env;
 
     jobject objectActivity = activity->clazz;
@@ -216,7 +215,6 @@ void getScreenSizeInPixels(ANativeActivity* activity, int* width, int* height)
     // DisplayMetrics dm = new DisplayMetrics();
     // getWindowManager().getDefaultDisplay().getMetrics(dm);
 
-    JavaVM* lJavaVM = activity->vm;
     JNIEnv* lJNIEnv = activity->env;
 
     jobject objectActivity = activity->clazz;
@@ -248,6 +246,7 @@ void getScreenSizeInPixels(ANativeActivity* activity, int* width, int* height)
 ////////////////////////////////////////////////////////////
 static void onStart(ANativeActivity* activity)
 {
+    (void) activity;
 }
 
 
@@ -287,6 +286,7 @@ static void onPause(ANativeActivity* activity)
 ////////////////////////////////////////////////////////////
 static void onStop(ANativeActivity* activity)
 {
+    (void) activity;
 }
 
 
@@ -339,6 +339,8 @@ static void onDestroy(ANativeActivity* activity)
 ////////////////////////////////////////////////////////////
 static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window)
 {
+    (void) window;
+
     sf::priv::ActivityStates* states = sf::priv::retrieveStates(activity);
     sf::Lock lock(states->mutex);
 
@@ -364,6 +366,8 @@ static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* wind
 ////////////////////////////////////////////////////////////
 static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window)
 {
+    (void) window;
+
     sf::priv::ActivityStates* states = sf::priv::retrieveStates(activity);
     sf::Lock lock(states->mutex);
 
@@ -389,12 +393,16 @@ static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* wi
 ////////////////////////////////////////////////////////////
 static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window)
 {
+    (void) activity;
+    (void) window;
 }
 
 
 ////////////////////////////////////////////////////////////
 static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window)
 {
+    (void) activity;
+    (void) window;
 }
 
 
@@ -435,12 +443,16 @@ static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue)
 ////////////////////////////////////////////////////////////
 static void onWindowFocusChanged(ANativeActivity* activity, int focused)
 {
+    (void) activity;
+    (void) focused;
 }
 
 
 ////////////////////////////////////////////////////////////
 static void onContentRectChanged(ANativeActivity* activity, const ARect* rect)
 {
+    (void) rect;
+
     // Retrieve our activity states from the activity instance
     sf::priv::ActivityStates* states = sf::priv::retrieveStates(activity);
     sf::Lock lock(states->mutex);
@@ -450,8 +462,8 @@ static void onContentRectChanged(ANativeActivity* activity, const ARect* rect)
         // Send an event to warn people about the window move/resize
         sf::Event event;
         event.type = sf::Event::Resized;
-        event.size.width = ANativeWindow_getWidth(states->window);
-        event.size.height = ANativeWindow_getHeight(states->window);
+        event.size.width = static_cast<unsigned int>(ANativeWindow_getWidth(states->window));
+        event.size.height = static_cast<unsigned int>(ANativeWindow_getHeight(states->window));
 
         states->forwardEvent(event);
     }
@@ -461,12 +473,14 @@ static void onContentRectChanged(ANativeActivity* activity, const ARect* rect)
 ////////////////////////////////////////////////////////////
 static void onConfigurationChanged(ANativeActivity* activity)
 {
+    (void) activity;
 }
 
 
 ////////////////////////////////////////////////////////////
 static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen)
 {
+    (void) activity;
     *outLen = 0;
 
     return NULL;
@@ -476,6 +490,7 @@ static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen)
 ////////////////////////////////////////////////////////////
 static void onLowMemory(ANativeActivity* activity)
 {
+    (void) activity;
 }
 
 
diff --git a/src/SFML/Main/MainWin32.cpp b/src/SFML/Main/MainWin32.cpp
index 93a9a528..3e76a7ff 100644
--- a/src/SFML/Main/MainWin32.cpp
+++ b/src/SFML/Main/MainWin32.cpp
@@ -46,7 +46,10 @@ extern int main(int argc, char* argv[]);
 ////////////////////////////////////////////////////////////
 int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, INT)
 {
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic"
     return main(__argc, __argv);
+    #pragma GCC diagnostic pop
 }
 
 #endif // SFML_SYSTEM_WINDOWS
diff --git a/src/SFML/Network/Ftp.cpp b/src/SFML/Network/Ftp.cpp
index 598891db..c76f2f29 100644
--- a/src/SFML/Network/Ftp.cpp
+++ b/src/SFML/Network/Ftp.cpp
@@ -549,7 +549,7 @@ Ftp::Response Ftp::DataChannel::open(Ftp::TransferMode mode)
                 // Extract the current number
                 while (isdigit(str[index]))
                 {
-                    data[i] = static_cast<Uint8>(data[i] * 10) + static_cast<Uint8>(str[index] - '0');
+                    data[i] = static_cast<Uint8>(static_cast<Uint8>(data[i] * 10) + static_cast<Uint8>(str[index] - '0'));
                     index++;
                 }
 
diff --git a/src/SFML/Network/IpAddress.cpp b/src/SFML/Network/IpAddress.cpp
index 2c6bc6b2..0130c637 100644
--- a/src/SFML/Network/IpAddress.cpp
+++ b/src/SFML/Network/IpAddress.cpp
@@ -198,7 +198,9 @@ void IpAddress::resolve(const std::string& address)
             {
                 if (result)
                 {
-                    ip = reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr.s_addr;
+                    sockaddr_in sin;
+                    std::memcpy(&sin, result->ai_addr, sizeof(*result->ai_addr));
+                    ip = sin.sin_addr.s_addr;
                     freeaddrinfo(result);
                     m_address = ip;
                     m_valid = true;
diff --git a/src/SFML/Network/TcpSocket.cpp b/src/SFML/Network/TcpSocket.cpp
index 7181df0e..02ed063b 100644
--- a/src/SFML/Network/TcpSocket.cpp
+++ b/src/SFML/Network/TcpSocket.cpp
@@ -178,7 +178,7 @@ Socket::Status TcpSocket::connect(const IpAddress& remoteAddress, unsigned short
             time.tv_usec = static_cast<long>(timeout.asMicroseconds() % 1000000);
 
             // Wait for something to write on our socket (which means that the connection request has returned)
-            if (select(getHandle() + 1, NULL, &selector, NULL, &time) > 0)
+            if (select(static_cast<int>(getHandle() + 1), NULL, &selector, NULL, &time) > 0)
             {
                 // At this point the connection may have been either accepted or refused.
                 // To know whether it's a success or a failure, we must check the address of the connected peer
@@ -242,13 +242,13 @@ Socket::Status TcpSocket::send(const void* data, std::size_t size, std::size_t&
     }
 
     // Loop until every byte has been sent
-    ssize_t result = 0;
+    int result = 0;
     for (sent = 0; sent < size; sent += static_cast<std::size_t>(result))
     {
         #pragma GCC diagnostic push
         #pragma GCC diagnostic ignored "-Wuseless-cast"
         // Send a chunk of data
-        result = ::send(getHandle(), static_cast<const char*>(data) + sent, static_cast<priv::SocketImpl::Size>(size - sent), flags);
+        result = static_cast<int>(::send(getHandle(), static_cast<const char*>(data) + sent, static_cast<priv::SocketImpl::Size>(size - sent), flags));
         #pragma GCC diagnostic pop
 
         // Check for errors
@@ -326,16 +326,25 @@ Socket::Status TcpSocket::send(Packet& packet)
     std::vector<char> blockToSend(sizeof(packetSize) + size);
 
     // Copy the packet size and data into the block to send
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wnull-dereference" // False positive.
     std::memcpy(&blockToSend[0], &packetSize, sizeof(packetSize));
+    #pragma GCC diagnostic pop
     if (size > 0)
         std::memcpy(&blockToSend[0] + sizeof(packetSize), data, size);
 
+    // These warnings are ignored here for portability, as even on Windows the
+    // signature of `send` might change depending on whether Win32 or MinGW is
+    // being used.
     #pragma GCC diagnostic push
     #pragma GCC diagnostic ignored "-Wuseless-cast"
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wsign-conversion"
     // Send the data block
     std::size_t sent;
     Status status = send(&blockToSend[0] + packet.m_sendPos, static_cast<priv::SocketImpl::Size>(blockToSend.size() - packet.m_sendPos), sent);
     #pragma GCC diagnostic pop
+    #pragma GCC diagnostic pop
 
     // In the case of a partial send, record the location to resume from
     if (status == Partial)
diff --git a/src/SFML/Network/Win32/SocketImpl.cpp b/src/SFML/Network/Win32/SocketImpl.cpp
index cd2580ab..e639ef2d 100644
--- a/src/SFML/Network/Win32/SocketImpl.cpp
+++ b/src/SFML/Network/Win32/SocketImpl.cpp
@@ -64,7 +64,7 @@ void SocketImpl::close(SocketHandle sock)
 void SocketImpl::setBlocking(SocketHandle sock, bool block)
 {
     u_long blocking = block ? 0 : 1;
-    ioctlsocket(sock, FIONBIO, &blocking);
+    ioctlsocket(sock, static_cast<long>(FIONBIO), &blocking);
 }
 
 
diff --git a/src/SFML/System/Unix/SleepImpl.cpp b/src/SFML/System/Unix/SleepImpl.cpp
index 6bed85de..474778d4 100644
--- a/src/SFML/System/Unix/SleepImpl.cpp
+++ b/src/SFML/System/Unix/SleepImpl.cpp
@@ -41,8 +41,8 @@ void sleepImpl(Time time)
 
     // Construct the time to wait
     timespec ti;
-    ti.tv_nsec = (usecs % 1000000) * 1000;
-    ti.tv_sec = usecs / 1000000;
+    ti.tv_nsec = static_cast<long>((usecs % 1000000) * 1000);
+    ti.tv_sec = static_cast<time_t>(usecs / 1000000);
 
     // Wait...
     // If nanosleep returns -1, we check errno. If it is EINTR
diff --git a/src/SFML/System/Win32/ClockImpl.cpp b/src/SFML/System/Win32/ClockImpl.cpp
index 2f69ece6..3d28d7ea 100644
--- a/src/SFML/System/Win32/ClockImpl.cpp
+++ b/src/SFML/System/Win32/ClockImpl.cpp
@@ -56,7 +56,7 @@ Time ClockImpl::getCurrentTime()
 {
     // Calculate inverse of frequency multiplied by 1000000 to prevent overflow in final calculation
     // Frequency is constant across the program lifetime
-    static double inverse = 1000000.0 / getFrequency().QuadPart;
+    static double inverse = 1000000.0 / static_cast<double>(getFrequency().QuadPart);
 
     // Detect if we are on Windows XP or older
     static bool oldWindows = isWindowsXpOrOlder();
@@ -80,7 +80,7 @@ Time ClockImpl::getCurrentTime()
     }
 
     // Return the current time as microseconds
-    return sf::microseconds(static_cast<sf::Int64>(time.QuadPart * inverse));
+    return sf::microseconds(static_cast<sf::Int64>(static_cast<double>(time.QuadPart) * inverse));
 }
 
 } // namespace priv
diff --git a/src/SFML/System/Win32/SleepImpl.cpp b/src/SFML/System/Win32/SleepImpl.cpp
index e0697c22..056f1c5f 100644
--- a/src/SFML/System/Win32/SleepImpl.cpp
+++ b/src/SFML/System/Win32/SleepImpl.cpp
@@ -44,7 +44,7 @@ void sleepImpl(Time time)
     timeBeginPeriod(tc.wPeriodMin);
 
     // Wait...
-    ::Sleep(time.asMilliseconds());
+    ::Sleep(static_cast<DWORD>(time.asMilliseconds()));
 
     // Reset the timer resolution back to the system default
     timeEndPeriod(tc.wPeriodMin);
diff --git a/src/SFML/Window/GlContext.cpp b/src/SFML/Window/GlContext.cpp
index 9ed2315e..9074d31a 100644
--- a/src/SFML/Window/GlContext.cpp
+++ b/src/SFML/Window/GlContext.cpp
@@ -291,14 +291,14 @@ namespace
         {
             std::size_t prefixLength = std::strlen(prefix);
 
-        if ((std::strlen(version) >= (prefixLength + 3)) &&
-            (std::strncmp(version, prefix, prefixLength) == 0) &&
-            std::isdigit(version[prefixLength]) &&
-            (version[prefixLength + 1] == '.') &&
-            std::isdigit(version[prefixLength + 2]))
-        {
-            major = static_cast<unsigned int>(version[prefixLength] - '0');
-            minor = static_cast<unsigned int>(version[prefixLength + 2] - '0');
+            if ((std::strlen(version) >= (prefixLength + 3)) &&
+                (std::strncmp(version, prefix, prefixLength) == 0) &&
+                std::isdigit(version[prefixLength]) &&
+                (version[prefixLength + 1] == '.') &&
+                std::isdigit(version[prefixLength + 2]))
+            {
+                major = static_cast<unsigned int>(version[prefixLength] - '0');
+                minor = static_cast<unsigned int>(version[prefixLength + 2] - '0');
 
                 return true;
             }
diff --git a/src/SFML/Window/Unix/WindowImplX11.cpp b/src/SFML/Window/Unix/WindowImplX11.cpp
index f46d9df7..569f5f15 100644
--- a/src/SFML/Window/Unix/WindowImplX11.cpp
+++ b/src/SFML/Window/Unix/WindowImplX11.cpp
@@ -48,6 +48,7 @@
 #include <vector>
 #include <string>
 #include <cstring>
+#include <cassert>
 
 #ifdef SFML_OPENGL_ES
     #include <SFML/Window/EglContext.hpp>
@@ -81,10 +82,10 @@ namespace
 
         static const unsigned int             maxTrialsCount = 5;
 
-    // Predicate we use to find key repeat events in processEvent
-    struct KeyRepeatFinder
-    {
-        KeyRepeatFinder(unsigned int initalKeycode, Time initialTime) : keycode(initalKeycode), time(initialTime) {}
+        // Predicate we use to find key repeat events in processEvent
+        struct KeyRepeatFinder
+        {
+            KeyRepeatFinder(unsigned int initalKeycode, Time initialTime) : keycode(initalKeycode), time(initialTime) {}
 
             // Predicate operator that checks event type, keycode and timestamp
             bool operator()(const XEvent& event)
@@ -117,11 +118,11 @@ namespace
             std::size_t offset = 0;
             ssize_t result = 0;
 
-        while ((result = read(file, &buffer[offset], 256)) > 0)
-        {
-            buffer.resize(buffer.size() + static_cast<std::size_t>(result), 0);
-            offset += static_cast<std::size_t>(result);
-        }
+            while ((result = read(file, &buffer[offset], 256)) > 0)
+            {
+                buffer.resize(buffer.size() + static_cast<std::size_t>(result), 0);
+                offset += static_cast<std::size_t>(result);
+            }
 
             ::close(file);
 
@@ -184,7 +185,10 @@ namespace
                 return false;
             }
 
+            #pragma GCC diagnostic push
+            #pragma GCC diagnostic ignored "-Wcast-align"
             ::Window rootWindow = *reinterpret_cast< ::Window* >(data);
+            #pragma GCC diagnostic pop
 
             XFree(data);
 
@@ -216,7 +220,10 @@ namespace
                 return false;
             }
 
+            #pragma GCC diagnostic push
+            #pragma GCC diagnostic ignored "-Wcast-align"
             ::Window childWindow = *reinterpret_cast< ::Window* >(data);
+            #pragma GCC diagnostic pop
 
             XFree(data);
 
@@ -335,7 +342,10 @@ namespace
             {
                 gotFrameExtents = true;
 
-            long* extents = reinterpret_cast<long*>(data);
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wcast-align"
+                long* extents = reinterpret_cast<long*>(data);
+                #pragma GCC diagnostic pop
 
                 xFrameExtent = extents[0]; // Left.
                 yFrameExtent = extents[2]; // Top.
@@ -1056,8 +1066,11 @@ void WindowImplX11::setIcon(unsigned int width, unsigned int height, const Uint8
     std::vector<unsigned long> icccmIconPixels(2 + width * height, 0);
     unsigned long* ptr = &icccmIconPixels[0];
 
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wnull-dereference" // False positive.
     *ptr++ = width;
     *ptr++ = height;
+    #pragma GCC diagnostic pop
 
     for (std::size_t i = 0; i < width * height; ++i)
     {
diff --git a/src/SFML/Window/Win32/CursorImpl.cpp b/src/SFML/Window/Win32/CursorImpl.cpp
index 98f5a1cc..725447d6 100755
--- a/src/SFML/Window/Win32/CursorImpl.cpp
+++ b/src/SFML/Window/Win32/CursorImpl.cpp
@@ -60,8 +60,8 @@ bool CursorImpl::loadFromPixels(const Uint8* pixels, Vector2u size, Vector2u hot
     std::memset(&bitmapHeader, 0, sizeof(BITMAPV5HEADER));
 
     bitmapHeader.bV5Size        = sizeof(BITMAPV5HEADER);
-    bitmapHeader.bV5Width       = size.x;
-    bitmapHeader.bV5Height      = -static_cast<int>(size.y); // Negative indicates origin is in upper-left corner
+    bitmapHeader.bV5Width       = static_cast<LONG>(size.x);
+    bitmapHeader.bV5Height      = -static_cast<LONG>(size.y); // Negative indicates origin is in upper-left corner
     bitmapHeader.bV5Planes      = 1;
     bitmapHeader.bV5BitCount    = 32;
     bitmapHeader.bV5Compression = BI_BITFIELDS;
@@ -94,11 +94,11 @@ bool CursorImpl::loadFromPixels(const Uint8* pixels, Vector2u size, Vector2u hot
     Uint32* bitmapOffset = bitmapData;
     for (std::size_t remaining = size.x * size.y; remaining > 0; --remaining, pixels += 4)
     {
-        *bitmapOffset++ = (pixels[3] << 24) | (pixels[0] << 16) | (pixels[1] << 8) | pixels[2];
+        *bitmapOffset++ = static_cast<Uint32>((pixels[3] << 24) | (pixels[0] << 16) | (pixels[1] << 8) | pixels[2]);
     }
 
     // Create a dummy mask bitmap (it won't be used)
-    HBITMAP mask = CreateBitmap(size.x, size.y, 1, 1, NULL);
+    HBITMAP mask = CreateBitmap(static_cast<int>(size.x), static_cast<int>(size.y), 1, 1, NULL);
 
     if (!mask)
     {
diff --git a/src/SFML/Window/Win32/JoystickImpl.cpp b/src/SFML/Window/Win32/JoystickImpl.cpp
index 84985d49..8918cc9b 100644
--- a/src/SFML/Window/Win32/JoystickImpl.cpp
+++ b/src/SFML/Window/Win32/JoystickImpl.cpp
@@ -152,7 +152,7 @@ namespace
 
             if (result != ERROR_SUCCESS)
             {
-                sf::err() << "Unable to open registry for joystick at index " << index << ": " << getErrorString(result) << std::endl;
+                sf::err() << "Unable to open registry for joystick at index " << index << ": " << getErrorString(static_cast<DWORD>(result)) << std::endl;
                 return joystickDescription;
             }
         }
@@ -172,7 +172,7 @@ namespace
 
         if (result != ERROR_SUCCESS)
         {
-            sf::err() << "Unable to query registry key for joystick at index " << index << ": " << getErrorString(result) << std::endl;
+            sf::err() << "Unable to query registry key for joystick at index " << index << ": " << getErrorString(static_cast<DWORD>(result)) << std::endl;
             return joystickDescription;
         }
 
@@ -184,7 +184,7 @@ namespace
 
         if (result != ERROR_SUCCESS)
         {
-            sf::err() << "Unable to open registry key for joystick at index " << index << ": " << getErrorString(result) << std::endl;
+            sf::err() << "Unable to open registry key for joystick at index " << index << ": " << getErrorString(static_cast<DWORD>(result)) << std::endl;
             return joystickDescription;
         }
 
@@ -195,7 +195,7 @@ namespace
 
         if (result != ERROR_SUCCESS)
         {
-            sf::err() << "Unable to query name for joystick at index " << index << ": " << getErrorString(result) << std::endl;
+            sf::err() << "Unable to query name for joystick at index " << index << ": " << getErrorString(static_cast<DWORD>(result)) << std::endl;
             return joystickDescription;
         }
 
@@ -365,17 +365,17 @@ JoystickState JoystickImpl::update()
         state.connected = true;
 
         // Axes
-        state.axes[Joystick::X] = (pos.dwXpos - (m_caps.wXmax + m_caps.wXmin) / 2.f) * 200.f / (m_caps.wXmax - m_caps.wXmin);
-        state.axes[Joystick::Y] = (pos.dwYpos - (m_caps.wYmax + m_caps.wYmin) / 2.f) * 200.f / (m_caps.wYmax - m_caps.wYmin);
-        state.axes[Joystick::Z] = (pos.dwZpos - (m_caps.wZmax + m_caps.wZmin) / 2.f) * 200.f / (m_caps.wZmax - m_caps.wZmin);
-        state.axes[Joystick::R] = (pos.dwRpos - (m_caps.wRmax + m_caps.wRmin) / 2.f) * 200.f / (m_caps.wRmax - m_caps.wRmin);
-        state.axes[Joystick::U] = (pos.dwUpos - (m_caps.wUmax + m_caps.wUmin) / 2.f) * 200.f / (m_caps.wUmax - m_caps.wUmin);
-        state.axes[Joystick::V] = (pos.dwVpos - (m_caps.wVmax + m_caps.wVmin) / 2.f) * 200.f / (m_caps.wVmax - m_caps.wVmin);
+        state.axes[Joystick::X] = (static_cast<float>(pos.dwXpos) - static_cast<float>(m_caps.wXmax + m_caps.wXmin) / 2.f) * 200.f / static_cast<float>(m_caps.wXmax - m_caps.wXmin);
+        state.axes[Joystick::Y] = (static_cast<float>(pos.dwYpos) - static_cast<float>(m_caps.wYmax + m_caps.wYmin) / 2.f) * 200.f / static_cast<float>(m_caps.wYmax - m_caps.wYmin);
+        state.axes[Joystick::Z] = (static_cast<float>(pos.dwZpos) - static_cast<float>(m_caps.wZmax + m_caps.wZmin) / 2.f) * 200.f / static_cast<float>(m_caps.wZmax - m_caps.wZmin);
+        state.axes[Joystick::R] = (static_cast<float>(pos.dwRpos) - static_cast<float>(m_caps.wRmax + m_caps.wRmin) / 2.f) * 200.f / static_cast<float>(m_caps.wRmax - m_caps.wRmin);
+        state.axes[Joystick::U] = (static_cast<float>(pos.dwUpos) - static_cast<float>(m_caps.wUmax + m_caps.wUmin) / 2.f) * 200.f / static_cast<float>(m_caps.wUmax - m_caps.wUmin);
+        state.axes[Joystick::V] = (static_cast<float>(pos.dwVpos) - static_cast<float>(m_caps.wVmax + m_caps.wVmin) / 2.f) * 200.f / static_cast<float>(m_caps.wVmax - m_caps.wVmin);
 
         // Special case for POV, it is given as an angle
         if (pos.dwPOV != 0xFFFF)
         {
-            float angle = pos.dwPOV / 18000.f * 3.141592654f;
+            float angle = static_cast<float>(pos.dwPOV) / 18000.f * 3.141592654f;
             state.axes[Joystick::PovX] = std::sin(angle) * 100;
             state.axes[Joystick::PovY] = std::cos(angle) * 100;
         }
@@ -387,7 +387,7 @@ JoystickState JoystickImpl::update()
 
         // Buttons
         for (unsigned int i = 0; i < Joystick::ButtonCount; ++i)
-            state.buttons[i] = (pos.dwButtons & (1 << i)) != 0;
+            state.buttons[i] = (pos.dwButtons & (1u << i)) != 0;
     }
 
     return state;
@@ -404,7 +404,7 @@ void JoystickImpl::initializeDInput()
     {
         // Try to get the address of the DirectInput8Create entry point
         typedef HRESULT(WINAPI *DirectInput8CreateFunc)(HINSTANCE, DWORD, REFIID, LPVOID*, LPUNKNOWN);
-        DirectInput8CreateFunc directInput8Create = reinterpret_cast<DirectInput8CreateFunc>(GetProcAddress(dinput8dll, "DirectInput8Create"));
+        DirectInput8CreateFunc directInput8Create = reinterpret_cast<DirectInput8CreateFunc>(reinterpret_cast<void*>(GetProcAddress(dinput8dll, "DirectInput8Create")));
 
         if (directInput8Create)
         {
@@ -643,7 +643,7 @@ bool JoystickImpl::openDInput(unsigned int index)
                 for (int i = 0; i < 4; ++i)
                 {
                     data[8 * 4 + i].pguid = &guids::GUID_POV;
-                    data[8 * 4 + i].dwOfs = static_cast<DWORD>(DIJOFS_POV(i));
+                    data[8 * 4 + i].dwOfs = static_cast<DWORD>(DIJOFS_POV(static_cast<unsigned int>(i)));
                     data[8 * 4 + i].dwType = povType;
                     data[8 * 4 + i].dwFlags = 0;
                 }
diff --git a/src/SFML/Window/Win32/VideoModeImpl.cpp b/src/SFML/Window/Win32/VideoModeImpl.cpp
index 22385b12..2facb871 100644
--- a/src/SFML/Window/Win32/VideoModeImpl.cpp
+++ b/src/SFML/Window/Win32/VideoModeImpl.cpp
@@ -43,7 +43,7 @@ std::vector<VideoMode> VideoModeImpl::getFullscreenModes()
     DEVMODE win32Mode;
     win32Mode.dmSize = sizeof(win32Mode);
     win32Mode.dmDriverExtra = 0;
-    for (int count = 0; EnumDisplaySettings(NULL, count, &win32Mode); ++count)
+    for (int count = 0; EnumDisplaySettings(NULL, static_cast<DWORD>(count), &win32Mode); ++count)
     {
         // Convert to sf::VideoMode
         VideoMode mode(win32Mode.dmPelsWidth, win32Mode.dmPelsHeight, win32Mode.dmBitsPerPel);
diff --git a/src/SFML/Window/Win32/VulkanImplWin32.cpp b/src/SFML/Window/Win32/VulkanImplWin32.cpp
index d6b1f602..d2eb2a40 100644
--- a/src/SFML/Window/Win32/VulkanImplWin32.cpp
+++ b/src/SFML/Window/Win32/VulkanImplWin32.cpp
@@ -91,7 +91,7 @@ namespace
         template<typename T>
         bool loadEntryPoint(T& entryPoint, const char* name)
         {
-            entryPoint = reinterpret_cast<T>(GetProcAddress(library, name));
+            entryPoint = reinterpret_cast<T>(reinterpret_cast<void*>(GetProcAddress(library, name)));
 
             return (entryPoint != NULL);
         }
diff --git a/src/SFML/Window/Win32/WglContext.cpp b/src/SFML/Window/Win32/WglContext.cpp
index 09d306d6..9191503c 100644
--- a/src/SFML/Window/Win32/WglContext.cpp
+++ b/src/SFML/Window/Win32/WglContext.cpp
@@ -480,8 +480,8 @@ void WglContext::updateSettingsFromPixelFormat()
 
         if (wglGetPixelFormatAttribivARB(m_deviceContext, format, PFD_MAIN_PLANE, 2, attributes, values) == TRUE)
         {
-            m_settings.depthBits   = values[0];
-            m_settings.stencilBits = values[1];
+            m_settings.depthBits   = static_cast<unsigned int>(values[0]);
+            m_settings.stencilBits = static_cast<unsigned int>(values[1]);
         }
         else
         {
@@ -497,7 +497,7 @@ void WglContext::updateSettingsFromPixelFormat()
 
             if (wglGetPixelFormatAttribivARB(m_deviceContext, format, PFD_MAIN_PLANE, 2, sampleAttributes, sampleValues) == TRUE)
             {
-                m_settings.antialiasingLevel = sampleValues[0] ? sampleValues[1] : 0;
+                m_settings.antialiasingLevel = static_cast<unsigned int>(sampleValues[0] ? sampleValues[1] : 0);
             }
             else
             {
@@ -551,7 +551,7 @@ void WglContext::createSurface(WglContext* shared, unsigned int width, unsigned
         {
             int attributes[] = {0, 0};
 
-            m_pbuffer = wglCreatePbufferARB(shared->m_deviceContext, bestFormat, width, height, attributes);
+            m_pbuffer = wglCreatePbufferARB(shared->m_deviceContext, bestFormat, static_cast<int>(width), static_cast<int>(height), attributes);
 
             if (m_pbuffer)
             {
@@ -580,7 +580,7 @@ void WglContext::createSurface(WglContext* shared, unsigned int width, unsigned
         // with other contexts and thus wglShareLists would always fail
 
         // Create the hidden window
-        m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, width, height, NULL, NULL, GetModuleHandle(NULL), NULL);
+        m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, static_cast<int>(width), static_cast<int>(height), NULL, NULL, GetModuleHandle(NULL), NULL);
         ShowWindow(m_window, SW_HIDE);
         m_deviceContext = GetDC(m_window);
 
@@ -633,9 +633,9 @@ void WglContext::createContext(WglContext* shared)
             if ((m_settings.majorVersion > 1) || ((m_settings.majorVersion == 1) && (m_settings.minorVersion > 1)))
             {
                 attributes.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB);
-                attributes.push_back(m_settings.majorVersion);
+                attributes.push_back(static_cast<int>(m_settings.majorVersion));
                 attributes.push_back(WGL_CONTEXT_MINOR_VERSION_ARB);
-                attributes.push_back(m_settings.minorVersion);
+                attributes.push_back(static_cast<int>(m_settings.minorVersion));
             }
 
             // Check if setting the profile is supported
diff --git a/src/SFML/Window/Win32/WindowImplWin32.cpp b/src/SFML/Window/Win32/WindowImplWin32.cpp
index b489cea3..b2815c85 100755
--- a/src/SFML/Window/Win32/WindowImplWin32.cpp
+++ b/src/SFML/Window/Win32/WindowImplWin32.cpp
@@ -86,7 +86,7 @@ namespace
             };
 
             typedef HRESULT (WINAPI* SetProcessDpiAwarenessFuncType)(ProcessDpiAwareness);
-            SetProcessDpiAwarenessFuncType SetProcessDpiAwarenessFunc = reinterpret_cast<SetProcessDpiAwarenessFuncType>(GetProcAddress(shCoreDll, "SetProcessDpiAwareness"));
+            SetProcessDpiAwarenessFuncType SetProcessDpiAwarenessFunc = reinterpret_cast<SetProcessDpiAwarenessFuncType>(reinterpret_cast<void*>(GetProcAddress(shCoreDll, "SetProcessDpiAwareness")));
 
             if (SetProcessDpiAwarenessFunc)
             {
@@ -114,7 +114,7 @@ namespace
         if (user32Dll)
         {
             typedef BOOL (WINAPI* SetProcessDPIAwareFuncType)(void);
-            SetProcessDPIAwareFuncType SetProcessDPIAwareFunc = reinterpret_cast<SetProcessDPIAwareFuncType>(GetProcAddress(user32Dll, "SetProcessDPIAware"));
+            SetProcessDPIAwareFuncType SetProcessDPIAwareFunc = reinterpret_cast<SetProcessDPIAwareFuncType>(reinterpret_cast<void*>(GetProcAddress(user32Dll, "SetProcessDPIAware")));
 
             if (SetProcessDPIAwareFunc)
             {
@@ -190,8 +190,8 @@ m_cursorGrabbed   (m_fullscreen)
     HDC screenDC = GetDC(NULL);
     int left   = (GetDeviceCaps(screenDC, HORZRES) - static_cast<int>(mode.width))  / 2;
     int top    = (GetDeviceCaps(screenDC, VERTRES) - static_cast<int>(mode.height)) / 2;
-    int width  = mode.width;
-    int height = mode.height;
+    int width  = static_cast<int>(mode.width);
+    int height = static_cast<int>(mode.height);
     ReleaseDC(NULL, screenDC);
 
     // Choose the window style according to the Style parameter
@@ -333,7 +333,7 @@ Vector2u WindowImplWin32::getSize() const
     RECT rect;
     GetClientRect(m_handle, &rect);
 
-    return Vector2u(rect.right - rect.left, rect.bottom - rect.top);
+    return Vector2u(static_cast<unsigned int>(rect.right - rect.left), static_cast<unsigned int>(rect.bottom - rect.top));
 }
 
 
@@ -343,7 +343,7 @@ void WindowImplWin32::setSize(const Vector2u& size)
     // SetWindowPos wants the total size of the window (including title bar and borders),
     // so we have to compute it
     RECT rectangle = {0, 0, static_cast<long>(size.x), static_cast<long>(size.y)};
-    AdjustWindowRect(&rectangle, GetWindowLongPtr(m_handle, GWL_STYLE), false);
+    AdjustWindowRect(&rectangle, static_cast<DWORD>(GetWindowLongPtr(m_handle, GWL_STYLE)), false);
     int width  = rectangle.right - rectangle.left;
     int height = rectangle.bottom - rectangle.top;
 
@@ -376,13 +376,13 @@ void WindowImplWin32::setIcon(unsigned int width, unsigned int height, const Uin
     }
 
     // Create the icon from the pixel array
-    m_icon = CreateIcon(GetModuleHandleW(NULL), width, height, 1, 32, NULL, &iconPixels[0]);
+    m_icon = CreateIcon(GetModuleHandleW(NULL), static_cast<int>(width), static_cast<int>(height), 1, 32, NULL, &iconPixels[0]);
 
     // Set it as both big and small icon of the window
     if (m_icon)
     {
-        SendMessageW(m_handle, WM_SETICON, ICON_BIG,   (LPARAM)m_icon);
-        SendMessageW(m_handle, WM_SETICON, ICON_SMALL, (LPARAM)m_icon);
+        SendMessageW(m_handle, WM_SETICON, ICON_BIG,   reinterpret_cast<LPARAM>(m_icon));
+        SendMessageW(m_handle, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(m_icon));
     }
     else
     {
@@ -500,11 +500,11 @@ void WindowImplWin32::switchToFullscreen(const VideoMode& mode)
     }
 
     // Make the window flags compatible with fullscreen mode
-    SetWindowLongPtr(m_handle, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
+    SetWindowLongPtr(m_handle, GWL_STYLE, static_cast<LONG_PTR>(WS_POPUP) | static_cast<LONG_PTR>(WS_CLIPCHILDREN) | static_cast<LONG_PTR>(WS_CLIPSIBLINGS));
     SetWindowLongPtr(m_handle, GWL_EXSTYLE, WS_EX_APPWINDOW);
 
     // Resize the window so that it fits the entire screen
-    SetWindowPos(m_handle, HWND_TOP, 0, 0, mode.width, mode.height, SWP_FRAMECHANGED);
+    SetWindowPos(m_handle, HWND_TOP, 0, 0, static_cast<int>(mode.width), static_cast<int>(mode.height), SWP_FRAMECHANGED);
     ShowWindow(m_handle, SW_SHOW);
 
     // Set "this" as the current fullscreen window
@@ -1131,7 +1131,7 @@ LRESULT CALLBACK WindowImplWin32::globalOnEvent(HWND handle, UINT message, WPARA
     if (message == WM_CREATE)
     {
         // Get WindowImplWin32 instance (it was passed as the last argument of CreateWindow)
-        LONG_PTR window = (LONG_PTR)reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams;
+        LONG_PTR window = reinterpret_cast<LONG_PTR>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
 
         // Set as the "user data" parameter of the window
         SetWindowLongPtrW(handle, GWLP_USERDATA, window);