diff --git a/src/surface.c b/src/surface.c
index a056bd3..e505f2f 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -82,167 +82,101 @@ float *generate_data_surface(int grid_size, unsigned char *m)
 	return d_surface;
 }
 
-/* pa' rearmar la funcion _calc_normal te entendi que creara las funciones de cglm artesanalmente, entonces ps eso hago xd */
-
-void subtract(const float *v1, const float *v2, float *result, unsigned char n) 
-{
-    for (unsigned char i = 0; i < n; i++) {
-        result[i] = v1[i] - v2[i];
-    }
-}
-
-float dot_product(const float *a, const float *b, unsigned char n) 
-{
-    float result = 0.0f;
-    for (unsigned char i = 0; i < n; i++) {
-        result += a[i] * b[i];
-    }
-    return result;
-}
-
-void escalar_product(float a, const float *v1, float *result, unsigned char n) 
-{
-    for (unsigned char i = 0; i < n; i++) {
-        result[i] = a * v1[i];
-    }
-}
-
-void norm(const float *v1, float *result, unsigned char n) 
-{
-    float lenght = sqrtf(dot_product(v1, v1, n));
-    float inv_lenght = 1.0f / lenght;
-    escalar_product(inv_lenght, v1, result, n);
-}
-
 static void __calculate_normal(
-	float *p1, float *p2, float *p3, float *normal, unsigned char n)
+    float *p1, float *p2, float *p3, float *normal, unsigned char n)
 {
-	unsigned char i;
-	float alpha;
-	float *v1, *v2, *v3;
-	float *u1, *u2, *u3;
+    unsigned char i;
+    float alpha;
+    float *v1, *v2, *v3;
+    float *u1, *u2, *u3;
 
-	v1=malloc(n*sizeof(float));
-	v2=malloc(n*sizeof(float));
-	v3=malloc(n*sizeof(float));
-	u1=malloc(n*sizeof(float));
-	u2=malloc(n*sizeof(float));
-	u3=malloc(n*sizeof(float));
+    v1 = malloc(n * sizeof(float));
+    v2 = malloc(n * sizeof(float));
+    v3 = malloc(n * sizeof(float));
+    u1 = malloc(n * sizeof(float));
+    u2 = malloc(n * sizeof(float));
+    u3 = malloc(n * sizeof(float));
 
-	switch (n)
-	{
-	case 3:
-		glm_vec3_sub(p2, p1, v1);
-		glm_vec3_sub(p3, p1, v2);
+    switch (n)
+    {
+    case 3:
+        glm_vec3_sub(p2, p1, v1);
+        glm_vec3_sub(p3, p1, v2);
 
-		glm_vec3_cross(v1, v2, normal);
-		glm_vec3_normalize(normal);
-		return;
-		/*
-			In Grant-Shmidth we need 3 linearly independian vector that forms a
-		   basis, so we can have a ortonormal version of that basis, since, we
-		   must have v1 = p3 - p1 v2 = p2 - p1 Then v3 = p1, will most certantly
-		   be linerly independiant to v1 and v2.
-		*/
-    default:
-    	for( i=0; i<n; ++i )
-    	{
-    		v1[i]=p2[i]-p1[i]; //cglm_vec4_sub( p2, p1, v1 );
-    		v2[i]=p3[i]-p1[i]; //cglm_vec4_sub( p3, p1, v2 );
-    		v3[i]=p1[i];   //cglm_vec4_copy( p1, v3 );
-        }
-
-    	for( i=0; i<n; ++i )
-    		u1[i]=v1[i];   //cglm_vec4_copy( v1, u1 );
-
-        {
-            vec4 proj;
-            alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
-            glm_vec4_scale(u1, alpha, proj);
-            glm_vec4_sub(v2, proj, u2);
-        }
-		
-        {
-            vec4 proj1, proj2;
-            alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
-            glm_vec4_scale(u1, alpha, proj1);
-
-            alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
-            glm_vec4_scale(u2, alpha, proj2);
-
-            glm_vec4_sub(v3, proj1, u3);
-            glm_vec4_sub(u3, proj2, u3);
-        }
-
-        glm_vec4_copy(u3, normal);
-        glm_vec4_normalize(normal);
-
-	free(v1);
-	free(v2);
-	free(v3);
-	free(u1);
-	free(u2);
-	free(u3);
+        glm_vec3_cross(v1, v2, normal);
+        glm_vec3_normalize(normal);
         return;
-#if 0
-	default:
-		u = malloc((n - 1) * sizeof(float *));
-		for (unsigned char i = 0; i < n - 1; i++)
-		{
-			u[i] = malloc(n * sizeof(float));
-		}
 
-		for (unsigned char i = 0; i < n - 1; i++)
-		{
-			float *vi = malloc(n * sizeof(float));
-			for (unsigned char j = 0; j < n; j++)
-			{
-				vi[j] = p2[j] - p1[j];
-			}
+    default:
+        for (i = 0; i < n; ++i) {
+            v1[i] = p2[i] - p1[i];  
+            v2[i] = p3[i] - p1[i]; 
+            v3[i] = p1[i];          
+        }
 
-			for (unsigned char j = 0; j < i; j++)
-			{
-				float dot_vu = 0.0f, dot_uu = 0.0f;
+        for (i = 0; i < n; ++i) {
+            u1[i] = v1[i]; 
+        }
 
-				for (unsigned char k = 0; k < n; k++)
-				{
-					dot_vu += vi[k] * u[j][k];
-					dot_uu += u[j][k] * u[j][k];
-				}
+        {
+            float proj[n];
+            float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
+            for (i = 0; i < n; ++i) {
+                dot_v2_u1 += v2[i] * u1[i];
+                dot_u1_u1 += u1[i] * u1[i];
+            }
+            alpha = dot_v2_u1 / dot_u1_u1;
 
-				for (unsigned char k = 0; k < n; k++)
-				{
-					vi[k] -= (dot_vu / dot_uu) * u[j][k];
-				}
-			}
+            for (i = 0; i < n; ++i) {
+                proj[i] = u1[i] * alpha;
+                u2[i] = v2[i] - proj[i]; 
+            }
+        }
 
-			memcpy(u[i], vi, n * sizeof(float));
-			free(vi);
-		}
+        {
+            float proj1[n], proj2[n];
+            float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
+            float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
 
-		memcpy(normal, u[n - 2], n * sizeof(float));
+            for (i = 0; i < n; ++i) {
+                dot_v3_u1 += v3[i] * u1[i];
+                dot_u1_u1 += u1[i] * u1[i];
+            }
+            for (i = 0; i < n; ++i) {
+                proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
+            }
 
-		float norm = 0.0f;
-		for (unsigned char i = 0; i < n; i++)
-		{
-			norm += normal[i] * normal[i];
-		}
-		norm = sqrtf(norm);
-		for (unsigned char i = 0; i < n; i++)
-		{
-			normal[i] /= norm;
-		}
+            for (i = 0; i < n; ++i) {
+                dot_v3_u2 += v3[i] * u2[i];
+                dot_u2_u2 += u2[i] * u2[i];
+            }
+            for (i = 0; i < n; ++i) {
+                proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
+                u3[i] = v3[i] - proj1[i] - proj2[i]; 
+            }
+        }
 
-		for (unsigned char i = 0; i < n - 1; i++)
-		{
-			free(u[i]);
-		}
-		free(u);
-		return;
-#endif
-	}
+        float magnitude = 0.0f;
+        for (i = 0; i < n; ++i) {
+            magnitude += u3[i] * u3[i];
+        }
+        magnitude = sqrtf(magnitude);
+
+        for (i = 0; i < n; ++i) {
+            normal[i] = u3[i] / magnitude;  
+        }
+
+        free(v1);
+        free(v2);
+        free(v3);
+        free(u1);
+        free(u2);
+        free(u3);
+        return;
+    }
 }
 
+
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;
@@ -265,4 +199,4 @@ float *generate_normals_surface(float *d, unsigned char m)
 
 	free(norm_vec);
 	return n;
-}
+}
\ No newline at end of file