diff --git a/custom_types/latex_type.py b/custom_types/latex_type.py
index 1987722..045b833 100644
--- a/custom_types/latex_type.py
+++ b/custom_types/latex_type.py
@@ -69,7 +69,7 @@ class Class_LaTeX(SympyClassBase):
             Class_LaTeX: Nueva instancia con la expresión parseada
             
         Examples:
-            LaTeX.parse_latex(r"$$Brix_{Bev} = \frac{Brix_{syr} + Brix_{H_2O} \cdot R_M}{R_M + 1}$$")
+            LaTeX.parse_latex(r"$$Brix_{Bev} = \\frac{Brix_{syr} + Brix_{H_2O} \\cdot R_M}{R_M + 1}$$")
         """
         # Primero intentar conversión manual mejorada (más confiable para subíndices)
         try:
@@ -234,6 +234,7 @@ class Class_LaTeX(SympyClassBase):
             (r'\\cdot', '*'),  # multiplicación
             (r'\\times', '*'),  # multiplicación  
             (r'\\div', '/'),  # división
+            (r'\\([a-zA-Z]+)', r'\1'),  # convertir \delta a delta, \alpha a alpha, etc.
             (r'\{([^}]*)\}', r'\1'),  # eliminar llaves restantes
         ]
         
@@ -276,19 +277,26 @@ class Class_LaTeX(SympyClassBase):
                 symbols_dict[name] = sympy.Symbol(name)
             
             if symbols_dict:
-                # Si es una ecuación, intentar crearla manualmente
+                # Si es una ecuación, intentar parsearlo lado por lado
                 if is_equation and '=' in result:
                     left, right = result.split('=', 1)
-                    # Crear una ecuación simple usando el primer símbolo encontrado
-                    first_symbol = list(symbols_dict.values())[0]
-                    return sympy.Eq(first_symbol, sum(list(symbols_dict.values())[1:], 0))
+                    try:
+                        # Intentar parsear cada lado individualmente
+                        left_expr = sympy.sympify(left.strip(), locals=symbols_dict)
+                        right_expr = sympy.sympify(right.strip(), locals=symbols_dict)
+                        return sympy.Eq(left_expr, right_expr)
+                    except Exception as e2:
+                        print(f"Debug: Error parseando lados de ecuación: {e2}")
+                        # Como último recurso, devolver un símbolo con la expresión completa
+                        return sympy.Symbol(f"LaTeX_parse_error_{len(symbols_dict)}_symbols")
                 else:
-                    # Para expresiones, devolver el primer símbolo o una suma
-                    symbols_list = list(symbols_dict.values())
-                    if len(symbols_list) == 1:
-                        return symbols_list[0]
-                    else:
-                        return sum(symbols_list[1:], symbols_list[0])
+                    # Para expresiones, intentar parsear con el contexto de símbolos
+                    try:
+                        return sympy.sympify(result, locals=symbols_dict)
+                    except Exception as e2:
+                        print(f"Debug: Error parseando expresión: {e2}")
+                        # Si todo falla, devolver el primer símbolo
+                        return list(symbols_dict.values())[0] if symbols_dict else sympy.Symbol('LaTeX_parse_error')
             else:
                 return sympy.Symbol('LaTeX_parse_error')
     
diff --git a/hybrid_calc_history.txt b/hybrid_calc_history.txt
index 9efcc89..8290874 100644
--- a/hybrid_calc_history.txt
+++ b/hybrid_calc_history.txt
@@ -1,20 +1,4 @@
 
-x=t**2+5/m
-m=3
-x=4
-t=?
-solve(t)
-form=solve(t)
-
-
-ip=IP4(10.1.1.1,20)
-ip.BroadcastAddress()
-
-# Test LATEX
 $$Brix = \frac{Brix_{syrup} \cdot \delta_{syrup} + (Brix_{water} \cdot \delta_{water} \cdot Rateo)}{\delta_{syrup} + \delta_{water} \cdot Rateo}$$
-$$Brix = \frac{Solid_Weight}{Total_Weight}$$
-$$\delta = \frac{W}{V} \Rightarrow W = \delta \cdot V$$
-$$Brix_{Bev} = \frac{Brix_{syr} + Brix_{H_2O} \cdot R_M}{R_M + 1}$$
-
 
 
diff --git a/main_calc_app_pyside6.py b/main_calc_app_pyside6.py
index 41c9867..c45ad10 100644
--- a/main_calc_app_pyside6.py
+++ b/main_calc_app_pyside6.py
@@ -1133,21 +1133,98 @@ class HybridCalculatorPySide6(QMainWindow):
                     equation_type = "symbolic"
             
             if should_add_to_latex:
-                latex_content = ""
-                
-                if result.actual_result_object is not None:
-                    try:
-                        latex_content = sympy.latex(result.actual_result_object)
-                    except:
-                        latex_content = result.output if result.output else str(result.actual_result_object)
-                else:
-                    latex_content = result.output if result.output else ""
-                
+                # Generar contenido LaTeX que incluya toda la información del output
+                latex_content = self._generate_complete_latex_content(result)
                 self._add_to_latex_panel(equation_type, latex_content)
                 
         except Exception as e:
             self.logger.error(f"Error procesando para panel LaTeX: {e}")
     
+    def _generate_complete_latex_content(self, result: EvaluationResult) -> str:
+        """Genera contenido LaTeX completo incluyendo toda la información del output"""
+        try:
+            # Para comentarios, usar el texto directamente
+            if result.result_type == "comment":
+                return result.output or ""
+            
+            latex_parts = []
+            
+            # PARTE 1: Contenido principal (con LaTeX de SymPy si es posible)
+            main_content = ""
+            if result.actual_result_object is not None:
+                try:
+                    # Intentar generar LaTeX de SymPy para el objeto matemático
+                    import sympy
+                    main_content = sympy.latex(result.actual_result_object)
+                    
+                    # Para asignaciones, necesitamos agregar el lado izquierdo
+                    if result.is_assignment and result.input_line:
+                        # Extraer la variable del lado izquierdo
+                        if '=' in result.input_line:
+                            left_side = result.input_line.split('=')[0].strip()
+                            # Limpiar posibles símbolos LaTeX del lado izquierdo
+                            left_side = left_side.replace('$$', '').strip()
+                            main_content = f"{left_side} = {main_content}"
+                    
+                except Exception:
+                    # Si falla el LaTeX de SymPy, usar el output textual
+                    main_content = result.output or ""
+            else:
+                main_content = result.output or ""
+            
+            latex_parts.append(main_content)
+            
+            # PARTE 2: Aproximación numérica (si está disponible en el output)
+            if result.output and "≈" in result.output:
+                approx_parts = result.output.split("≈", 1)
+                if len(approx_parts) == 2:
+                    approx_value = approx_parts[1].strip()
+                    # Extraer solo la parte numérica antes del indicador de tipo
+                    if ";" in approx_value:
+                        approx_value = approx_value.split(";")[0].strip()
+                    
+                    # Intentar convertir la aproximación a LaTeX si es una ecuación
+                    try:
+                        import sympy
+                        if "Eq(" in approx_value:
+                            # Es una ecuación, intentar parserarla para LaTeX
+                            approx_obj = eval(approx_value, {'Eq': sympy.Eq, 'sqrt': sympy.sqrt})
+                            approx_latex = sympy.latex(approx_obj)
+                            latex_parts.append(f"\\approx {approx_latex}")
+                        else:
+                            # Es un valor numérico simple
+                            latex_parts.append(f"\\approx {approx_value}")
+                    except:
+                        # Si falla, usar la aproximación como texto
+                        latex_parts.append(f"\\approx {approx_value}")
+            
+            # PARTE 3: Indicador de tipo (si está en el output)
+            if result.output and "[" in result.output and "]" in result.output:
+                # Extraer el indicador de tipo (ej: [=], [Equality], etc.)
+                parts = result.output.split("[")
+                if len(parts) >= 2:
+                    type_part = "[" + parts[-1]  # Tomar el último indicador
+                    if "]" in type_part:
+                        type_indicator = type_part.split("]")[0] + "]"
+                        latex_parts.append(f"\\quad \\text{{{type_indicator}}}")
+            
+            # Combinar todas las partes
+            complete_latex = " ".join(latex_parts)
+            
+            # Limpiar caracteres problemáticos para MathJax
+            complete_latex = complete_latex.replace("__", "_{").replace("**", "^")
+            
+            # Agregar llaves de cierre para subíndices
+            import re
+            complete_latex = re.sub(r'_\{(\w+)', r'_{\1}', complete_latex)
+            
+            return complete_latex
+            
+        except Exception as e:
+            self.logger.error(f"Error generando LaTeX completo: {e}")
+            # Fallback al output original
+            return result.output or ""
+    
     def _add_to_latex_panel(self, equation_type: str, latex_content: str):
         """Añade una ecuación al panel LaTeX"""
         if not hasattr(self, '_latex_equations'):