diff --git a/.appveyor.yml b/.appveyor.yml
index 2240fa4b8..63adb70c2 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -47,7 +47,7 @@ install:
         #Get-ChildItem $env:ASSETS_DIR | Measure-Object -property length -sum
 
 before_build:
-    - ps: Copy-Item "${env:DEPS_DIR}\windows_64bit\dependencies" c:\projects\stk-code\dependencies –Recurse
+    - ps: Copy-Item "${env:DEPS_DIR}\windows_64bit\dependencies" c:\projects\stk-code\dependencies-64bit –Recurse
     - cmd: |
         md build
         cd build
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 713fffdb4..b529b2f1e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@
 * Code refactoring of both render pipeline by Benau and Elderme
 * New kart Wilber and Hexley by Jymis
 * New kart Kiki by Benau
-* New tracks Cornfield Crossing and Candela City by samuncle
+* New tracks Candela City, Cornfield Crossing and Las Dunas Arena by samuncle
 * Physics improvements and various physics bugfixes by hiker
 * Kart GFX improvements (exhaust and headlight)
 * In-game screen recording powered by libopenglrecorder
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9e142e1fb..33ceb3a28 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,6 +10,13 @@ endif()
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 include(CMakeDependentOption)
 
+set(DEPENDENCIES "dependencies")
+# In case of 64-bit windows, use a different path for dependencies
+# so that both dependencies can be installed next to each other
+if ( WIN32 AND (CMAKE_SIZEOF_VOID_P EQUAL 8 ) )
+    set(DEPENDENCIES "dependencies-64bit")
+endif()
+
 include(BuildTypeSTKRelease)
 if (NOT CMAKE_BUILD_TYPE)
     message(STATUS "No build type selected, default to STKRelease")
@@ -62,15 +69,16 @@ set(STK_INSTALL_DATA_DIR "share/supertuxkart" CACHE
 
 # These variables enable MSVC to find libraries located in "dependencies"
 if(WIN32)
-    set(ENV{PATH} "$ENV{PATH};${PROJECT_SOURCE_DIR}/dependencies/include")
-    set(ENV{LIB} ${PROJECT_SOURCE_DIR}/dependencies/lib)
-    set(ENV{OPENALDIR} ${PROJECT_SOURCE_DIR}/dependencies)
+    set(ENV{PATH} "$ENV{PATH};${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/include")
+    set(ENV{LIB} ${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib)
+    set(ENV{OPENALDIR} ${PROJECT_SOURCE_DIR}/${DEPENDENCIES})
     add_definitions(-D_IRR_STATIC_LIB_)
     add_definitions(-DNO_IRR_COMPILE_WITH_X11_)
 endif()
 
 if(USE_GLES2)
     add_definitions(-DUSE_GLES2)
+    add_definitions(-D_IRR_COMPILE_WITH_OGLES2_ -DNO_IRR_COMPILE_WITH_OPENGL_)
 endif()
 
 if(SERVER_ONLY)
@@ -78,9 +86,9 @@ if(SERVER_ONLY)
     add_definitions(-DNO_IRR_COMPILE_WITH_X11_)
 endif()
 
-if(DISABLE_VPX)
-    add_definitions(-DNO_VPX)
-endif()
+#if(DISABLE_VPX)
+#    add_definitions(-DNO_VPX)
+#endif()
 
 # Build the Bullet physics library
 add_subdirectory("${PROJECT_SOURCE_DIR}/lib/bullet")
@@ -352,7 +360,7 @@ else()
     elseif(MINGW)
         set(PTHREAD_NAMES "winpthread-1" "libwinpthread-1" "pthreadGC2")
     endif()
-    find_library(PTHREAD_LIBRARY NAMES pthread ${PTHREAD_NAMES} PATHS ${PROJECT_SOURCE_DIR}/dependencies/lib)
+    find_library(PTHREAD_LIBRARY NAMES pthread ${PTHREAD_NAMES} PATHS ${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib)
     mark_as_advanced(PTHREAD_LIBRARY)
 
     # Set data dir (absolute or relative to CMAKE_INSTALL_PREFIX)
@@ -374,9 +382,9 @@ endif()
 
 # CURL
 if(MSVC)
-    target_link_libraries(supertuxkart ${PROJECT_SOURCE_DIR}/dependencies/lib/libcurl.lib)
+    target_link_libraries(supertuxkart ${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib/libcurl.lib)
 elseif(MINGW)
-    target_link_libraries(supertuxkart ${PROJECT_SOURCE_DIR}/dependencies/lib/libcurldll.a)
+    target_link_libraries(supertuxkart ${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib/libcurldll.a)
 else()
     find_package(CURL REQUIRED)
     include_directories(${CURL_INCLUDE_DIRS})
@@ -396,7 +404,7 @@ target_link_libraries(supertuxkart
     ${FREETYPE_LIBRARIES}
     ${JPEG_LIBRARIES}
     ${TURBOJPEG_LIBRARY}
-    ${VPX_LIBRARIES}
+    #${VPX_LIBRARIES}
     )
 
 if(NOT SERVER_ONLY)
@@ -451,7 +459,7 @@ if(USE_WIIUSE)
         if(WIIUSE_BUILD)
             target_link_libraries(supertuxkart wiiuse)
         else()
-            target_link_libraries(supertuxkart ${PROJECT_SOURCE_DIR}/dependencies/lib/wiiuse.lib)
+            target_link_libraries(supertuxkart ${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib/wiiuse.lib)
         endif()
     else()
         target_link_libraries(supertuxkart wiiuse bluetooth)
@@ -464,7 +472,7 @@ if(MSVC OR MINGW)
   target_link_libraries(supertuxkart iphlpapi.lib)
   add_custom_command(TARGET supertuxkart POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_directory
-        "${PROJECT_SOURCE_DIR}/dependencies/dll"
+        "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/dll"
         $<TARGET_FILE_DIR:supertuxkart>)
   add_custom_target(stkshaders SOURCES ${STK_SHADERS})
 endif()
diff --git a/README.md b/README.md
index 03804f03c..8f50b2fd0 100644
--- a/README.md
+++ b/README.md
@@ -109,7 +109,7 @@ To Build SuperTuxKart on Windows, follow these instructions:
 2. Download the SuperTuxKart source package from either [SuperTuxKart download area - SourceForge.net](https://sourceforge.net/projects/supertuxkart/files/SuperTuxKart/0.9.2) or [SuperTuxKart.net - Source Control](https://supertuxkart.net/Source_control), and unpack it. 
 *Note: If you downloaded the source package from here: [SuperTuxKart.net - Source Control](https://supertuxkart.net/Source_control), then both `stk-code` and `stk-assets` **must** be in the same directory, otherwise the build can result in failure*
 3. Download the Windows dependencies package from either [SuperTuxKart download area: Dependecies - SourceForge.net](https://sourceforge.net/projects/supertuxkart/files/SuperTuxKart%20Dependencies/Windows/)
-or [SuperTuxKart on GitHub - Dependencies](https://github.com/supertuxkart/dependencies), and unpack it; then, copy the `dependencies` directory from either the `windows` or the `windows_64bit` directories into the `stk-code` directory
+or [SuperTuxKart on GitHub - Dependencies](https://github.com/supertuxkart/dependencies), and unpack it; then, copy the `dependencies` directory from either the `windows` or the `windows_64bit` directories into the `stk-code` directory, rename it to `dependencies-64bit` if you want to compile a 64bit build.
 4. Download CMake from here: [CMake - download page](https://cmake.org/download/), install it; once CMake is installed, double click on the CMake icon on your desktop, and point it towards your `stk-code` directory in the 'Where is the source code' field, and point it to a directory called `build` or `bld` inside the stk-code directory.
 5. Press 'Configure'; CMake will ask you if it is OK to create the aformentioned directory, press `Yes`. CMake will then ask you about your version of Visual Studio. 
 Confirm your selection; *Please look at the table below to avoid confusion between version numbers and releases of Visual Studio*;
diff --git a/android/generate_assets.sh b/android/generate_assets.sh
index d3b61a5c4..e759724d7 100755
--- a/android/generate_assets.sh
+++ b/android/generate_assets.sh
@@ -20,10 +20,11 @@
 ################################################################################
 
 export KARTS="all"
-export TRACKS="battleisland cornfield_crossing featunlocked gplose gpwin   \
-               hacienda introcutscene introcutscene2 lighthouse olivermath \
-               overworld sandtrack scotland snowmountain snowtuxpeak       \
-               soccer_field tutorial"
+export TRACKS="abyss battleisland cave cornfield_crossing endcutscene        \
+               featunlocked fortmagma gplose gpwin hacienda icy_soccer_field \
+               introcutscene introcutscene2 lighthouse mines olivermath      \
+               overworld sandtrack scotland snowmountain snowtuxpeak         \
+               soccer_field stadium tutorial zengarden"
 
 export ASSETS_PATHS="../data                    \
                      ../../stk-assets           \
diff --git a/android/make.sh b/android/make.sh
index 401c3aefc..95a905d3d 100755
--- a/android/make.sh
+++ b/android/make.sh
@@ -342,6 +342,10 @@ check_error
 # Build apk
 echo "Building APK"
 
+sed -i "s/minSdkVersion=\".*\"/minSdkVersion=\"$SDK_VERSION\"/g" \
+       "$DIRNAME/AndroidManifest.xml"
+
+
 if [ "$BUILD_TOOL" = "gradle" ]; then
     export ANDROID_HOME="$SDK_PATH"
     gradle -Psdk_version=$SDK_VERSION           \
diff --git a/cmake/FindFreetype.cmake b/cmake/FindFreetype.cmake
index 7d27a2102..3e15de92e 100644
--- a/cmake/FindFreetype.cmake
+++ b/cmake/FindFreetype.cmake
@@ -10,8 +10,8 @@
 #     Freetype library list
 
 if(WIN32)
-    find_path(FREETYPE_INCLUDE_DIRS NAMES freetype/freetype.h PATHS "${PROJECT_SOURCE_DIR}/dependencies/include")
-    find_library(FREETYPE_LIBRARY NAMES freetype PATHS "${PROJECT_SOURCE_DIR}/dependencies/lib")
+    find_path(FREETYPE_INCLUDE_DIRS NAMES freetype/freetype.h PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/include")
+    find_library(FREETYPE_LIBRARY NAMES freetype PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib")
     set(FREETYPE_FOUND 1)
     set(FREETYPE_LIBRARIES ${FREETYPE_LIBRARY})
 elseif(APPLE)
diff --git a/cmake/FindFribidi.cmake b/cmake/FindFribidi.cmake
index 5d772f041..c31f4bfe3 100644
--- a/cmake/FindFribidi.cmake
+++ b/cmake/FindFribidi.cmake
@@ -24,8 +24,8 @@ else()
 endif()
 
 if(NOT FRIBIDI_FOUND)
-    find_path(FRIBIDI_INCLUDE_DIR NAMES fribidi/fribidi.h PATHS /Library/Frameworks/fribidi.framework/Headers "${PROJECT_SOURCE_DIR}/dependencies/include")
-    find_library(FRIBIDI_LIBRARY NAMES fribidi PATHS /Library/Frameworks/fribidi.framework "${PROJECT_SOURCE_DIR}/dependencies/lib")
+    find_path(FRIBIDI_INCLUDE_DIR NAMES fribidi/fribidi.h PATHS /Library/Frameworks/fribidi.framework/Headers "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/include")
+    find_library(FRIBIDI_LIBRARY NAMES fribidi PATHS /Library/Frameworks/fribidi.framework "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib")
 
     include(FindPackageHandleStandardArgs)
     find_package_handle_standard_args(Fribidi DEFAULT_MSG FRIBIDI_INCLUDE_DIR FRIBIDI_LIBRARY)
diff --git a/cmake/FindOggVorbis.cmake b/cmake/FindOggVorbis.cmake
index 387861c42..7f16d7e66 100644
--- a/cmake/FindOggVorbis.cmake
+++ b/cmake/FindOggVorbis.cmake
@@ -10,12 +10,12 @@
 #     OggVorbis library list
 
 
-find_path(OGGVORBIS_OGG_INCLUDE_DIR NAMES ogg/ogg.h PATHS "${PROJECT_SOURCE_DIR}/dependencies/include")
-find_path(OGGVORBIS_VORBIS_INCLUDE_DIR NAMES vorbis/vorbisfile.h PATHS "${PROJECT_SOURCE_DIR}/dependencies/include")
-find_library(OGGVORBIS_OGG_LIBRARY NAMES ogg Ogg libogg PATHS "${PROJECT_SOURCE_DIR}/dependencies/lib")
-find_library(OGGVORBIS_VORBIS_LIBRARY NAMES vorbis Vorbis libvorbis PATHS "${PROJECT_SOURCE_DIR}/dependencies/lib")
-find_library(OGGVORBIS_VORBISFILE_LIBRARY NAMES vorbisfile libvorbisfile PATHS "${PROJECT_SOURCE_DIR}/dependencies/lib")
-find_library(OGGVORBIS_VORBISENC_LIBRARY NAMES vorbisenc libvorbisenc PATHS "${PROJECT_SOURCE_DIR}/dependencies/lib")
+find_path(OGGVORBIS_OGG_INCLUDE_DIR NAMES ogg/ogg.h PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/include")
+find_path(OGGVORBIS_VORBIS_INCLUDE_DIR NAMES vorbis/vorbisfile.h PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/include")
+find_library(OGGVORBIS_OGG_LIBRARY NAMES ogg Ogg libogg PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib")
+find_library(OGGVORBIS_VORBIS_LIBRARY NAMES vorbis Vorbis libvorbis PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib")
+find_library(OGGVORBIS_VORBISFILE_LIBRARY NAMES vorbisfile libvorbisfile PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib")
+find_library(OGGVORBIS_VORBISENC_LIBRARY NAMES vorbisenc libvorbisenc PATHS "${PROJECT_SOURCE_DIR}/${DEPENDENCIES}/lib")
 
 if (APPLE)
     set(OGGVORBIS_OGG_INCLUDE_DIR "/Library/Frameworks/Ogg.framework/Headers/")
diff --git a/data/gfx/explosion_low.xml b/data/gfx/explosion_low.xml
new file mode 100644
index 000000000..d534eb557
--- /dev/null
+++ b/data/gfx/explosion_low.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<particles emitter="sphere" radius="0.1">
+
+    <spreading angle="180"         />
+    
+    <velocity  x="0.000"
+               y="0.0035"
+               z="0.000"           />
+    
+    <material  file="explode.png"  />
+    
+    <!-- Amount of particles emitted per second -->
+    <rate      min="100"
+               max="150" />
+    
+    <!-- Minimal and maximal lifetime of a particle, in milliseconds. -->
+    <lifetime  min="700"
+               max="900"         />
+    
+    <!-- Size of the particles -->
+    <size      min="0.8"
+               max="1.0"
+               x-increase-factor="0.6"
+               y-increase-factor="0.6"
+               />
+    
+    <color     min="255 255 255"
+               max="255 255 255"  />
+
+</particles>
diff --git a/data/graphical_restrictions.xml b/data/graphical_restrictions.xml
index b0ecf177d..596fd1d5a 100644
--- a/data/graphical_restrictions.xml
+++ b/data/graphical_restrictions.xml
@@ -38,4 +38,5 @@
   <card contains="Adreno"         os="android"  version="<=19"     disable="VertexIdWorking"/>
   <card contains="Android Emulator" os="android"                   disable="ForceLegacyDevice"/>
   <card                           os="android"                     disable="UniformBufferObject"/>
+  <card vendor="Broadcom"         os="linux"                       disable="HighDefinitionTextures256"/>
 </graphical-restrictions>
diff --git a/data/shaders/alphatest_particle.vert b/data/shaders/alphatest_particle.vert
index 420e40ec7..2cdd479ab 100644
--- a/data/shaders/alphatest_particle.vert
+++ b/data/shaders/alphatest_particle.vert
@@ -36,12 +36,13 @@ void main(void)
     }
 
     float lifetime = color_lifetime.w;
-    pc = vec4(color_lifetime.zyx, 1.0);
+    vec4 particle_color = vec4(color_lifetime.zyx, 1.0);
     tc = Texcoord;
 
 #if !defined(sRGB_Framebuffer_Usable) && !defined(Advanced_Lighting_Enabled)
-    pc.rgb = pow(pc.rgb, vec3(1.0 / 2.2));
+    particle_color.rgb = pow(particle_color.rgb, vec3(1.0 / 2.2));
 #endif
+    pc = particle_color;
 
     vec4 viewpos = vec4(0.);
     if (flips == 1)
diff --git a/data/shaders/header.txt b/data/shaders/header.txt
index c5d5326b7..158a55612 100644
--- a/data/shaders/header.txt
+++ b/data/shaders/header.txt
@@ -64,10 +64,12 @@ layout (std140) uniform LightingData
     float rL22;
 };
 
-layout (std140) uniform SkinningData
+#ifdef SSBO_SKINNING
+layout (std140, binding = 0) readonly buffer SkinningData
 {
     mat4 joint_matrices[MAX_BONES];
 };
+#endif
 
 #endif
 #endif // HEADER_TXT
diff --git a/data/shaders/instanced_objectref_pass2.frag b/data/shaders/instanced_objectref_pass2.frag
index c2b3cd5e7..9fd9588c4 100644
--- a/data/shaders/instanced_objectref_pass2.frag
+++ b/data/shaders/instanced_objectref_pass2.frag
@@ -22,6 +22,7 @@ void main(void)
 #ifdef Use_Bindless_Texture
     vec4 col = texture(handle, uv);
     float specmap = texture(secondhandle, uv).g;
+    float emitmap = texture(secondhandle, uv).b;
     float mask = texture(thirdhandle, uv).a;
 #ifdef SRGBBindlessFix
     col.xyz = pow(col.xyz, vec3(2.2));
diff --git a/data/shaders/instanced_skinning.vert b/data/shaders/instanced_skinning.vert
index 607bfc4f9..ee4d12638 100644
--- a/data/shaders/instanced_skinning.vert
+++ b/data/shaders/instanced_skinning.vert
@@ -49,6 +49,8 @@ flat out sampler2D fourthhandle;
 
 #stk_include "utils/getworldmatrix.vert"
 
+uniform samplerBuffer skinning_tex;
+
 void main(void)
 {
     mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale);
@@ -61,18 +63,35 @@ void main(void)
     vec4 skinned_normal = vec4(0.);
     vec4 skinned_tangent = vec4(0.);
     vec4 skinned_bitangent = vec4(0.);
-    // Note : For normal we assume no scale factor in bone (otherwise we'll have to compute inversematrix for each bones...)
-    for (int i = 0; i < 4; i++)
+    if (Weight[0] < 0.01)
     {
-        vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
-        single_bone_influenced_position /= single_bone_influenced_position.w;
-        vec4 single_bone_influenced_normal = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_normal;
-        vec4 single_bone_influenced_tangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_tangent;
-        vec4 single_bone_influenced_bitangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_bitangent;
-        skinned_position += Weight[i] * single_bone_influenced_position;
-        skinned_normal += Weight[i] * single_bone_influenced_normal;
-        skinned_tangent += Weight[i] * single_bone_influenced_tangent;
-        skinned_bitangent += Weight[i] * single_bone_influenced_bitangent;
+        skinned_position = idle_position;
+        skinned_normal = idle_normal;
+        skinned_tangent = idle_tangent;
+        skinned_bitangent = idle_bitangent;
+    }
+    else
+    {
+        for (int i = 0; i < 4; i++)
+        {
+            if (Weight[i] < 0.01)
+            {
+                break;
+            }
+#ifdef SSBO_SKINNING
+            mat4 joint_matrix = joint_matrices[Joint[i] + skinning_offset];
+#else
+            mat4 joint_matrix = mat4(
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
+#endif
+            skinned_position += Weight[i] * joint_matrix * idle_position;
+            skinned_normal += Weight[i] * joint_matrix * idle_normal;
+            skinned_tangent += Weight[i] * joint_matrix * idle_tangent;
+            skinned_bitangent += Weight[i] * joint_matrix * idle_bitangent;
+        }
     }
 
     gl_Position = ProjectionViewMatrix *  ModelMatrix * skinned_position;
diff --git a/data/shaders/instanced_skinning_shadow.vert b/data/shaders/instanced_skinning_shadow.vert
index 7f72e56fb..2fc326218 100644
--- a/data/shaders/instanced_skinning_shadow.vert
+++ b/data/shaders/instanced_skinning_shadow.vert
@@ -38,16 +38,36 @@ flat out uvec2 hdle;
 
 #stk_include "utils/getworldmatrix.vert"
 
+uniform samplerBuffer skinning_tex;
+
 void main(void)
 {
     mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale);
     vec4 idle_position = vec4(Position, 1.);
     vec4 skinned_position = vec4(0.);
-    for (int i = 0; i < 4; i++)
+    if (Weight[0] < 0.01)
     {
-        vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
-        single_bone_influenced_position /= single_bone_influenced_position.w;
-        skinned_position += Weight[i] * single_bone_influenced_position;
+        skinned_position = idle_position;
+    }
+    else
+    {
+        for (int i = 0; i < 4; i++)
+        {
+            if (Weight[i] < 0.01)
+            {
+                break;
+            }
+#ifdef SSBO_SKINNING
+            mat4 joint_matrix = joint_matrices[Joint[i] + skinning_offset];
+#else
+            mat4 joint_matrix = mat4(
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
+#endif
+            skinned_position += Weight[i] * joint_matrix * idle_position;
+        }
     }
 
 #ifdef VSLayer
diff --git a/data/shaders/simple_particle.vert b/data/shaders/simple_particle.vert
index 3f993b955..41cf4ca58 100644
--- a/data/shaders/simple_particle.vert
+++ b/data/shaders/simple_particle.vert
@@ -41,12 +41,13 @@ void main(void)
     float lifetime = color_lifetime.w;
     float alpha = mix(smoothstep(1.0, 0.8, lifetime), lifetime, billboard);
     billboard_mix = billboard;
-    pc = vec4(color_lifetime.zyx, 1.0) * alpha;
+    vec4 particle_color = vec4(color_lifetime.zyx, 1.0) * alpha;
     tc = Texcoord;
 
 #if !defined(sRGB_Framebuffer_Usable) && !defined(Advanced_Lighting_Enabled)
-    pc.rgb = pow(pc.rgb, vec3(1.0 / 2.2));
+    particle_color.rgb = pow(particle_color.rgb, vec3(1.0 / 2.2));
 #endif
+    pc = particle_color;
 
     vec4 viewpos = vec4(0.);
     if (flips == 1)
diff --git a/data/shaders/skinning.vert b/data/shaders/skinning.vert
index 192f4247f..d1496f4f8 100644
--- a/data/shaders/skinning.vert
+++ b/data/shaders/skinning.vert
@@ -17,6 +17,11 @@ uniform mat4 InverseModelMatrix =
 uniform vec2 texture_trans = vec2(0., 0.);
 #endif
 uniform int skinning_offset;
+#ifdef GL_ES
+uniform sampler2D skinning_tex;
+#else
+uniform samplerBuffer skinning_tex;
+#endif
 
 #ifdef Explicit_Attrib_Location_Usable
 layout(location = 0) in vec3 Position;
@@ -55,18 +60,41 @@ void main(void)
     vec4 skinned_normal = vec4(0.);
     vec4 skinned_tangent = vec4(0.);
     vec4 skinned_bitangent = vec4(0.);
-    // Note : For normal we assume no scale factor in bone (otherwise we'll have to compute inversematrix for each bones...)
-    for (int i = 0; i < 4; i++)
+    if (Weight[0] < 0.01)
     {
-        vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
-        single_bone_influenced_position /= single_bone_influenced_position.w;
-        vec4 single_bone_influenced_normal = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_normal;
-        vec4 single_bone_influenced_tangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_tangent;
-        vec4 single_bone_influenced_bitangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_bitangent;
-        skinned_position += Weight[i] * single_bone_influenced_position;
-        skinned_normal += Weight[i] * single_bone_influenced_normal;
-        skinned_tangent += Weight[i] * single_bone_influenced_tangent;
-        skinned_bitangent += Weight[i] * single_bone_influenced_bitangent;
+        skinned_position = idle_position;
+        skinned_normal = idle_normal;
+        skinned_tangent = idle_tangent;
+        skinned_bitangent = idle_bitangent;
+    }
+    else
+    {
+        for (int i = 0; i < 4; i++)
+        {
+            if (Weight[i] < 0.01)
+            {
+                break;
+            }
+#ifdef SSBO_SKINNING
+            mat4 joint_matrix = joint_matrices[Joint[i] + skinning_offset];
+#elif defined(GL_ES)
+            mat4 joint_matrix = mat4(
+                texelFetch(skinning_tex, ivec2(0, skinning_offset + Joint[i]), 0),
+                texelFetch(skinning_tex, ivec2(1, skinning_offset + Joint[i]), 0),
+                texelFetch(skinning_tex, ivec2(2, skinning_offset + Joint[i]), 0),
+                texelFetch(skinning_tex, ivec2(3, skinning_offset + Joint[i]), 0));
+#else
+            mat4 joint_matrix = mat4(
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
+#endif
+            skinned_position += Weight[i] * joint_matrix * idle_position;
+            skinned_normal += Weight[i] * joint_matrix * idle_normal;
+            skinned_tangent += Weight[i] * joint_matrix * idle_tangent;
+            skinned_bitangent += Weight[i] * joint_matrix * idle_bitangent;
+        }
     }
 
     gl_Position = ProjectionViewMatrix * ModelMatrix * skinned_position;
diff --git a/data/shaders/skinning_shadow.vert b/data/shaders/skinning_shadow.vert
index eca18ec1a..71af0b9ae 100644
--- a/data/shaders/skinning_shadow.vert
+++ b/data/shaders/skinning_shadow.vert
@@ -1,6 +1,7 @@
 uniform mat4 ModelMatrix;
 uniform int skinning_offset;
 uniform int layer;
+uniform samplerBuffer skinning_tex;
 
 #ifdef Explicit_Attrib_Location_Usable
 layout(location = 0) in vec3 Position;
@@ -25,11 +26,35 @@ void main(void)
 {
     vec4 idle_position = vec4(Position, 1.);
     vec4 skinned_position = vec4(0.);
-    for (int i = 0; i < 4; i++)
+    if (Weight[0] < 0.01)
     {
-        vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
-        single_bone_influenced_position /= single_bone_influenced_position.w;
-        skinned_position += Weight[i] * single_bone_influenced_position;
+        skinned_position = idle_position;
+    }
+    else
+    {
+        for (int i = 0; i < 4; i++)
+        {
+            if (Weight[i] < 0.01)
+            {
+                break;
+            }
+#ifdef SSBO_SKINNING
+            mat4 joint_matrix = joint_matrices[Joint[i] + skinning_offset];
+#elif defined(GL_ES)
+            mat4 joint_matrix = mat4(
+                texelFetch(skinning_tex, ivec2(0, skinning_offset + Joint[i]), 0),
+                texelFetch(skinning_tex, ivec2(1, skinning_offset + Joint[i]), 0),
+                texelFetch(skinning_tex, ivec2(2, skinning_offset + Joint[i]), 0),
+                texelFetch(skinning_tex, ivec2(3, skinning_offset + Joint[i]), 0));
+#else
+            mat4 joint_matrix = mat4(
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
+                texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
+#endif
+            skinned_position += Weight[i] * joint_matrix * idle_position;
+        }
     }
 
 #ifdef VSLayer
diff --git a/data/stk_config.xml b/data/stk_config.xml
index fb73a6b6f..fdfa07ca9 100644
--- a/data/stk_config.xml
+++ b/data/stk_config.xml
@@ -461,4 +461,10 @@
   <fonts-list normal-ttf="Cantarell-Regular.otf FreeSans.ttf wqy-microhei.ttf NotoNaskhArabicUI-Bold.ttf"
               digit-ttf="SigmarOne.otf" />
 
+  <!-- Maximum bones from all animated meshes in each frame to be uploaded for
+       hardware skinning, For gles 3.0 the specification guarantees at least 2048, for
+       TBO in desktop at least 65536 (max buffer size) / 64, SSBO at least 2^24 / 64,
+       so 1024 will work everywhere. -->
+  <skinning max-bones="1024"/>
+
 </config>
diff --git a/lib/bullet/src/LinearMath/btSerializer.h b/lib/bullet/src/LinearMath/btSerializer.h
index 689449a73..0b2dc1087 100644
--- a/lib/bullet/src/LinearMath/btSerializer.h
+++ b/lib/bullet/src/LinearMath/btSerializer.h
@@ -213,7 +213,7 @@ protected:
 
 			int *intPtr=0;
 			short *shtPtr=0;
-#ifdef __MINGW64__
+#if defined(__MINGW64__) || defined(_WIN64) 
 			char *cp = 0;int dataLen =0;intptr_t nr=0;
 #else
 			char *cp = 0;int dataLen =0;long nr=0;
@@ -251,7 +251,7 @@ protected:
 				cp++;
 			}
 			{
-#ifdef __MINGW64__
+#if defined(__MINGW64__) || defined(_WIN64)
 				nr= (intptr_t)cp;
 #else
 				nr= (long)cp;
@@ -290,7 +290,7 @@ protected:
 			}
 
 		{
-#ifdef __MINGW64__
+#if defined(__MINGW64__) || defined(_WIN64)
 				nr= (intptr_t)cp;
 #else
 				nr= (long)cp;
diff --git a/lib/irrlicht/include/S3DVertex.h b/lib/irrlicht/include/S3DVertex.h
index 3d12edde6..ce3fe91a0 100644
--- a/lib/irrlicht/include/S3DVertex.h
+++ b/lib/irrlicht/include/S3DVertex.h
@@ -255,14 +255,8 @@ struct S3DVertexTangents : public S3DVertex
 
 struct S3DVertexSkinnedMesh : public S3DVertexTangents
 {
-	s32 m_joint_idx1;
-	s32 m_joint_idx2;
-	s32 m_joint_idx3;
-	s32 m_joint_idx4;
-	f32 m_weight1;
-	f32 m_weight2;
-	f32 m_weight3;
-	f32 m_weight4;
+	s16 m_joint_idx[4];
+	s16 m_weight[4];
 
 	E_VERTEX_TYPE getType() const
 	{
diff --git a/lib/irrlicht/include/SSkinMeshBuffer.h b/lib/irrlicht/include/SSkinMeshBuffer.h
index c12a2aa43..659d5a186 100644
--- a/lib/irrlicht/include/SSkinMeshBuffer.h
+++ b/lib/irrlicht/include/SSkinMeshBuffer.h
@@ -243,14 +243,14 @@ struct SSkinMeshBuffer : public IMeshBuffer
 				Vertex.TCoords=Vertices_Standard[n].TCoords;
 				Vertex.Tangent=core::vector3df(0.0f, 0.0f, 0.0f);
 				Vertex.Binormal=core::vector3df(0.0f, 0.0f, 0.0f);
-				Vertex.m_joint_idx1 = 0;
-				Vertex.m_joint_idx2 = 0;
-				Vertex.m_joint_idx3 = 0;
-				Vertex.m_joint_idx4 = 0;
-				Vertex.m_weight1 = 0;
-				Vertex.m_weight2 = 0;
-				Vertex.m_weight3 = 0;
-				Vertex.m_weight4 = 0;
+				Vertex.m_joint_idx[0] = 0;
+				Vertex.m_joint_idx[1] = 0;
+				Vertex.m_joint_idx[2] = 0;
+				Vertex.m_joint_idx[3] = 0;
+				Vertex.m_weight[0] = 0;
+				Vertex.m_weight[1] = 0;
+				Vertex.m_weight[2] = 0;
+				Vertex.m_weight[3] = 0;
 				Vertices_SkinnedMesh.push_back(Vertex);
 			}
 		}
@@ -265,14 +265,14 @@ struct SSkinMeshBuffer : public IMeshBuffer
 				Vertex.TCoords=Vertices_Tangents[n].TCoords;
 				Vertex.Tangent=Vertices_Tangents[n].Tangent;
 				Vertex.Binormal=Vertices_Tangents[n].Binormal;
-				Vertex.m_joint_idx1 = 0;
-				Vertex.m_joint_idx2 = 0;
-				Vertex.m_joint_idx3 = 0;
-				Vertex.m_joint_idx4 = 0;
-				Vertex.m_weight1 = 0;
-				Vertex.m_weight2 = 0;
-				Vertex.m_weight3 = 0;
-				Vertex.m_weight4 = 0;
+				Vertex.m_joint_idx[0] = 0;
+				Vertex.m_joint_idx[1] = 0;
+				Vertex.m_joint_idx[2] = 0;
+				Vertex.m_joint_idx[3] = 0;
+				Vertex.m_weight[0] = 0;
+				Vertex.m_weight[1] = 0;
+				Vertex.m_weight[2] = 0;
+				Vertex.m_weight[3] = 0;
 				Vertices_SkinnedMesh.push_back(Vertex);
 			}
 		}
diff --git a/lib/irrlicht/source/Irrlicht/CAnimatedMeshSceneNode.cpp b/lib/irrlicht/source/Irrlicht/CAnimatedMeshSceneNode.cpp
index 030b107e2..52c9b5636 100644
--- a/lib/irrlicht/source/Irrlicht/CAnimatedMeshSceneNode.cpp
+++ b/lib/irrlicht/source/Irrlicht/CAnimatedMeshSceneNode.cpp
@@ -101,12 +101,12 @@ void CAnimatedMeshSceneNode::buildFrameNr(u32 timeMs)
 		if (FramesPerSecond > 0.f) //forwards...
 		{
 			if (CurrentFrameNr > EndFrame)
-				CurrentFrameNr = StartFrame + fmod(CurrentFrameNr - StartFrame, (f32)(EndFrame-StartFrame));
+				CurrentFrameNr = StartFrame + fmodf(CurrentFrameNr - StartFrame, (f32)(EndFrame-StartFrame));
 		}
 		else //backwards...
 		{
 			if (CurrentFrameNr < StartFrame)
-				CurrentFrameNr = EndFrame - fmod(EndFrame - CurrentFrameNr, (f32)(EndFrame-StartFrame));
+				CurrentFrameNr = EndFrame - fmodf(EndFrame - CurrentFrameNr, (f32)(EndFrame-StartFrame));
 		}
 	}
 	else
diff --git a/lib/irrlicht/source/Irrlicht/CSkinnedMesh.cpp b/lib/irrlicht/source/Irrlicht/CSkinnedMesh.cpp
index 411ba1077..4144d5b9e 100644
--- a/lib/irrlicht/source/Irrlicht/CSkinnedMesh.cpp
+++ b/lib/irrlicht/source/Irrlicht/CSkinnedMesh.cpp
@@ -11,6 +11,55 @@
 #include "os.h"
 #include "irrMap.h"
 
+inline irr::s16 float_16(irr::f32 in)
+{
+	irr::s32 i;
+	memcpy(&i, &in, 4);
+	irr::s32 s = (i >> 16) & 0x00008000;
+	irr::s32 e = ((i >> 23) & 0x000000ff) - (127 - 15);
+	irr::s32 m = i & 0x007fffff;
+	if (e <= 0)
+	{
+		if (e < -10)
+		{
+			return irr::s16(s);
+		}
+		m = (m | 0x00800000) >> (1 - e);
+		if (m & 0x00001000)
+			m += 0x00002000;
+		return irr::s16(s | (m >> 13));
+	}
+	else if (e == 0xff - (127 - 15))
+	{
+		if (m == 0)
+		{
+			return irr::s16(s | 0x7c00);
+		}
+		else
+		{
+			m >>= 13;
+			return irr::s16(s | 0x7c00 | m | (m == 0));
+		}
+	}
+	else
+	{
+		if (m &  0x00001000)
+		{
+			m += 0x00002000;
+			if (m & 0x00800000)
+			{
+				m =  0;     // overflow in significand,
+				e += 1;     // adjust exponent
+			}
+		}
+		if (e > 30)
+		{
+            return irr::s16(s | 0x7c00);
+		}
+		return irr::s16(s | (e << 10) | (m >> 13));
+	}
+}
+
 namespace irr
 {
 namespace scene
@@ -1450,28 +1499,34 @@ void CSkinnedMesh::convertForSkinning()
 				core::array<JointInfluence> this_influence;
 				core::array<JointInfluence> reported_weight = wi[b][i];
 				reported_weight.sort(sortJointInfluenceFunc);
-				float remaining_weight = 1.0f;
 				for (u32 j = 0; j < 4; j++)
 				{
 					JointInfluence influence;
-					if (reported_weight.size() > j)
-						influence = reported_weight[j];
-					else
-					{
-						influence.joint_idx = -100000;
-						influence.weight = remaining_weight;
-					}
-					remaining_weight -= influence.weight;
+					influence.joint_idx = -100000;
+					influence.weight = 0.0f;
 					this_influence.push_back(influence);
 				}
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx1 = this_influence[0].joint_idx;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx2 = this_influence[1].joint_idx;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx3 = this_influence[2].joint_idx;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx4 = this_influence[3].joint_idx;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight1 = this_influence[0].weight;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight2 = this_influence[1].weight;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight3 = this_influence[2].weight;
-				LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight4 = this_influence[3].weight;
+				float total_weight = 0.0f;
+				for (u32 j = 0; j < reported_weight.size(); j++)
+				{
+					total_weight += reported_weight[j].weight;
+					this_influence[j].joint_idx = reported_weight[j].joint_idx;
+					this_influence[j].weight = reported_weight[j].weight;
+				}
+				if (!reported_weight.empty())
+				{
+					for (u32 j = 0; j < reported_weight.size(); j++)
+					{
+						this_influence[j].weight =
+							this_influence[j].weight / total_weight;
+					}
+				}
+				for (int j = 0; j < 4; j++)
+				{
+					LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx[j] = (s16)this_influence[j].joint_idx;
+					LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight[j] = float_16
+						(this_influence[j].weight);
+				}
 			}
 		}
 	}
@@ -1488,7 +1543,7 @@ void CSkinnedMesh::computeWeightInfluence(SJoint *joint, size_t &index, WeightIn
 		{
 			SWeight& weight = joint->Weights[i];
 			JointInfluence tmp;
-			tmp.joint_idx = index;
+			tmp.joint_idx = (int)index;
 			tmp.weight = weight.strength;
 			wi[weight.buffer_id][weight.vertex_id].push_back(tmp);
 		}
diff --git a/src/audio/sfx_manager.cpp b/src/audio/sfx_manager.cpp
index 9cecda9dc..a49eae713 100644
--- a/src/audio/sfx_manager.cpp
+++ b/src/audio/sfx_manager.cpp
@@ -529,7 +529,7 @@ void SFXManager::loadSfx()
     delete root;
 
     // Now load them in parallel
-    const int max = m_all_sfx_types.size();
+    const int max = (int)m_all_sfx_types.size();
     SFXBuffer **array = new SFXBuffer *[max];
     i = 0;
 
diff --git a/src/config/saved_grand_prix.cpp b/src/config/saved_grand_prix.cpp
index 5ee5b5371..7a2d5cbad 100644
--- a/src/config/saved_grand_prix.cpp
+++ b/src/config/saved_grand_prix.cpp
@@ -172,7 +172,7 @@ void SavedGrandPrix::loadKarts(std::vector<RaceManager::KartStatus> & kart_list)
         else
         {
             // Get correct player
-            for(unsigned int x = kart_list.size()-m_player_karts;
+            for(unsigned int x = (unsigned int)kart_list.size()-m_player_karts;
                 x < kart_list.size(); x++)
             {
                 if(kart_list[x].m_local_player_id == m_karts[i].m_local_player_id)
diff --git a/src/config/stk_config.cpp b/src/config/stk_config.cpp
index add75014f..5bb1a5c1c 100644
--- a/src/config/stk_config.cpp
+++ b/src/config/stk_config.cpp
@@ -181,6 +181,7 @@ void STKConfig::init_defaults()
     m_disable_steer_while_unskid = false;
     m_camera_follow_skid         = false;
     m_cutscene_fov               = 0.61f;
+    m_max_skinning_bones         = 1024;
 
     m_score_increase.clear();
     m_leader_intervals.clear();
@@ -364,6 +365,11 @@ void STKConfig::getAllData(const XMLNode * root)
         fonts_list->get("digit-ttf",  &m_digit_ttf );
     }
 
+    if (const XMLNode *skinning = root->getNode("skinning"))
+    {
+        skinning->get("max-bones", &m_max_skinning_bones);
+    }
+
     // Get the default KartProperties
     // ------------------------------
     const XMLNode *node = root -> getNode("general-kart-defaults");
diff --git a/src/config/stk_config.hpp b/src/config/stk_config.hpp
index b29d91891..761c8b56d 100644
--- a/src/config/stk_config.hpp
+++ b/src/config/stk_config.hpp
@@ -152,6 +152,8 @@ public:
 
     float m_cutscene_fov;
 
+    unsigned m_max_skinning_bones;
+
     /** Lists of TTF files used in STK. */
     std::vector<std::string> m_normal_ttf;
     std::vector<std::string> m_digit_ttf;
diff --git a/src/config/user_config.cpp b/src/config/user_config.cpp
index 95f013d91..c4aa910ab 100644
--- a/src/config/user_config.cpp
+++ b/src/config/user_config.cpp
@@ -122,7 +122,7 @@ void GroupUserConfigParam::writeInner(std::ofstream& stream, int level) const
 {
     std::string tab(level * 4,' ');
     for(int i = 0; i < level; i++) tab =+ "    ";
-    const int children_amount = m_attributes.size();
+    const int  children_amount = (int)m_attributes.size();
 
     stream << "    " << tab.c_str() << "<" << m_param_name.c_str() << "\n";
 
@@ -144,7 +144,7 @@ void GroupUserConfigParam::findYourDataInAChildOf(const XMLNode* node)
         return;
     }
 
-    const int attributes_amount = m_attributes.size();
+    const int attributes_amount = (int)m_attributes.size();
     for (int n=0; n<attributes_amount; n++)
     {
         m_attributes[n]->findYourDataInAnAttributeOf(child);
@@ -246,7 +246,7 @@ ListUserConfigParam<T, U>::ListUserConfigParam(const char* param_name,
 template<typename T, typename U>
 void ListUserConfigParam<T, U>::write(std::ofstream& stream) const
 {
-    const int elts_amount = m_elements.size();
+    const int elts_amount = (int)m_elements.size();
 
     // comment
     if(m_comment.size() > 0) stream << "    <!-- " << m_comment.c_str();
@@ -728,7 +728,7 @@ bool UserConfig::loadConfig()
     UserConfigParams::m_saved_grand_prix_list.clearAndDeleteAll();
     std::vector<XMLNode*> saved_gps;
     root->getNodes("SavedGP", saved_gps);
-    const int gp_amount = saved_gps.size();
+    const int gp_amount = (int)saved_gps.size();
     for (int i=0; i<gp_amount; i++)
     {
         UserConfigParams::m_saved_grand_prix_list.push_back(
diff --git a/src/font/face_ttf.hpp b/src/font/face_ttf.hpp
index 93d5e115e..24ab75e22 100644
--- a/src/font/face_ttf.hpp
+++ b/src/font/face_ttf.hpp
@@ -51,7 +51,7 @@ public:
     FT_Face getFace(unsigned int i) const;
     // ------------------------------------------------------------------------
     /** Return the total TTF files loaded. */
-    unsigned int getTotalFaces() const               { return m_faces.size(); }
+    unsigned int getTotalFaces() const { return (unsigned int)m_faces.size(); }
 
 };   // FaceTTF
 
diff --git a/src/font/font_with_face.cpp b/src/font/font_with_face.cpp
index 9754a63d2..44cb641c1 100644
--- a/src/font/font_with_face.cpp
+++ b/src/font/font_with_face.cpp
@@ -30,6 +30,8 @@
 #include "guiengine/skin.hpp"
 #include "utils/string_utils.hpp"
 
+#include <array>
+
 // ----------------------------------------------------------------------------
 /** Constructor. It will initialize the \ref m_spritebank and TTF files to use.
  *  \param name The name of face, used by irrlicht to distinguish spritebank.
@@ -677,15 +679,24 @@ void FontWithFace::render(const core::stringw& text,
             top.setAlpha(color.getAlpha());
             bottom.setAlpha(color.getAlpha());
 
-            video::SColor title_colors[] = {top, bottom, top, bottom};
-            if (char_collector != NULL)
+            std::array<video::SColor, 4> title_colors;
+            if (CVS->isGLSL())
             {
-                char_collector->collectChar(texture, dest, source,
-                    title_colors);
+                title_colors = { { top, bottom, top, bottom } };
             }
             else
             {
-                draw2DImage(texture, dest, source, clip, title_colors, true);
+                title_colors = { { bottom, top, top, bottom } };
+            }
+            if (char_collector != NULL)
+            {
+                char_collector->collectChar(texture, dest, source,
+                    title_colors.data());
+            }
+            else
+            {
+                draw2DImage(texture, dest, source, clip, title_colors.data(),
+                    true);
             }
         }
         else
diff --git a/src/graphics/camera.cpp b/src/graphics/camera.cpp
index d70d5f419..3f26c6e9a 100644
--- a/src/graphics/camera.cpp
+++ b/src/graphics/camera.cpp
@@ -55,7 +55,8 @@ Camera::CameraType   Camera::m_default_type  = Camera::CM_TYPE_NORMAL;
  */
 Camera* Camera::createCamera(AbstractKart* kart)
 {
-    Camera *camera = createCamera(m_all_cameras.size(), m_default_type, kart);
+    Camera *camera = createCamera((int)m_all_cameras.size(), 
+                                   m_default_type, kart      );
     m_all_cameras.push_back(camera);
     return camera;
 }   // createCamera(kart)
diff --git a/src/graphics/central_settings.cpp b/src/graphics/central_settings.cpp
index 871d27e7a..aad4e96e4 100644
--- a/src/graphics/central_settings.cpp
+++ b/src/graphics/central_settings.cpp
@@ -93,7 +93,8 @@ void CentralVideoSettings::init()
     {
         std::string driver((char*)(glGetString(GL_VERSION)));
         std::string card((char*)(glGetString(GL_RENDERER)));
-        GraphicsRestrictions::init(driver, card);
+        std::string vendor((char*)(glGetString(GL_VENDOR)));
+        GraphicsRestrictions::init(driver, card, vendor);
 
         if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_FORCE_LEGACY_DEVICE))
         {
@@ -210,13 +211,6 @@ void CentralVideoSettings::init()
             hasSRGBFramebuffer = true;
             Log::info("GLDriver", "ARB framebuffer sRGB Present");
         }
-        // Only unset the high def textures if they are set as default. If the
-        // user has enabled them (bit 1 set), then leave them enabled.
-        if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_HIGHDEFINITION_TEXTURES) &&
-            (UserConfigParams::m_high_definition_textures & 0x02) == 0)
-        {
-            UserConfigParams::m_high_definition_textures = 0x00;
-        }
 
         if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_GI))
         {
@@ -293,6 +287,24 @@ void CentralVideoSettings::init()
             m_need_vertex_id_workaround = true;
         }
 #endif
+
+        // Only unset the high def textures if they are set as default. If the
+        // user has enabled them (bit 1 set), then leave them enabled.
+        if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_HIGHDEFINITION_TEXTURES) &&
+            (UserConfigParams::m_high_definition_textures & 0x02) == 0)
+        {
+            UserConfigParams::m_high_definition_textures = 0x00;
+        }
+        
+        if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_HIGHDEFINITION_TEXTURES_256))
+        {
+            UserConfigParams::m_high_definition_textures = 0;
+            
+            if (UserConfigParams::m_max_texture_size > 256)
+            {
+                UserConfigParams::m_max_texture_size = 256;
+            }
+        }
     }
 }
 
@@ -515,7 +527,7 @@ bool CentralVideoSettings::isDefferedEnabled() const
 
 bool CentralVideoSettings::supportsHardwareSkinning() const
 {
-    return isARBUniformBufferObjectUsable();
+    return !GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_HARDWARE_SKINNING);
 }
 
 bool CentralVideoSettings::isARBTextureSwizzleUsable() const
diff --git a/src/graphics/command_buffer.hpp b/src/graphics/command_buffer.hpp
index c1e7543bd..35021a8f4 100644
--- a/src/graphics/command_buffer.hpp
+++ b/src/graphics/command_buffer.hpp
@@ -74,13 +74,13 @@ template<typename T>
 void FillInstances_impl(const InstanceList& instance_list,
                         T * instance_buffer,
                         DrawElementsIndirectCommand *command_buffer,
-                        size_t &instance_buffer_offset,
-                        size_t &command_buffer_offset,
-                        size_t &poly_count)
+                        unsigned int &instance_buffer_offset,
+                        unsigned int &command_buffer_offset,
+                        unsigned int&poly_count)
 {
     // Should never be empty
     GLMesh *mesh = instance_list.m_mesh;
-    size_t initial_offset = instance_buffer_offset;
+    unsigned int initial_offset = instance_buffer_offset;
 
     for (unsigned i = 0; i < instance_list.m_instance_settings.size(); i++)
     {
@@ -92,7 +92,7 @@ void FillInstances_impl(const InstanceList& instance_list,
     DrawElementsIndirectCommand &CurrentCommand = command_buffer[command_buffer_offset++];
     CurrentCommand.baseVertex = mesh->vaoBaseVertex;
     CurrentCommand.count = mesh->IndexCount;
-    CurrentCommand.firstIndex = mesh->vaoOffset / 2;
+    CurrentCommand.firstIndex = GLuint(mesh->vaoOffset / 2);
     CurrentCommand.baseInstance = initial_offset;
     CurrentCommand.instanceCount = instance_buffer_offset - initial_offset;
     
@@ -145,12 +145,12 @@ protected:
     DrawElementsIndirectCommand *m_draw_indirect_cmd;
     
     std::array<std::vector<GLMesh *>, N> m_meshes;
-    std::array<size_t,N> m_offset;
-    std::array<size_t,N> m_size;
+    std::array<unsigned int,N> m_offset;
+    std::array<unsigned int,N> m_size;
     
-    size_t m_poly_count;
-    size_t m_instance_buffer_offset;
-    size_t m_command_buffer_offset;
+    unsigned int m_poly_count;
+    unsigned int m_instance_buffer_offset;
+    unsigned int m_command_buffer_offset;
 
     void clearMeshes();
     void mapIndirectBuffer();
@@ -230,7 +230,7 @@ public:
     CommandBuffer();
     virtual ~CommandBuffer() { glDeleteBuffers(1, &m_draw_indirect_cmd_id); }
 
-    inline size_t getPolyCount() const {return m_poly_count;}
+    inline unsigned int getPolyCount() const {return m_poly_count;}
 
     inline void bind() const
     {
@@ -263,7 +263,7 @@ public:
     {
         T::InstancedFirstPassShader::getInstance()->use();
         T::InstancedFirstPassShader::getInstance()->setUniforms(uniforms...);
-        
+        handleSkinning(T::InstancedFirstPassShader::getInstance());
         glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
                                                                     T::Instance));
         for (unsigned i = 0; i < m_meshes[T::MaterialType].size(); i++)
@@ -303,7 +303,7 @@ public:
         {
             T::InstancedFirstPassShader::getInstance()->use();
             T::InstancedFirstPassShader::getInstance()->setUniforms(uniforms...);
-
+            handleSkinning(T::InstancedFirstPassShader::getInstance());
             glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
                                                                         T::Instance));
             glMultiDrawElementsIndirect(GL_TRIANGLES,
@@ -329,7 +329,7 @@ public:
     {
         T::InstancedSecondPassShader::getInstance()->use();
         T::InstancedSecondPassShader::getInstance()->setUniforms(uniforms...);
-
+        handleSkinning(T::InstancedSecondPassShader::getInstance());
         glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
                                                                     T::Instance));
         for (unsigned i = 0; i < m_meshes[T::MaterialType].size(); i++)
@@ -364,7 +364,7 @@ public:
         {
             T::InstancedSecondPassShader::getInstance()->use();
             T::InstancedSecondPassShader::getInstance()->setUniforms(uniforms...);
-            
+            handleSkinning(T::InstancedSecondPassShader::getInstance());
             glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
                                                                         T::Instance));
             expandHandlesSecondPass<T>(handles);
@@ -451,7 +451,7 @@ public:
     {
         T::InstancedShadowPassShader::getInstance()->use();
         T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, uniforms...);
-        
+        handleSkinning(T::InstancedShadowPassShader::getInstance());
         glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
                                                                     InstanceTypeShadow));
                                                                     
@@ -488,7 +488,7 @@ public:
         {
             T::InstancedShadowPassShader::getInstance()->use();
             T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, uniforms...);
-            
+            handleSkinning(T::InstancedShadowPassShader::getInstance());
             glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
                                                                         InstanceTypeShadow));
             glMultiDrawElementsIndirect(GL_TRIANGLES,
diff --git a/src/graphics/cpu_particle_manager.cpp b/src/graphics/cpu_particle_manager.cpp
index 46c2fe2db..fdd3b275e 100644
--- a/src/graphics/cpu_particle_manager.cpp
+++ b/src/graphics/cpu_particle_manager.cpp
@@ -302,7 +302,7 @@ void CPUParticleManager::drawAll()
         }
         glBindVertexArray(std::get<0>(m_gl_particles[p.second]));
         glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4,
-            m_particles_generated.at(p.second).size());
+            (unsigned)m_particles_generated.at(p.second).size());
     }
 
 }   // drawAll
diff --git a/src/graphics/draw_calls.cpp b/src/graphics/draw_calls.cpp
index 67a3a041f..cc689df95 100644
--- a/src/graphics/draw_calls.cpp
+++ b/src/graphics/draw_calls.cpp
@@ -18,6 +18,7 @@
 #ifndef SERVER_ONLY
 #include "graphics/draw_calls.hpp"
 
+#include "config/stk_config.hpp"
 #include "config/user_config.hpp"
 #include "graphics/command_buffer.hpp"
 #include "graphics/cpu_particle_manager.hpp"
@@ -258,14 +259,14 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
         (!culled_for_cams[0] || !culled_for_cams[1] || !culled_for_cams[2] ||
         !culled_for_cams[3] || !culled_for_cams[4] || !culled_for_cams[5]))
     {
-        skinning_offset = getSkinningOffset() + 1/*reserved identity matrix*/;
+        skinning_offset = getSkinningOffset();
         if (skinning_offset + am->getTotalJoints() >
-            SharedGPUObjects::getMaxMat4Size())
+            stk_config->m_max_skinning_bones)
         {
             Log::error("DrawCalls", "Don't have enough space to render skinned"
                 " mesh %s! Max joints can hold: %d",
                 am->getMeshDebugName().c_str(),
-                SharedGPUObjects::getMaxMat4Size());
+                stk_config->m_max_skinning_bones);
             return;
         }
         m_mesh_for_skinning.insert(am);
@@ -684,8 +685,30 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices,
     }*/
 
     PROFILER_PUSH_CPU_MARKER("- Animations/Buffer upload", 0x0, 0x0, 0x0);
+    shadow_matrices.updateUBO();
+    if (CVS->supportsHardwareSkinning())
+    {
+#ifdef USE_GLES2
+        glBindTexture(GL_TEXTURE_2D, SharedGPUObjects::getSkinningTexture());
+#else
+        glBindBuffer(CVS->isARBShaderStorageBufferObjectUsable() ?
+            GL_SHADER_STORAGE_BUFFER : GL_TEXTURE_BUFFER,
+            SharedGPUObjects::getSkinningBuffer());
+#endif
+    }
     for (unsigned i = 0; i < m_deferred_update.size(); i++)
+    {
         m_deferred_update[i]->updateGL();
+    }
+    if (CVS->supportsHardwareSkinning())
+    {
+#ifdef USE_GLES2
+        glBindTexture(GL_TEXTURE_2D, 0);
+#else
+        glBindBuffer(CVS->isARBShaderStorageBufferObjectUsable() ?
+            GL_SHADER_STORAGE_BUFFER : GL_TEXTURE_BUFFER, 0);
+#endif
+    }
     PROFILER_POP_CPU_MARKER();
 
     PROFILER_PUSH_CPU_MARKER("- cpu particle upload", 0x3F, 0x03, 0x61);
@@ -964,7 +987,7 @@ int32_t DrawCalls::getSkinningOffset() const
 {
     return std::accumulate(m_mesh_for_skinning.begin(),
         m_mesh_for_skinning.end(), 0, []
-        (const size_t previous, const STKAnimatedMesh* m)
+        (const unsigned int previous, const STKAnimatedMesh* m)
         { return previous + m->getTotalJoints(); });
 }   // getSkinningOffset
 #endif   // !SERVER_ONLY
diff --git a/src/graphics/draw_policies.cpp b/src/graphics/draw_policies.cpp
index b9e593f2e..ba42419ac 100644
--- a/src/graphics/draw_policies.cpp
+++ b/src/graphics/draw_policies.cpp
@@ -28,6 +28,7 @@ void renderMeshes1stPass()
 {
     auto &meshes = T::List::getInstance()->SolidPass;
     T::FirstPassShader::getInstance()->use();
+    handleSkinning(T::FirstPassShader::getInstance());
     if (CVS->isARBBaseInstanceUsable())
         glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
     for (unsigned i = 0; i < meshes.size(); i++)
@@ -58,6 +59,7 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
 {
     auto &meshes = T::List::getInstance()->SolidPass;
     T::SecondPassShader::getInstance()->use();
+    handleSkinning(T::SecondPassShader::getInstance());
     if (CVS->isARBBaseInstanceUsable())
         glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
     for (unsigned i = 0; i < meshes.size(); i++)
@@ -95,6 +97,7 @@ void renderShadow(unsigned cascade)
 {
     auto &t = T::List::getInstance()->Shadows[cascade];
     T::ShadowPassShader::getInstance()->use();
+    handleSkinning(T::ShadowPassShader::getInstance());
     if (CVS->isARBBaseInstanceUsable())
         glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
     for (unsigned i = 0; i < t.size(); i++)
diff --git a/src/graphics/draw_tools.hpp b/src/graphics/draw_tools.hpp
index b4d68cc4d..b738f2070 100644
--- a/src/graphics/draw_tools.hpp
+++ b/src/graphics/draw_tools.hpp
@@ -183,5 +183,14 @@ struct HandleExpander
     }   // Expand
 };   // HandleExpander
 
+// ----------------------------------------------------------------------------
+template <typename Shader>
+inline void handleSkinning(Shader* s)
+{
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(s))
+    {
+        sms->bindSkinningTexture();
+    }
+}
 
 #endif //HEADER_DRAW_TOOLS_HPP
diff --git a/src/graphics/explosion.cpp b/src/graphics/explosion.cpp
index 2d300ef67..d4040dcaf 100644
--- a/src/graphics/explosion.cpp
+++ b/src/graphics/explosion.cpp
@@ -42,8 +42,20 @@ Explosion::Explosion(const Vec3& coord, const char* explosion_sound, const char
     m_emission_frames = 0;
 
 #ifndef SERVER_ONLY
+    std::string filename = particle_file;
+    
+#ifdef ANDROID
+    // Use a lower quality effect on Android for better performance
+    if (filename == "explosion.xml" || 
+        filename == "explosion_bomb.xml" ||
+        filename == "explosion_cake.xml")
+    {
+        filename = "explosion_low.xml";
+    }
+#endif
+    
     ParticleKindManager* pkm = ParticleKindManager::get();
-    ParticleKind* particles = pkm->getParticles(particle_file);
+    ParticleKind* particles = pkm->getParticles(filename);
     m_emitter = NULL;
     
     if (UserConfigParams::m_graphical_effects > 1)
diff --git a/src/graphics/geometry_passes.cpp b/src/graphics/geometry_passes.cpp
index 8a8bcbd00..0c35f06d9 100644
--- a/src/graphics/geometry_passes.cpp
+++ b/src/graphics/geometry_passes.cpp
@@ -202,6 +202,7 @@ void renderTransparenPass(const std::vector<RenderGeometry::TexUnit> &TexUnits,
                           std::vector<std::tuple<TupleType...> > *meshes)
 {
     Shader::getInstance()->use();
+    handleSkinning(Shader::getInstance());
     if (CVS->isARBBaseInstanceUsable())
         glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
     for (unsigned i = 0; i < meshes->size(); i++)
diff --git a/src/graphics/glwrap.cpp b/src/graphics/glwrap.cpp
index f1c18877d..e889ade21 100644
--- a/src/graphics/glwrap.cpp
+++ b/src/graphics/glwrap.cpp
@@ -226,8 +226,8 @@ unsigned GPUTimer::elapsedTimeus()
 
 FrameBuffer::FrameBuffer() {}
 
-FrameBuffer::FrameBuffer(const std::vector<GLuint> &RTTs, size_t w, size_t h,
-                         bool layered)
+FrameBuffer::FrameBuffer(const std::vector<GLuint> &RTTs, unsigned int w, 
+                         unsigned int h, bool layered)
            : fbolayer(0), RenderTargets(RTTs), DepthTexture(0), 
              width(w), height(h)
 {
@@ -248,8 +248,8 @@ FrameBuffer::FrameBuffer(const std::vector<GLuint> &RTTs, size_t w, size_t h,
     assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE_EXT);
 }
 
-FrameBuffer::FrameBuffer(const std::vector<GLuint> &RTTs, GLuint DS, size_t w,
-                         size_t h, bool layered) 
+FrameBuffer::FrameBuffer(const std::vector<GLuint> &RTTs, GLuint DS, unsigned int w,
+                         unsigned int h, bool layered) 
            : fbolayer(0), RenderTargets(RTTs), DepthTexture(DS), width(w), 
              height(h)
 {
diff --git a/src/graphics/glwrap.hpp b/src/graphics/glwrap.hpp
index a9e42b9e5..c2572862b 100644
--- a/src/graphics/glwrap.hpp
+++ b/src/graphics/glwrap.hpp
@@ -66,18 +66,18 @@ private:
     GLuint fbo, fbolayer;
     std::vector<GLuint> RenderTargets;
     GLuint DepthTexture;
-    size_t width, height;
+    unsigned int width, height;
 public:
     FrameBuffer();
-    FrameBuffer(const std::vector <GLuint> &RTTs, size_t w, size_t h, bool layered = false);
-    FrameBuffer(const std::vector <GLuint> &RTTs, GLuint DS, size_t w, size_t h, bool layered = false);
+    FrameBuffer(const std::vector <GLuint> &RTTs, unsigned int w, unsigned int h, bool layered = false);
+    FrameBuffer(const std::vector <GLuint> &RTTs, GLuint DS, unsigned int w, unsigned int h, bool layered = false);
     ~FrameBuffer();
     void bind() const;
     void bindLayer(unsigned) const;
     const std::vector<GLuint> &getRTT() const { return RenderTargets; }
     GLuint getDepthTexture() const { assert(DepthTexture); return DepthTexture; }
-    size_t getWidth() const { return width; }
-    size_t getHeight() const { return height; }
+    unsigned int getWidth() const { return width; }
+    unsigned int getHeight() const { return height; }
     static void Blit(const FrameBuffer &Src, const FrameBuffer &Dst, GLbitfield mask = GL_COLOR_BUFFER_BIT, GLenum filter = GL_NEAREST);
     void BlitToDefault(size_t, size_t, size_t, size_t);
 
@@ -154,9 +154,9 @@ public:
             glEnableVertexAttribArray(4);
             glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(tp), (GLvoid*)44);
             glEnableVertexAttribArray(5);
-            glVertexAttribIPointer(5, 4, GL_INT, getVertexPitchFromType(tp), (GLvoid*)60);
+            glVertexAttribIPointer(5, 4, GL_SHORT, getVertexPitchFromType(tp), (GLvoid*)60);
             glEnableVertexAttribArray(6);
-            glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(tp), (GLvoid*)76);
+            glVertexAttribPointer(6, 4, GL_HALF_FLOAT, GL_FALSE, getVertexPitchFromType(tp), (GLvoid*)68);
             break;
         }
     }
diff --git a/src/graphics/graphics_restrictions.cpp b/src/graphics/graphics_restrictions.cpp
index 8f447c5e2..176d8b16c 100644
--- a/src/graphics/graphics_restrictions.cpp
+++ b/src/graphics/graphics_restrictions.cpp
@@ -44,36 +44,41 @@ namespace GraphicsRestrictions
         /** The list of names used in the XML file for the graphics
          *  restriction types. They must be in the same order as the types. */
 
-        std::array<std::string, 29> m_names_of_restrictions = {
-            "UniformBufferObject",
-            "GeometryShader",
-            "DrawIndirect",
-            "TextureView",
-            "TextureStorage",
-            "ImageLoadStore",
-            "BaseInstance",
-            "ComputeShader",
-            "ArraysOfArrays",
-            "ShaderStorageBufferObject",
-            "MultiDrawIndirect",
-            "ShaderAtomicCounters",
-            "BufferStorage",
-            "BindlessTexture",
-            "TextureCompressionS3TC",
-            "AMDVertexShaderLayer",
-            "ExplicitAttribLocation",
-            "TextureFilterAnisotropic",
-            "TextureFormatBGRA8888",
-            "ColorBufferFloat",
-            "DriverRecentEnough",
-            "HighDefinitionTextures",
-            "AdvancedPipeline",
-            "FramebufferSRGB",
-            "FramebufferSRGBWorkaround1",
-            "FramebufferSRGBWorkaround2",
-            "GI",
-            "ForceLegacyDevice",
-            "VertexIdWorking"
+        std::array<std::string, 31> m_names_of_restrictions =
+        {
+            {
+                "UniformBufferObject",
+                "GeometryShader",
+                "DrawIndirect",
+                "TextureView",
+                "TextureStorage",
+                "ImageLoadStore",
+                "BaseInstance",
+                "ComputeShader",
+                "ArraysOfArrays",
+                "ShaderStorageBufferObject",
+                "MultiDrawIndirect",
+                "ShaderAtomicCounters",
+                "BufferStorage",
+                "BindlessTexture",
+                "TextureCompressionS3TC",
+                "AMDVertexShaderLayer",
+                "ExplicitAttribLocation",
+                "TextureFilterAnisotropic",
+                "TextureFormatBGRA8888",
+                "ColorBufferFloat",
+                "DriverRecentEnough",
+                "HighDefinitionTextures",
+                "HighDefinitionTextures256",
+                "AdvancedPipeline",
+                "FramebufferSRGB",
+                "FramebufferSRGBWorkaround1",
+                "FramebufferSRGBWorkaround2",
+                "GI",
+                "ForceLegacyDevice",
+                "VertexIdWorking",
+                "HardwareSkinning"
+            }
         };
     }   // namespace Private
     using namespace Private;
@@ -261,7 +266,7 @@ public:
     /** If *this < other. */
     bool operator< (const Version &other) const
     {
-        unsigned int min_n = std::min(m_version.size(), other.m_version.size());
+        unsigned int min_n = (unsigned int)std::min(m_version.size(), other.m_version.size());
         for (unsigned int i = 0; i<min_n; i++)
         {
             if (m_version[i] > other.m_version[i]) return false;
@@ -276,7 +281,7 @@ public:
     /** If *this <= other. */
     bool operator<= (const Version &other) const
     {
-        unsigned int min_n = std::min(m_version.size(), other.m_version.size());
+        unsigned int min_n = (unsigned int)std::min(m_version.size(), other.m_version.size());
         for (unsigned int i = 0; i<min_n; i++)
         {
             if (m_version[i] > other.m_version[i]) return false;
@@ -309,6 +314,9 @@ private:
     /** For which OS this rule applies. */
     std::string m_os;
 
+    /** For which vendor this rule applies. */
+    std::string m_vendor;
+
     /** Which options to disable. */
     std::vector<std::string> m_disable_options;
 public:
@@ -327,6 +335,7 @@ public:
         }
 
         rule->get("os", &m_os);
+        rule->get("vendor", &m_vendor);
 
         std::string s;
         if(rule->get("version", &s) && s.size()>1)
@@ -358,7 +367,8 @@ public:
             m_disable_options = StringUtils::split(s, ' ');
     }   // Rule
     // ------------------------------------------------------------------------
-    bool applies(const std::string &card, const Version &version) const
+    bool applies(const std::string &card, const Version &version,
+                 const std::string &vendor) const
     {
         // Test for OS
         // -----------
@@ -378,6 +388,14 @@ public:
             return false;
 #endif
         }   // m_os.size()>0
+        
+        // Test for vendor
+        // ---------------
+        if (m_vendor.size() > 0)
+        {
+            if (m_vendor != vendor)
+                return false;
+        }
 
         // Test for card
         // -------------
@@ -482,9 +500,11 @@ void unitTesting()
  *  \param driver_version The GL_VERSION string (i.e. opengl and version
  *         number).
  *  \param card_name The GL_RENDERER string (i.e. graphics card).
+ *  \param vendor The GL_VENDOR string
  */
 void init(const std::string &driver_version,
-          const std::string &card_name)
+          const std::string &card_name,
+          const std::string &vendor)
 {
     for (unsigned int i = 0; i < GR_COUNT; i++)
         m_all_graphics_restriction.push_back(false);
@@ -518,7 +538,7 @@ void init(const std::string &driver_version,
             continue;
         }
         Rule rule(xml_rule);
-        if (rule.applies(card_name, version))
+        if (rule.applies(card_name, version, vendor))
         {
             std::vector<std::string> restrictions = rule.getRestrictions();
             std::vector<std::string>::iterator p;
diff --git a/src/graphics/graphics_restrictions.hpp b/src/graphics/graphics_restrictions.hpp
index 593a0ee3b..2d73c1578 100644
--- a/src/graphics/graphics_restrictions.hpp
+++ b/src/graphics/graphics_restrictions.hpp
@@ -56,6 +56,7 @@ namespace GraphicsRestrictions
         GR_COLOR_BUFFER_FLOAT,
         GR_DRIVER_RECENT_ENOUGH,
         GR_HIGHDEFINITION_TEXTURES,
+        GR_HIGHDEFINITION_TEXTURES_256,
         GR_ADVANCED_PIPELINE,
         GR_FRAMEBUFFER_SRGB,
         GR_FRAMEBUFFER_SRGB_WORKAROUND1,
@@ -63,11 +64,13 @@ namespace GraphicsRestrictions
         GR_GI,
         GR_FORCE_LEGACY_DEVICE,
         GR_VERTEX_ID_WORKING,
+        GR_HARDWARE_SKINNING,
         GR_COUNT  /** MUST be last entry. */
     } ;
 
     void init(const std::string &driver_version,
-              const std::string &card_name       );
+              const std::string &card_name,
+              const std::string &vendor       );
     bool isDisabled(GraphicsRestrictionsType type);
 
     void unitTesting();
diff --git a/src/graphics/material.hpp b/src/graphics/material.hpp
index c8f52aa5b..7a873689e 100644
--- a/src/graphics/material.hpp
+++ b/src/graphics/material.hpp
@@ -317,7 +317,7 @@ public:
     {
         if (m_hue_settings.empty())
             return 0.0f;
-        const unsigned int hue = m_random_hue.get(m_hue_settings.size());
+        const unsigned int hue = m_random_hue.get((int)m_hue_settings.size());
         assert(hue < m_hue_settings.size());
         return m_hue_settings[hue];
     }
diff --git a/src/graphics/material_manager.cpp b/src/graphics/material_manager.cpp
index 4d82a40d2..023daa1e4 100644
--- a/src/graphics/material_manager.cpp
+++ b/src/graphics/material_manager.cpp
@@ -24,6 +24,7 @@
 
 #include "config/user_config.hpp"
 #include "graphics/material.hpp"
+#include "graphics/particle_kind_manager.hpp"
 #include "graphics/shaders.hpp"
 #include "io/file_manager.hpp"
 #include "io/xml_node.hpp"
@@ -381,14 +382,26 @@ void MaterialManager::makeMaterialsPermanent()
 }   // makeMaterialsPermanent
 
 // ----------------------------------------------------------------------------
-
 void MaterialManager::unloadAllTextures()
 {
-    std::string texture_folder = file_manager->getAssetDirectory(FileManager::TEXTURE);
+    std::string texture_folder =
+        file_manager->getAssetDirectory(FileManager::TEXTURE);
+    texture_folder = file_manager->getFileSystem()->getAbsolutePath
+        (texture_folder.c_str()).c_str();
+    core::stringc texfname(texture_folder.c_str());
+    texfname.make_lower();
+    texture_folder = texfname.c_str();
     for (int i = 0; i < m_shared_material_index; i++)
     {
-        if (m_materials[i]->getTexFullPath().find(texture_folder) != std::string::npos)
-            m_materials[i]->unloadTexture();
+        // Global particle textures will stay until exit
+        // STK, which avoid hangs when lazy-loading the texture when being
+        // triggered.
+        Material* m = m_materials[i];
+        if (!ParticleKindManager::get()->isGlobalParticleMaterial(m)
+            && m->getTexFullPath().find(texture_folder) != std::string::npos)
+        {
+            m->unloadTexture();
+        }
     }
 }
 
diff --git a/src/graphics/materials.cpp b/src/graphics/materials.cpp
index e8ed79880..1ae3460a9 100644
--- a/src/graphics/materials.cpp
+++ b/src/graphics/materials.cpp
@@ -488,6 +488,10 @@ SkinnedPass1Shader::SkinnedPass1Shader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                               GL_FRAGMENT_SHADER, "object_pass1.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 }   // SkinnedPass1Shader
@@ -499,6 +503,10 @@ InstancedSkinnedPass1Shader::InstancedSkinnedPass1Shader()
     loadProgram(SKINNED_MESH,
                 GL_VERTEX_SHADER, "instanced_skinning.vert",
                 GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms();
     assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 }   // InstancedSkinnedPass1Shader
@@ -509,6 +517,10 @@ SkinnedPass2Shader::SkinnedPass2Shader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                               GL_FRAGMENT_SHADER, "object_pass2.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "texture_trans", "color_change",
                    "skinning_offset");
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -527,6 +539,10 @@ InstancedSkinnedPass2Shader::InstancedSkinnedPass2Shader()
     loadProgram(SKINNED_MESH,
                 GL_VERTEX_SHADER, "instanced_skinning.vert",
                 GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms();
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                        1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -543,6 +559,10 @@ SkinnedRefPass1Shader::SkinnedRefPass1Shader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                               GL_FRAGMENT_SHADER, "objectref_pass1.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans",
                    "skinning_offset");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -556,6 +576,10 @@ InstancedSkinnedRefPass1Shader::InstancedSkinnedRefPass1Shader()
     loadProgram(SKINNED_MESH,
                 GL_VERTEX_SHADER, "instanced_skinning.vert",
                 GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms();
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                        1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -567,6 +591,10 @@ SkinnedRefPass2Shader::SkinnedRefPass2Shader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                               GL_FRAGMENT_SHADER, "objectref_pass2.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "texture_trans", "color_change",
                    "skinning_offset");
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -585,6 +613,10 @@ InstancedSkinnedRefPass2Shader::InstancedSkinnedRefPass2Shader()
     loadProgram(SKINNED_MESH,
                 GL_VERTEX_SHADER, "instanced_skinning.vert",
                 GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms();
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                        1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -601,6 +633,10 @@ SkinnedUnlitShader::SkinnedUnlitShader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                               GL_FRAGMENT_SHADER, "object_unlit.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "texture_trans", "skinning_offset");
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                        1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -615,6 +651,10 @@ InstancedSkinnedUnlitShader::InstancedSkinnedUnlitShader()
     loadProgram(SKINNED_MESH,
                 GL_VERTEX_SHADER, "instanced_skinning.vert",
                 GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms();
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                        1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -628,6 +668,10 @@ SkinnedNormalMapShader::SkinnedNormalMapShader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                               GL_FRAGMENT_SHADER, "normalmap.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
     assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                        1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -639,6 +683,10 @@ InstancedSkinnedNormalMapShader::InstancedSkinnedNormalMapShader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "instanced_skinning.vert",
                               GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms();
     assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                        1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -662,6 +710,10 @@ SkinnedShadowShader::SkinnedShadowShader()
                                   GL_GEOMETRY_SHADER, "shadow.geom",
                                   GL_FRAGMENT_SHADER, "shadow.frag");
     }
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "skinning_offset", "layer");
 #endif
 }   // SkinnedShadowShader
@@ -686,6 +738,10 @@ InstancedSkinnedShadowShader::InstancedSkinnedShadowShader()
                     GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                     GL_FRAGMENT_SHADER, "shadow.frag");
     }
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("layer");
 #endif
 }   // InstancedSkinnedShadowShader
@@ -708,6 +764,10 @@ SkinnedRefShadowShader::SkinnedRefShadowShader()
                                   GL_GEOMETRY_SHADER, "shadow.geom",
                                   GL_FRAGMENT_SHADER, "shadowref.frag");
     }
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "skinning_offset", "layer");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 #endif
@@ -733,6 +793,10 @@ InstancedSkinnedRefShadowShader::InstancedSkinnedRefShadowShader()
                     GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                     GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
     }
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("layer");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 #endif
diff --git a/src/graphics/materials.hpp b/src/graphics/materials.hpp
index 61ce7f847..b088a9882 100644
--- a/src/graphics/materials.hpp
+++ b/src/graphics/materials.hpp
@@ -296,7 +296,8 @@ public:
 // ============================================================================
 class SkinnedPass1Shader : public TextureShader<SkinnedPass1Shader, 1,
                                                 core::matrix4, core::matrix4,
-                                                int>
+                                                int>,
+                          public SkinnedMeshShader
 {
 public:
     SkinnedPass1Shader();
@@ -304,7 +305,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedPass1Shader
-                         : public TextureShader<InstancedSkinnedPass1Shader, 1>
+                        : public TextureShader<InstancedSkinnedPass1Shader, 1>,
+                          public SkinnedMeshShader
 {
 public:
     InstancedSkinnedPass1Shader();
@@ -313,7 +315,8 @@ public:
 // ============================================================================
 class SkinnedPass2Shader : public TextureShader<SkinnedPass2Shader, 6,
                                                 core::matrix4, core::vector2df,
-                                                core::vector2df, int >
+                                                core::vector2df, int >,
+                           public SkinnedMeshShader
 {
 public:
     SkinnedPass2Shader();
@@ -321,7 +324,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedPass2Shader
-                         : public TextureShader<InstancedSkinnedPass2Shader, 6>
+                        : public TextureShader<InstancedSkinnedPass2Shader, 6>,
+                          public SkinnedMeshShader
 {
 public:
     InstancedSkinnedPass2Shader();
@@ -331,7 +335,8 @@ public:
 class SkinnedRefPass1Shader : public TextureShader<SkinnedRefPass1Shader, 2,
                                                    core::matrix4,
                                                    core::matrix4,
-                                                   core::vector2df, int>
+                                                   core::vector2df, int>,
+                              public SkinnedMeshShader
 {
 public:
     SkinnedRefPass1Shader();
@@ -339,7 +344,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedRefPass1Shader
-                      : public TextureShader<InstancedSkinnedRefPass1Shader, 2>
+                     : public TextureShader<InstancedSkinnedRefPass1Shader, 2>,
+                       public SkinnedMeshShader
 {
 public:
     InstancedSkinnedRefPass1Shader();
@@ -349,7 +355,8 @@ public:
 class SkinnedRefPass2Shader : public TextureShader<SkinnedRefPass2Shader, 6,
                                                    core::matrix4,
                                                    core::vector2df,
-                                                   core::vector2df, int>
+                                                   core::vector2df, int>,
+                              public SkinnedMeshShader
 {
 public:
     SkinnedRefPass2Shader();
@@ -357,7 +364,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedRefPass2Shader
-                      : public TextureShader<InstancedSkinnedRefPass2Shader, 6>
+                     : public TextureShader<InstancedSkinnedRefPass2Shader, 6>,
+                       public SkinnedMeshShader
 {
 public:
     InstancedSkinnedRefPass2Shader();
@@ -366,7 +374,8 @@ public:
 // ============================================================================
 class SkinnedUnlitShader : public TextureShader<SkinnedUnlitShader, 4,
                                                 core::matrix4, core::vector2df,
-                                                int>
+                                                int>,
+                           public SkinnedMeshShader
 {
 public:
     SkinnedUnlitShader();
@@ -374,7 +383,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedUnlitShader
-                         : public TextureShader<InstancedSkinnedUnlitShader, 4>
+                        : public TextureShader<InstancedSkinnedUnlitShader, 4>,
+                          public SkinnedMeshShader
 {
 public:
     InstancedSkinnedUnlitShader();
@@ -383,7 +393,8 @@ public:
 // ============================================================================
 class SkinnedNormalMapShader : public TextureShader<SkinnedNormalMapShader, 2,
                                                     core::matrix4,
-                                                    core::matrix4, int>
+                                                    core::matrix4, int>,
+                               public SkinnedMeshShader
 {
 public:
     SkinnedNormalMapShader();
@@ -391,7 +402,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedNormalMapShader
-                     : public TextureShader<InstancedSkinnedNormalMapShader, 2>
+                    : public TextureShader<InstancedSkinnedNormalMapShader, 2>,
+                      public SkinnedMeshShader
 {
 public:
     InstancedSkinnedNormalMapShader();
@@ -399,7 +411,8 @@ public:
 
 // ============================================================================
 class SkinnedShadowShader : public TextureShader<SkinnedShadowShader, 0,
-                                                 core::matrix4, int, int>
+                                                 core::matrix4, int, int>,
+                            public SkinnedMeshShader
 {
 public:
     SkinnedShadowShader();
@@ -407,7 +420,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedShadowShader
-                   : public TextureShader<InstancedSkinnedShadowShader, 0, int>
+                  : public TextureShader<InstancedSkinnedShadowShader, 0, int>,
+                    public SkinnedMeshShader
 {
 public:
     InstancedSkinnedShadowShader();
@@ -415,7 +429,8 @@ public:
 
 // ============================================================================
 class SkinnedRefShadowShader : public TextureShader<SkinnedRefShadowShader, 1,
-                                                    core::matrix4, int, int>
+                                                    core::matrix4, int, int>,
+                               public SkinnedMeshShader
 {
 public:
     SkinnedRefShadowShader();
@@ -423,7 +438,8 @@ public:
 
 // ============================================================================
 class InstancedSkinnedRefShadowShader
-                : public TextureShader<InstancedSkinnedRefShadowShader, 1, int>
+               : public TextureShader<InstancedSkinnedRefShadowShader, 1, int>,
+                 public SkinnedMeshShader
 {
 public:
     InstancedSkinnedRefShadowShader();
diff --git a/src/graphics/particle_kind_manager.cpp b/src/graphics/particle_kind_manager.cpp
index e6406c935..0a73be364 100644
--- a/src/graphics/particle_kind_manager.cpp
+++ b/src/graphics/particle_kind_manager.cpp
@@ -124,3 +124,14 @@ ParticleKind* ParticleKindManager::getParticles(const std::string &name)
 }
 
 // ----------------------------------------------------------------------------
+bool ParticleKindManager::isGlobalParticleMaterial(Material* m) const
+{
+    for (auto& p : m_kinds)
+    {
+        if (p.second->getMaterial() == m)
+        {
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/src/graphics/particle_kind_manager.hpp b/src/graphics/particle_kind_manager.hpp
index 55f55eac2..9771fde3d 100644
--- a/src/graphics/particle_kind_manager.hpp
+++ b/src/graphics/particle_kind_manager.hpp
@@ -24,6 +24,8 @@
 #include <string>
 #include <map>
 
+class Material;
+
 /**
  * \brief Holds and manages a list of all types of particles
  * \ingroup graphics
@@ -45,6 +47,7 @@ public:
 
     ParticleKind* getParticles(const std::string &name);
 
+    bool   isGlobalParticleMaterial(Material* m) const;
     void   cleanUpTrackSpecificGfx();
     void   cleanup();
 
diff --git a/src/graphics/post_processing.cpp b/src/graphics/post_processing.cpp
index 5e380b58b..15abf7a30 100644
--- a/src/graphics/post_processing.cpp
+++ b/src/graphics/post_processing.cpp
@@ -998,7 +998,7 @@ void PostProcessing::renderGaussian3Blur(const FrameBuffer &in_fbo,
 // ----------------------------------------------------------------------------
 void PostProcessing::renderGaussian6BlurLayer(const FrameBuffer &in_fbo,
                                               const FrameBuffer &scalar_fbo,
-                                              size_t layer, float sigma_h,
+                                              unsigned int layer, float sigma_h,
                                               float sigma_v) const
 {
 #if !defined(USE_GLES2)
diff --git a/src/graphics/post_processing.hpp b/src/graphics/post_processing.hpp
index d78a0ae96..c140bdf43 100644
--- a/src/graphics/post_processing.hpp
+++ b/src/graphics/post_processing.hpp
@@ -93,7 +93,7 @@ public:
 	void renderHorizontalBlur(const FrameBuffer &in_fbo, const FrameBuffer &auxiliary) const;
 
     void renderGaussian6BlurLayer(const FrameBuffer &in_fbo, const FrameBuffer &scalar_fbo,
-                                  size_t layer, float sigmaH, float sigmaV) const;
+                                  unsigned int layer, float sigmaH, float sigmaV) const;
     void renderGaussian17TapBlur(const FrameBuffer &in_fbo,
                                  const FrameBuffer &auxiliary,
                                  const FrameBuffer &linear_depth) const;
diff --git a/src/graphics/render_info.hpp b/src/graphics/render_info.hpp
index fe669b091..4bd5f7f91 100644
--- a/src/graphics/render_info.hpp
+++ b/src/graphics/render_info.hpp
@@ -76,7 +76,10 @@ public:
       */
     bool isStatic() const                    { return m_dynamic_hue.empty(); }
     // ------------------------------------------------------------------------
-    unsigned int getNumberOfHue() const       { return m_dynamic_hue.size(); }
+    unsigned int getNumberOfHue() const 
+    {
+        return (unsigned int)m_dynamic_hue.size(); 
+    }   // getNumberOfHue
     // ------------------------------------------------------------------------
     float getDynamicHue(unsigned int hue) const
     {
diff --git a/src/graphics/rtts.cpp b/src/graphics/rtts.cpp
index 8ac4636ee..5460a87a6 100644
--- a/src/graphics/rtts.cpp
+++ b/src/graphics/rtts.cpp
@@ -25,7 +25,9 @@
 #include "graphics/materials.hpp"
 #include "utils/log.hpp"
 
-static GLuint generateRTT3D(GLenum target, size_t w, size_t h, size_t d, GLint internalFormat, GLint format, GLint type, unsigned mipmaplevel = 1)
+static GLuint generateRTT3D(GLenum target, unsigned int w, unsigned int h, 
+                            unsigned int d, GLint internalFormat, GLint format,
+                            GLint type, unsigned mipmaplevel = 1)
 {
     GLuint result;
     glGenTextures(1, &result);
@@ -49,10 +51,10 @@ static GLuint generateRTT(const core::dimension2du &res, GLint internalFormat, G
     return result;
 }
 
-RTT::RTT(size_t width, size_t height, float rtt_scale)
+RTT::RTT(unsigned int width, unsigned int height, float rtt_scale)
 {
-    m_width = size_t(width * rtt_scale);
-    m_height = size_t(height  * rtt_scale);
+    m_width = (unsigned int)(width * rtt_scale);
+    m_height = (unsigned int)(height  * rtt_scale);
     m_shadow_FBO = NULL;
     m_RH_FBO = NULL;
     m_RSM = NULL;
diff --git a/src/graphics/rtts.hpp b/src/graphics/rtts.hpp
index 4e38322c8..23d0653d7 100644
--- a/src/graphics/rtts.hpp
+++ b/src/graphics/rtts.hpp
@@ -144,11 +144,11 @@ enum TypeRTT : unsigned int
 class RTT
 {
 public:
-    RTT(size_t width, size_t height, float rtt_scale = 1.0f);
+    RTT(unsigned int width, unsigned int height, float rtt_scale = 1.0f);
     ~RTT();
     
-    size_t getWidth () const { return m_width ; }
-    size_t getHeight() const { return m_height; }
+    unsigned int getWidth () const { return m_width ; }
+    unsigned int getHeight() const { return m_height; }
 
     FrameBuffer &getShadowFrameBuffer() { return *m_shadow_FBO; }
     FrameBuffer &getRadianceHintFrameBuffer() { return *m_RH_FBO; }
@@ -165,8 +165,8 @@ private:
     std::vector<uint64_t> m_prefilled_handles;
     unsigned DepthStencilTexture;
 
-    size_t m_width;
-    size_t m_height;
+    unsigned int m_width;
+    unsigned int m_height;
 
     unsigned shadowColorTex, shadowDepthTex;
     unsigned RSM_Color, RSM_Normal, RSM_Depth;
diff --git a/src/graphics/shader.hpp b/src/graphics/shader.hpp
index 302cc4370..41a385864 100644
--- a/src/graphics/shader.hpp
+++ b/src/graphics/shader.hpp
@@ -146,9 +146,8 @@ private:
     /** End of recursive implementation of assignUniforms. */
     void assignUniformsImpl()
     {
-        bindPoint("MatrixData",   0);
+        bindPoint("MatrixesData", 0);
         bindPoint("LightingData", 1);
-        bindPoint("SkinningData", 2);
     }   // assignUniformsImpl
 
     // ------------------------------------------------------------------------
@@ -367,6 +366,8 @@ public:
         }
     }   // loadProgram
 
+    // ------------------------------------------------------------------------
+    virtual void bindCustomTextures() {}
     // ------------------------------------------------------------------------
     void drawFullScreenEffect(Args...args)
     {
@@ -379,6 +380,50 @@ public:
 };   // Shader
 
 // ============================================================================
+class SkinnedMeshShader
+{
+private:
+    GLuint m_skinning_location;
+public:
+    SkinnedMeshShader() : m_skinning_location(0) {}
+    // ------------------------------------------------------------------------
+    template <typename Shader>
+    void init(Shader* s)
+    {
+        s->use();
+#ifndef USE_GLES2
+        if (CVS->isARBShaderStorageBufferObjectUsable() &&
+            CVS->supportsHardwareSkinning())
+        {
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0,
+                SharedGPUObjects::getSkinningBuffer());
+        }
+        else
+#endif
+        {
+            m_skinning_location = s->getUniformLocation("skinning_tex");
+            glUniform1i(m_skinning_location, 15);
+        }
+    }
+    // ------------------------------------------------------------------------
+    void bindSkinningTexture()
+    {
+#ifdef USE_GLES2
+        glActiveTexture(GL_TEXTURE0 + 15);
+        glBindTexture(GL_TEXTURE_2D, SharedGPUObjects::getSkinningTexture());
+        glBindSampler(15, 0);
+#else
+        if (!CVS->isARBShaderStorageBufferObjectUsable())
+        {
+            glActiveTexture(GL_TEXTURE0 + 15);
+            glBindTexture(GL_TEXTURE_BUFFER,
+                SharedGPUObjects::getSkinningTexture());
+            glBindSampler(15, 0);
+        }
+#endif
+    }
+};
+
 
 #endif
 
diff --git a/src/graphics/shader_based_renderer.cpp b/src/graphics/shader_based_renderer.cpp
index 2a5b19011..54bcc1cf7 100644
--- a/src/graphics/shader_based_renderer.cpp
+++ b/src/graphics/shader_based_renderer.cpp
@@ -152,42 +152,9 @@ void ShaderBasedRenderer::prepareForwardRenderer()
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);    
 }
 
-// ----------------------------------------------------------------------------
-/** Upload lighting info to the dedicated uniform buffer
- */
-void ShaderBasedRenderer::uploadLightingData() const
-{
-    assert(CVS->isARBUniformBufferObjectUsable());
-    
-    float Lighting[36];
-    
-    core::vector3df sun_direction = irr_driver->getSunDirection();
-    video::SColorf sun_color = irr_driver->getSunColor();
-
-    Lighting[0] = sun_direction.X;
-    Lighting[1] = sun_direction.Y;
-    Lighting[2] = sun_direction.Z;
-    Lighting[4] = sun_color.getRed();
-    Lighting[5] = sun_color.getGreen();
-    Lighting[6] = sun_color.getBlue();
-    Lighting[7] = 0.54f;
-
-    const SHCoefficients* sh_coeff = m_spherical_harmonics->getCoefficients();
-
-    if(sh_coeff) {
-        memcpy(&Lighting[8], sh_coeff->blue_SH_coeff, 9 * sizeof(float));
-        memcpy(&Lighting[17], sh_coeff->green_SH_coeff, 9 * sizeof(float));
-        memcpy(&Lighting[26], sh_coeff->red_SH_coeff, 9 * sizeof(float));
-    }
-
-    glBindBuffer(GL_UNIFORM_BUFFER, SharedGPUObjects::getLightingDataUBO());
-    glBufferSubData(GL_UNIFORM_BUFFER, 0, 36 * sizeof(float), Lighting);
-}   // uploadLightingData
-
-
 // ----------------------------------------------------------------------------
 void ShaderBasedRenderer::computeMatrixesAndCameras(scene::ICameraSceneNode *const camnode,
-                                                    size_t width, size_t height)
+                                                    unsigned int width, unsigned int height)
 {
     m_current_screen_size = core::vector2df((float)width, (float)height);
     m_shadow_matrices.computeMatrixesAndCameras(camnode, width, height,
@@ -237,8 +204,6 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
     {
         glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedGPUObjects::getViewProjectionMatricesUBO());
         glBindBufferBase(GL_UNIFORM_BUFFER, 1, SharedGPUObjects::getLightingDataUBO());
-        if (CVS->supportsHardwareSkinning())
-            glBindBufferBase(GL_UNIFORM_BUFFER, 2, SharedGPUObjects::getSkinningUBO());
     }
     irr_driver->getSceneManager()->setActiveCamera(camnode);
 
@@ -668,8 +633,8 @@ ShaderBasedRenderer::~ShaderBasedRenderer()
 void ShaderBasedRenderer::onLoadWorld()
 {
     const core::recti &viewport = Camera::getCamera(0)->getViewport();
-    size_t width = viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X;
-    size_t height = viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y;
+    unsigned int width = viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X;
+    unsigned int height = viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y;
     RTT* rtts = new RTT(width, height, CVS->isDefferedEnabled() ?
                         UserConfigParams::m_scale_rtts_factor : 1.0f);
     setRTT(rtts);
@@ -812,11 +777,9 @@ void ShaderBasedRenderer::render(float dt)
             glEnable(GL_FRAMEBUFFER_SRGB);
 #endif
         
-        PROFILER_PUSH_CPU_MARKER("UBO upload", 0x0, 0xFF, 0x0);
+        PROFILER_PUSH_CPU_MARKER("Update camera matrices", 0x0, 0xFF, 0x0);
         computeMatrixesAndCameras(camnode, m_rtts->getWidth(), m_rtts->getHeight());
         m_shadow_matrices.updateSunOrthoMatrices();
-        if(CVS->isARBUniformBufferObjectUsable())
-            uploadLightingData();
         PROFILER_POP_CPU_MARKER();
         renderScene(camnode, dt, track->hasShadows(), false); 
         
@@ -923,9 +886,6 @@ void ShaderBasedRenderer::renderToTexture(GL3RenderTarget *render_target,
     irr_driver->getSceneManager()->setActiveCamera(camera);
 
     computeMatrixesAndCameras(camera, m_rtts->getWidth(), m_rtts->getHeight());
-    if (CVS->isARBUniformBufferObjectUsable())
-        uploadLightingData();
-
     renderScene(camera, dt, false, true);
     render_target->setFrameBuffer(m_post_processing
         ->render(camera, false, m_rtts));
diff --git a/src/graphics/shader_based_renderer.hpp b/src/graphics/shader_based_renderer.hpp
index 59a340b1e..cf68e0c64 100644
--- a/src/graphics/shader_based_renderer.hpp
+++ b/src/graphics/shader_based_renderer.hpp
@@ -52,7 +52,7 @@ private:
     /** Static glowing things are loaded once per track.
      * Glowing items can appear ordisappear each frame */
     std::vector<GlowData>       m_glowing;
-    size_t                      m_nb_static_glowing;
+    unsigned int                m_nb_static_glowing;
 
     void setOverrideMaterial();
     
@@ -61,10 +61,8 @@ private:
     
     void prepareForwardRenderer();
 
-    void uploadLightingData() const;
-
     void computeMatrixesAndCameras(scene::ICameraSceneNode * const camnode,
-                                   size_t width, size_t height);
+                                   unsigned int width, unsigned int height);
     
     void resetShadowCamNodes(){m_shadow_matrices.resetShadowCamNodes();}
     
diff --git a/src/graphics/shader_files_manager.cpp b/src/graphics/shader_files_manager.cpp
index 6e882c5d3..5f4c3a566 100644
--- a/src/graphics/shader_files_manager.cpp
+++ b/src/graphics/shader_files_manager.cpp
@@ -18,8 +18,8 @@
 #ifndef SERVER_ONLY
 
 #include "graphics/shader_files_manager.hpp"
+#include "config/stk_config.hpp"
 #include "graphics/central_settings.hpp"
-#include "graphics/shared_gpu_objects.hpp"
 #include "io/file_manager.hpp"
 #include "utils/log.hpp"
 
@@ -170,7 +170,9 @@ GLuint ShaderFilesManager::loadShader(const std::string &file, unsigned type)
         code << "#define Advanced_Lighting_Enabled\n";
     if (CVS->isARBSRGBFramebufferUsable())
         code << "#define sRGB_Framebuffer_Usable\n";
-
+    if (CVS->isARBShaderStorageBufferObjectUsable() &&
+        CVS->supportsHardwareSkinning())
+        code << "#define SSBO_SKINNING\n";
 #if !defined(USE_GLES2)
     // shader compilation fails with some drivers if there is no precision
     // qualifier
@@ -186,7 +188,7 @@ GLuint ShaderFilesManager::loadShader(const std::string &file, unsigned type)
     else
         code << "precision mediump float;\n";
 #endif
-    code << "#define MAX_BONES " << SharedGPUObjects::getMaxMat4Size() << "\n";
+    code << "#define MAX_BONES " << stk_config->m_max_skinning_bones << "\n";
 
     code << getHeader();
 
@@ -195,7 +197,7 @@ GLuint ShaderFilesManager::loadShader(const std::string &file, unsigned type)
     Log::info("ShaderFilesManager", "Compiling shader : %s", file.c_str());
     const std::string &source  = code.str();
     char const *source_pointer = source.c_str();
-    int len                    = source.size();
+    int len                    = (int)source.size();
     glShaderSource(id, 1, &source_pointer, &len);
     glCompileShader(id);
 
diff --git a/src/graphics/shaders.cpp b/src/graphics/shaders.cpp
index 122c27870..10c5de731 100644
--- a/src/graphics/shaders.cpp
+++ b/src/graphics/shaders.cpp
@@ -277,6 +277,10 @@ Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
     if (!CVS->supportsHardwareSkinning()) return;
     loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
                         GL_FRAGMENT_SHADER, "transparent.frag");
+    if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
+    {
+        sms->init(this);
+    }
     assignUniforms("ModelMatrix", "texture_trans", "skinning_offset",  "custom_alpha");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 }   // SkinnedTransparentShader
diff --git a/src/graphics/shaders.hpp b/src/graphics/shaders.hpp
index 7aa4f8f6c..599aa5010 100644
--- a/src/graphics/shaders.hpp
+++ b/src/graphics/shaders.hpp
@@ -140,7 +140,8 @@ public:
     // ========================================================================
     class SkinnedTransparentShader : public TextureShader<SkinnedTransparentShader, 1,
                                                  core::matrix4, core::vector2df,
-                                                 int, float >
+                                                 int, float >,
+                                     public SkinnedMeshShader
     {
     public:
         SkinnedTransparentShader();
diff --git a/src/graphics/shadow_matrices.cpp b/src/graphics/shadow_matrices.cpp
index 9681c14e3..74ada55b2 100644
--- a/src/graphics/shadow_matrices.cpp
+++ b/src/graphics/shadow_matrices.cpp
@@ -26,6 +26,7 @@
 #include "graphics/post_processing.hpp"
 #include "graphics/rtts.hpp"
 #include "graphics/shared_gpu_objects.hpp"
+#include "graphics/spherical_harmonics.hpp"
 #include "graphics/texture_shader.hpp"
 #include "modes/world.hpp"
 #include "physics/triangle_mesh.hpp"
@@ -311,6 +312,55 @@ void ShadowMatrices::updateSplitAndLightcoordRangeFromComputeShaders(unsigned in
 #endif
 }   // updateSplitAndLightcoordRangeFromComputeShaders
 
+    // ----------------------------------------------------------------------------
+
+void ShadowMatrices::updateUBO()
+{
+    if (!CVS->isARBUniformBufferObjectUsable())
+    {
+        return;
+    }
+    float lighting[36] = {};
+    core::vector3df sun_direction = irr_driver->getSunDirection();
+    video::SColorf sun_color = irr_driver->getSunColor();
+
+    lighting[0] = sun_direction.X;
+    lighting[1] = sun_direction.Y;
+    lighting[2] = sun_direction.Z;
+    lighting[4] = sun_color.getRed();
+    lighting[5] = sun_color.getGreen();
+    lighting[6] = sun_color.getBlue();
+    lighting[7] = 0.54f;
+
+    const SHCoefficients* sh_coeff = irr_driver->getSHCoefficients();
+
+    if (sh_coeff)
+    {
+        memcpy(&lighting[8], sh_coeff->blue_SH_coeff, 9 * sizeof(float));
+        memcpy(&lighting[17], sh_coeff->green_SH_coeff, 9 * sizeof(float));
+        memcpy(&lighting[26], sh_coeff->red_SH_coeff, 9 * sizeof(float));
+    }
+    glBindBuffer(GL_UNIFORM_BUFFER, SharedGPUObjects::getLightingDataUBO());
+    void* ptr = glMapBufferRange(GL_UNIFORM_BUFFER, 0, 36 * 4,
+        GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT |
+        GL_MAP_INVALIDATE_BUFFER_BIT);
+    memcpy(ptr, lighting, 36 * 4);
+    glUnmapBuffer(GL_UNIFORM_BUFFER);
+
+    if (CVS->isSDSMEnabled())
+    {
+        return;
+    }
+    glBindBuffer(GL_UNIFORM_BUFFER,
+    SharedGPUObjects::getViewProjectionMatricesUBO());
+    ptr = glMapBufferRange(GL_UNIFORM_BUFFER, 0, (16 * 9 + 2) * 4,
+        GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT |
+        GL_MAP_INVALIDATE_BUFFER_BIT);
+    memcpy(ptr, m_ubo_data, (16 * 9 + 2) * 4);
+    glUnmapBuffer(GL_UNIFORM_BUFFER);
+    glBindBuffer(GL_UNIFORM_BUFFER, 0);
+}   // updateUBO
+
 // ----------------------------------------------------------------------------
 /** Generate View, Projection, Inverse View, Inverse Projection, ViewProjection
  *  and InverseProjection matrixes and matrixes and cameras for the four shadow
@@ -338,12 +388,11 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
     const float oldfar = camnode->getFarValue();
     const float oldnear = camnode->getNearValue();
 
-    float tmp[16 * 9 + 2];
-    memcpy(tmp, irr_driver->getViewMatrix().pointer(),          16 * sizeof(float));
-    memcpy(&tmp[16], irr_driver->getProjMatrix().pointer(),     16 * sizeof(float));
-    memcpy(&tmp[32], irr_driver->getInvViewMatrix().pointer(),  16 * sizeof(float));
-    memcpy(&tmp[48], irr_driver->getInvProjMatrix().pointer(),  16 * sizeof(float));
-    memcpy(&tmp[64], irr_driver->getProjViewMatrix().pointer(), 16 * sizeof(float));
+    memcpy(m_ubo_data, irr_driver->getViewMatrix().pointer(),          16 * sizeof(float));
+    memcpy(&m_ubo_data[16], irr_driver->getProjMatrix().pointer(),     16 * sizeof(float));
+    memcpy(&m_ubo_data[32], irr_driver->getInvViewMatrix().pointer(),  16 * sizeof(float));
+    memcpy(&m_ubo_data[48], irr_driver->getInvProjMatrix().pointer(),  16 * sizeof(float));
+    memcpy(&m_ubo_data[64], irr_driver->getProjViewMatrix().pointer(), 16 * sizeof(float));
 
     m_sun_cam->render();
     for (unsigned i = 0; i < 4; i++)
@@ -469,27 +518,23 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
 
         size_t size = m_sun_ortho_matrices.size();
         for (unsigned i = 0; i < size; i++)
-            memcpy(&tmp[16 * i + 80],
+            memcpy(&m_ubo_data[16 * i + 80],
                    m_sun_ortho_matrices[i].pointer(),
                    16 * sizeof(float));
     }
 
-    if(!CVS->isARBUniformBufferObjectUsable())
-        return;
-    
-    tmp[144] = float(width);
-    tmp[145] = float(height);
-    glBindBuffer(GL_UNIFORM_BUFFER,
-                 SharedGPUObjects::getViewProjectionMatricesUBO());
+    m_ubo_data[144] = float(width);
+    m_ubo_data[145] = float(height);
     if (CVS->isSDSMEnabled())
     {
-        glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 5) * sizeof(float), tmp);
+        glBindBuffer(GL_UNIFORM_BUFFER,
+        SharedGPUObjects::getViewProjectionMatricesUBO());
+        glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 5) * sizeof(float),
+            m_ubo_data);
         glBufferSubData(GL_UNIFORM_BUFFER, (16 * 9) * sizeof(float),
-                        2 * sizeof(float), &tmp[144]);
+            2 * sizeof(float), &m_ubo_data[144]);
+        glBindBuffer(GL_UNIFORM_BUFFER, 0);
     }
-    else
-        glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 9 + 2) * sizeof(float),
-                        tmp);
 }   // computeMatrixesAndCameras
 
 // ----------------------------------------------------------------------------
diff --git a/src/graphics/shadow_matrices.hpp b/src/graphics/shadow_matrices.hpp
index 1a63f3f00..c7f356f34 100644
--- a/src/graphics/shadow_matrices.hpp
+++ b/src/graphics/shadow_matrices.hpp
@@ -49,6 +49,7 @@ private:
     core::matrix4              m_rsm_matrix;
     bool                       m_rsm_matrix_initialized;
     float                      m_shadows_cam[4][24];
+    float                      m_ubo_data[16 * 9 + 2];
     bool                       m_rsm_map_available;
     core::vector3df            m_rh_extend;
     core::matrix4              m_rh_matrix;
@@ -104,6 +105,7 @@ public:
         return m_shadow_scales;
     }
     // ------------------------------------------------------------------------
+    void updateUBO();
 
 };   // class ShadowMatrices
 
diff --git a/src/graphics/shared_gpu_objects.cpp b/src/graphics/shared_gpu_objects.cpp
index a04a915d9..c8eb8caa1 100644
--- a/src/graphics/shared_gpu_objects.cpp
+++ b/src/graphics/shared_gpu_objects.cpp
@@ -18,12 +18,10 @@
 #ifndef SERVER_ONLY
 
 #include "graphics/shared_gpu_objects.hpp"
+#include "config/stk_config.hpp"
 #include "graphics/central_settings.hpp"
 #include "utils/log.hpp"
 
-#include "matrix4.h"
-#include <algorithm>
-
 GLuint SharedGPUObjects::m_sky_tri_vbo;
 GLuint SharedGPUObjects::m_frustrum_vbo;
 GLuint SharedGPUObjects::m_frustrum_indices;
@@ -33,8 +31,8 @@ GLuint SharedGPUObjects::m_full_screen_quad_vao;
 GLuint SharedGPUObjects::m_ui_vao;
 GLuint SharedGPUObjects::m_quad_buffer;
 GLuint SharedGPUObjects::m_quad_vbo;
-GLuint SharedGPUObjects::m_skinning_ubo;
-int    SharedGPUObjects::m_max_mat4_size = 1024;
+GLuint SharedGPUObjects::m_skinning_tex;
+GLuint SharedGPUObjects::m_skinning_buf;
 bool   SharedGPUObjects::m_has_been_initialised = false;
 
 /** Initialises m_full_screen_quad_vbo.
@@ -158,24 +156,61 @@ void SharedGPUObjects::initLightingDataUBO()
 }   // initLightingDataUBO
 
 // ----------------------------------------------------------------------------
-void SharedGPUObjects::initSkinningUBO()
+void SharedGPUObjects::initSkinning()
 {
-    assert(CVS->isARBUniformBufferObjectUsable());
-    irr::core::matrix4 m;
-    glGenBuffers(1, &m_skinning_ubo);
-    glBindBuffer(GL_UNIFORM_BUFFER, m_skinning_ubo);
+    glGenTextures(1, &m_skinning_tex);
     int max_size = 0;
-    glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &max_size);
-    max_size = std::min(max_size, 65536);
-    m_max_mat4_size = max_size / 16 / sizeof(float);
-    Log::info("SharedGPUObjects", "Hardware skinning supported, max joints"
-        " support: %d", m_max_mat4_size);
-    glBufferData(GL_UNIFORM_BUFFER, max_size, 0, GL_STREAM_DRAW);
-    // Reserve a identity matrix for non moving mesh in animated model used by
-    // vertex shader calculation
-    glBufferSubData(GL_UNIFORM_BUFFER, 0, 16 * sizeof(float), m.pointer());
-    glBindBuffer(GL_UNIFORM_BUFFER, 0);
-}   // initSkinningUBO
+#ifdef USE_GLES2
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
+
+    if (stk_config->m_max_skinning_bones > (unsigned)max_size)
+    {
+        Log::warn("SharedGPUObjects", "Too many bones for skinning, max: %d",
+            max_size);
+        stk_config->m_max_skinning_bones = max_size;
+    }
+    Log::info("SharedGPUObjects", "Hardware Skinning enabled, method: %u"
+        " (max bones) * 16 RGBA float texture",
+        stk_config->m_max_skinning_bones);
+
+    glBindTexture(GL_TEXTURE_2D, m_skinning_tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 16,
+        stk_config->m_max_skinning_bones, 0, GL_RGBA, GL_FLOAT, NULL);
+    glBindTexture(GL_TEXTURE_2D, 0);
+#else
+
+    glGenBuffers(1, &m_skinning_buf);
+    const bool ssbo = CVS->isARBShaderStorageBufferObjectUsable();
+    glGetIntegerv(ssbo ? GL_MAX_SHADER_STORAGE_BLOCK_SIZE :
+        GL_MAX_TEXTURE_BUFFER_SIZE, &max_size);
+
+    if (stk_config->m_max_skinning_bones * 64 > (unsigned)max_size)
+    {
+        Log::warn("SharedGPUObjects", "Too many bones for skinning, max: %d",
+            max_size >> 6);
+        stk_config->m_max_skinning_bones = max_size >> 6;
+    }
+    Log::info("SharedGPUObjects", "Hardware Skinning enabled, method: %s, "
+        "max bones: %u", CVS->isARBShaderStorageBufferObjectUsable() ?
+        "SSBO" : "TBO", stk_config->m_max_skinning_bones);
+
+    const GLenum buffer = ssbo ? GL_SHADER_STORAGE_BUFFER : GL_TEXTURE_BUFFER;
+    glBindBuffer(buffer, m_skinning_buf);
+    glBufferData(buffer, stk_config->m_max_skinning_bones * 64, NULL,
+        GL_DYNAMIC_DRAW);
+    if (!ssbo)
+    {
+        glBindTexture(GL_TEXTURE_BUFFER, m_skinning_tex);
+        glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_skinning_buf);
+        glBindTexture(GL_TEXTURE_BUFFER, 0);
+    }
+    glBindBuffer(buffer, 0);
+#endif
+}   // initSkinning
 
 // ----------------------------------------------------------------------------
 void SharedGPUObjects::init()
@@ -186,13 +221,14 @@ void SharedGPUObjects::init()
     initQuadBuffer();
     initSkyTriVBO();
     initFrustrumVBO();
-
+    if (CVS->supportsHardwareSkinning())
+    {
+        initSkinning();
+    }
     if (CVS->isARBUniformBufferObjectUsable())
     {
         initShadowVPMUBO();
         initLightingDataUBO();
-        if (CVS->supportsHardwareSkinning())
-            initSkinningUBO();
     }
 
     m_has_been_initialised = true;
diff --git a/src/graphics/shared_gpu_objects.hpp b/src/graphics/shared_gpu_objects.hpp
index 8d83e46d6..2287c13fc 100644
--- a/src/graphics/shared_gpu_objects.hpp
+++ b/src/graphics/shared_gpu_objects.hpp
@@ -35,8 +35,8 @@ private:
     static GLuint m_ui_vao;
     static GLuint m_quad_buffer;
     static GLuint m_quad_vbo;
-    static GLuint m_skinning_ubo;
-    static int m_max_mat4_size;
+    static GLuint m_skinning_tex;
+    static GLuint m_skinning_buf;
 
     static void initQuadVBO();
     static void initQuadBuffer();
@@ -44,7 +44,7 @@ private:
     static void initFrustrumVBO();
     static void initShadowVPMUBO();
     static void initLightingDataUBO();
-    static void initSkinningUBO();
+    static void initSkinning();
 
 public:
     static void init();
@@ -104,16 +104,18 @@ public:
         return m_quad_vbo;
     }   // getQuadVBO
     // ------------------------------------------------------------------------
-    static GLuint getSkinningUBO()
+    static GLuint getSkinningTexture()
     {
         assert(m_has_been_initialised);
-        return m_skinning_ubo;
-    }   // getSkinningUBO
+        return m_skinning_tex;
+    }   // getSkinningTexture
     // ------------------------------------------------------------------------
-    static int getMaxMat4Size()
+    static GLuint getSkinningBuffer()
     {
-        return m_max_mat4_size;
-    }   // getMaxMat4Size
+        assert(m_has_been_initialised);
+        return m_skinning_buf;
+    }   // getSkinningBuffer
+
 };   // class SharedGPUObjects
 
 
diff --git a/src/graphics/skybox.cpp b/src/graphics/skybox.cpp
index 98211dcde..b833cd552 100644
--- a/src/graphics/skybox.cpp
+++ b/src/graphics/skybox.cpp
@@ -206,7 +206,7 @@ void Skybox::generateSpecularCubemap()
 {
     glGenTextures(1, &m_specular_probe);
     glBindTexture(GL_TEXTURE_CUBE_MAP, m_specular_probe);
-    size_t cubemap_size = 256;
+    unsigned int cubemap_size = 256;
     for (int i = 0; i < 6; i++)
     {
 #if !defined(USE_GLES2)
diff --git a/src/graphics/spherical_harmonics.cpp b/src/graphics/spherical_harmonics.cpp
index 1b5ca8e6f..f9d46061a 100644
--- a/src/graphics/spherical_harmonics.cpp
+++ b/src/graphics/spherical_harmonics.cpp
@@ -233,7 +233,8 @@ namespace
  *  \param sh_rgba The 6 cubemap faces (sRGB byte textures)
  *  \param edge_size Size of the cubemap face
  */
-void SphericalHarmonics::generateSphericalHarmonics(unsigned char *sh_rgba[6], size_t edge_size)
+void SphericalHarmonics::generateSphericalHarmonics(unsigned char *sh_rgba[6],
+                                                    unsigned int edge_size)
 {
 
 #if SIMD_SSE2_SUPPORT
@@ -644,7 +645,7 @@ void SphericalHarmonics::printCoeff() {
 *  \param Yml The sphericals harmonics functions values
 *  \param[out] output The environment map texels values
 */    
-void SphericalHarmonics::unprojectSH(size_t width, size_t height,
+void SphericalHarmonics::unprojectSH(unsigned int width, unsigned int height,
                                      float *Y00[], float *Y1minus1[], float *Y10[],
                                      float *Y11[], float *Y2minus2[], float *Y2minus1[],
                                      float *Y20[], float *Y21[], float *Y22[],
diff --git a/src/graphics/spherical_harmonics.hpp b/src/graphics/spherical_harmonics.hpp
index 3e803a332..3e6fd7695 100644
--- a/src/graphics/spherical_harmonics.hpp
+++ b/src/graphics/spherical_harmonics.hpp
@@ -49,7 +49,7 @@ private:
     /** The spherical harmonics coefficients */
     SHCoefficients *m_SH_coeff;
 
-    void generateSphericalHarmonics(unsigned char *sh_rgba[6], size_t edge_size);
+    void generateSphericalHarmonics(unsigned char *sh_rgba[6], unsigned int edge_size);
     
 public:
     SphericalHarmonics(const std::vector<irr::video::ITexture *> &spherical_harmonics_textures);
@@ -65,7 +65,7 @@ public:
     
     void printCoeff();
     
-    void unprojectSH (size_t width, size_t height,
+    void unprojectSH (unsigned int width, unsigned int height,
                       float *Y00[], float *Y1minus1[], float *Y10[],
                       float *Y11[], float *Y2minus2[], float *Y2minus1[],
                       float * Y20[], float *Y21[], float *Y22[],
diff --git a/src/graphics/stk_animated_mesh.cpp b/src/graphics/stk_animated_mesh.cpp
index 275baacc4..2d8d69c59 100644
--- a/src/graphics/stk_animated_mesh.cpp
+++ b/src/graphics/stk_animated_mesh.cpp
@@ -378,9 +378,15 @@ void STKAnimatedMesh::uploadJoints(const irr::core::matrix4& m,
                                    int joint, int offset)
 {
     assert(offset != -1);
-    glBindBuffer(GL_UNIFORM_BUFFER, SharedGPUObjects::getSkinningUBO());
-    glBufferSubData(GL_UNIFORM_BUFFER, offset + joint * 16 * sizeof(float),
+#ifdef USE_GLES2
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, (offset >> 6) + joint, 16, 1, GL_RGBA,
+        GL_FLOAT, m.pointer());
+#else
+    glBufferSubData(CVS->isARBShaderStorageBufferObjectUsable() ?
+        GL_SHADER_STORAGE_BUFFER : GL_TEXTURE_BUFFER,
+        offset + joint * 16 * sizeof(float),
         16 * sizeof(float), m.pointer());
+#endif
 }
 
 #endif   // !SERVER_ONLY
diff --git a/src/graphics/stk_mesh.cpp b/src/graphics/stk_mesh.cpp
index a7a3bcd7d..4fec00fb0 100644
--- a/src/graphics/stk_mesh.cpp
+++ b/src/graphics/stk_mesh.cpp
@@ -193,9 +193,9 @@ GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type)
         glEnableVertexAttribArray(4);
         glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)44);
         glEnableVertexAttribArray(5);
-        glVertexAttribIPointer(5, 4, GL_INT, getVertexPitchFromType(type), (GLvoid*)60);
+        glVertexAttribIPointer(5, 4, GL_SHORT, getVertexPitchFromType(type), (GLvoid*)60);
         glEnableVertexAttribArray(6);
-        glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)76);
+        glVertexAttribPointer(6, 4, GL_HALF_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)68);
         break;
     default:
         assert(0 && "Wrong vertex type");
diff --git a/src/graphics/stk_mesh.hpp b/src/graphics/stk_mesh.hpp
index 09eb771bd..fb6c96735 100644
--- a/src/graphics/stk_mesh.hpp
+++ b/src/graphics/stk_mesh.hpp
@@ -52,11 +52,11 @@ struct GLMesh
     video::ITexture *textures[8];
     GLenum PrimitiveType;
     GLenum IndexType;
-    size_t IndexCount;
-    size_t Stride;
+    unsigned int IndexCount;
+    unsigned int Stride;
     core::vector2df texture_trans;
-    size_t vaoBaseVertex;
-    size_t vaoOffset;
+    unsigned int vaoBaseVertex;
+    intptr_t vaoOffset;
     video::E_VERTEX_TYPE VAOType;
     uint64_t TextureHandles[8];
     scene::IMeshBuffer *mb;
@@ -72,7 +72,7 @@ GLMesh               allocateMeshBuffer(scene::IMeshBuffer* mb,
                                         const std::string& debug_name,
                                         RenderInfo* render_info);
 void                 fillLocalBuffer(GLMesh &, scene::IMeshBuffer* mb);
-video::E_VERTEX_TYPE getVTXTYPEFromStride(size_t stride);
+video::E_VERTEX_TYPE getVTXTYPEFromStride(unsigned int stride);
 GLuint               createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type);
 core::matrix4        computeMVP(const core::matrix4 &ModelViewProjectionMatrix);
 bool                 isObject(video::E_MATERIAL_TYPE type);
diff --git a/src/graphics/stk_mesh_scene_node.cpp b/src/graphics/stk_mesh_scene_node.cpp
index f06fa3d00..a1f92e499 100644
--- a/src/graphics/stk_mesh_scene_node.cpp
+++ b/src/graphics/stk_mesh_scene_node.cpp
@@ -158,7 +158,7 @@ void STKMeshSceneNode::drawGlow(const GLMesh &mesh)
 
     GLenum ptype = mesh.PrimitiveType;
     GLenum itype = mesh.IndexType;
-    size_t count = mesh.IndexCount;
+    unsigned int count = mesh.IndexCount;
     ColorizeShader::getInstance()->setUniforms(AbsoluteTransformation, video::SColorf(glowcolor.getRed() / 255.f, glowcolor.getGreen() / 255.f, glowcolor.getBlue() / 255.f));
     glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh.vaoOffset, mesh.vaoBaseVertex);
 }
@@ -352,7 +352,7 @@ void STKMeshSceneNode::render()
             GLMesh &mesh = GLmeshes[i];
             GLenum ptype = mesh.PrimitiveType;
             GLenum itype = mesh.IndexType;
-            size_t count = mesh.IndexCount;
+            unsigned int count = mesh.IndexCount;
 
 #if !defined(USE_GLES2)
             if (CVS->isAZDOEnabled())
@@ -392,7 +392,7 @@ void STKMeshSceneNode::render()
             GLMesh &mesh = GLmeshes[i];
             GLenum ptype = mesh.PrimitiveType;
             GLenum itype = mesh.IndexType;
-            size_t count = mesh.IndexCount;
+            unsigned int count = mesh.IndexCount;
 
 #if !defined(USE_GLES2)
             if (CVS->isAZDOEnabled())
@@ -484,7 +484,7 @@ void STKMeshSceneNode::render()
                     irr_driver->increaseObjectCount();
                     GLenum ptype = mesh.PrimitiveType;
                     GLenum itype = mesh.IndexType;
-                    size_t count = mesh.IndexCount;
+                    unsigned int count = mesh.IndexCount;
 
                     // This function is only called once per frame - thus no need for setters.
                     const float fogmax = track->getFogMax();
@@ -531,7 +531,7 @@ void STKMeshSceneNode::render()
                     GLMesh &mesh = GLmeshes[i];
                     GLenum ptype = mesh.PrimitiveType;
                     GLenum itype = mesh.IndexType;
-                    size_t count = mesh.IndexCount;
+                    unsigned int count = mesh.IndexCount;
 
 #if !defined(USE_GLES2)
                     if (CVS->isAZDOEnabled())
diff --git a/src/graphics/stk_particle.cpp b/src/graphics/stk_particle.cpp
index 5868c46d7..cb282e25c 100644
--- a/src/graphics/stk_particle.cpp
+++ b/src/graphics/stk_particle.cpp
@@ -253,11 +253,11 @@ void STKParticle::generate(std::vector<CPUParticle>* out)
         {
             if (m_hm != NULL)
             {
-                stimulateHeightMap(i, active_count, NULL);
+                stimulateHeightMap((float)i, active_count, NULL);
             }
             else
             {
-                stimulateNormal(i, active_count, NULL);
+                stimulateNormal((float)i, active_count, NULL);
             }
         }
         m_first_execution = false;
@@ -513,6 +513,10 @@ void STKParticle::OnRegisterSceneNode()
             continue;
         }
         scene::SParticle p;
+        p.startTime = 0;
+        p.endTime = 0;
+        p.color = 0;
+        p.startColor = 0;
         p.pos = m_particles_generating[i].m_position;
         Buffer->BoundingBox.addInternalPoint(p.pos);
         p.size = core::dimension2df(m_particles_generating[i].m_size,
diff --git a/src/graphics/stk_texture.cpp b/src/graphics/stk_texture.cpp
index b4007851d..bb53e9f4a 100644
--- a/src/graphics/stk_texture.cpp
+++ b/src/graphics/stk_texture.cpp
@@ -65,7 +65,7 @@ STKTexture::STKTexture(const std::string& path, TexConfig* tc, bool no_upload)
 }   // STKTexture
 
 // ----------------------------------------------------------------------------
-STKTexture::STKTexture(uint8_t* data, const std::string& name, size_t size,
+STKTexture::STKTexture(uint8_t* data, const std::string& name, unsigned int size,
                        bool single_channel, bool delete_ttl)
           : video::ITexture(name.c_str()), m_texture_handle(0),
             m_single_channel(single_channel), m_tex_config(NULL),
diff --git a/src/graphics/stk_texture.hpp b/src/graphics/stk_texture.hpp
index 3eb09c0b2..7ac07798b 100644
--- a/src/graphics/stk_texture.hpp
+++ b/src/graphics/stk_texture.hpp
@@ -90,7 +90,7 @@ public:
     // ------------------------------------------------------------------------
     STKTexture(const std::string& path, TexConfig* tc, bool no_upload = false);
     // ------------------------------------------------------------------------
-    STKTexture(uint8_t* data, const std::string& name, size_t size,
+    STKTexture(uint8_t* data, const std::string& name, unsigned int size,
                bool single_channel = false, bool delete_ttl = false);
     // ------------------------------------------------------------------------
     STKTexture(video::IImage* img, const std::string& name);
diff --git a/src/graphics/texture_shader.hpp b/src/graphics/texture_shader.hpp
index 1fc52555b..1a883c5c2 100644
--- a/src/graphics/texture_shader.hpp
+++ b/src/graphics/texture_shader.hpp
@@ -177,6 +177,7 @@ public:
     template<int N, typename... TexIds>
     void setTextureUnitsImpl(GLuint tex_id, TexIds... args)
     {
+        static_assert(N != 15, "15 is reserved for skinning texture");
 #if defined(USE_GLES2)
         if (CVS->getGLSLVersion() >= 300)
 #else
diff --git a/src/graphics/vao_manager.cpp b/src/graphics/vao_manager.cpp
index e553162d0..c6aa4b564 100644
--- a/src/graphics/vao_manager.cpp
+++ b/src/graphics/vao_manager.cpp
@@ -83,7 +83,9 @@ VAOManager::~VAOManager()
 }
 
 static void
-resizeBufferIfNecessary(size_t &lastIndex, size_t newLastIndex, size_t& bufferSize, size_t stride, GLenum type, GLuint &id, void *&Pointer)
+resizeBufferIfNecessary(unsigned int &lastIndex, unsigned int  newLastIndex,
+                        unsigned int &bufferSize, unsigned int stride, GLenum type,
+                        GLuint &id, void *&Pointer)
 {
     if (newLastIndex >= bufferSize)
     {
@@ -116,11 +118,14 @@ resizeBufferIfNecessary(size_t &lastIndex, size_t newLastIndex, size_t& bufferSi
     lastIndex = newLastIndex;
 }
 
-void VAOManager::regenerateBuffer(enum VTXTYPE tp, size_t newlastvertex, size_t newlastindex)
+void VAOManager::regenerateBuffer(enum VTXTYPE tp, unsigned int newlastvertex,
+                                  unsigned int newlastindex)
 {
     glBindVertexArray(0);
-    resizeBufferIfNecessary(last_vertex[tp], newlastvertex, RealVBOSize[tp], getVertexPitch(tp), GL_ARRAY_BUFFER, vbo[tp], VBOPtr[tp]);
-    resizeBufferIfNecessary(last_index[tp], newlastindex, RealIBOSize[tp], sizeof(u16), GL_ELEMENT_ARRAY_BUFFER, ibo[tp], IBOPtr[tp]);
+    resizeBufferIfNecessary(last_vertex[tp], newlastvertex, RealVBOSize[tp],
+                            getVertexPitch(tp), GL_ARRAY_BUFFER, vbo[tp], VBOPtr[tp]);
+    resizeBufferIfNecessary(last_index[tp], newlastindex, RealIBOSize[tp],
+                            sizeof(u16), GL_ELEMENT_ARRAY_BUFFER, ibo[tp], IBOPtr[tp]);
 }
 
 void VAOManager::regenerateVAO(enum VTXTYPE tp)
@@ -265,7 +270,7 @@ void VAOManager::regenerateInstancedVAO()
 
 }
 
-size_t VAOManager::getVertexPitch(enum VTXTYPE tp) const
+unsigned int VAOManager::getVertexPitch(enum VTXTYPE tp) const
 {
     switch (tp)
     {
@@ -318,8 +323,8 @@ irr::video::E_VERTEX_TYPE VAOManager::getVertexType(enum VTXTYPE tp)
 
 void VAOManager::append(scene::IMeshBuffer *mb, VTXTYPE tp)
 {
-    size_t old_vtx_cnt = last_vertex[tp];
-    size_t old_idx_cnt = last_index[tp];
+    unsigned int old_vtx_cnt = last_vertex[tp];
+    unsigned int old_idx_cnt = last_index[tp];
 
     regenerateBuffer(tp, old_vtx_cnt + mb->getVertexCount(), old_idx_cnt + mb->getIndexCount());
 #if !defined(USE_GLES2)
diff --git a/src/graphics/vao_manager.hpp b/src/graphics/vao_manager.hpp
index 2799fd83f..e93388c61 100644
--- a/src/graphics/vao_manager.hpp
+++ b/src/graphics/vao_manager.hpp
@@ -194,16 +194,16 @@ class VAOManager : public Singleton<VAOManager>
     GLuint instance_vbo[InstanceTypeCount];
     void *Ptr[InstanceTypeCount];
     void *VBOPtr[VTXTYPE_COUNT], *IBOPtr[VTXTYPE_COUNT];
-    size_t RealVBOSize[VTXTYPE_COUNT], RealIBOSize[VTXTYPE_COUNT];
-    size_t last_vertex[VTXTYPE_COUNT], last_index[VTXTYPE_COUNT];
+    unsigned int RealVBOSize[VTXTYPE_COUNT], RealIBOSize[VTXTYPE_COUNT];
+    unsigned int last_vertex[VTXTYPE_COUNT], last_index[VTXTYPE_COUNT];
     std::unordered_map<irr::scene::IMeshBuffer*, unsigned> mappedBaseVertex[VTXTYPE_COUNT], mappedBaseIndex[VTXTYPE_COUNT];
     std::map<std::pair<irr::video::E_VERTEX_TYPE, InstanceType>, GLuint> InstanceVAO;
 
     void cleanInstanceVAOs();
-    void regenerateBuffer(enum VTXTYPE, size_t, size_t);
+    void regenerateBuffer(enum VTXTYPE, unsigned int, unsigned int);
     void regenerateVAO(enum VTXTYPE);
     void regenerateInstancedVAO();
-    size_t getVertexPitch(enum VTXTYPE) const;
+    unsigned int getVertexPitch(enum VTXTYPE) const;
     VTXTYPE getVTXTYPE(irr::video::E_VERTEX_TYPE type);
     irr::video::E_VERTEX_TYPE getVertexType(enum VTXTYPE tp);
     void append(irr::scene::IMeshBuffer *, VTXTYPE tp);
diff --git a/src/guiengine/abstract_state_manager.hpp b/src/guiengine/abstract_state_manager.hpp
index cd5d4d5e4..91a794def 100644
--- a/src/guiengine/abstract_state_manager.hpp
+++ b/src/guiengine/abstract_state_manager.hpp
@@ -170,7 +170,10 @@ namespace GUIEngine
         // --------------------------------------------------------------------
         /** Returns the number of screens on the stack. Is used to decide
          *  if exiting a screen would cause STK to end or not. */
-        unsigned int getMenuStackSize() const { return m_menu_stack.size(); }
+        unsigned int getMenuStackSize() const
+        { 
+            return (unsigned int)m_menu_stack.size();
+        }
     };   // Class AbstractStateManager
 
 }   // GUIEngine
diff --git a/src/guiengine/widgets/spinner_widget.cpp b/src/guiengine/widgets/spinner_widget.cpp
index 24270ebb5..07f124516 100644
--- a/src/guiengine/widgets/spinner_widget.cpp
+++ b/src/guiengine/widgets/spinner_widget.cpp
@@ -318,7 +318,7 @@ void SpinnerWidget::addLabel(stringw label)
 {
     m_labels.push_back(label);
     m_min = 0;
-    m_max = m_labels.size()-1;
+    m_max = (int)m_labels.size()-1;
 
     if (m_element != NULL) setValue(0);
 }
diff --git a/src/input/input_manager.cpp b/src/input/input_manager.cpp
index 1b6b21056..2c8c64932 100644
--- a/src/input/input_manager.cpp
+++ b/src/input/input_manager.cpp
@@ -1038,7 +1038,7 @@ EventPropagation InputManager::input(const SEvent& event)
     else if (event.EventType == EET_TOUCH_INPUT_EVENT)
     {
         MultitouchDevice* device = m_device_manager->getMultitouchDevice();
-        unsigned int id = event.TouchInput.ID;
+        unsigned int id = (unsigned int)event.TouchInput.ID;
 
         if (device != NULL && id < device->m_events.size())
         {
diff --git a/src/input/multitouch_device.hpp b/src/input/multitouch_device.hpp
index 8dd21d153..4cc6fd0ad 100644
--- a/src/input/multitouch_device.hpp
+++ b/src/input/multitouch_device.hpp
@@ -114,7 +114,7 @@ public:
     void reset();
 
     /** Returns the number of created buttons */
-    unsigned int getButtonsCount() {return m_buttons.size();}
+    unsigned int getButtonsCount() { return (unsigned int)m_buttons.size();}
 
     /** Returns pointer to the selected button */
     MultitouchButton* getButton(unsigned int i) {return m_buttons.at(i);}
diff --git a/src/karts/kart.cpp b/src/karts/kart.cpp
index 4b7a21f13..31eef47f9 100644
--- a/src/karts/kart.cpp
+++ b/src/karts/kart.cpp
@@ -828,7 +828,7 @@ float Kart::getSpeedForTurnRadius(float radius) const
 {
     InterpolationArray turn_angle_at_speed = m_kart_properties->getTurnRadius();
     // Convert the turn radius into turn angle
-    for(std::size_t i = 0; i < turn_angle_at_speed.size(); i++)
+    for(int i = 0; i < (int)turn_angle_at_speed.size(); i++)
         turn_angle_at_speed.setY(i, sin(m_kart_properties->getWheelBase() /
             turn_angle_at_speed.getY(i)));
 
@@ -842,7 +842,7 @@ float Kart::getMaxSteerAngle(float speed) const
 {
     InterpolationArray turn_angle_at_speed = m_kart_properties->getTurnRadius();
     // Convert the turn radius into turn angle
-    for(std::size_t i = 0; i < turn_angle_at_speed.size(); i++)
+    for(int i = 0; i < (int)turn_angle_at_speed.size(); i++)
         turn_angle_at_speed.setY(i, sin(m_kart_properties->getWheelBase() /
             turn_angle_at_speed.getY(i)));
 
diff --git a/src/karts/kart_model.cpp b/src/karts/kart_model.cpp
index 4aeaa80f3..71eb1a2eb 100644
--- a/src/karts/kart_model.cpp
+++ b/src/karts/kart_model.cpp
@@ -570,7 +570,8 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool human_playe
             m_animated_node->getJointNode(m_hat_bone.c_str()) : node;
         scene::IMesh* hat_mesh = irr_driver->getAnimatedMesh
             (file_manager->getAsset(FileManager::MODEL, m_hat_name));
-        scene::ISceneNode* node = irr_driver->addMesh(hat_mesh, "hat", parent);
+        scene::ISceneNode* node = irr_driver->addMesh(hat_mesh, "hat", parent,
+            getRenderInfo());
         configNode(node, *m_hat_location, bone_attachment ?
                 getInverseBoneMatrix(m_hat_bone) : core::matrix4());
     }
diff --git a/src/modes/follow_the_leader.cpp b/src/modes/follow_the_leader.cpp
index 06cf0b461..4de734069 100644
--- a/src/modes/follow_the_leader.cpp
+++ b/src/modes/follow_the_leader.cpp
@@ -251,7 +251,7 @@ void FollowTheLeaderRace::terminateRace()
     endSetKartPositions();
 
     // Mark all still racing karts to be finished.
-    for (int i = m_karts.size(); i>0; i--)
+    for (int i = (int)m_karts.size(); i>0; i--)
     {
         AbstractKart *kart = getKartAtPosition(i);
         if (kart->isEliminated() || kart->hasFinishedRace())
diff --git a/src/modes/soccer_world.cpp b/src/modes/soccer_world.cpp
index 43cfced9c..61e3363e2 100644
--- a/src/modes/soccer_world.cpp
+++ b/src/modes/soccer_world.cpp
@@ -618,7 +618,7 @@ void SoccerWorld::enterRaceOverState()
         std::sort(m_goal_frame.begin(), m_goal_frame.end());
 
         const int mean = std::accumulate(m_goal_frame.begin(),
-            m_goal_frame.end(), 0) / m_goal_frame.size();
+            m_goal_frame.end(), 0) / (int)m_goal_frame.size();
 
         // Prevent overflow if there is a large frame in vector
         double squared_sum = 0;
@@ -660,9 +660,9 @@ void SoccerWorld::enterRaceOverState()
         }
 
         int red_goal = ((int(m_red_scorers.size()) - blue_own_goal) >= 0 ?
-            m_red_scorers.size() - blue_own_goal : 0);
+            (int)m_red_scorers.size() - blue_own_goal : 0);
         int blue_goal = ((int(m_blue_scorers.size()) - red_own_goal) >= 0 ?
-            m_blue_scorers.size() - red_own_goal : 0);
+            (int)m_blue_scorers.size() - red_own_goal : 0);
 
         Log::verbose("Soccer AI profiling", "Red goal: %d, Red own goal: %d,"
             "Blue goal: %d, Blue own goal: %d", red_goal, red_own_goal,
diff --git a/src/modes/soccer_world.hpp b/src/modes/soccer_world.hpp
index 701b848f5..495f9f6e1 100644
--- a/src/modes/soccer_world.hpp
+++ b/src/modes/soccer_world.hpp
@@ -340,8 +340,8 @@ public:
     // ------------------------------------------------------------------------
     int getScore(SoccerTeam team) const
     {
-        return (team == SOCCER_TEAM_BLUE ? m_blue_scorers.size() :
-            m_red_scorers.size());
+        return (int)(team == SOCCER_TEAM_BLUE ? m_blue_scorers.size()
+                                              : m_red_scorers.size());
     }
     // ------------------------------------------------------------------------
     const std::vector<ScorerData>& getScorers(SoccerTeam team) const
diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index e22a2bb7d..3b47eebca 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -655,7 +655,7 @@ void ThreeStrikesBattle::spawnSpareTireKarts()
     if (ratio < 1.5f) return;
     unsigned int spawn_sta = unsigned(ratio);
     if (spawn_sta > m_spare_tire_karts.size())
-        spawn_sta = m_spare_tire_karts.size();
+        spawn_sta = (int)m_spare_tire_karts.size();
     m_race_gui->addMessage(_P("%i spare tire kart has been spawned!",
                               "%i spare tire karts have been spawned!",
                               spawn_sta), NULL, 2.0f);
@@ -714,15 +714,15 @@ void ThreeStrikesBattle::loadCustomModels()
 
             // Compute a random kart list
             std::vector<std::string> sta_list;
-            kart_properties_manager->getRandomKartList(pos.size(), NULL,
-                &sta_list);
+            kart_properties_manager->getRandomKartList((int)pos.size(), NULL,
+                                                       &sta_list);
 
             assert(sta_list.size() == pos.size());
             // Now add them
             for (unsigned int i = 0; i < pos.size(); i++)
             {
-                AbstractKart* sta = new Kart(sta_list[i], m_karts.size(),
-                    m_karts.size() + 1, pos[i], PLAYER_DIFFICULTY_NORMAL,
+                AbstractKart* sta = new Kart(sta_list[i], (int)m_karts.size(),
+                    (int)m_karts.size() + 1, pos[i], PLAYER_DIFFICULTY_NORMAL,
                     KRT_RED);
                 sta->init(RaceManager::KartType::KT_SPARE_TIRE);
                 sta->setController(new SpareTireAI(sta));
diff --git a/src/modes/world.cpp b/src/modes/world.cpp
index 93ae8c83d..d6fac88f9 100644
--- a/src/modes/world.cpp
+++ b/src/modes/world.cpp
@@ -1202,10 +1202,15 @@ void World::eliminateKart(int kart_id, bool notify_of_elimination)
                 m_race_gui->addMessage(_("You have been eliminated!"), kart,
                                        2.0f);
             else
+            {
+                // Store the temporary string because clang would mess this up
+                // (remove the stringw before the wchar_t* is used).
+                const core::stringw &kart_name = kart->getName();
                 m_race_gui->addMessage(_("'%s' has been eliminated.",
-                                       kart->getName()),
+                                       kart_name),
                                        camera->getKart(),
                                        2.0f);
+            }
         }  // for i < number of cameras
     }   // if notify_of_elimination
 
diff --git a/src/network/event.cpp b/src/network/event.cpp
index e83550ad3..8aa30dc82 100644
--- a/src/network/event.cpp
+++ b/src/network/event.cpp
@@ -49,7 +49,7 @@ Event::Event(ENetEvent* event)
     if (m_type == EVENT_TYPE_MESSAGE)
     {
         m_data = new NetworkString(event->packet->data, 
-                                      event->packet->dataLength);
+                                   (int)event->packet->dataLength);
     }
     else
         m_data = NULL;
diff --git a/src/network/network_string.cpp b/src/network/network_string.cpp
index 38363ddaa..61089c7eb 100644
--- a/src/network/network_string.cpp
+++ b/src/network/network_string.cpp
@@ -75,7 +75,7 @@ void NetworkString::unitTesting()
  *  the characters of the given string. */
 BareNetworkString& BareNetworkString::encodeString(const std::string &value)
 {
-    int len = value.size();
+    int len = (int)value.size();
     if(len<=255)
         return this->addUInt8(len).addString(value);
     else
diff --git a/src/network/network_string.hpp b/src/network/network_string.hpp
index 0c521107a..4e2239259 100644
--- a/src/network/network_string.hpp
+++ b/src/network/network_string.hpp
@@ -171,7 +171,7 @@ public:
      *  difference to size() happens if the string to be sent was previously
      *  read, and has m_current_offset != 0. Even in this case the whole
      *  string must be sent. */
-    unsigned int getTotalSize() const { return m_buffer.size(); }
+    unsigned int getTotalSize() const { return (unsigned int)m_buffer.size(); }
     // ------------------------------------------------------------------------
     // All functions related to adding data to a network string
     /** Add 8 bit unsigned int. */
diff --git a/src/network/protocol.cpp b/src/network/protocol.cpp
index 269633c4f..d5f70f10f 100644
--- a/src/network/protocol.cpp
+++ b/src/network/protocol.cpp
@@ -53,9 +53,9 @@ Protocol::~Protocol()
 /** Returns a network string with the given type.
  *  \capacity Default preallocated size for the message.
  */
-NetworkString* Protocol::getNetworkString(int capacity)
+NetworkString* Protocol::getNetworkString(size_t capacity)
 {
-    return new NetworkString(m_type, capacity);
+    return new NetworkString(m_type, (int)capacity);
 }   // getNetworkString
 
 // ----------------------------------------------------------------------------
diff --git a/src/network/protocol.hpp b/src/network/protocol.hpp
index 12d3412fa..07e82fb54 100644
--- a/src/network/protocol.hpp
+++ b/src/network/protocol.hpp
@@ -128,7 +128,7 @@ public:
     virtual void asynchronousUpdate() = 0;
 
     /// functions to check incoming data easily
-    NetworkString* getNetworkString(int capacity=16);
+    NetworkString* getNetworkString(size_t capacity = 16);
     bool checkDataSize(Event* event, unsigned int minimum_size);
     void sendMessageToPeersChangingToken(NetworkString *message,
                                          bool reliable = true);
diff --git a/src/network/protocols/latency_protocol.cpp b/src/network/protocols/latency_protocol.cpp
index cffae92f2..f37f9d463 100644
--- a/src/network/protocols/latency_protocol.cpp
+++ b/src/network/protocols/latency_protocol.cpp
@@ -128,7 +128,7 @@ void LatencyProtocol::asynchronousUpdate()
         {
             NetworkString *ping_request = 
                             getNetworkString(5);
-            ping_request->addUInt8(1).addUInt32(m_pings[i].size());
+            ping_request->addUInt8(1).addUInt32((int)m_pings[i].size());
             m_pings[i] [ m_pings_count ] = current_time;
             peers[i]->sendPacket(ping_request, false);
             delete ping_request;
diff --git a/src/network/rewind_manager.cpp b/src/network/rewind_manager.cpp
index 7d33a764a..ee2a565a5 100644
--- a/src/network/rewind_manager.cpp
+++ b/src/network/rewind_manager.cpp
@@ -172,7 +172,7 @@ unsigned int RewindManager::findFirstIndex(float target_time) const
 #ifdef REWIND_SEARCH_STATS
     m_count_of_searches++;
 #endif
-    int index = m_rewind_info.size()-1;
+    int index = (int)m_rewind_info.size()-1;
     int index_last_state = -1;
     while(index>=0)
     {
@@ -294,7 +294,7 @@ void RewindManager::rewindTo(float rewind_time)
 
     // Then undo the rewind infos going backwards in time
     // --------------------------------------------------
-    for(int i=m_rewind_info.size()-1; i>=(int)index; i--)
+    for(int i=(int)m_rewind_info.size()-1; i>=(int)index; i--)
     {
         m_rewind_info[i]->undo();
 
diff --git a/src/network/stk_host.cpp b/src/network/stk_host.cpp
index 0583a88a9..62190c64f 100644
--- a/src/network/stk_host.cpp
+++ b/src/network/stk_host.cpp
@@ -618,7 +618,7 @@ void STKHost::handleDirectSocketRequest()
         // current players, and the client's ip address and port
         // number (which solves the problem which network interface
         // might be the right one if there is more than one).
-        BareNetworkString s(name.size()+1+11);
+        BareNetworkString s((int)name.size()+1+11);
         s.encodeString(name);
         s.addUInt8(NetworkConfig::get()->getMaxPlayers());
         s.addUInt8(0);   // FIXME: current number of connected players
diff --git a/src/race/grand_prix_data.cpp b/src/race/grand_prix_data.cpp
index 7890406f9..1a662f091 100644
--- a/src/race/grand_prix_data.cpp
+++ b/src/race/grand_prix_data.cpp
@@ -499,9 +499,9 @@ bool GrandPrixData::isEditable() const
 unsigned int GrandPrixData::getNumberOfTracks(bool includeLocked) const
 {
     if (includeLocked)
-        return m_tracks.size();
+        return (unsigned int)m_tracks.size();
     else
-        return getTrackNames(false).size();
+        return (unsigned int)getTrackNames(false).size();
 }   // getNumberOfTracks
 
 // ----------------------------------------------------------------------------
diff --git a/src/race/race_manager.cpp b/src/race/race_manager.cpp
index 7808712a1..8ac486314 100644
--- a/src/race/race_manager.cpp
+++ b/src/race/race_manager.cpp
@@ -338,7 +338,7 @@ void RaceManager::startNew(bool from_overworld)
                                          ->getUniqueID(),
                                          m_grand_prix.getId(),
                                          m_minor_mode,
-                                         m_player_karts.size());
+                                         (unsigned int)m_player_karts.size());
     
             // Saved GP only in offline mode
             if (m_continue_saved_gp)
@@ -394,7 +394,7 @@ void RaceManager::startNew(bool from_overworld)
 
     // Then add the AI karts (randomly chosen)
     // ----------------------------------------
-    const unsigned int ai_kart_count = m_ai_kart_list.size();
+    const unsigned int ai_kart_count = (unsigned int)m_ai_kart_list.size();
     for(unsigned int i = 0; i < ai_kart_count; i++)
     {
         m_kart_status.push_back(KartStatus(m_ai_kart_list[i], i, -1, -1,
@@ -445,7 +445,7 @@ void RaceManager::startNew(bool from_overworld)
                                              ->getUniqueID(),
                                              m_grand_prix.getId(),
                                              m_minor_mode,
-                                             m_player_karts.size());
+                                             (unsigned int)m_player_karts.size());
             }   // while m_saved_gp
         }   // if m_continue_saved_gp
     }   // if grand prix
diff --git a/src/replay/replay_play.cpp b/src/replay/replay_play.cpp
index 923374af9..1ea3609de 100644
--- a/src/replay/replay_play.cpp
+++ b/src/replay/replay_play.cpp
@@ -218,7 +218,7 @@ bool ReplayPlay::addReplayFile(const std::string& fn, bool custom_replay)
     assert(m_replay_file_list.size() > 0);
     // Force to use custom replay file immediately
     if (custom_replay)
-        m_current_replay_file = m_replay_file_list.size() - 1;
+        m_current_replay_file = (unsigned int)m_replay_file_list.size() - 1;
 
     return true;
 
diff --git a/src/replay/replay_play.hpp b/src/replay/replay_play.hpp
index 04b6ed7b4..86c9a99b9 100644
--- a/src/replay/replay_play.hpp
+++ b/src/replay/replay_play.hpp
@@ -132,15 +132,16 @@ public:
                                           { return m_replay_file_list.at(n); }
     // ------------------------------------------------------------------------
     const unsigned int getNumReplayFile() const
-                                         { return m_replay_file_list.size(); }
+                           { return (unsigned int)m_replay_file_list.size(); }
     // ------------------------------------------------------------------------
     GhostKart*         getGhostKart(int n)    { return m_ghost_karts.get(n); }
     // ------------------------------------------------------------------------
     const unsigned int getNumGhostKart() const
     {
         assert(m_replay_file_list.size() > 0);
-        return m_replay_file_list.at(m_current_replay_file).m_kart_list.size();
-    }
+        return (unsigned int)m_replay_file_list.at(m_current_replay_file)
+                                               .m_kart_list.size();
+    }   // getNumGhostKart
     // ------------------------------------------------------------------------
     const std::string& getGhostKartName(int n) const
     {
diff --git a/src/scriptengine/script_challenges.cpp b/src/scriptengine/script_challenges.cpp
index 792b21697..d1340afaa 100644
--- a/src/scriptengine/script_challenges.cpp
+++ b/src/scriptengine/script_challenges.cpp
@@ -53,7 +53,7 @@ namespace Scripting
         /** Get total number of challenges */
         int getChallengeCount()
         {
-            return ::Track::getCurrentTrack()->getChallengeList().size();
+            return (int)::Track::getCurrentTrack()->getChallengeList().size();
         }   // getChallengeCount
 
         // --------------------------------------------------------------------
diff --git a/src/scriptengine/script_engine.cpp b/src/scriptengine/script_engine.cpp
index 388c9d0fb..47458c93d 100644
--- a/src/scriptengine/script_engine.cpp
+++ b/src/scriptengine/script_engine.cpp
@@ -108,7 +108,7 @@ namespace Scripting
         // Read the entire file
         std::string script;
         script.resize(len);
-        int c = fread(&script[0], len, 1, f);
+        size_t c = fread(&script[0], len, 1, f);
         fclose(f);
         if (c != 1)
         {
diff --git a/src/scriptengine/script_track.cpp b/src/scriptengine/script_track.cpp
index 114657ba7..a377bade7 100644
--- a/src/scriptengine/script_track.cpp
+++ b/src/scriptengine/script_track.cpp
@@ -270,7 +270,7 @@ namespace Scripting
             {
                 if (memory)
                 {
-                    return ((scene::IAnimatedMeshSceneNode*)(memory))->getFrameNr();
+                    return (int)((scene::IAnimatedMeshSceneNode*)(memory))->getFrameNr();
                 }
                 return -1;
             }
@@ -290,7 +290,7 @@ namespace Scripting
             {
                 if (memory)
                 {
-                    ((scene::IAnimatedMeshSceneNode*)(memory))->setCurrentFrame(frame);
+                    ((scene::IAnimatedMeshSceneNode*)(memory))->setCurrentFrame((float)frame);
                 }
             }
 
diff --git a/src/states_screens/arenas_screen.cpp b/src/states_screens/arenas_screen.cpp
index 24d90ee93..ff60893de 100644
--- a/src/states_screens/arenas_screen.cpp
+++ b/src/states_screens/arenas_screen.cpp
@@ -342,7 +342,7 @@ void ArenasScreen::buildTrackList()
     if (m_unsupported_arena.size() > 0)
         w->setText( _P("%d arena unavailable in single player.",
                        "%d arenas unavailable in single player.",
-                       m_unsupported_arena.size()) );
+                       (int)m_unsupported_arena.size()) );
 }
 
 // ------------------------------------------------------------------------------------------------------
diff --git a/src/states_screens/dialogs/custom_video_settings.cpp b/src/states_screens/dialogs/custom_video_settings.cpp
index 939320533..2ceda81a5 100644
--- a/src/states_screens/dialogs/custom_video_settings.cpp
+++ b/src/states_screens/dialogs/custom_video_settings.cpp
@@ -17,6 +17,7 @@
 
 #include "states_screens/dialogs/custom_video_settings.hpp"
 
+#include "config/stk_config.hpp"
 #include "config/user_config.hpp"
 #include "guiengine/widgets/check_box_widget.hpp"
 #include "guiengine/widgets/spinner_widget.hpp"
@@ -24,7 +25,6 @@
 #include "utils/translation.hpp"
 #include "graphics/central_settings.hpp"
 #include "graphics/irr_driver.hpp"
-#include "graphics/shared_gpu_objects.hpp"
 
 #include <IGUIEnvironment.h>
 
@@ -40,7 +40,7 @@ CustomVideoSettingsDialog::CustomVideoSettingsDialog(const float w, const float
         ModalDialog(w, h), m_all_kart_animated(true)
 {
 #ifndef SERVER_ONLY
-    m_all_kart_animated = SharedGPUObjects::getMaxMat4Size() > 512 ||
+    m_all_kart_animated = stk_config->m_max_skinning_bones > 512 ||
         !CVS->supportsHardwareSkinning();
 #endif
     loadFromFile("custom_video_settings.stkgui");
diff --git a/src/states_screens/gp_info_screen.cpp b/src/states_screens/gp_info_screen.cpp
index 161de15e8..cfea05eed 100644
--- a/src/states_screens/gp_info_screen.cpp
+++ b/src/states_screens/gp_info_screen.cpp
@@ -137,7 +137,7 @@ void GPInfoScreen::beforeAddingWidget()
             race_manager->getMinorMode(),
             race_manager->getNumLocalPlayers());
             
-        int tracks = m_gp.getTrackNames().size();
+        int tracks = (int)m_gp.getTrackNames().size();
         bool continue_visible = saved_gp && saved_gp->getNextTrack() > 0 &&
                                             saved_gp->getNextTrack() < tracks;
 
diff --git a/src/states_screens/options_screen_video.cpp b/src/states_screens/options_screen_video.cpp
index 611bc043d..ee8805556 100644
--- a/src/states_screens/options_screen_video.cpp
+++ b/src/states_screens/options_screen_video.cpp
@@ -19,10 +19,10 @@
 
 #include "audio/sfx_manager.hpp"
 #include "audio/sfx_base.hpp"
+#include "config/stk_config.hpp"
 #include "config/user_config.hpp"
 #include "graphics/central_settings.hpp"
 #include "graphics/irr_driver.hpp"
-#include "graphics/shared_gpu_objects.hpp"
 #include "graphics/stk_tex_manager.hpp"
 #include "guiengine/screen.hpp"
 #include "guiengine/widgets/button_widget.hpp"
@@ -88,7 +88,7 @@ void OptionsScreenVideo::initPresets()
         true /* lightshaft */, true /* glow */, true /* mlaa */, true /* ssao */, true /* weather */,
         2 /* animatedScenery */,
 #ifndef SERVER_ONLY
-        (SharedGPUObjects::getMaxMat4Size() > 512 || !CVS->supportsHardwareSkinning() ? 2 : 1),
+        (stk_config->m_max_skinning_bones > 512 || !CVS->supportsHardwareSkinning() ? 2 : 1),
 #else
         2 /* animatedCharacters */,
 #endif
@@ -102,7 +102,7 @@ void OptionsScreenVideo::initPresets()
         true /* lightshaft */, true /* glow */, true /* mlaa */, true /* ssao */, true /* weather */,
         2 /* animatedScenery */,
 #ifndef SERVER_ONLY
-        (SharedGPUObjects::getMaxMat4Size() > 512 || !CVS->supportsHardwareSkinning() ? 2 : 1),
+        (stk_config->m_max_skinning_bones > 512 || !CVS->supportsHardwareSkinning() ? 2 : 1),
 #else
         2 /* animatedCharacters */,
 #endif
diff --git a/src/states_screens/race_result_gui.cpp b/src/states_screens/race_result_gui.cpp
index 0a1b65ec6..be8b4a026 100644
--- a/src/states_screens/race_result_gui.cpp
+++ b/src/states_screens/race_result_gui.cpp
@@ -135,7 +135,7 @@ void RaceResultGUI::init()
     else
     {
         m_start_track = 0;
-        m_end_track = tracks.size();
+        m_end_track = (int)tracks.size();
     }
 }   // init
 
@@ -1317,7 +1317,7 @@ void RaceResultGUI::backToLobby()
     // ----------------------------------------------------------------------------
     void RaceResultGUI::cleanupGPProgress()
     {
-        for (size_t i = 0; i < m_gp_progress_widgets.size(); i++)
+        for (unsigned int i = 0; i < m_gp_progress_widgets.size(); i++)
             m_widgets.remove(m_gp_progress_widgets.get(i));
         m_gp_progress_widgets.clearAndDeleteAll();
     }   // cleanupGPProgress
diff --git a/src/tracks/arena_graph.cpp b/src/tracks/arena_graph.cpp
index 6fa3e6ac1..0040ad6fa 100644
--- a/src/tracks/arena_graph.cpp
+++ b/src/tracks/arena_graph.cpp
@@ -149,11 +149,11 @@ void ArenaGraph::loadNavmesh(const std::string &navmesh)
 
                 createQuad(all_vertices[quad_index[0]],
                     all_vertices[quad_index[1]], all_vertices[quad_index[2]],
-                    all_vertices[quad_index[3]], m_all_nodes.size(),
+                    all_vertices[quad_index[3]], (int)m_all_nodes.size(),
                     false/*invisible*/, false/*ai_ignore*/, true/*is_arena*/,
                     false/*ignore*/);
 
-                ArenaNode* cur_node = getNode(m_all_nodes.size() - 1);
+                ArenaNode* cur_node = getNode((int)m_all_nodes.size() - 1);
                 cur_node->setAdjacentNodes(adjacent_quad_index);
             }
         }
@@ -349,7 +349,7 @@ void ArenaGraph::setNearbyNodesOfAllNodes()
         {
             std::vector<float>::iterator it =
                 std::min_element(dist.begin(), dist.end());
-            const int pos = it - dist.begin();
+            const int pos = int(it - dist.begin());
             nearby_nodes.push_back(pos);
             dist[pos] = 999999.0f;
         }
diff --git a/src/tracks/check_cannon.cpp b/src/tracks/check_cannon.cpp
index b28fdf399..8f3757af1 100644
--- a/src/tracks/check_cannon.cpp
+++ b/src/tracks/check_cannon.cpp
@@ -159,7 +159,7 @@ void CheckCannon::removeFlyable(Flyable *flyable)
                                                   m_all_flyables.end(),
                                                   flyable);
     assert(i != m_all_flyables.end());
-    int index = i - m_all_flyables.begin();   // get the index
+    size_t index = i - m_all_flyables.begin();   // get the index
     m_all_flyables.erase(i);
     m_flyable_previous_position.erase(m_flyable_previous_position.begin() + index);
 }   // removeFlyable
diff --git a/src/tracks/drive_graph.cpp b/src/tracks/drive_graph.cpp
index 8155b2ab0..00a4d8e36 100644
--- a/src/tracks/drive_graph.cpp
+++ b/src/tracks/drive_graph.cpp
@@ -146,7 +146,7 @@ void DriveGraph::load(const std::string &quad_file_name,
             ai_ignore = true;
         }
 
-        createQuad(p0, p1, p2, p3, m_all_nodes.size(), invisible, ai_ignore,
+        createQuad(p0, p1, p2, p3, (unsigned int)m_all_nodes.size(), invisible, ai_ignore,
                    false/*is_arena*/, ignored);
     }
     for (unsigned i = 0; i < m_all_nodes.size(); i++)
@@ -167,8 +167,8 @@ void DriveGraph::load(const std::string &quad_file_name,
 
         if (m_all_nodes.size() > 0)
         {
-            m_lap_length = getNode(m_all_nodes.size()-1)->getDistanceFromStart()
-                         + getNode(m_all_nodes.size()-1)->getDistanceToSuccessor(0);
+            m_lap_length = getNode((int)m_all_nodes.size()-1)->getDistanceFromStart()
+                         + getNode((int)m_all_nodes.size()-1)->getDistanceToSuccessor(0);
         }
         else
         {
diff --git a/src/tracks/graph.hpp b/src/tracks/graph.hpp
index 54de20be0..41a0bac7f 100644
--- a/src/tracks/graph.hpp
+++ b/src/tracks/graph.hpp
@@ -149,7 +149,7 @@ public:
         return m_all_nodes[i];
     }
     // ------------------------------------------------------------------------
-    unsigned int getNumNodes() const             { return m_all_nodes.size(); }
+    unsigned int getNumNodes() const { return (unsigned int)m_all_nodes.size(); }
     // ------------------------------------------------------------------------
     void findRoadSector(const Vec3& XYZ, int *sector,
                         std::vector<int> *all_sectors = NULL,
diff --git a/src/tracks/track_manager.cpp b/src/tracks/track_manager.cpp
index 4bdbdaeae..c7cb68c42 100644
--- a/src/tracks/track_manager.cpp
+++ b/src/tracks/track_manager.cpp
@@ -233,7 +233,7 @@ void TrackManager::removeTrack(const std::string &ident)
     if (it == m_tracks.end())
         Log::fatal("TrackManager", "Cannot find track '%s' in map!!", ident.c_str());
 
-    int index = it - m_tracks.begin();
+    int index = int(it - m_tracks.begin());
 
     // Remove the track from all groups it belongs to
     Group2Indices &group_2_indices =
diff --git a/src/tracks/track_object.cpp b/src/tracks/track_object.cpp
index f68dc3f0c..0d441d123 100644
--- a/src/tracks/track_object.cpp
+++ b/src/tracks/track_object.cpp
@@ -376,8 +376,8 @@ void TrackObject::onWorldReady()
             // There are arguments to pass to the function
             // TODO: For the moment we only support string arguments
             // TODO: this parsing could be improved
-            unsigned first = m_visibility_condition.find("(");
-            unsigned last = m_visibility_condition.find_last_of(")");
+            unsigned first = (unsigned)m_visibility_condition.find("(");
+            unsigned last = (unsigned)m_visibility_condition.find_last_of(")");
             std::string fn_name = m_visibility_condition.substr(0, first);
             std::string str_arguments = m_visibility_condition.substr(first + 1, last - first - 1);
             arguments = StringUtils::split(str_arguments, ',');
@@ -406,7 +406,7 @@ void TrackObject::onWorldReady()
                 {
                     ctx->SetArgObject(i, &arguments[i]);
                 }
-                ctx->SetArgObject(arguments.size(), self);
+                ctx->SetArgObject((int)arguments.size(), self);
             },
             [&](asIScriptContext* ctx) { result = ctx->GetReturnByte(); });
 
diff --git a/src/utils/crash_reporting.cpp b/src/utils/crash_reporting.cpp
index 0440c9360..a5ddd3e3a 100644
--- a/src/utils/crash_reporting.cpp
+++ b/src/utils/crash_reporting.cpp
@@ -17,10 +17,13 @@
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "crash_reporting.hpp"
-#include "log.hpp"
+
+#include "utils/log.hpp"
+#include "utils/string_utils.hpp"
+
 #include <string.h>
 
-#if defined(WIN32) && !defined(DEBUG) && !defined(__MINGW32__) && !defined(_WIN64)
+#if defined(WIN32) && !defined(DEBUG) && !defined(__MINGW32__)
     // --------------------- Windows version -----------------
     #include <Windows.h>
     #include <DbgHelp.h>
@@ -76,11 +79,19 @@
         _In_ DWORD maxStringLength,
         _In_ DWORD flags
     );
+    typedef BOOL (__stdcall *tSymFromAddr) (
+        _In_ HANDLE hProcess,
+        _In_ DWORD64 Address,
+        _Out_opt_ PDWORD64 Displacement,
+        _Inout_ PSYMBOL_INFO Symbol
+        );
+
 
     namespace CrashReporting
     {
         void getCallStackWithContext(std::string& callstack, PCONTEXT pContext);
 
+        // --------------------------------------------------------------------
         void winCrashHandler(PCONTEXT pContext=NULL)
         {
             std::string callstack;
@@ -95,35 +106,43 @@
                                 "\n"
                                 "Call stack:\n";
             msg += callstack;
+            Log::error("StackTrace", "%s", msg.c_str());
             MessageBoxA(NULL, msg.c_str(), "SuperTuxKart crashed :/", MB_OK);
-        }
+        }   // winCrashHandler
 
+        // --------------------------------------------------------------------
         LONG WINAPI sehHandler(_In_ struct _EXCEPTION_POINTERS *ExceptionInfo)
         {
             winCrashHandler(ExceptionInfo->ContextRecord);
             return EXCEPTION_EXECUTE_HANDLER;
-        }
+        }   // sehHandler
 
+        // --------------------------------------------------------------------
         void pureCallHandler()
         {
             winCrashHandler();
-        }
+        }   // pureCallHandler
 
+        // --------------------------------------------------------------------
         int newHandler( size_t )
         {
             winCrashHandler();
             return 0;
-        }
+        }   // newHandler
 
-        void invalidParameterHandler(const wchar_t *, const wchar_t *, const wchar_t *, unsigned int, uintptr_t)
+        // --------------------------------------------------------------------
+        void invalidParameterHandler(const wchar_t *, const wchar_t *,
+                                     const wchar_t *, unsigned int, uintptr_t)
         {
             winCrashHandler();
-        }
+        }   // invalidParameterHandler
 
+        // --------------------------------------------------------------------
         void signalHandler(int code)
         {
             winCrashHandler();
-        }
+        }   // signalHandler
+        // --------------------------------------------------------------------
 
         void installHandlers()
         {
@@ -144,182 +163,161 @@
 
             // ----- Per-thread handlers -----
             // TODO
-        }
+        }   // installHandlers
 
+        // --------------------------------------------------------------------
         void getCallStackWithContext(std::string& callstack, PCONTEXT pContext)
         {
-            HINSTANCE hImageHlpDll = LoadLibraryA("imagehlp.dll");
-            if(!hImageHlpDll)
+            HINSTANCE hDbgHelpDll = LoadLibraryA("DbgHelp.dll");
+            if (!hDbgHelpDll)
             {
-                Log::warn("CrashReporting", "Failed to load DLL imagehlp.dll");
-                callstack = "Crash reporting failed to load DLL imagehlp.dll";
+                Log::warn("CrashReporting", "Failed to load DLL dbghelp.dll");
+                callstack = "Crash reporting failed to load DLL dbghelp.dll";
                 return;
             }
 
             // Retrieve the DLL functions
 #define GET_FUNC_PTR(FuncName)  \
-    t##FuncName _##FuncName = (t##FuncName)GetProcAddress(hImageHlpDll, #FuncName); \
-    if(!_##FuncName) {    \
-    Log::warn("CrashReporting", "Failed to import symbol " #FuncName " from imagehlp.dll"); \
-            FreeLibrary(hImageHlpDll);  \
-            return; \
-    }
-
-            GET_FUNC_PTR(SymCleanup                 )
-            GET_FUNC_PTR(SymFunctionTableAccess64   )
-            GET_FUNC_PTR(SymGetLineFromAddr64       )
-            GET_FUNC_PTR(SymGetModuleBase64         )
-            GET_FUNC_PTR(SymGetSymFromAddr64        )
-            GET_FUNC_PTR(SymInitialize              )
-            GET_FUNC_PTR(SymSetOptions              )
-            GET_FUNC_PTR(StackWalk64                )
-            GET_FUNC_PTR(UnDecorateSymbolName       )
+    t##FuncName _##FuncName = (t##FuncName)GetProcAddress(hDbgHelpDll, #FuncName); \
+    if(!_##FuncName)                                                               \
+     {                                                                             \
+         Log::warn("CrashReporting", "Failed to import symbol " #FuncName          \
+                   " from hDbgHelpDll");                                           \
+            FreeLibrary(hDbgHelpDll);                                              \
+            return;                                                                \
+    } 
 
+                GET_FUNC_PTR(SymCleanup)
+                GET_FUNC_PTR(SymFunctionTableAccess64)
+                GET_FUNC_PTR(SymGetLineFromAddr64)
+                GET_FUNC_PTR(SymGetModuleBase64)
+                GET_FUNC_PTR(SymGetSymFromAddr64)
+                GET_FUNC_PTR(SymInitialize)
+                GET_FUNC_PTR(SymSetOptions)
+                GET_FUNC_PTR(UnDecorateSymbolName)
+                GET_FUNC_PTR(SymFromAddr);
+                GET_FUNC_PTR(StackWalk64);
 #undef GET_FUNC_PTR
 
             const HANDLE  hProcess  = GetCurrentProcess();
             const HANDLE  hThread   = GetCurrentThread();
 
+            // Since the stack trace can also be used for leak checks, don't
+            // initialise this all the time.
+            static bool first_time = true;
+
             // Initialize the symbol hander for the process
+            if (first_time)
             {
                 // Get the file path of the executable
-                char    filepath[512];
+                char filepath[512];
                 GetModuleFileNameA(NULL, filepath, sizeof(filepath));
-                if(!filepath)
+                if (!filepath)
                 {
                     Log::warn("CrashReporting", "GetModuleFileNameA failed");
-                    FreeLibrary(hImageHlpDll);
+                    FreeLibrary(hDbgHelpDll);
+                    return;
+                }
+                // Only keep the directory
+                std::string s(filepath);
+                std::string path = StringUtils::getPath(s);
+
+                // Finally initialize the symbol handler.
+                BOOL bOk = _SymInitialize(hProcess,
+                                          path.empty() ? NULL : path.c_str(),
+                                          TRUE);
+                if (!bOk)
+                {
+                    Log::warn("CrashReporting", "SymInitialize() failed");
+                    FreeLibrary(hDbgHelpDll);
                     return;
                 }
 
-                // Only keep the directory
-                char* last_separator = strrchr(filepath, '/');
-                if(!last_separator) last_separator = strrchr(filepath, '\\');
-                if(last_separator)
-                    last_separator[0] = '\0';
-
-                // Since the stack trace can also be used for leak checks, don't
-                // initialise this all the time.
-                static bool first_time = true;
-
-                if (first_time)
-                {
-                    // Finally initialize the symbol handler.
-                    BOOL    bOk = _SymInitialize(hProcess, filepath ? filepath : NULL, TRUE);
-                    if (!bOk)
-                    {
-                        Log::warn("CrashReporting", "SymInitialize() failed");
-                        FreeLibrary(hImageHlpDll);
-                        return;
-                    }
-
-                    _SymSetOptions(SYMOPT_LOAD_LINES);
-                    first_time = false;
-                }
-            }
+                _SymSetOptions(SYMOPT_LOAD_LINES);
+                first_time = false;
+            }   // if first_time
 
             // Get the stack trace
             {
-                // Initialize the IMAGEHLP_SYMBOL64 structure
-                const size_t    MaxNameLength = 256;
-                IMAGEHLP_SYMBOL64*  sym = (IMAGEHLP_SYMBOL64*)_malloca(sizeof(IMAGEHLP_SYMBOL64) + MaxNameLength);
-                sym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
-                sym->MaxNameLength = MaxNameLength;
-
                 // Initialize the STACKFRAME structure so that it
                 // corresponds to the current function call
                 STACKFRAME64    stackframe;
                 memset(&stackframe, 0, sizeof(stackframe));
-                stackframe.AddrPC.Offset    = pContext->Eip;
                 stackframe.AddrPC.Mode      = AddrModeFlat;
-                stackframe.AddrStack.Offset = pContext->Esp;
                 stackframe.AddrStack.Mode   = AddrModeFlat;
-                stackframe.AddrFrame.Offset = pContext->Ebp;
                 stackframe.AddrFrame.Mode   = AddrModeFlat;
+#ifdef _WIN64
+                stackframe.AddrPC.Offset    = pContext->Rip;
+                stackframe.AddrStack.Offset = pContext->Rsp;
+                stackframe.AddrFrame.Offset = pContext->Rsp;
+                const DWORD machine_type    = IMAGE_FILE_MACHINE_AMD64;
+#else
+                stackframe.AddrPC.Offset    = pContext->Eip;
+                stackframe.AddrStack.Offset = pContext->Esp;
+                stackframe.AddrFrame.Offset = pContext->Ebp;
+                const DWORD machine_type = IMAGE_FILE_MACHINE_I386;
+#endif
 
-                const DWORD machine_type    = IMAGE_FILE_MACHINE_I386;
 
                 // Walk the stack
                 const int   max_nb_calls = 32;
                 for(int i=0 ; i < max_nb_calls ; i++)
                 {
-                    const BOOL stackframe_ok = _StackWalk64(   machine_type,
-                                                               hProcess,
-                                                               hThread,
-                                                               &stackframe,
-                                                               pContext,
-                                                               NULL,
-                                                               _SymFunctionTableAccess64,
-                                                               _SymGetModuleBase64,
-                                                               NULL);
-                    if(stackframe_ok)
+                    const BOOL stackframe_ok =
+                         _StackWalk64(machine_type, hProcess, hThread,
+                                      &stackframe, pContext, NULL,
+                                      _SymFunctionTableAccess64,
+                                      _SymGetModuleBase64, NULL       );
+                    if (!stackframe_ok) break;
+
+                    // Decode the symbol and add it to the call stack
+                    DWORD64 sym_displacement;
+                    char buffer[ sizeof(SYMBOL_INFO) + 
+                                 MAX_SYM_NAME * sizeof(TCHAR) ];
+                    PSYMBOL_INFO symbol = (PSYMBOL_INFO)buffer;
+                    symbol->MaxNameLen = MAX_SYM_NAME;
+                    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+                    if (!_SymFromAddr(hProcess, stackframe.AddrPC.Offset,
+                        &sym_displacement, symbol))
                     {
-                        // Decode the symbol and add it to the call stack
-                        DWORD64 sym_displacement;
-                        if(_SymGetSymFromAddr64(    hProcess,
-                                                    stackframe.AddrPC.Offset,
-                                                    &sym_displacement,
-                                                    sym))
-                        {
-                            IMAGEHLP_LINE64 line64;
-                            DWORD   dwDisplacement = (DWORD)sym_displacement;
-                            if(_SymGetLineFromAddr64(hProcess, stackframe.AddrPC.Offset, &dwDisplacement, &line64))
-                            {
-                                callstack += "\n ";
-
-                                // Directory + filename -> filename only
-                                const char* filename = line64.FileName;
-                                const char* ptr = line64.FileName;
-                                while(*ptr)
-                                {
-                                    if(*ptr == '\\' || *ptr == '/')
-                                        filename = ptr+1;
-                                    ptr++;
-                                }
-                                callstack += filename;
-                                callstack += ":";
-                                callstack += sym->Name;
-
-                                char str[128];
-                                _itoa(line64.LineNumber, str, 10);
-                                callstack += ":";
-                                callstack += str;
-                            }
-                            else
-                            {
-                                callstack += "\n ";
-                                callstack += sym->Name;
-                            }
-                        }
-                        else
-                            callstack += "\n <no symbol available>";
+                        callstack += "\n <no symbol available>";
+                        continue;
                     }
+                    IMAGEHLP_LINE64 line64;
+                    DWORD   dwDisplacement = (DWORD)sym_displacement;
+                    if (_SymGetLineFromAddr64(hProcess,
+                        stackframe.AddrPC.Offset,
+                        &dwDisplacement, &line64))
+                    {
+                        std::string s(line64.FileName);
+                        callstack += "\n " + StringUtils::getBasename(s)
+                                  + ":" + symbol->Name + ":"
+                                  + StringUtils::toString(line64.LineNumber);
+                    }   // if SymGetLineFromAddr64
                     else
-                        break;  // done
-                }
-            }
-
-            FreeLibrary(hImageHlpDll);
-        }
+                    {
+                        callstack += std::string("\n ") + symbol->Name;
+                    }
+                }   // for i < max_calls
+            }   // get the stack trace
 
+            FreeLibrary(hDbgHelpDll);
+        }   //   // getCallStackWithContext
 
+        // --------------------------------------------------------------------
         void getCallStack(std::string& callstack)
         {
-            // Get the current CONTEXT
-            // NB: this code is ONLY VALID FOR X86 (32 bit)!
-            CONTEXT ctx;
-            memset(&ctx, '\0', sizeof(ctx));
-            ctx.ContextFlags = CONTEXT_FULL;
-            __asm    call x
-            __asm x: pop eax    // get eip (can't directly use mov)
-            __asm    mov ctx.Eip, eax
-            __asm    mov ctx.Ebp, ebp
-            __asm    mov ctx.Esp, esp
+            CONTEXT context;
+            memset(&context, 0, sizeof(CONTEXT));
+            context.ContextFlags = CONTEXT_FULL;
+            RtlCaptureContext(&context);
+            getCallStackWithContext(callstack, &context);
+        }   // getCallStack
 
-            getCallStackWithContext(callstack, &ctx);
-        }
     }   // end namespace CrashReporting
 
+// ============================================================================
+
 #elif ENABLE_LIBBFD
     // --------------------- Unix version -----------------------
     /* Derived from addr2line.c from binutils
diff --git a/src/utils/crash_reporting.hpp b/src/utils/crash_reporting.hpp
index dd1804f7f..cf041c810 100644
--- a/src/utils/crash_reporting.hpp
+++ b/src/utils/crash_reporting.hpp
@@ -24,7 +24,7 @@
 namespace CrashReporting
 {
     void installHandlers();
-    void getCallStack(std::string& callstack);
+    void getCallStack(std::string& callstack); 
 }
 
 
diff --git a/src/utils/profiler.cpp b/src/utils/profiler.cpp
index 76af5680b..1c45bc16d 100644
--- a/src/utils/profiler.cpp
+++ b/src/utils/profiler.cpp
@@ -180,12 +180,12 @@ void Profiler::pushCPUMarker(const char* name, const video::SColor& colour)
     double  start = getTimeMilliseconds() - m_time_last_sync;
     if (i != td.m_all_event_data.end())
     {
-        i->second.setStart(m_current_frame, start, td.m_event_stack.size());
+        i->second.setStart(m_current_frame, start, (int)td.m_event_stack.size());
     }
     else
     {
         EventData ed(colour, m_max_frames);
-        ed.setStart(m_current_frame, start, td.m_event_stack.size());
+        ed.setStart(m_current_frame, start, (int)td.m_event_stack.size());
         td.m_all_event_data[name] = ed;
         // Ordered headings is used to determine the order in which the
         // bar graph is drawn. Outer profiling events will be added first,
@@ -392,8 +392,8 @@ void Profiler::draw()
                 start_xpos += factor*marker.getDuration();
 
             // Reduce vertically the size of the markers according to their layer
-            pos.UpperLeftCorner.Y  += 2 * marker.getLayer();
-            pos.LowerRightCorner.Y -= 2 * marker.getLayer();
+            pos.UpperLeftCorner.Y  += 2 * (int)marker.getLayer();
+            pos.LowerRightCorner.Y -= 2 * (int)marker.getLayer();
 
             GL32_draw2DRectangle(j->second.getColour(), pos);
             // If the mouse cursor is over the marker, get its information
diff --git a/src/utils/ptr_vector.hpp b/src/utils/ptr_vector.hpp
index 23347185b..2485c9700 100644
--- a/src/utils/ptr_vector.hpp
+++ b/src/utils/ptr_vector.hpp
@@ -28,6 +28,7 @@
 
 #include <vector>
 #include <assert.h>
+#include <stdint.h>
 
 #include "utils/aligned_array.hpp"
 
@@ -161,7 +162,7 @@ public:
         {
             TYPE * pointer = m_contents_vector[n];
             delete pointer;
-            m_contents_vector[n] = (TYPE*)0xDEADBEEF;
+            m_contents_vector[n] = (TYPE*)(intptr_t)0xDEADBEEF;
 
             // When deleting, it's important that the same pointer cannot be
             // twice in the vector, resulting in a double delete
diff --git a/src/utils/translation.cpp b/src/utils/translation.cpp
index eadd937d0..39f7ca96a 100644
--- a/src/utils/translation.cpp
+++ b/src/utils/translation.cpp
@@ -451,7 +451,7 @@ bool Translations::isRTLText(const wchar_t *in_ptr)
     FriBidiChar *fribidiInput = toFribidiChar(in_ptr);
 
     FriBidiCharType *types = new FriBidiCharType[length];
-    fribidi_get_bidi_types(fribidiInput, length, types);
+    fribidi_get_bidi_types(fribidiInput, (FriBidiStrIndex)length, types);
     freeFribidiChar(fribidiInput);
 
     // Declare as RTL if one character is RTL
@@ -608,7 +608,7 @@ core::stringw Translations::fribidizeLine(const core::stringw &str)
     FriBidiChar *fribidiOutput = new FriBidiChar[length + 1];
     memset(fribidiOutput, 0, (length + 1) * sizeof(FriBidiChar));
     fribidi_boolean result = fribidi_log2vis(fribidiInput,
-                                                length,
+                                                (FriBidiStrIndex)length,
                                                 &pbase_dir,
                                                 fribidiOutput,
             /* gint   *position_L_to_V_list */ NULL,