diff --git a/drape/glfunctions.cpp b/drape/glfunctions.cpp
index a156f7fc0d..9b636cdc2f 100644
--- a/drape/glfunctions.cpp
+++ b/drape/glfunctions.cpp
@@ -632,8 +632,8 @@ void GLFunctions::glGetActiveUniform(uint32_t programID, uint32_t uniformIndex,
                                      int32_t * uniformSize, glConst * type, string & name)
 {
   ASSERT(glGetActiveUniformFn != nullptr, ());
-  char buff[256];
-  GLCHECK(glGetActiveUniformFn(programID, uniformIndex, 256, nullptr, uniformSize, type, buff));
+  GLchar buff[256];
+  GLCHECK(glGetActiveUniformFn(programID, uniformIndex, ARRAY_SIZE(buff), nullptr, uniformSize, type, buff));
   name = buff;
 }
 
diff --git a/drape/gpu_program.cpp b/drape/gpu_program.cpp
index 4390c30ec8..4ce50a0e82 100644
--- a/drape/gpu_program.cpp
+++ b/drape/gpu_program.cpp
@@ -11,48 +11,6 @@
 namespace dp
 {
 
-#ifdef DEBUG
-  class UniformValidator
-  {
-  private:
-    uint32_t m_programID;
-    map<string, UniformTypeAndSize> m_uniformsMap;
-
-  public:
-    UniformValidator(uint32_t programId)
-      : m_programID(programId)
-    {
-      int32_t numberOfUnis = GLFunctions::glGetProgramiv(m_programID, gl_const::GLActiveUniforms);
-      for (size_t unIndex = 0; unIndex < numberOfUnis; ++unIndex)
-      {
-        string name;
-        glConst type;
-        UniformSize size;
-        GLCHECK(GLFunctions::glGetActiveUniform(m_programID, unIndex, &size, &type, name));
-        m_uniformsMap[name] = make_pair(type, size);
-      }
-    }
-
-    bool HasValidTypeAndSizeForName(string const & name, glConst type, UniformSize size)
-    {
-      map<string, UniformTypeAndSize>::iterator it = m_uniformsMap.find(name);
-      if (it != m_uniformsMap.end())
-      {
-        UniformTypeAndSize actualParams = (*it).second;
-        return type == actualParams.first && size == actualParams.second;
-      }
-      else
-        return false;
-    }
-  };
-
-  bool GpuProgram::HasUniform(string const & name, glConst type, UniformSize size)
-  {
-    return m_validator->HasValidTypeAndSizeForName(name, type, size);
-  }
-#endif // UniformValidator
-
-
 GpuProgram::GpuProgram(ref_ptr<Shader> vertexShader, ref_ptr<Shader> fragmentShader)
 {
   m_programID = GLFunctions::glCreateProgram();
@@ -61,15 +19,14 @@ GpuProgram::GpuProgram(ref_ptr<Shader> vertexShader, ref_ptr<Shader> fragmentSha
 
   string errorLog;
   if (!GLFunctions::glLinkProgram(m_programID, errorLog))
-    LOG(LINFO, ("Program ", m_programID, " link error = ", errorLog));
+    LOG(LERROR, ("Program ", m_programID, " link error = ", errorLog));
+
+  // originaly i detached shaders there, but then i try it on Tegra3 device.
+  // on Tegra3, glGetActiveUniform will not work if you detach shaders after linking
+  LoadUniformLocations();
 
   GLFunctions::glDetachShader(m_programID, vertexShader->GetID());
   GLFunctions::glDetachShader(m_programID, fragmentShader->GetID());
-
-
-#ifdef DEBUG
-  m_validator.reset(new UniformValidator(m_programID));
-#endif
 }
 
 GpuProgram::~GpuProgram()
@@ -95,7 +52,24 @@ int8_t GpuProgram::GetAttributeLocation(string const & attributeName) const
 
 int8_t GpuProgram::GetUniformLocation(string const & uniformName) const
 {
-  return GLFunctions::glGetUniformLocation(m_programID, uniformName);
+  auto const it = m_uniforms.find(uniformName);
+  if (it == m_uniforms.end())
+    return -1;
+
+  return it->second;
+}
+
+void GpuProgram::LoadUniformLocations()
+{
+  int32_t uniformsCount = GLFunctions::glGetProgramiv(m_programID, gl_const::GLActiveUniforms);
+  for (int32_t i = 0; i < uniformsCount; ++i)
+  {
+    int32_t size = 0;
+    glConst type = gl_const::GLFloatVec4;
+    string name;
+    GLFunctions::glGetActiveUniform(m_programID, i, &size, &type, name);
+    m_uniforms[name] = GLFunctions::glGetUniformLocation(m_programID, name);
+  }
 }
 
 } // namespace dp
diff --git a/drape/gpu_program.hpp b/drape/gpu_program.hpp
index 844da3ac1b..4092dfaefd 100644
--- a/drape/gpu_program.hpp
+++ b/drape/gpu_program.hpp
@@ -13,12 +13,6 @@
 namespace dp
 {
 
-#ifdef DEBUG
-  class UniformValidator;
-  typedef int32_t UniformSize;
-  typedef pair<glConst, UniformSize> UniformTypeAndSize;
-#endif
-
 class GpuProgram
 {
 public:
@@ -32,15 +26,14 @@ public:
   int8_t GetAttributeLocation(string const & attributeName) const;
   int8_t GetUniformLocation(string const & uniformName) const;
 
+private:
+  void LoadUniformLocations();
+
 private:
   uint32_t m_programID;
 
-#ifdef DEBUG
-private:
-  unique_ptr<UniformValidator> m_validator;
-public:
-  bool HasUniform(string const & name, glConst type, UniformSize size);
-#endif
+  using TUniformLocations = map<string, int8_t>;
+  TUniformLocations m_uniforms;
 };
 
 } // namespace dp
diff --git a/drape/uniform_value.cpp b/drape/uniform_value.cpp
index 3d6d9e8243..06597fea20 100644
--- a/drape/uniform_value.cpp
+++ b/drape/uniform_value.cpp
@@ -232,11 +232,12 @@ void UniformValue::SetMatrix4x4Value(float const * matrixValue)
 
 void UniformValue::Apply(ref_ptr<GpuProgram> program) const
 {
-  ASSERT(program->HasUniform(m_name, GetCorrespondingGLType(), 1),
-         ("Failed to find uniform", m_name, GetCorrespondingGLType(), 1));
+  int8_t location = program->GetUniformLocation(m_name);
+  if (location == -1)
+    return;
 
-  uint8_t location = program->GetUniformLocation(m_name);
-  switch (m_type) {
+  switch (m_type)
+  {
   case Int:
     ApplyInt(location, CastMemory<int32_t>(), m_componentCount);
     break;
@@ -251,41 +252,6 @@ void UniformValue::Apply(ref_ptr<GpuProgram> program) const
   }
 }
 
-#ifdef DEBUG
-glConst UniformValue::GetCorrespondingGLType() const
-{
-  if (Int == m_type)
-  {
-    static glConst intTypes[4] = {
-      gl_const::GLIntType,
-      gl_const::GLIntVec2,
-      gl_const::GLIntVec3,
-      gl_const::GLIntVec4
-    };
-    return intTypes[m_componentCount - 1];
-  }
-  else if (Float == m_type)
-  {
-    static glConst floatTypes[4] = {
-      gl_const::GLFloatType,
-      gl_const::GLFloatVec2,
-      gl_const::GLFloatVec3,
-      gl_const::GLFloatVec4
-    };
-    return floatTypes[m_componentCount - 1];
-  }
-  else if (Matrix4x4 == m_type)
-  {
-    return gl_const::GLFloatMat4;
-  }
-  else
-  {
-    ASSERT(false, ());
-    return -1;
-  }
-}
-#endif
-
 void UniformValue::Allocate(size_t byteCount)
 {
   m_values.reset(new uint8_t[byteCount]);
diff --git a/drape/uniform_value.hpp b/drape/uniform_value.hpp
index ed26fc676b..32b6ecdce6 100644
--- a/drape/uniform_value.hpp
+++ b/drape/uniform_value.hpp
@@ -64,11 +64,6 @@ public:
   }
 
 private:
-
-#ifdef DEBUG
-  glConst GetCorrespondingGLType() const;
-#endif
-
   void Allocate(size_t byteCount);
 
   template <typename T>