diff --git a/source/jail_shader.cpp b/source/jail_shader.cpp
index 8f35ed2..32bff38 100644
--- a/source/jail_shader.cpp
+++ b/source/jail_shader.cpp
@@ -67,7 +67,7 @@ namespace shader
 #endif
 
     // Función para compilar un shader a partir de un std::string
-    GLuint compileShader(const std::string &source, GLuint shaderType)
+    GLuint compileShader(const std::string &source, GLuint shader_type)
     {
         if (source.empty())
         {
@@ -76,92 +76,92 @@ namespace shader
         }
 
         // Crear identificador del shader
-        GLuint resultado = glCreateShader(shaderType);
+        GLuint shader_id = glCreateShader(shader_type);
 
         // Agregar una directiva según el tipo de shader
-        std::string directiva = (shaderType == GL_VERTEX_SHADER)
+        std::string directive = (shader_type == GL_VERTEX_SHADER)
                                     ? "#define VERTEX\n"
                                     : "#define FRAGMENT\n";
 
-        const char *sources[2] = {directiva.c_str(), source.c_str()};
+        const char *sources[2] = {directive.c_str(), source.c_str()};
 
         // Especificar el código fuente del shader
-        glShaderSource(resultado, 2, sources, nullptr);
+        glShaderSource(shader_id, 2, sources, nullptr);
 
         // Compilar el shader
-        glCompileShader(resultado);
+        glCompileShader(shader_id);
 
         // Verificar si la compilación fue exitosa
-        GLint compiladoCorrectamente = GL_FALSE;
-        glGetShaderiv(resultado, GL_COMPILE_STATUS, &compiladoCorrectamente);
-        if (compiladoCorrectamente != GL_TRUE)
+        GLint compiled_ok = GL_FALSE;
+        glGetShaderiv(shader_id, GL_COMPILE_STATUS, &compiled_ok);
+        if (compiled_ok != GL_TRUE)
         {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error en la compilación del shader (%d)!", resultado);
-            GLint longitudLog;
-            glGetShaderiv(resultado, GL_INFO_LOG_LENGTH, &longitudLog);
-            if (longitudLog > 0)
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error en la compilación del shader (%d)!", shader_id);
+            GLint log_length;
+            glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &log_length);
+            if (log_length > 0)
             {
-                std::vector<GLchar> log(longitudLog);
-                glGetShaderInfoLog(resultado, longitudLog, &longitudLog, log.data());
+                std::vector<GLchar> log(log_length);
+                glGetShaderInfoLog(shader_id, log_length, &log_length, log.data());
                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Registro de compilación del shader: %s", log.data());
             }
-            glDeleteShader(resultado);
-            resultado = 0;
+            glDeleteShader(shader_id);
+            shader_id = 0;
         }
-        return resultado;
+        return shader_id;
     }
 
     // Función para compilar un programa de shaders (vertex y fragment) a partir de std::string
-    GLuint compileProgram(const std::string &vertexShaderSource, const std::string &fragmentShaderSource)
+    GLuint compileProgram(const std::string &vertex_shader_source, const std::string &fragment_shader_source)
     {
-        GLuint idPrograma = glCreateProgram();
+        GLuint program_id = glCreateProgram();
 
         // Si el fragment shader está vacío, reutilizamos el código del vertex shader
-        GLuint idShaderVertice = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
-        GLuint idShaderFragmento = compileShader(fragmentShaderSource.empty() ? vertexShaderSource : fragmentShaderSource, GL_FRAGMENT_SHADER);
+        GLuint vertex_shader_id = compileShader(vertex_shader_source, GL_VERTEX_SHADER);
+        GLuint fragment_shader_id = compileShader(fragment_shader_source.empty() ? vertex_shader_source : fragment_shader_source, GL_FRAGMENT_SHADER);
 
-        if (idShaderVertice && idShaderFragmento)
+        if (vertex_shader_id && fragment_shader_id)
         {
             // Asociar los shaders al programa
-            glAttachShader(idPrograma, idShaderVertice);
-            glAttachShader(idPrograma, idShaderFragmento);
-            glLinkProgram(idPrograma);
-            glValidateProgram(idPrograma);
+            glAttachShader(program_id, vertex_shader_id);
+            glAttachShader(program_id, fragment_shader_id);
+            glLinkProgram(program_id);
+            glValidateProgram(program_id);
 
             // Verificar el estado del enlace
-            GLint longitudLog;
-            glGetProgramiv(idPrograma, GL_INFO_LOG_LENGTH, &longitudLog);
-            if (longitudLog > 0)
+            GLint log_length;
+            glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &log_length);
+            if (log_length > 0)
             {
-                std::vector<char> log(longitudLog);
-                glGetProgramInfoLog(idPrograma, longitudLog, &longitudLog, log.data());
+                std::vector<char> log(log_length);
+                glGetProgramInfoLog(program_id, log_length, &log_length, log.data());
                 SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Registro de información del programa:\n%s", log.data());
             }
         }
-        if (idShaderVertice)
+        if (vertex_shader_id)
         {
-            glDeleteShader(idShaderVertice);
+            glDeleteShader(vertex_shader_id);
         }
-        if (idShaderFragmento)
+        if (fragment_shader_id)
         {
-            glDeleteShader(idShaderFragmento);
+            glDeleteShader(fragment_shader_id);
         }
-        return idPrograma;
+        return program_id;
     }
 
-    bool init(SDL_Window *ventana, SDL_Texture *texturaBackBuffer, const std::string &vertexShader, const std::string &fragmentShader)
+    bool init(SDL_Window *window, SDL_Texture *back_buffer_texture, const std::string &vertex_shader, const std::string &fragment_shader)
     {
-        shader::win = ventana;
-        shader::renderer = SDL_GetRenderer(ventana);
-        shader::backBuffer = texturaBackBuffer;
-        SDL_GetWindowSize(ventana, &win_size.x, &win_size.y);
+        shader::win = window;
+        shader::renderer = SDL_GetRenderer(window);
+        shader::backBuffer = back_buffer_texture;
+        SDL_GetWindowSize(window, &win_size.x, &win_size.y);
 
-        SDL_GetTextureSize(texturaBackBuffer, &tex_size.x, &tex_size.y);
+        SDL_GetTextureSize(back_buffer_texture, &tex_size.x, &tex_size.y);
 
-        const auto RENDER_NAME = SDL_GetRendererName(renderer);
+        const auto render_name = SDL_GetRendererName(renderer);
 
         // Verificar que el renderer sea OpenGL
-        if (!strncmp(RENDER_NAME, "opengl", 6))
+        if (!strncmp(render_name, "opengl", 6))
         {
 #ifndef __APPLE__
             if (!initGLExtensions())
@@ -172,7 +172,7 @@ namespace shader
             }
 #endif
             // Compilar el programa de shaders utilizando std::string
-            programId = compileProgram(vertexShader, fragmentShader);
+            programId = compileProgram(vertex_shader, fragment_shader);
         }
         else
         {