Update app.py

app.py

@@ -10,7 +10,7 @@ import sys
 import subprocess
 import json
 from pygments import highlight
-from pygments.lexers import PythonLexer
+from pygments.lexers import PythonLexer, CppLexer
 from pygments.formatters import HtmlFormatter
 import base64
 from transformers import pipeline
@@ -1003,6 +1003,7 @@ def generate_manim_video(python_code, format_type, quality_preset, animation_spe
             except Exception as e:
                 logger.error(f"Failed to clean temp dir: {str(e)}")
 
+# ENHANCED PYTHON RUNNER FUNCTIONS
 def detect_input_calls(code):
     """Detect input() calls in Python code to prepare for handling"""
     input_calls = []
@@ -1015,21 +1016,149 @@ def detect_input_calls(code):
             input_calls.append({"line": i+1, "prompt": prompt})
     return input_calls
 
-def run_python_script(code, inputs=None, timeout=60):
-    """Execute a Python script and capture output, handling input calls"""
+def run_python_script_enhanced(code, inputs=None, timeout=60, enable_debug=False, enable_profile=False, 
+                              additional_libs=None, project_files=None, realtime_viz=False):
+    """Enhanced version of run_python_script with debugging, profiling, etc."""
     result = {
         "stdout": "",
         "stderr": "",
         "exception": None,
         "plots": [],
         "dataframes": [],
-        "execution_time": 0
+        "execution_time": 0,
+        "profile_data": None,
+        "debug_steps": [],
+        "realtime_data": []
     }
     
-    # Replace input() calls with predefined values if provided
-    if inputs and len(inputs) > 0:
-        # Modify the code to use predefined inputs instead of waiting for user input
-        modified_code = """
+    # Create a tempdir for script execution
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Path for saving plots
+        plot_dir = os.path.join(temp_dir, 'plots')
+        os.makedirs(plot_dir, exist_ok=True)
+        
+        # Handle multi-file project if provided
+        if project_files:
+            for filename, file_content in project_files.items():
+                with open(os.path.join(temp_dir, filename), 'w', encoding='utf-8') as f:
+                    f.write(file_content)
+            
+            # Set the main script path
+            main_script = os.path.join(temp_dir, "main.py")
+        else:
+            # Write the single code file
+            main_script = os.path.join(temp_dir, "script.py")
+            with open(main_script, 'w', encoding='utf-8') as f:
+                f.write(code)
+        
+        # Add library imports if specified
+        if additional_libs:
+            lib_imports = "\n".join([f"import {lib}" for lib in additional_libs if lib != "numpy" and lib != "matplotlib"])
+            if lib_imports:
+                with open(main_script, 'r+', encoding='utf-8') as f:
+                    content = f.read()
+                    f.seek(0, 0)
+                    f.write(lib_imports + "\n\n" + content)
+        
+        # Add debugging setup if enabled
+        if enable_debug:
+            debug_setup = """
+import pdb
+import sys
+import traceback
+
+class StringIODebugger:
+    def __init__(self):
+        self.steps = []
+        
+    def add_step(self, frame, event, arg):
+        if event == 'line':
+            self.steps.append({
+                'file': frame.f_code.co_filename,
+                'line': frame.f_lineno,
+                'function': frame.f_code.co_name,
+                'locals': {k: str(v) for k, v in frame.f_locals.items() if not k.startswith('__')}
+            })
+        return self
+
+debug_steps = []
+def trace_calls(frame, event, arg):
+    if event != 'call':
+        return
+    co = frame.f_code
+    func_name = co.co_name
+    if func_name == 'write':
+        return
+    line_no = frame.f_lineno
+    filename = co.co_filename
+    if 'debugger' in filename or func_name.startswith('__'):
+        return
+    debug_steps.append(f"Calling {func_name} in {filename} at line {line_no}")
+    return trace_calls
+
+sys.settrace(trace_calls)
+"""
+            with open(main_script, 'r+', encoding='utf-8') as f:
+                content = f.read()
+                f.seek(0, 0)
+                f.write(debug_setup + "\n" + content)
+        
+        # Add profiling if enabled
+        if enable_profile:
+            profile_setup = """
+import cProfile
+import pstats
+import io
+
+# Set up profiler
+profiler = cProfile.Profile()
+profiler.enable()
+"""
+            profile_teardown = """
+# Finish profiling
+profiler.disable()
+s = io.StringIO()
+ps = pstats.Stats(profiler, stream=s).sort_stats('cumulative')
+ps.print_stats()
+with open('profile_results.txt', 'w') as f:
+    f.write(s.getvalue())
+"""
+            with open(main_script, 'r+', encoding='utf-8') as f:
+                content = f.read()
+                f.seek(0, 0)
+                f.write(profile_setup + "\n" + content + "\n" + profile_teardown)
+        
+        # Add real-time visualization if enabled
+        if realtime_viz:
+            realtime_viz_setup = """
+# Setup for real-time visualization
+import threading
+import json
+import time
+
+class RealTimeData:
+    def __init__(self):
+        self.data = []
+        
+    def add_data(self, label, value):
+        self.data.append({'label': label, 'value': value, 'time': time.time()})
+        # Write to file for real-time monitoring
+        with open('realtime_data.json', 'w') as f:
+            json.dump(self.data, f)
+
+rt_data = RealTimeData()
+
+# Example usage: rt_data.add_data("iteration", i)
+"""
+            with open(main_script, 'r+', encoding='utf-8') as f:
+                content = f.read()
+                f.seek(0, 0)
+                f.write(realtime_viz_setup + "\n" + content)
+        
+        # Add input handling code
+        if inputs and len(inputs) > 0:
+            # Modify the code to use predefined inputs instead of waiting for user input
+            input_handling = """
 # Input values provided by the user
 __INPUT_VALUES = {}
 __INPUT_INDEX = 0
@@ -1046,73 +1175,62 @@ def input(prompt=''):
         print("\\n[WARNING] No more predefined inputs available, using empty string")
         return ""
 """.format(inputs)
-        
-        code = modified_code + code
-    
-    # Create a tempdir for script execution
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Path for saving plots
-        plot_dir = os.path.join(temp_dir, 'plots')
-        os.makedirs(plot_dir, exist_ok=True)
-        
-        # Files for capturing stdout and stderr
-        stdout_file = os.path.join(temp_dir, 'stdout.txt')
-        stderr_file = os.path.join(temp_dir, 'stderr.txt')
-        
-        # Add plot saving code
-        if 'matplotlib' in code or 'plt' in code:
-            if 'import matplotlib.pyplot as plt' not in code and 'from matplotlib import pyplot as plt' not in code:
-                code = "import matplotlib.pyplot as plt\n" + code
-            
-            # Add code to save plots
-            save_plots_code = """
-# Save all figures
-import matplotlib.pyplot as plt
-import os
-__figures = plt.get_fignums()
-for __i, __num in enumerate(__figures):
-    __fig = plt.figure(__num)
-    __fig.savefig(os.path.join('{}', f'plot_{{__i}}.png'))
-""".format(plot_dir.replace('\\', '\\\\'))
             
-            code += "\n" + save_plots_code
+            with open(main_script, 'r+', encoding='utf-8') as f:
+                content = f.read()
+                f.seek(0, 0)
+                f.write(input_handling + "\n" + content)
         
-        # Add dataframe display code if pandas is used
-        if 'pandas' in code or 'pd.' in code or 'DataFrame' in code:
-            if 'import pandas as pd' not in code and 'from pandas import' not in code:
-                code = "import pandas as pd\n" + code
-            
-            # Add code to save dataframe info
-            dataframes_code = """
-# Capture DataFrames
-import pandas as pd
-import json
-import io
+        # Add matplotlib and pandas handling
+        data_handling = """
+# Add plot saving code if matplotlib is used
 import os
-__globals_dict = globals()
-__dataframes = []
-for __var_name, __var_val in __globals_dict.items():
-    if isinstance(__var_val, pd.DataFrame) and not __var_name.startswith('__'):
+
+# For matplotlib plots
+if 'matplotlib' in globals() or 'matplotlib.pyplot' in globals() or 'plt' in globals():
+    import matplotlib
+    matplotlib.use('Agg')  # Use non-interactive backend
+    import matplotlib.pyplot as plt
+    
+    # Hook to save all figures
+    original_show = plt.show
+    def custom_show(*args, **kwargs):
+        for i, fig in enumerate(map(plt.figure, plt.get_fignums())):
+            fig.savefig(os.path.join('{}', f'plot_{{i}}.png'))
+        return original_show(*args, **kwargs)
+    plt.show = custom_show
+
+# For pandas DataFrames
+if 'pandas' in globals() or 'pd' in globals():
+    import pandas as pd
+    import json
+    
+    # Save DataFrames
+    original_df_repr_html = pd.DataFrame._repr_html_
+    def custom_df_repr_html(self):
         try:
-            # Save basic info
-            __df_info = {
-                "name": __var_name,
-                "shape": __var_val.shape,
-                "columns": list(__var_val.columns),
-                "preview_html": __var_val.head().to_html()
-            }
-            with open(os.path.join('{}', f'df_{{__var_name}}.json'), 'w') as __f:
-                json.dump(__df_info, __f)
+            df_info = {{
+                "name": str(id(self)),
+                "shape": self.shape,
+                "columns": list(map(str, self.columns)),
+                "preview_html": self.head().to_html()
+            }}
+            with open(f'df_{{id(self)}}.json', 'w') as f:
+                json.dump(df_info, f)
         except:
             pass
-""".format(temp_dir.replace('\\', '\\\\'))
-            
-            code += "\n" + dataframes_code
+        return original_df_repr_html(self)
+    pd.DataFrame._repr_html_ = custom_df_repr_html
+""".format(plot_dir.replace('\\', '\\\\'))
+        
+        with open(main_script, 'r+', encoding='utf-8') as f:
+            content = f.read()
+            f.seek(0, 0)
+            f.write(data_handling + "\n" + content)
         
-        # Create the script file
-        script_path = os.path.join(temp_dir, 'script.py')
-        with open(script_path, 'w') as f:
-            f.write(code)
+        # Files for capturing stdout and stderr
+        stdout_file = os.path.join(temp_dir, 'stdout.txt')
+        stderr_file = os.path.join(temp_dir, 'stderr.txt')
         
         # Execute with timeout
         start_time = time.time()
@@ -1120,19 +1238,37 @@ for __var_name, __var_val in __globals_dict.items():
             # Run the script with stdout and stderr redirection
             with open(stdout_file, 'w') as stdout_f, open(stderr_file, 'w') as stderr_f:
                 process = subprocess.Popen(
-                    [sys.executable, script_path],
+                    [sys.executable, main_script],
                     stdout=stdout_f,
                     stderr=stderr_f,
                     cwd=temp_dir
                 )
                 
-                try:
-                    process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    result["stderr"] += f"\nScript execution timed out after {timeout} seconds."
-                    result["exception"] = "TimeoutError"
-                    return result
+                # Real-time monitoring for real-time visualization
+                if realtime_viz:
+                    realtime_data_file = os.path.join(temp_dir, 'realtime_data.json')
+                    while process.poll() is None:
+                        if os.path.exists(realtime_data_file):
+                            try:
+                                with open(realtime_data_file, 'r') as f:
+                                    result["realtime_data"] = json.load(f)
+                            except:
+                                pass
+                        time.sleep(0.1)
+                        
+                        # Check for timeout
+                        if time.time() - start_time > timeout:
+                            process.kill()
+                            result["stderr"] += f"\nScript execution timed out after {timeout} seconds."
+                            result["exception"] = "TimeoutError"
+                            break
+                else:
+                    try:
+                        process.wait(timeout=timeout)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                        result["stderr"] += f"\nScript execution timed out after {timeout} seconds."
+                        result["exception"] = "TimeoutError"
             
             # Read the output
             with open(stdout_file, 'r') as f:
@@ -1154,6 +1290,15 @@ for __var_name, __var_val in __globals_dict.items():
                 with open(os.path.join(temp_dir, df_file), 'r') as f:
                     result["dataframes"].append(json.load(f))
             
+            # Collect profiling data if enabled
+            if enable_profile and os.path.exists(os.path.join(temp_dir, 'profile_results.txt')):
+                with open(os.path.join(temp_dir, 'profile_results.txt'), 'r') as f:
+                    result["profile_data"] = f.read()
+            
+            # Collect debug data if enabled
+            if enable_debug and 'debug_steps' in globals():
+                result["debug_steps"] = debug_steps
+            
             # Calculate execution time
             result["execution_time"] = time.time() - start_time
             
@@ -1163,8 +1308,8 @@ for __var_name, __var_val in __globals_dict.items():
             
     return result
 
-def display_python_script_results(result):
-    """Display the results from the Python script execution"""
+def display_python_script_results_enhanced(result):
+    """Display the enhanced results from the Python script execution"""
     if not result:
         st.error("No results to display.")
         return
@@ -1180,24 +1325,415 @@ def display_python_script_results(result):
         st.error("Errors:")
         st.code(result["stderr"], language="bash")
     
+    # Display profiling data if available
+    if result.get("profile_data"):
+        with st.expander("Profiling Results"):
+            st.code(result["profile_data"], language="bash")
+    
+    # Display debugging steps if available
+    if result.get("debug_steps"):
+        with st.expander("Debugging Steps"):
+            for i, step in enumerate(result["debug_steps"]):
+                st.markdown(f"**Step {i+1}**: {step}")
+    
     # Display plots if any
     if result["plots"]:
         st.markdown("### Plots")
         cols = st.columns(min(3, len(result["plots"])))
         for i, plot_data in enumerate(result["plots"]):
             cols[i % len(cols)].image(plot_data, use_column_width=True)
+            
+            # Add button to use this plot in Manim
+            if cols[i % len(cols)].button(f"Use in Manim", key=f"use_plot_{i}"):
+                # Create a temporary file
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
+                    tmp.write(plot_data)
+                    plot_path = tmp.name
+                
+                # Generate Manim code
+                plot_code = f"""
+# Import the plot image
+plot_image = ImageMobject(r"{plot_path}")
+plot_image.scale(2)  # Adjust size as needed
+self.play(FadeIn(plot_image))
+self.wait(1)
+"""
+                if st.session_state.code:
+                    st.session_state.code += "\n" + plot_code
+                else:
+                    st.session_state.code = f"""from manim import *
+class PlotScene(Scene):
+    def construct(self):
+        {plot_code}
+"""
+                st.session_state.temp_code = st.session_state.code
+                st.success(f"Added plot to your Manim code!")
+                # Set pending tab switch to editor tab
+                st.session_state.pending_tab_switch = 0
+                st.rerun()
     
     # Display dataframes if any
     if result["dataframes"]:
         st.markdown("### DataFrames")
         for df_info in result["dataframes"]:
-            with st.expander(f"{df_info['name']} - {df_info['shape'][0]} rows × {df_info['shape'][1]} columns"):
+            with st.expander(f"{df_info.get('name', 'DataFrame')} - {df_info['shape'][0]} rows × {df_info['shape'][1]} columns"):
                 st.markdown(df_info["preview_html"], unsafe_allow_html=True)
+                
+                # Add button to visualize this dataframe in Manim
+                if st.button(f"Visualize in Manim", key=f"viz_df_{df_info.get('name', 'df')}"):
+                    # Generate Manim code for dataframe visualization
+                    df_viz_code = f"""
+# Create a simple table visualization
+columns = {df_info['columns']}
+table = Table(
+    col_labels=[Text(col, font_size=24) for col in columns]
+)
+
+# Add data rows (showing first 5 rows)
+for i in range(min(5, {df_info['shape'][0]})):
+    # This is a placeholder - in a real implementation, you'd extract actual data
+    table.add_row(*[Text(f"Row {{i}}, Col {{j}}", font_size=20) for j in range(len(columns))])
+
+self.play(Create(table))
+self.wait(1)
+"""
+                    if st.session_state.code:
+                        st.session_state.code += "\n" + df_viz_code
+                    else:
+                        st.session_state.code = f"""from manim import *
+class DataFrameScene(Scene):
+    def construct(self):
+        {df_viz_code}
+"""
+                    st.session_state.temp_code = st.session_state.code
+                    st.success(f"Added DataFrame visualization to your Manim code!")
+                    # Set pending tab switch to editor tab
+                    st.session_state.pending_tab_switch = 0
+                    st.rerun()
     
     # Display standard output
     if result["stdout"]:
         st.markdown("### Standard Output")
         st.code(result["stdout"], language="bash")
+    
+    # Display real-time data if available
+    if result.get("realtime_data"):
+        st.markdown("### Real-time Data")
+        
+        # Convert to DataFrame for easier visualization
+        import pandas as pd
+        rt_df = pd.DataFrame(result["realtime_data"])
+        
+        # Create a plotly chart
+        import plotly.express as px
+        if not rt_df.empty and "time" in rt_df.columns and "value" in rt_df.columns:
+            fig = px.line(rt_df, x="time", y="value", color="label" if "label" in rt_df.columns else None,
+                        title="Real-time Data Visualization")
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Add button to create Manim animation from this data
+            if st.button("Create Manim Animation from Data", key="create_manim_from_rt"):
+                # Extract data points
+                data_points = []
+                for _, row in rt_df.iterrows():
+                    if "value" in row:
+                        data_points.append(float(row["value"]))
+                
+                # Generate Manim code
+                rt_viz_code = f"""
+# Visualize real-time data
+data = {data_points}
+axes = Axes(
+    x_range=[0, {len(data_points)}, 1],
+    y_range=[{min(data_points) if data_points else 0}, {max(data_points) if data_points else 10}, {(max(data_points)-min(data_points))/10 if data_points and max(data_points) > min(data_points) else 1}],
+    axis_config={{"color": BLUE}}
+)
+points = [axes.coords_to_point(i, v) for i, v in enumerate(data)]
+graph = VMobject(color=RED)
+graph.set_points_as_corners(points)
+
+self.play(Create(axes))
+self.play(Create(graph), run_time=2)
+self.wait(1)
+"""
+                if st.session_state.code:
+                    st.session_state.code += "\n" + rt_viz_code
+                else:
+                    st.session_state.code = f"""from manim import *
+class DataVisualizationScene(Scene):
+    def construct(self):
+        {rt_viz_code}
+"""
+                st.session_state.temp_code = st.session_state.code
+                st.success(f"Added real-time data visualization to your Manim code!")
+                # Set pending tab switch to editor tab
+                st.session_state.pending_tab_switch = 0
+                st.rerun()
+
+# C/C++ RUNNER FUNCTIONS
+def compile_cpp_code_enhanced(code, settings, project_files=None, enable_debug=False, breakpoints=None, watch_vars=None):
+    """Enhanced function to compile C++ code with advanced options."""
+    try:
+        # Create a temporary directory for compilation
+        temp_dir = tempfile.mkdtemp(prefix="cpp_runner_")
+        
+        # Write the project files
+        if project_files:
+            for filename, content in project_files.items():
+                file_path = os.path.join(temp_dir, filename)
+                with open(file_path, "w") as f:
+                    f.write(content)
+            # Set main file for single file mode
+            cpp_file = os.path.join(temp_dir, "main.cpp")
+        else:
+            # Write the single code file
+            cpp_file = os.path.join(temp_dir, "main.cpp")
+            with open(cpp_file, "w") as f:
+                f.write(code)
+        
+        # Output executable path
+        exe_file = os.path.join(temp_dir, "program.exe" if platform.system() == "Windows" else "program")
+        
+        # Build the compilation command
+        compiler = settings.get("compiler", "g++")
+        std_version = settings.get("std", "c++17")
+        optimization = settings.get("optimization", "-O2")
+        
+        compile_cmd = [
+            compiler,
+            "-std=" + std_version,
+            optimization
+        ]
+        
+        # Add debug flag if debugging is enabled
+        if enable_debug:
+            compile_cmd.append("-g")
+        
+        # Add preprocessor definitions
+        for definition in settings.get("definitions", []):
+            if "=" in definition:
+                name, value = definition.split("=", 1)
+                compile_cmd.append(f"-D{name}={value}")
+            else:
+                compile_cmd.append(f"-D{definition}")
+        
+        # Add include paths
+        for path in settings.get("include_paths", []):
+            compile_cmd.append(f"-I{path}")
+        
+        # Add library paths
+        for path in settings.get("library_paths", []):
+            compile_cmd.append(f"-L{path}")
+        
+        # Add files to compile
+        if project_files:
+            source_files = [os.path.join(temp_dir, f) for f in project_files.keys() if f.endswith((".cpp", ".c", ".cc"))]
+            compile_cmd.extend(source_files)
+        else:
+            compile_cmd.append(cpp_file)
+        
+        # Output file
+        compile_cmd.extend(["-o", exe_file])
+        
+        # Add libraries
+        for lib in settings.get("libraries", []):
+            if lib == "Eigen":
+                # Eigen is header-only, nothing to link
+                pass
+            elif lib == "OpenCV":
+                # Add OpenCV libraries
+                try:
+                    # Get OpenCV libraries using pkg-config
+                    pkg_config = subprocess.run(
+                        ["pkg-config", "--libs", "opencv4"],
+                        capture_output=True,
+                        text=True,
+                        check=False
+                    )
+                    if pkg_config.returncode == 0:
+                        compile_cmd.extend(pkg_config.stdout.strip().split())
+                    else:
+                        # Try opencv instead of opencv4
+                        pkg_config = subprocess.run(
+                            ["pkg-config", "--libs", "opencv"],
+                            capture_output=True,
+                            text=True,
+                            check=False
+                        )
+                        if pkg_config.returncode == 0:
+                            compile_cmd.extend(pkg_config.stdout.strip().split())
+                        else:
+                            # Fallback to common OpenCV libraries
+                            compile_cmd.extend(["-lopencv_core", "-lopencv_imgproc", "-lopencv_highgui"])
+                except:
+                    # Fallback to common OpenCV libraries
+                    compile_cmd.extend(["-lopencv_core", "-lopencv_imgproc", "-lopencv_highgui"])
+            elif lib == "Boost":
+                # Add common Boost libraries
+                compile_cmd.extend(["-lboost_system", "-lboost_filesystem"])
+            elif lib == "FFTW":
+                compile_cmd.append("-lfftw3")
+            elif lib == "SDL2":
+                compile_cmd.append("-lSDL2")
+            elif lib == "SFML":
+                compile_cmd.extend(["-lsfml-graphics", "-lsfml-window", "-lsfml-system"])
+            elif lib == "OpenGL":
+                compile_cmd.extend(["-lGL", "-lGLU", "-lglut"])
+        
+        # Add additional libraries
+        for lib in settings.get("additional_libs", []):
+            compile_cmd.append(f"-l{lib}")
+        
+        # Add advanced flags
+        if settings.get("advanced_flags"):
+            compile_cmd.extend(settings["advanced_flags"].split())
+        
+        # Run the compilation process
+        logger.info(f"Compiling with command: {' '.join(compile_cmd)}")
+        result = subprocess.run(
+            compile_cmd,
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=temp_dir
+        )
+        
+        if result.returncode != 0:
+            return None, result.stderr, temp_dir
+        
+        return exe_file, None, temp_dir
+    except Exception as e:
+        return None, str(e), None
+
+def run_cpp_executable_enhanced(exe_path, temp_dir, inputs=None, timeout=30, enable_debug=False, breakpoints=None, watch_vars=None):
+    """Enhanced function to run C++ executable with debugging support."""
+    result = {
+        "stdout": "",
+        "stderr": "",
+        "execution_time": 0,
+        "images": [],
+        "exception": None,
+        "debug_output": None,
+        "memory_usage": None
+    }
+    
+    try:
+        # Prepare input data if provided
+        input_data = "\n".join(inputs) if inputs else None
+        
+        # Start timing
+        start_time = time.time()
+        
+        if enable_debug and breakpoints:
+            # Run with GDB for debugging
+            gdb_commands = ["set pagination off"]
+            
+            # Add breakpoints
+            for bp in breakpoints:
+                gdb_commands.append(f"break {bp}")
+            
+            # Add watchpoints for variables
+            if watch_vars:
+                for var in watch_vars:
+                    gdb_commands.append(f"watch {var}")
+            
+            # Run the program
+            gdb_commands.append("run")
+            
+            # Continue to end
+            gdb_commands.append("continue")
+            
+            # Quit GDB
+            gdb_commands.append("quit")
+            
+            # Create GDB command file
+            gdb_cmd_file = os.path.join(temp_dir, "gdb_commands.txt")
+            with open(gdb_cmd_file, "w") as f:
+                f.write("\n".join(gdb_commands))
+            
+            # Run with GDB
+            process = subprocess.run(
+                ["gdb", "-x", gdb_cmd_file, "-batch", exe_path],
+                input=input_data,
+                text=True,
+                capture_output=True,
+                timeout=timeout,
+                cwd=temp_dir
+            )
+            
+            # Capture outputs
+            result["stdout"] = process.stdout
+            result["stderr"] = process.stderr
+            result["debug_output"] = process.stdout
+        else:
+            # Run normally
+            process = subprocess.run(
+                [exe_path],
+                input=input_data,
+                text=True,
+                capture_output=True,
+                timeout=timeout,
+                cwd=temp_dir
+            )
+            
+            # Capture outputs
+            result["stdout"] = process.stdout
+            result["stderr"] = process.stderr
+        
+        # Calculate execution time
+        result["execution_time"] = time.time() - start_time
+        
+        # Look for generated images in the executable directory
+        for ext in [".png", ".jpg", ".jpeg", ".bmp", ".ppm"]:
+            image_files = [f for f in os.listdir(temp_dir) if f.endswith(ext)]
+            for img_file in image_files:
+                try:
+                    img_path = os.path.join(temp_dir, img_file)
+                    
+                    # For PPM files, convert to PNG for easier display
+                    if img_file.endswith(".ppm"):
+                        # Create output path
+                        png_path = os.path.join(temp_dir, img_file.replace(".ppm", ".png"))
+                        
+                        # Convert using PIL
+                        from PIL import Image
+                        Image.open(img_path).save(png_path)
+                        img_path = png_path
+                        img_file = img_file.replace(".ppm", ".png")
+                    
+                    with open(img_path, "rb") as f:
+                        result["images"].append({
+                            "name": img_file,
+                            "data": f.read()
+                        })
+                except Exception as e:
+                    logger.error(f"Error processing image {img_file}: {str(e)}")
+        
+        # Estimate memory usage
+        try:
+            if platform.system() != "Windows":
+                # Use ps command to get memory usage
+                ps_output = subprocess.run(
+                    ["ps", "-p", str(process.pid), "-o", "rss="],
+                    capture_output=True,
+                    text=True,
+                    check=False
+                )
+                if ps_output.returncode == 0:
+                    mem_kb = int(ps_output.stdout.strip())
+                    result["memory_usage"] = mem_kb / 1024  # Convert to MB
+        except:
+            pass
+        
+        return result
+    except subprocess.TimeoutExpired:
+        result["stderr"] += f"\nProgram execution timed out after {timeout} seconds."
+        result["exception"] = "TimeoutError"
+        return result
+    except Exception as e:
+        result["stderr"] += f"\nError executing program: {str(e)}"
+        result["exception"] = str(e)
+        return result
 
 def parse_animation_steps(python_code):
     """Parse Manim code to extract animation steps for timeline editor"""
@@ -1703,6 +2239,39 @@ def main():
         st.session_state.custom_model = "gpt-4o"  # Default model
         st.session_state.first_load_complete = False  # Prevent refreshes on first load
         st.session_state.pending_tab_switch = None  # Track pending tab switches
+        # C++ runner state
+        st.session_state.cpp_code = """#include <iostream>
+#include <vector>
+#include <algorithm>
+
+int main() {
+    std::cout << "Hello, Manim Animation Studio!" << std::endl;
+    
+    // Create a vector of numbers
+    std::vector<int> numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
+    
+    // Sort the vector
+    std::sort(numbers.begin(), numbers.end());
+    
+    // Print the sorted numbers
+    std::cout << "Sorted numbers: ";
+    for (int num : numbers) {
+        std::cout << num << " ";
+    }
+    std::cout << std::endl;
+    
+    return 0;
+}"""
+        st.session_state.cpp_result = None
+        st.session_state.cpp_project_files = {"main.cpp": st.session_state.cpp_code}
+        st.session_state.cpp_settings = {
+            "compiler": "g++",
+            "std": "c++17",
+            "optimization": "-O2",
+            "include_paths": [],
+            "library_paths": [],
+            "libraries": []
+        }
 
     # Page configuration with improved layout
     st.set_page_config(
@@ -1873,8 +2442,8 @@ def main():
             st.error("Failed to install required packages. Please try again.")
             st.stop()
     
-    # Create main tabs - LaTeX tab removed
-    tab_names = ["✨ Editor", "🤖 AI Assistant", "🎨 Assets", "🎞️ Timeline", "🎓 Educational Export", "🐍 Python Runner"]
+    # Create main tabs
+    tab_names = ["✨ Editor", "🤖 AI Assistant", "🎨 Assets", "🎞️ Timeline", "🎓 Educational Export", "🐍 Python Runner", "🔧 C/C++ Runner"]
     tabs = st.tabs(tab_names)
     
     # Sidebar for rendering settings and custom libraries
@@ -1947,6 +2516,34 @@ def main():
         if st.session_state.custom_library_result:
             with st.expander("Installation Results"):
                 st.code(st.session_state.custom_library_result)
+                
+        # C/C++ Library Options
+        with st.sidebar.expander("C/C++ Library Options"):
+            st.markdown("### Advanced C/C++ Settings")
+            
+            cpp_libs = st.multiselect(
+                "Include Libraries",
+                options=["Eigen", "Boost", "OpenCV", "FFTW", "Matplotlib-cpp"],
+                default=st.session_state.cpp_settings.get("libraries", [])
+            )
+            
+            st.session_state.cpp_settings["libraries"] = cpp_libs
+            
+            custom_include = st.text_input("Custom Include Path:")
+            custom_lib = st.text_input("Custom Library Path:")
+            
+            if custom_include and custom_include not in st.session_state.cpp_settings.get("include_paths", []):
+                if "include_paths" not in st.session_state.cpp_settings:
+                    st.session_state.cpp_settings["include_paths"] = []
+                st.session_state.cpp_settings["include_paths"].append(custom_include)
+                
+            if custom_lib and custom_lib not in st.session_state.cpp_settings.get("library_paths", []):
+                if "library_paths" not in st.session_state.cpp_settings:
+                    st.session_state.cpp_settings["library_paths"] = []
+                st.session_state.cpp_settings["library_paths"].append(custom_lib)
+            
+            if st.button("Update Library Settings"):
+                st.success("Library settings updated!")
 
     # EDITOR TAB
     with tabs[0]:
@@ -2421,8 +3018,8 @@ class MyScene(Scene):
                                     if "Scene" not in completed_code:
                                         completed_code = f"""from manim import *
                 
-                class MyScene(Scene):
-                    def construct(self):
+class MyScene(Scene):
+    def construct(self):
                         {completed_code}"""
                                     
                                     # Store the generated code
@@ -2788,6 +3385,60 @@ class YourScene(Scene):
         st.markdown("### 🐍 Python Script Runner")
         st.markdown("Execute Python scripts and visualize the results directly.")
         
+        # New UI elements for advanced features
+        with st.expander("🔧 Advanced Python Features"):
+            py_feature_col1, py_feature_col2 = st.columns(2)
+            
+            with py_feature_col1:
+                enable_debugging = st.checkbox("Enable Debugging", value=False, key="py_debug_enable")
+                enable_profiling = st.checkbox("Enable Profiling", value=False, key="py_profile_enable")
+                
+            with py_feature_col2:
+                py_libs = st.multiselect(
+                    "Additional Libraries",
+                    options=["numpy", "scipy", "pandas", "matplotlib", "seaborn", "plotly", "scikit-learn", "tensorflow", "pytorch", "sympy"],
+                    default=["numpy", "matplotlib"],
+                    key="py_additional_libs"
+                )
+
+        # Multi-file project support
+        with st.expander("📁 Multi-file Project"):
+            st.markdown("Add multiple Python files to your project")
+            
+            # File manager
+            if "py_project_files" not in st.session_state:
+                st.session_state.py_project_files = {"main.py": st.session_state.python_script}
+            
+            # File selector
+            current_file = st.selectbox(
+                "Select File",
+                options=list(st.session_state.py_project_files.keys()),
+                key="py_current_file"
+            )
+            
+            # New file creation
+            new_file_col1, new_file_col2 = st.columns([3, 1])
+            with new_file_col1:
+                new_filename = st.text_input("New File Name", value="", key="py_new_filename")
+            with new_file_col2:
+                if st.button("Add File", key="py_add_file_btn"):
+                    if new_filename and new_filename not in st.session_state.py_project_files:
+                        if not new_filename.endswith(".py"):
+                            new_filename += ".py"
+                        st.session_state.py_project_files[new_filename] = "# New Python file\n\n"
+                        st.session_state.py_current_file = new_filename
+                        st.experimental_rerun()
+            
+            # Update the current file content in session state
+            if current_file in st.session_state.py_project_files:
+                st.session_state.py_project_files[current_file] = st.session_state.python_script
+                # Update main script if we're editing the main file
+                if current_file == "main.py":
+                    st.session_state.python_script = st.session_state.python_script
+
+        # Real-time visualization toggle
+        real_time_viz = st.checkbox("Enable Real-time Visualization", value=False, key="py_realtime_viz")
+        
         # Predefined example scripts
         example_scripts = {
             "Select an example...": "",
@@ -2912,58 +3563,22 @@ plt.title('Distribution of A by Category')
         
         if run_btn:
             with st.spinner("Executing Python script..."):
-                result = run_python_script(python_code, inputs=user_inputs, timeout=timeout_seconds)
+                # Use the enhanced function
+                result = run_python_script_enhanced(
+                    python_code, 
+                    inputs=user_inputs, 
+                    timeout=timeout_seconds,
+                    enable_debug=enable_debugging,
+                    enable_profile=enable_profiling,
+                    additional_libs=py_libs,
+                    project_files=st.session_state.py_project_files if "py_project_files" in st.session_state else None,
+                    realtime_viz=real_time_viz
+                )
                 st.session_state.python_result = result
         
         # Display results
         if st.session_state.python_result:
-            display_python_script_results(st.session_state.python_result)
-            
-            # Option to insert plots into Manim animation
-            if st.session_state.python_result["plots"]:
-                with st.expander("Add Plots to Manim Animation"):
-                    st.markdown("Select a plot to include in your Manim animation:")
-                    
-                    plot_cols = st.columns(min(3, len(st.session_state.python_result["plots"])))
-                    
-                    for i, plot_data in enumerate(st.session_state.python_result["plots"]):
-                        # Create a unique temporary file for each plot
-                        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
-                            tmp.write(plot_data)
-                            plot_path = tmp.name
-                        
-                        # Display the plot with selection button
-                        with plot_cols[i % len(plot_cols)]:
-                            st.image(plot_data, use_column_width=True)
-                            if st.button(f"Use Plot {i+1}", key=f"use_plot_{i}"):
-                                # Create code to include this plot in Manim
-                                plot_code = f"""
-# Import the plot image
-plot_image = ImageMobject(r"{plot_path}")
-plot_image.scale(2)  # Adjust size as needed
-self.play(FadeIn(plot_image))
-self.wait(1)
-"""
-                                # Insert into editor code
-                                if st.session_state.code:
-                                    st.session_state.code += "\n" + plot_code
-                                    st.session_state.temp_code = st.session_state.code
-                                    st.success(f"Plot {i+1} added to your animation code!")
-                                    # Set pending tab switch to editor tab
-                                    st.session_state.pending_tab_switch = 0
-                                    st.rerun()
-                                else:
-                                    basic_scene = f"""from manim import *
-class PlotScene(Scene):
-    def construct(self):
-        {plot_code}
-"""
-                                    st.session_state.code = basic_scene
-                                    st.session_state.temp_code = basic_scene
-                                    st.success(f"Created new scene with Plot {i+1}!")
-                                    # Set pending tab switch to editor tab
-                                    st.session_state.pending_tab_switch = 0
-                                    st.rerun()
+            display_python_script_results_enhanced(st.session_state.python_result)
             
             # Provide option to save the script
             if st.button("📄 Save This Script", key="save_script_btn"):
@@ -3011,6 +3626,1218 @@ class PlotScene(Scene):
             - Perfect for educational content combining data and animations
             """)
 
+    # C/C++ RUNNER TAB
+    with tabs[6]:  # Assuming this is the 7th tab (index 6)
+        st.markdown("### 🔧 C/C++ Runner")
+        st.markdown("Write, compile, and run C/C++ code with advanced features.")
+        
+        # Create a tabbed interface for different C++ features
+        cpp_tabs = st.tabs(["Code Editor", "Project Files", "Libraries", "Build Settings", "Debugger"])
+        
+        with cpp_tabs[0]:  # Code Editor tab
+            # Compiler options
+            cpp_col1, cpp_col2, cpp_col3 = st.columns(3)
+            
+            with cpp_col1:
+                compiler = st.selectbox(
+                    "Compiler",
+                    options=["g++", "clang++", "gcc", "msvc"],
+                    index=["g++", "clang++", "gcc", "msvc"].index(st.session_state.cpp_settings["compiler"]),
+                    key="cpp_compiler"
+                )
+                st.session_state.cpp_settings["compiler"] = compiler
+            
+            with cpp_col2:
+                std_version = st.selectbox(
+                    "Standard",
+                    options=["c++11", "c++14", "c++17", "c++20"],
+                    index=["c++11", "c++14", "c++17", "c++20"].index(st.session_state.cpp_settings["std"]),
+                    key="cpp_std"
+                )
+                st.session_state.cpp_settings["std"] = std_version
+            
+            with cpp_col3:
+                optimization = st.selectbox(
+                    "Optimization",
+                    options=["-O0", "-O1", "-O2", "-O3"],
+                    index=["-O0", "-O1", "-O2", "-O3"].index(st.session_state.cpp_settings["optimization"]),
+                    key="cpp_opt"
+                )
+                st.session_state.cpp_settings["optimization"] = optimization
+            
+            # Example code templates
+            cpp_examples = {
+                "Select an example...": "",
+                "Hello World": """#include <iostream>
+
+int main() {
+    std::cout << "Hello, World!" << std::endl;
+    return 0;
+}""",
+                "Calculate Prime Numbers": """#include <iostream>
+#include <vector>
+#include <chrono>
+
+bool isPrime(int n) {
+    if (n <= 1) return false;
+    if (n <= 3) return true;
+    if (n % 2 == 0 || n % 3 == 0) return false;
+    
+    for (int i = 5; i * i <= n; i += 6) {
+        if (n % i == 0 || n % (i + 2) == 0)
+            return false;
+    }
+    return true;
+}
+
+int main() {
+    int limit = 10000;
+    std::vector<int> primes;
+    
+    auto start = std::chrono::high_resolution_clock::now();
+    
+    for (int i = 2; i <= limit; i++) {
+        if (isPrime(i)) {
+            primes.push_back(i);
+        }
+    }
+    
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+    
+    std::cout << "Found " << primes.size() << " prime numbers up to " << limit << std::endl;
+    std::cout << "First 10 primes: ";
+    for (int i = 0; i < std::min(10, (int)primes.size()); i++) {
+        std::cout << primes[i] << " ";
+    }
+    std::cout << std::endl;
+    std::cout << "Computation time: " << duration.count() << " ms" << std::endl;
+    
+    return 0;
+}""",
+                "Image Generation (PPM)": """#include <iostream>
+#include <fstream>
+#include <cmath>
+
+// Generate a simple gradient image in PPM format
+int main() {
+    const int width = 800;
+    const int height = 600;
+    
+    // Create a PPM file (P3 format - ASCII)
+    std::ofstream image("output.ppm");
+    image << "P3\\n" << width << " " << height << "\\n255\\n";
+    
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            // Create a gradient based on position
+            int r = static_cast<int>(255.0 * x / width);
+            int g = static_cast<int>(255.0 * y / height);
+            int b = static_cast<int>(255.0 * (x + y) / (width + height));
+            
+            // Write RGB values
+            image << r << " " << g << " " << b << "\\n";
+        }
+    }
+    
+    image.close();
+    std::cout << "Generated gradient image: output.ppm" << std::endl;
+    return 0;
+}""",
+                "Data Processing with Vectors": """#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <numeric>
+#include <random>
+#include <iomanip>
+
+int main() {
+    const int data_size = 1000;
+    
+    // Generate random data
+    std::vector<double> data(data_size);
+    
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::normal_distribution<double> dist(100.0, 15.0);
+    
+    std::cout << "Generating " << data_size << " random values..." << std::endl;
+    for (auto& value : data) {
+        value = dist(gen);
+    }
+    
+    // Calculate statistics
+    double sum = std::accumulate(data.begin(), data.end(), 0.0);
+    double mean = sum / data.size();
+    
+    std::vector<double> deviations(data_size);
+    std::transform(data.begin(), data.end(), deviations.begin(),
+                  [mean](double x) { return x - mean; });
+    
+    double sq_sum = std::inner_product(deviations.begin(), deviations.end(),
+                                      deviations.begin(), 0.0);
+    double stddev = std::sqrt(sq_sum / data.size());
+    
+    // Sort data
+    std::sort(data.begin(), data.end());
+    double median = data.size() % 2 == 0 ?
+                   (data[data.size()/2 - 1] + data[data.size()/2]) / 2 :
+                   data[data.size()/2];
+    
+    // Output results
+    std::cout << std::fixed << std::setprecision(2);
+    std::cout << "Data analysis results:" << std::endl;
+    std::cout << "Mean:   " << mean << std::endl;
+    std::cout << "Median: " << median << std::endl;
+    std::cout << "StdDev: " << stddev << std::endl;
+    std::cout << "Min:    " << data.front() << std::endl;
+    std::cout << "Max:    " << data.back() << std::endl;
+    
+    return 0;
+}""",
+                "Interactive User Input": """#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    std::string name;
+    int age;
+    
+    // Get user input
+    std::cout << "Enter your name: ";
+    std::getline(std::cin, name);
+    
+    std::cout << "Enter your age: ";
+    std::cin >> age;
+    std::cin.ignore(); // Clear the newline from the buffer
+    
+    std::cout << "Hello, " << name << "! ";
+    std::cout << "In 10 years, you will be " << age + 10 << " years old." << std::endl;
+    
+    // Get multiple numbers
+    int num_count;
+    std::cout << "How many numbers would you like to enter? ";
+    std::cin >> num_count;
+    
+    std::vector<double> numbers;
+    double total = 0.0;
+    
+    for (int i = 0; i < num_count; i++) {
+        double num;
+        std::cout << "Enter number " << (i+1) << ": ";
+        std::cin >> num;
+        numbers.push_back(num);
+        total += num;
+    }
+    
+    if (!numbers.empty()) {
+        double average = total / numbers.size();
+        std::cout << "The average of your numbers is: " << average << std::endl;
+    }
+    
+    return 0;
+}""",
+                "Eigen Matrix Operations": """#include <iostream>
+#include <Eigen/Dense>
+
+using Eigen::MatrixXd;
+using Eigen::VectorXd;
+
+int main() {
+    // Create a 3x3 matrix
+    MatrixXd A(3, 3);
+    A << 1, 2, 3,
+         4, 5, 6,
+         7, 8, 9;
+    
+    // Create a 3D vector
+    VectorXd b(3);
+    b << 1, 2, 3;
+    
+    // Perform operations
+    std::cout << "Matrix A:\\n" << A << std::endl;
+    std::cout << "Vector b:\\n" << b << std::endl;
+    std::cout << "A * b:\\n" << A * b << std::endl;
+    std::cout << "A transpose:\\n" << A.transpose() << std::endl;
+    
+    // Solve a linear system Ax = b
+    VectorXd x = A.colPivHouseholderQr().solve(b);
+    std::cout << "Solution to Ax = b:\\n" << x << std::endl;
+    
+    // Compute eigenvalues and eigenvectors
+    Eigen::EigenSolver<MatrixXd> solver(A);
+    std::cout << "Eigenvalues:\\n" << solver.eigenvalues() << std::endl;
+    std::cout << "Eigenvectors:\\n" << solver.eigenvectors() << std::endl;
+    
+    return 0;
+}""",
+                "OpenCV Image Processing": """#include <iostream>
+#include <opencv2/opencv.hpp>
+
+int main() {
+    // Load an image (this will create a blank image if no file is found)
+    cv::Mat image = cv::Mat::zeros(500, 500, CV_8UC3);
+    
+    // Draw a circle
+    cv::circle(image, cv::Point(250, 250), 100, cv::Scalar(0, 0, 255), 5);
+    
+    // Draw a rectangle
+    cv::rectangle(image, cv::Point(150, 150), cv::Point(350, 350), cv::Scalar(0, 255, 0), 3);
+    
+    // Add text
+    cv::putText(image, "OpenCV Example", cv::Point(100, 50), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(255, 255, 255), 2);
+    
+    // Save the image
+    cv::imwrite("opencv_output.png", image);
+    
+    std::cout << "Image created and saved as 'opencv_output.png'" << std::endl;
+    
+    return 0;
+}"""
+            }
+            
+            # Example selection
+            selected_cpp_example = st.selectbox("Example code:", options=list(cpp_examples.keys()))
+            
+            # Set initial code from example or session state
+            if selected_cpp_example != "Select an example..." and cpp_examples[selected_cpp_example] != "":
+                initial_code = cpp_examples[selected_cpp_example]
+            else:
+                if "cpp_current_file" in st.session_state and st.session_state.cpp_current_file in st.session_state.cpp_project_files:
+                    initial_code = st.session_state.cpp_project_files[st.session_state.cpp_current_file]
+                else:
+                    initial_code = st.session_state.cpp_code
+            
+            # Code editor for C++
+            if ACE_EDITOR_AVAILABLE:
+                cpp_code = st_ace(
+                    value=initial_code,
+                    language="c_cpp",
+                    theme="monokai",
+                    min_lines=15,
+                    key=f"cpp_editor_{st.session_state.editor_key}"
+                )
+            else:
+                cpp_code = st.text_area(
+                    "C/C++ Code",
+                    value=initial_code,
+                    height=400,
+                    key=f"cpp_textarea_{st.session_state.editor_key}"
+                )
+            
+            # Save the code to session state
+            st.session_state.cpp_code = cpp_code
+            
+            # Update project files
+            if "cpp_current_file" in st.session_state and st.session_state.cpp_current_file in st.session_state.cpp_project_files:
+                st.session_state.cpp_project_files[st.session_state.cpp_current_file] = cpp_code
+            
+            # Check for standard input in the code
+            has_cin = "std::cin" in cpp_code or "cin" in cpp_code
+            
+            # Input values section if needed
+            cpp_inputs = []
+            if has_cin:
+                with st.expander("Input Values"):
+                    st.info("This program uses standard input. Please provide input values below:")
+                    
+                    num_inputs = st.number_input("Number of input lines:", min_value=1, max_value=10, value=1)
+                    for i in range(int(num_inputs)):
+                        cpp_input = st.text_input(f"Input line {i+1}:", key=f"cpp_input_{i}")
+                        cpp_inputs.append(cpp_input)
+        
+        with cpp_tabs[1]:  # Project Files tab
+            st.markdown("### Project Files")
+            st.markdown("Manage multiple source files for your C/C++ project")
+            
+            # File selector
+            cpp_current_file = st.selectbox(
+                "Current File",
+                options=list(st.session_state.cpp_project_files.keys()),
+                index=list(st.session_state.cpp_project_files.keys()).index(st.session_state.cpp_current_file) if "cpp_current_file" in st.session_state else 0,
+                key="cpp_file_selector"
+            )
+            
+            # Update the current file in session state
+            st.session_state.cpp_current_file = cpp_current_file
+            
+            # Create new file form
+            new_file_col1, new_file_col2 = st.columns([3, 1])
+            with new_file_col1:
+                new_cpp_filename = st.text_input("New File Name", placeholder="e.g., utils.h, helper.cpp", key="new_cpp_file")
+            with new_file_col2:
+                if st.button("Add File", key="add_cpp_file"):
+                    if new_cpp_filename and new_cpp_filename not in st.session_state.cpp_project_files:
+                        # Add file extension if missing
+                        if not new_cpp_filename.endswith((".cpp", ".h", ".hpp", ".c", ".cc")):
+                            new_cpp_filename += ".cpp"
+                        
+                        # Create a template based on file type
+                        if new_cpp_filename.endswith((".h", ".hpp")):
+                            template = f"""#ifndef {new_cpp_filename.split('.')[0].upper()}_H
+#define {new_cpp_filename.split('.')[0].upper()}_H
+
+// Your header content here
+
+#endif // {new_cpp_filename.split('.')[0].upper()}_H
+"""
+                        else:
+                            template = f"""#include <iostream>
+
+// Your implementation here
+
+"""
+                        
+                        st.session_state.cpp_project_files[new_cpp_filename] = template
+                        st.session_state.cpp_current_file = new_cpp_filename
+                        st.experimental_rerun()
+            
+            # File actions
+            file_action_col1, file_action_col2 = st.columns(2)
+            with file_action_col1:
+                if st.button("Delete Current File", key="delete_cpp_file"):
+                    if cpp_current_file != "main.cpp" and cpp_current_file in st.session_state.cpp_project_files:
+                        del st.session_state.cpp_project_files[cpp_current_file]
+                        st.session_state.cpp_current_file = "main.cpp"
+                        st.experimental_rerun()
+                    else:
+                        st.error("Cannot delete main.cpp")
+            
+            with file_action_col2:
+                if st.button("Download Project Files", key="download_cpp_project"):
+                    # Create a zip file with all project files
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp:
+                        with zipfile.ZipFile(tmp.name, 'w') as zipf:
+                            for filename, content in st.session_state.cpp_project_files.items():
+                                # Add file to zip
+                                zipf.writestr(filename, content)
+                        
+                        # Download the zip file
+                        with open(tmp.name, "rb") as f:
+                            zip_data = f.read()
+                            
+                        st.download_button(
+                            label="Download ZIP",
+                            data=zip_data,
+                            file_name="cpp_project.zip",
+                            mime="application/zip"
+                        )
+            
+            # Project structure visualization
+            st.markdown("### Project Structure")
+            
+            # Group files by type
+            headers = []
+            sources = []
+            others = []
+            
+            for filename in st.session_state.cpp_project_files:
+                if filename.endswith((".h", ".hpp")):
+                    headers.append(filename)
+                elif filename.endswith((".cpp", ".c", ".cc")):
+                    sources.append(filename)
+                else:
+                    others.append(filename)
+            
+            # Display structure
+            st.markdown("#### Header Files")
+            if headers:
+                for header in sorted(headers):
+                    st.markdown(f"- `{header}`")
+            else:
+                st.markdown("No header files")
+            
+            st.markdown("#### Source Files")
+            if sources:
+                for source in sorted(sources):
+                    st.markdown(f"- `{source}`")
+            else:
+                st.markdown("No source files")
+            
+            if others:
+                st.markdown("#### Other Files")
+                for other in sorted(others):
+                    st.markdown(f"- `{other}`")
+                    
+        with cpp_tabs[2]:  # Libraries tab
+            st.markdown("### Library Manager")
+            st.markdown("Configure libraries and dependencies for your C/C++ project")
+            
+            # Common library selection
+            common_libs = st.multiselect(
+                "Common Libraries",
+                options=["Eigen", "Boost", "OpenCV", "FFTW", "SDL2", "SFML", "OpenGL", "stb_image", "nlohmann_json", "fmt"],
+                default=st.session_state.cpp_settings.get("libraries", []),
+                key="cpp_common_libs"
+            )
+            
+            # Update libraries in settings
+            st.session_state.cpp_settings["libraries"] = common_libs
+            
+            # Include paths
+            st.markdown("#### Include Paths")
+            include_paths = st.text_area(
+                "Include Directories (one per line)",
+                value="\n".join(st.session_state.cpp_settings.get("include_paths", [])),
+                height=100,
+                key="cpp_include_paths"
+            )
+            
+            # Update include paths in settings
+            st.session_state.cpp_settings["include_paths"] = [path for path in include_paths.split("\n") if path.strip()]
+            
+            # Library paths
+            st.markdown("#### Library Paths")
+            library_paths = st.text_area(
+                "Library Directories (one per line)",
+                value="\n".join(st.session_state.cpp_settings.get("library_paths", [])),
+                height=100,
+                key="cpp_library_paths"
+            )
+            
+            # Update library paths in settings
+            st.session_state.cpp_settings["library_paths"] = [path for path in library_paths.split("\n") if path.strip()]
+            
+            # Additional libraries
+            st.markdown("#### Additional Libraries")
+            additional_libs = st.text_area(
+                "Additional Libraries (one per line, without -l prefix)",
+                value="\n".join(st.session_state.cpp_settings.get("additional_libs", [])),
+                height=100,
+                key="cpp_additional_libs"
+            )
+            
+            # Update additional libraries in settings
+            st.session_state.cpp_settings["additional_libs"] = [lib for lib in additional_libs.split("\n") if lib.strip()]
+            
+            # Library detection
+            if st.button("Detect Installed Libraries", key="detect_libs"):
+                with st.spinner("Detecting libraries..."):
+                    # This is a placeholder - in a real implementation, you'd scan the system
+                    detected_libs = []
+                    
+                    # Check for Eigen
+                    try:
+                        result = subprocess.run(
+                            ["find", "/usr/include", "-name", "Eigen"],
+                            capture_output=True,
+                            text=True,
+                            timeout=5
+                        )
+                        if "Eigen" in result.stdout:
+                            detected_libs.append("Eigen")
+                    except:
+                        pass
+                    
+                    # Check for Boost
+                    try:
+                        result = subprocess.run(
+                            ["find", "/usr/include", "-name", "boost"],
+                            capture_output=True,
+                            text=True,
+                            timeout=5
+                        )
+                        if "boost" in result.stdout:
+                            detected_libs.append("Boost")
+                    except:
+                        pass
+                    
+                    # Check for OpenCV
+                    try:
+                        result = subprocess.run(
+                            ["pkg-config", "--exists", "opencv4"],
+                            capture_output=True,
+                            timeout=5
+                        )
+                        if result.returncode == 0:
+                            detected_libs.append("OpenCV")
+                    except:
+                        pass
+                    
+                    # Display detected libraries
+                    if detected_libs:
+                        st.success(f"Detected libraries: {', '.join(detected_libs)}")
+                        # Add to selected libraries if not already present
+                        for lib in detected_libs:
+                            if lib not in st.session_state.cpp_settings["libraries"]:
+                                st.session_state.cpp_settings["libraries"].append(lib)
+                    else:
+                        st.warning("No common libraries detected")
+        
+        with cpp_tabs[3]:  # Build Settings tab
+            st.markdown("### Build Configuration")
+            
+            # Build type
+            build_type = st.radio(
+                "Build Type",
+                options=["Debug", "Release", "RelWithDebInfo"],
+                index=1,  # Default to Release
+                key="cpp_build_type"
+            )
+            
+            # Update build type in settings
+            st.session_state.cpp_settings["build_type"] = build_type
+            
+            # Advanced compiler flags
+            st.markdown("#### Advanced Compiler Flags")
+            advanced_flags = st.text_area(
+                "Additional Compiler Flags",
+                value=st.session_state.cpp_settings.get("advanced_flags", ""),
+                height=100,
+                key="cpp_advanced_flags"
+            )
+            
+            # Update advanced flags in settings
+            st.session_state.cpp_settings["advanced_flags"] = advanced_flags
+            
+            # Preprocessor definitions
+            st.markdown("#### Preprocessor Definitions")
+            definitions = st.text_area(
+                "Preprocessor Definitions (one per line)",
+                value="\n".join(st.session_state.cpp_settings.get("definitions", [])),
+                height=100,
+                placeholder="Example:\nDEBUG\nVERSION=1.0\nUSE_FEATURE_X",
+                key="cpp_definitions"
+            )
+            
+            # Update definitions in settings
+            st.session_state.cpp_settings["definitions"] = [d for d in definitions.split("\n") if d.strip()]
+            
+            # Generate CMakeLists.txt
+            if st.button("Generate CMakeLists.txt", key="gen_cmake"):
+                # Create CMakeLists.txt content
+                cmake_content = f"""cmake_minimum_required(VERSION 3.10)
+project(ManimCppProject)
+
+set(CMAKE_CXX_STANDARD {st.session_state.cpp_settings["std"].replace("c++", "")})
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Build type
+set(CMAKE_BUILD_TYPE {build_type})
+
+# Preprocessor definitions
+"""
+                
+                # Add definitions
+                for definition in st.session_state.cpp_settings.get("definitions", []):
+                    if "=" in definition:
+                        name, value = definition.split("=", 1)
+                        cmake_content += f'add_definitions(-D{name}="{value}")\n'
+                    else:
+                        cmake_content += f"add_definitions(-D{definition})\n"
+                
+                # Add include paths
+                if st.session_state.cpp_settings.get("include_paths", []):
+                    cmake_content += "\n# Include directories\n"
+                    for path in st.session_state.cpp_settings["include_paths"]:
+                        cmake_content += f"include_directories({path})\n"
+                
+                # Add library paths
+                if st.session_state.cpp_settings.get("library_paths", []):
+                    cmake_content += "\n# Library directories\n"
+                    for path in st.session_state.cpp_settings["library_paths"]:
+                        cmake_content += f"link_directories({path})\n"
+                
+                # Add common libraries
+                if "Eigen" in st.session_state.cpp_settings.get("libraries", []):
+                    cmake_content += "\n# Eigen\n"
+                    cmake_content += "find_package(Eigen3 REQUIRED)\n"
+                    cmake_content += "include_directories(${EIGEN3_INCLUDE_DIR})\n"
+                
+                if "OpenCV" in st.session_state.cpp_settings.get("libraries", []):
+                    cmake_content += "\n# OpenCV\n"
+                    cmake_content += "find_package(OpenCV REQUIRED)\n"
+                    cmake_content += "include_directories(${OpenCV_INCLUDE_DIRS})\n"
+                
+                if "Boost" in st.session_state.cpp_settings.get("libraries", []):
+                    cmake_content += "\n# Boost\n"
+                    cmake_content += "find_package(Boost REQUIRED)\n"
+                    cmake_content += "include_directories(${Boost_INCLUDE_DIRS})\n"
+                
+                # Add source files
+                cmake_content += "\n# Source files\n"
+                source_files = [f for f in st.session_state.cpp_project_files.keys() if f.endswith((".cpp", ".c", ".cc"))]
+                cmake_content += "add_executable(main\n"
+                for src in source_files:
+                    cmake_content += f"    {src}\n"
+                cmake_content += ")\n"
+                
+                # Add libraries to link
+                cmake_content += "\n# Link libraries\n"
+                cmake_content += "target_link_libraries(main\n"
+                
+                if "OpenCV" in st.session_state.cpp_settings.get("libraries", []):
+                    cmake_content += "    ${OpenCV_LIBS}\n"
+                
+                if "Boost" in st.session_state.cpp_settings.get("libraries", []):
+                    cmake_content += "    ${Boost_LIBRARIES}\n"
+                
+                # Additional libraries
+                for lib in st.session_state.cpp_settings.get("additional_libs", []):
+                    cmake_content += f"    {lib}\n"
+                
+                cmake_content += ")\n"
+                
+                # Save CMakeLists.txt to project files
+                st.session_state.cpp_project_files["CMakeLists.txt"] = cmake_content
+                
+                # Show the generated file
+                st.success("CMakeLists.txt generated!")
+                st.code(cmake_content, language="cmake")
+                
+        with cpp_tabs[4]:  # Debugger tab
+            st.markdown("### C++ Debugger")
+            st.markdown("Debug your C++ code with breakpoints and variable inspection")
+            
+            # Enable debugging
+            enable_cpp_debug = st.checkbox("Enable Debugging", value=False, key="cpp_debug_enable")
+            
+            if enable_cpp_debug:
+                # Breakpoints
+                st.markdown("#### Breakpoints")
+                st.markdown("Enter line numbers for breakpoints (one per line)")
+                
+                breakpoints = st.text_area(
+                    "Breakpoints",
+                    placeholder="Example:\n10\n15\n20",
+                    height=100,
+                    key="cpp_breakpoints"
+                )
+                
+                breakpoint_lines = []
+                for line in breakpoints.split("\n"):
+                    try:
+                        line_num = int(line.strip())
+                        if line_num > 0:
+                            breakpoint_lines.append(line_num)
+                    except:
+                        pass
+                
+                # Watch variables
+                st.markdown("#### Watch Variables")
+                st.markdown("Enter variable names to watch (one per line)")
+                
+                watch_vars = st.text_area(
+                    "Watch Variables",
+                    placeholder="Example:\ni\nsum\nresult",
+                    height=100,
+                    key="cpp_watch_vars"
+                )
+                
+                watch_variables = [var.strip() for var in watch_vars.split("\n") if var.strip()]
+        
+        # Compilation and execution options
+        st.markdown("### Run Configuration")
+        
+        run_options_col1, run_options_col2 = st.columns(2)
+        
+        with run_options_col1:
+            cpp_timeout = st.slider("Execution Timeout (seconds)", 1, 60, 10)
+        
+        with run_options_col2:
+            compile_btn = st.button("🛠️ Compile and Run", use_container_width=True)
+        
+        # Compile and run the C++ code
+        if compile_btn:
+            with st.spinner("Compiling C++ code..."):
+                cpp_code_to_compile = st.session_state.cpp_code
+                if "cpp_project_files" in st.session_state and st.session_state.cpp_project_files:
+                    # Use project files
+                    executable_path, compile_error, temp_dir = compile_cpp_code_enhanced(
+                        cpp_code_to_compile, 
+                        st.session_state.cpp_settings,
+                        project_files=st.session_state.cpp_project_files,
+                        enable_debug=enable_cpp_debug if "enable_cpp_debug" in locals() else False,
+                        breakpoints=breakpoint_lines if "breakpoint_lines" in locals() else None,
+                        watch_vars=watch_variables if "watch_variables" in locals() else None
+                    )
+                else:
+                    # Use single file
+                    executable_path, compile_error, temp_dir = compile_cpp_code_enhanced(
+                        cpp_code_to_compile, 
+                        st.session_state.cpp_settings,
+                        enable_debug=enable_cpp_debug if "enable_cpp_debug" in locals() else False,
+                        breakpoints=breakpoint_lines if "breakpoint_lines" in locals() else None,
+                        watch_vars=watch_variables if "watch_variables" in locals() else None
+                    )
+                
+                if compile_error:
+                    st.error("Compilation Error:")
+                    st.code(compile_error, language="bash")
+                else:
+                    st.success("Compilation successful!")
+                    
+                    with st.spinner("Running program..."):
+                        result = run_cpp_executable_enhanced(
+                            executable_path,
+                            temp_dir,
+                            inputs=cpp_inputs if "cpp_inputs" in locals() else None,
+                            timeout=cpp_timeout,
+                            enable_debug=enable_cpp_debug if "enable_cpp_debug" in locals() else False,
+                            breakpoints=breakpoint_lines if "breakpoint_lines" in locals() else None,
+                            watch_vars=watch_variables if "watch_variables" in locals() else None
+                        )
+                        
+                        st.session_state.cpp_result = result
+        
+        # Display results
+        if "cpp_result" in st.session_state and st.session_state.cpp_result:
+            result = st.session_state.cpp_result
+            
+            st.markdown("### Results")
+            
+            # Execution information
+            info_cols = st.columns(3)
+            with info_cols[0]:
+                st.info(f"Execution Time: {result['execution_time']:.3f} seconds")
+            
+            with info_cols[1]:
+                if result.get("memory_usage"):
+                    st.info(f"Memory Usage: {result['memory_usage']:.2f} MB")
+            
+            with info_cols[2]:
+                if result["exception"]:
+                    st.error(f"Exception: {result['exception']}")
+            
+            # Show debug output if available
+            if result.get("debug_output"):
+                with st.expander("Debug Output", expanded=True):
+                    st.code(result["debug_output"], language="bash")
+            
+            # Result tabs
+            result_tabs = st.tabs(["Output", "Images", "Manim Integration"])
+            
+            with result_tabs[0]:  # Output tab
+                # Show stdout if any
+                if result["stdout"]:
+                    st.markdown("#### Standard Output")
+                    st.code(result["stdout"], language="bash")
+                
+                # Show stderr if any
+                if result["stderr"]:
+                    st.markdown("#### Standard Error")
+                    st.code(result["stderr"], language="bash")
+            
+            with result_tabs[1]:  # Images tab
+                # Show images if any
+                if result["images"]:
+                    st.markdown("#### Generated Images")
+                    img_cols = st.columns(min(3, len(result["images"])))
+                    
+                    for i, img in enumerate(result["images"]):
+                        with img_cols[i % len(img_cols)]:
+                            st.image(img["data"], caption=img["name"])
+                else:
+                    st.info("No images were generated by the program.")
+            
+            with result_tabs[2]:  # Manim Integration tab
+                st.markdown("#### Integrate C++ Results with Manim")
+                
+                # Create options for integration
+                integration_type = st.radio(
+                    "Integration Type",
+                    options=["Data Visualization", "Image Import", "Animation Sequence"],
+                    key="cpp_integration_type"
+                )
+                
+                if integration_type == "Data Visualization":
+                    # Extract numerical data from stdout if possible
+                    lines = result["stdout"].strip().split("\n")
+                    data_options = []
+                    
+                    for i, line in enumerate(lines):
+                        # Check if line contains numbers
+                        numbers = []
+                        try:
+                            # Try to extract numbers from the line
+                            numbers = [float(x) for x in line.split() if x.replace(".", "").isdigit()]
+                            if numbers:
+                                data_options.append(f"Line {i+1}: {line[:30]}{'...' if len(line) > 30 else ''}")
+                        except:
+                            pass
+                    
+                    if data_options:
+                        selected_data_line = st.selectbox(
+                            "Select Data to Visualize",
+                            options=["Select a line..."] + data_options,
+                            key="cpp_data_line"
+                        )
+                        
+                        if selected_data_line != "Select a line...":
+                            line_idx = int(selected_data_line.split(":")[0].replace("Line ", "")) - 1
+                            line = lines[line_idx]
+                            
+                            # Extract numbers
+                            try:
+                                numbers = [float(x) for x in line.split() if x.replace(".", "").isdigit()]
+                                
+                                # Preview the data
+                                st.markdown(f"**Extracted Data:** {numbers}")
+                                
+                                # Create visualization code
+                                if st.button("Create Manim Visualization", key="cpp_create_viz"):
+                                    viz_code = f"""
+# Visualize data from C++ output
+values = {numbers}
+axes = Axes(
+    x_range=[0, {len(numbers)}, 1],
+    y_range=[{min(numbers) if numbers else 0}, {max(numbers) if numbers else 10}, {(max(numbers)-min(numbers))/10 if numbers and max(numbers) > min(numbers) else 1}],
+    axis_config={{"color": BLUE}}
+)
+points = [axes.coords_to_point(i, v) for i, v in enumerate(values)]
+dots = VGroup(*[Dot(point, color=RED) for point in points])
+graph = VMobject(color=YELLOW)
+graph.set_points_as_corners(points)
+
+self.play(Create(axes))
+self.play(Create(dots), run_time=2)
+self.play(Create(graph), run_time=2)
+self.wait(1)
+"""
+                                    if st.session_state.code:
+                                        st.session_state.code += "\n" + viz_code
+                                    else:
+                                        st.session_state.code = f"""from manim import *
+class CppDataVisualizationScene(Scene):
+    def construct(self):
+        {viz_code}
+"""
+                                    st.session_state.temp_code = st.session_state.code
+                                    st.success("Added C++ data visualization to your Manim code!")
+                                    # Set pending tab switch to editor tab
+                                    st.session_state.pending_tab_switch = 0
+                                    st.rerun()
+                            except Exception as e:
+                                st.error(f"Error extracting numbers: {str(e)}")
+                    else:
+                        st.warning("No numeric data detected in the output.")
+                
+                elif integration_type == "Image Import":
+                    # Handle image import
+                    if result["images"]:
+                        st.markdown("#### Select Images to Import")
+                        
+                        for i, img in enumerate(result["images"]):
+                            st.markdown(f"**{img['name']}**")
+                            st.image(img["data"], width=300)
+                            
+                            if st.button(f"Use in Manim", key=f"use_cpp_img_{i}"):
+                                # Save image to a temporary file
+                                with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{img['name']}") as tmp:
+                                    tmp.write(img["data"])
+                                    img_path = tmp.name
+                                
+                                # Generate Manim code
+                                image_code = f"""
+# Load and display image generated from C++
+cpp_image = ImageMobject(r"{img_path}")
+cpp_image.scale(2)  # Adjust size as needed
+self.play(FadeIn(cpp_image))
+self.wait(1)
+"""
+                                if st.session_state.code:
+                                    st.session_state.code += "\n" + image_code
+                                else:
+                                    st.session_state.code = f"""from manim import *
+class CppImageScene(Scene):
+    def construct(self):
+        {image_code}
+"""
+                                st.session_state.temp_code = st.session_state.code
+                                st.success(f"Added C++ generated image to your Manim code!")
+                                st.session_state.pending_tab_switch = 0  # Switch to editor tab
+                                st.rerun()
+                    else:
+                        st.warning("No images were generated by the C++ program.")
+                
+                elif integration_type == "Animation Sequence":
+                    st.markdown("#### Create Animation Sequence")
+                    st.info("This will create a Manim animation that visualizes the execution of your C++ program.")
+                    
+                    # Animation type options
+                    animation_style = st.selectbox(
+                        "Animation Style",
+                        options=["Algorithm Visualization", "Data Flow", "Memory Model"],
+                        key="cpp_anim_style"
+                    )
+                    
+                    if st.button("Generate Animation Sequence", key="cpp_gen_anim_seq"):
+                        # Create different animations based on selected style
+                        if animation_style == "Algorithm Visualization":
+                            # Example code for algorithm visualization
+                            algo_code = f"""
+# C++ Algorithm Visualization
+title = Text("C++ Algorithm Visualization")
+self.play(Write(title))
+self.play(title.animate.to_edge(UP))
+self.wait(0.5)
+
+# Create an array representation
+values = [5, 2, 8, 1, 9, 3, 7, 4, 6]  # Example values
+squares = VGroup(*[Square(side_length=0.7, fill_opacity=0.8, fill_color=BLUE) for _ in values])
+squares.arrange(RIGHT, buff=0.1)
+labels = VGroup(*[Text(str(v), font_size=24) for v in values])
+for label, square in zip(labels, squares):
+    label.move_to(square.get_center())
+
+array = VGroup(squares, labels)
+array_label = Text("Array", font_size=20).next_to(array, UP)
+self.play(FadeIn(array), Write(array_label))
+self.wait(1)
+
+# Simulate sorting algorithm
+for i in range(len(values)-1):
+    # Highlight current element
+    self.play(squares[i].animate.set_fill(RED))
+    
+    for j in range(i+1, len(values)):
+        # Highlight comparison element
+        self.play(squares[j].animate.set_fill(YELLOW))
+        
+        # Simulate comparison
+        if values[i] > values[j]:
+            # Swap animation
+            self.play(
+                labels[i].animate.move_to(squares[j].get_center()),
+                labels[j].animate.move_to(squares[i].get_center())
+            )
+            
+            # Update values and labels
+            labels[i], labels[j] = labels[j], labels[i]
+            values[i], values[j] = values[j], values[i]
+        
+        # Reset comparison element
+        self.play(squares[j].animate.set_fill(BLUE))
+    
+    # Mark current element as processed
+    self.play(squares[i].animate.set_fill(GREEN))
+
+# Mark the last element as processed
+self.play(squares[-1].animate.set_fill(GREEN))
+
+# Show sorted array
+sorted_label = Text("Sorted Array", font_size=20).next_to(array, DOWN)
+self.play(Write(sorted_label))
+self.wait(2)
+"""
+                            if st.session_state.code:
+                                st.session_state.code += "\n" + algo_code
+                            else:
+                                st.session_state.code = f"""from manim import *
+class CppAlgorithmScene(Scene):
+    def construct(self):
+        {algo_code}
+"""
+                            st.session_state.temp_code = st.session_state.code
+                            st.success("Added C++ algorithm visualization to your Manim code!")
+                            st.session_state.pending_tab_switch = 0  # Switch to editor tab
+                            st.rerun()
+                        
+                        elif animation_style == "Data Flow":
+                            # Example code for data flow visualization
+                            data_flow_code = f"""
+# C++ Data Flow Visualization
+title = Text("C++ Data Flow")
+self.play(Write(title))
+self.play(title.animate.to_edge(UP))
+self.wait(0.5)
+
+# Create nodes for data flow
+input_node = Circle(radius=0.5, fill_opacity=0.8, fill_color=BLUE)
+process_node = Square(side_length=1, fill_opacity=0.8, fill_color=GREEN)
+output_node = Circle(radius=0.5, fill_opacity=0.8, fill_color=RED)
+
+# Position nodes
+input_node.move_to(LEFT*4)
+process_node.move_to(ORIGIN)
+output_node.move_to(RIGHT*4)
+
+# Add labels
+input_label = Text("Input", font_size=20).next_to(input_node, DOWN)
+process_label = Text("Process", font_size=20).next_to(process_node, DOWN)
+output_label = Text("Output", font_size=20).next_to(output_node, DOWN)
+
+# Create arrows
+arrow1 = Arrow(input_node.get_right(), process_node.get_left(), buff=0.2)
+arrow2 = Arrow(process_node.get_right(), output_node.get_left(), buff=0.2)
+
+# Display nodes and arrows
+self.play(FadeIn(input_node), Write(input_label))
+self.wait(0.5)
+self.play(FadeIn(process_node), Write(process_label))
+self.wait(0.5)
+self.play(FadeIn(output_node), Write(output_label))
+self.wait(0.5)
+self.play(Create(arrow1), Create(arrow2))
+self.wait(1)
+
+# Simulate data flow
+data = Text("Data", font_size=16).move_to(input_node.get_center())
+self.play(FadeIn(data))
+self.wait(0.5)
+
+# Move data along the flow
+self.play(data.animate.move_to(arrow1.get_center()))
+self.wait(0.5)
+self.play(data.animate.move_to(process_node.get_center()))
+self.wait(0.5)
+transformed_data = Text("Processed", font_size=16, color=YELLOW)
+transformed_data.move_to(process_node.get_center())
+self.play(Transform(data, transformed_data))
+self.wait(0.5)
+self.play(data.animate.move_to(arrow2.get_center()))
+self.wait(0.5)
+self.play(data.animate.move_to(output_node.get_center()))
+self.wait(1)
+
+result_text = Text("Final Result", font_size=24).to_edge(DOWN)
+self.play(Write(result_text))
+self.wait(2)
+"""
+                            if st.session_state.code:
+                                st.session_state.code += "\n" + data_flow_code
+                            else:
+                                st.session_state.code = f"""from manim import *
+class CppDataFlowScene(Scene):
+    def construct(self):
+        {data_flow_code}
+"""
+                            st.session_state.temp_code = st.session_state.code
+                            st.success("Added C++ data flow visualization to your Manim code!")
+                            st.session_state.pending_tab_switch = 0  # Switch to editor tab
+                            st.rerun()
+                        
+                        elif animation_style == "Memory Model":
+                            # Example code for memory model visualization
+                            memory_code = f"""
+# C++ Memory Model Visualization
+title = Text("C++ Memory Model")
+self.play(Write(title))
+self.play(title.animate.to_edge(UP))
+self.wait(0.5)
+
+# Create memory blocks
+stack_rect = Rectangle(height=3, width=4, fill_opacity=0.2, fill_color=BLUE)
+stack_rect.move_to(LEFT*3.5)
+stack_label = Text("Stack", font_size=20).next_to(stack_rect, UP)
+
+heap_rect = Rectangle(height=3, width=4, fill_opacity=0.2, fill_color=RED)
+heap_rect.move_to(RIGHT*3.5)
+heap_label = Text("Heap", font_size=20).next_to(heap_rect, UP)
+
+# Display memory areas
+self.play(
+    Create(stack_rect), Write(stack_label),
+    Create(heap_rect), Write(heap_label)
+)
+self.wait(1)
+
+# Create variables on the stack
+int_var = Rectangle(height=0.5, width=1.5, fill_opacity=0.8, fill_color=BLUE_C)
+int_var.move_to(stack_rect.get_center() + UP*1)
+int_label = Text("int x = 5", font_size=16).next_to(int_var, RIGHT)
+
+pointer_var = Rectangle(height=0.5, width=1.5, fill_opacity=0.8, fill_color=BLUE_D)
+pointer_var.move_to(stack_rect.get_center())
+pointer_label = Text("int* ptr", font_size=16).next_to(pointer_var, RIGHT)
+
+# Display stack variables
+self.play(FadeIn(int_var), Write(int_label))
+self.wait(0.5)
+self.play(FadeIn(pointer_var), Write(pointer_label))
+self.wait(1)
+
+# Create heap allocation
+heap_alloc = Rectangle(height=0.8, width=2, fill_opacity=0.8, fill_color=RED_C)
+heap_alloc.move_to(heap_rect.get_center() + UP*0.5)
+heap_label = Text("new int[4]", font_size=16).next_to(heap_alloc, LEFT)
+
+# Display heap allocation
+self.play(FadeIn(heap_alloc), Write(heap_label))
+self.wait(1)
+
+# Create arrow from pointer to heap
+arrow = Arrow(pointer_var.get_right(), heap_alloc.get_left(), buff=0.2, color=YELLOW)
+self.play(Create(arrow))
+self.wait(0.5)
+
+# Simulate pointer assignment
+assign_text = Text("ptr = new int[4]", font_size=24).to_edge(DOWN)
+self.play(Write(assign_text))
+self.wait(1)
+
+# Simulate memory deallocation
+delete_text = Text("delete[] ptr", font_size=24).to_edge(DOWN)
+self.play(Transform(assign_text, delete_text))
+self.play(FadeOut(arrow), FadeOut(heap_alloc), FadeOut(heap_label))
+self.wait(1)
+
+# Simulate end of scope
+end_scope = Text("End of scope", font_size=24).to_edge(DOWN)
+self.play(Transform(assign_text, end_scope))
+self.play(FadeOut(int_var), FadeOut(int_label), FadeOut(pointer_var), FadeOut(pointer_label))
+self.wait(2)
+"""
+                            if st.session_state.code:
+                                st.session_state.code += "\n" + memory_code
+                            else:
+                                st.session_state.code = f"""from manim import *
+class CppMemoryModelScene(Scene):
+    def construct(self):
+        {memory_code}
+"""
+                            st.session_state.temp_code = st.session_state.code
+                            st.success("Added C++ memory model visualization to your Manim code!")
+                            st.session_state.pending_tab_switch = 0  # Switch to editor tab
+                            st.rerun()
+                                
+        # C++ Information and tips
+        with st.expander("C/C++ Runner Information"):
+            st.markdown("""
+            ### C/C++ Runner Tips
+            
+            **Compilation Options:**
+            - Choose the appropriate compiler based on your platform
+            - Select the C++ standard version for your code
+            - Optimization levels affect performance and debugging
+            
+            **Library Support:**
+            - Common libraries like Eigen, OpenCV, and Boost are supported
+            - Add custom include paths and library paths as needed
+            - Use the library detection feature to find installed libraries
+            
+            **Input/Output:**
+            - Standard input/output (cin/cout) is fully supported
+            - File I/O works within the execution directory
+            - For interactive programs, provide input values in advance
+            
+            **Debugging:**
+            - Set breakpoints at specific line numbers
+            - Watch variables to track their values
+            - Debug with GDB for detailed analysis
+            
+            **Project Management:**
+            - Create multi-file projects with headers and source files
+            - Generate CMakeLists.txt for complex projects
+            - Download project files as a ZIP archive
+            
+            **Images and Visualization:**
+            - Generate images in PPM, PNG, JPG formats
+            - Use OpenCV for more advanced image processing
+            - All generated images can be used in Manim animations
+            
+            **Manim Integration:**
+            - Create algorithm visualizations from C++ code
+            - Import C++ generated images into Manim scenes
+            - Visualize data structures and memory models
+            
+            **Performance:**
+            - Use release mode for best performance
+            - Profile your code to identify bottlenecks
+            - C++ is ideal for computationally intensive tasks
+            """)
+
     # Help section
     with st.sidebar.expander("ℹ️ Help & Info"):
         st.markdown("""