Update app.py

app.py

@@ -284,22 +284,6 @@ Add this to your requirements.txt and redeploy the space."""
         if progress_callback:
             progress_callback(0.05, "Checking environment...")
         
-        # Check for Windows cross-compilation requirements
-        if output_extension == ".exe":
-            missing_mingw, available_mingw = check_mingw_installation()
-            if log_queue:
-                if available_mingw:
-                    log_queue.put(f"✅ Available MinGW-w64 compilers:\n")
-                    for compiler, arch in available_mingw:
-                        log_queue.put(f"  - {compiler} ({arch})\n")
-                else:
-                    log_queue.put("⚠️ No MinGW-w64 compilers found!\n")
-                
-                if missing_mingw:
-                    log_queue.put(f"⚠️ Missing MinGW-w64 components:\n")
-                    for compiler, arch in missing_mingw:
-                        log_queue.put(f"  - {compiler} ({arch})\n")
-        
         # Check if static libpython is available
         has_static_libpython = check_static_libpython()
         
@@ -466,88 +450,13 @@ except ImportError:
         # Prepare environment for cross-compilation
         env = os.environ.copy()
         
-        # Add Windows-specific options using MinGW-w64
-        if output_extension == ".exe":
-            # Check which MinGW-w64 compiler is available
-            x64_gcc = subprocess.run(["which", "x86_64-w64-mingw32-gcc"], capture_output=True)
-            i686_gcc = subprocess.run(["which", "i686-w64-mingw32-gcc"], capture_output=True)
-            
-            # Use the comprehensive approach to force 64-bit compilation
-            cmd.extend([
-                "--mingw64",  # Use MinGW-w64 for cross-compilation
-                "--windows-disable-console",  # Disable console window for GUI apps
-            ])
-            
-            # Create wrapper scripts with improved version handling
-            wrapper_dir = os.path.join(output_dir, "mingw_wrappers")
-            if log_queue:
-                log_queue.put("Creating improved version wrapper scripts...\n")
-            create_improved_version_wrappers(wrapper_dir, log_queue)
-            
-            # Prepend wrapper directory to PATH (this is crucial!)
-            env["PATH"] = wrapper_dir + ":" + env["PATH"]
-            
-            # Explicitly set the compiler environment variables
-            if x64_gcc.returncode == 0:
-                # Force 64-bit cross-compiler with proper paths to our wrappers
-                env["CC"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-gcc")
-                env["CXX"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-g++")
-                env["AR"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-ar")
-                env["NM"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-nm")
-                env["STRIP"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-strip")
-                env["RANLIB"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-ranlib")
-                env["OBJCOPY"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-objcopy")
-                env["OBJDUMP"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-objdump")
-                env["READELF"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-readelf")
-                env["SIZE"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-size")
-                env["STRINGS"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-strings")
-                
-                # Set additional environment variables for cross-compilation
-                env["CROSS_COMPILE"] = "x86_64-w64-mingw32-"
-                env["TARGET"] = "x86_64-w64-mingw32"
-                env["TARGET_ARCH"] = "x86_64"
-                env["CFLAGS"] = "-m64"
-                env["CXXFLAGS"] = "-m64"
-                env["LDFLAGS"] = "-m64"
-                
-                if log_queue:
-                    log_queue.put("=== Forcing 64-bit Windows Compilation with Improved Wrappers ===\n")
-                    log_queue.put("Environment variables set:\n")
-                    log_queue.put(f"  PATH={env['PATH'][:100]}...\n")
-                    log_queue.put(f"  CC={env['CC']}\n")
-                    log_queue.put(f"  CXX={env['CXX']}\n")
-                    log_queue.put(f"  CROSS_COMPILE={env['CROSS_COMPILE']}\n")
-                    log_queue.put(f"  TARGET={env['TARGET']}\n")
-                    log_queue.put(f"  TARGET_ARCH={env['TARGET_ARCH']}\n")
-                    log_queue.put(f"  CFLAGS={env['CFLAGS']}\n")
-                    log_queue.put("Wrapper scripts created with robust version handling\n")
-                    
-            elif i686_gcc.returncode == 0:
-                # Fall back to 32-bit if 64-bit not available
-                env["CC"] = os.path.join(wrapper_dir, "i686-w64-mingw32-gcc")
-                env["CXX"] = os.path.join(wrapper_dir, "i686-w64-mingw32-g++")
-                env["CROSS_COMPILE"] = "i686-w64-mingw32-"
-                env["TARGET"] = "i686-w64-mingw32"
-                env["TARGET_ARCH"] = "i686"
-                env["CFLAGS"] = "-m32"
-                env["CXXFLAGS"] = "-m32"
-                env["LDFLAGS"] = "-m32"
-                
-                if log_queue:
-                    log_queue.put("Using 32-bit Windows cross-compilation (fallback)\n")
-                    log_queue.put(f"Set CC={env['CC']}, CXX={env['CXX']}\n")
-                    log_queue.put("Created wrapper scripts for 32-bit compilation\n")
-            else:
-                if log_queue:
-                    log_queue.put("No specific MinGW-w64 compiler found, using --mingw64 flag only\n")
-        
         # Run compilation
         if progress_callback:
             progress_callback(0.4, "Executing Nuitka compilation...")
         
         if log_queue:
             log_queue.put(f"Final compilation command: {' '.join(cmd)}\n")
-            log_queue.put("Starting compilation with improved environment...\n")
+            log_queue.put("Starting compilation...\n")
         
         process = subprocess.Popen(
             cmd,
@@ -631,118 +540,54 @@ except ImportError:
                     log_queue.put(f"Binary info: {binary_info}\n")
                     
                 # Extract architecture information from file output
-                if "PE32+" in binary_info or "x86-64" in binary_info:
-                    arch_info = "64-bit"
-                elif "PE32" in binary_info and "PE32+" not in binary_info:
-                    arch_info = "32-bit"
+                if "ELF" in binary_info:
+                    if "64-bit" in binary_info:
+                        arch_info = "Linux 64-bit"
+                    elif "32-bit" in binary_info:
+                        arch_info = "Linux 32-bit"
+                    else:
+                        arch_info = "Linux"
                 else:
                     arch_info = "unknown"
                     
                 log_queue.put(f"Detected architecture: {arch_info}\n")
-                
-                # Verify the compilation was successful for 64-bit
-                if output_extension == ".exe" and arch_info != "64-bit":
-                    log_queue.put("⚠️ WARNING: Expected 64-bit but got different architecture\n")
-                    log_queue.put("Environment variables that were set:\n")
-                    log_queue.put(f"  CC={env.get('CC', 'not set')}\n")
-                    log_queue.put(f"  CROSS_COMPILE={env.get('CROSS_COMPILE', 'not set')}\n")
-                    log_queue.put(f"  TARGET_ARCH={env.get('TARGET_ARCH', 'not set')}\n")
-                elif output_extension == ".exe" and arch_info == "64-bit":
-                    log_queue.put("✅ SUCCESS: Confirmed 64-bit Windows executable\n")
-                    log_queue.put("✅ Version parsing issue resolved with improved wrappers!\n")
                     
             except:
                 binary_info = "Binary file (unable to get detailed info)"
                 arch_info = "unknown"
             
-            # Check linking type (only for non-Windows binaries on Linux)
-            if output_extension != ".exe":
-                try:
-                    ldd_process = subprocess.run(["ldd", binary_path], capture_output=True, text=True)
-                    if "not a dynamic executable" in ldd_process.stderr or "statically linked" in ldd_process.stdout:
-                        linking_info = "✅ Statically linked - fully portable!"
+            # Check linking type
+            try:
+                ldd_process = subprocess.run(["ldd", binary_path], capture_output=True, text=True)
+                if "not a dynamic executable" in ldd_process.stderr or "statically linked" in ldd_process.stdout:
+                    linking_info = "✅ Statically linked - fully portable!"
+                else:
+                    # Check what dynamic libraries are required
+                    if ldd_process.returncode == 0:
+                        libs = ldd_process.stdout.count("=>")
+                        linking_info = f"🔗 Dynamically linked ({libs} libraries) - designed for maximum compatibility"
                     else:
-                        # Check what dynamic libraries are required
-                        if ldd_process.returncode == 0:
-                            libs = ldd_process.stdout.count("=>")
-                            linking_info = f"🔗 Dynamically linked ({libs} libraries) - designed for maximum compatibility"
-                        else:
-                            linking_info = "ℹ️ Compiled binary - should work on compatible systems"
-                except:
-                    linking_info = "ℹ️ Compiled binary created successfully"
-            else:
-                # For Windows, show architecture information
-                linking_info = f"📦 Windows {arch_info} executable"
-                if env.get("CC"):
-                    linking_info += f" (cross-compiled with improved wrappers)"
-                    
-                if log_queue:
-                    log_queue.put(f"Final binary architecture: {linking_info}\n")
+                        linking_info = "ℹ️ Compiled binary - should work on compatible systems"
+            except:
+                linking_info = "ℹ️ Compiled binary created successfully"
             
             # Rename to desired extension
-            if output_extension in ['.bin', '.sh', '.exe'] and not binary_path.endswith(output_extension):
+            if output_extension in ['.bin', '.sh'] and not binary_path.endswith(output_extension):
                 new_binary_path = binary_path + output_extension
                 shutil.move(binary_path, new_binary_path)
                 binary_path = new_binary_path
             
-            # Make executable (for non-Windows)
-            if output_extension != ".exe":
-                os.chmod(binary_path, 0o755)
+            # Make executable
+            os.chmod(binary_path, 0o755)
             
             # Build the result summary string
             static_status = "Yes" if has_static_libpython else "No"
             file_size = os.path.getsize(binary_path) / 1024
             binary_basename = os.path.basename(binary_path)
             
-            # Determine architecture info
-            if output_extension == ".exe":
-                if env.get("TARGET_ARCH"):
-                    arch_used = f"{env['TARGET_ARCH']} via improved wrapper scripts"
-                else:
-                    arch_used = f"Windows {arch_info}"
-            else:
-                arch_used = "Native Linux"
-            
-            # Fix f-string issue by using separate variables
-            if output_extension == '.exe':
-                cross_compilation_details = f'''- Cross-compiler: {env.get('CC', 'default').split('/')[-1] if env.get('CC') else 'default'}
-- Target architecture: {env.get('TARGET_ARCH', 'default')}
-- Cross-compile prefix: {env.get('CROSS_COMPILE', 'none')}
-- Compiler flags: {env.get('CFLAGS', 'none')}
-- Verified architecture: {arch_info}
-- Wrapper scripts: Improved version parsing
-- Version handling: Fixed "12-win32" issue
-- Environment variables: {len([k for k in env.keys() if k.startswith(('CC', 'CXX', 'TARGET', 'CROSS'))])} variables'''
-                
-                cross_compilation_notes = f'''- Successfully cross-compiled for Windows {arch_info}
-- Fixed version parsing with improved wrapper scripts
-- Resolved "12-win32" to "12.0.0" issue
-- All MinGW-w64 tools properly wrapped
-- Version detection now robust and reliable
-- Binary verified with file command
-- Should run on Windows {arch_info} systems'''
-                
-                technical_details = f'''- VERSION FIX: Wrapper scripts now parse "12-win32" correctly
-- Robust regex parsing for version strings  
-- Fallback to "12.0.0" for problematic versions
-- PATH manipulation ensures wrappers are used
-- Environment variables use wrapper script paths
-- Binary architecture verified: {arch_info}
-- Network error handling enhanced for better diagnostics'''
-            else:
-                cross_compilation_details = "- Native Linux compilation"
-                cross_compilation_notes = "Native Linux compilation with maximum compatibility"
-                technical_details = """- Native compilation optimized for compatibility
-- Network error handling added for better runtime diagnostics"""
-            
             # Create result summary
             result_summary = f"""# ✅ Compilation Successful! 
 
-## 🛠️ VERSION PARSING FIXED!
-- **Issue resolved**: "12-win32" → "12.0.0" conversion
-- **Solution**: Improved wrapper scripts with regex parsing  
-- **Result**: Clean compilation without version errors
-
 ## Compilation Details:
 - **Mode**: {mode_name}
 - **Nuitka Version**: {nuitka_version}
@@ -752,8 +597,8 @@ except ImportError:
 - **Compiled with Python**: {current_python}
 - **Static Libpython Available**: {static_status}
 - **Linking**: {linking_info}
-- **Target Platform**: {'Windows (via MinGW-w64)' if output_extension == '.exe' else 'Linux'}
-- **Architecture**: {arch_used}
+- **Target Platform**: Linux
+- **Architecture**: {arch_info}
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -762,19 +607,12 @@ except ImportError:
 ## Binary Information:
 {binary_info}
 
-## 🚀 Cross-Compilation Details:
-{cross_compilation_details}
-
 ## 📋 Usage Instructions:
 ```bash
-{f'# For Windows ({arch_info}):' if output_extension == '.exe' else f'chmod +x {binary_basename}'}
-{f'# Download to Windows machine and run:' if output_extension == '.exe' else ''}
-{f'{binary_basename}' if output_extension == '.exe' else f'./{binary_basename}'}
+chmod +x {binary_basename}
+./{binary_basename}
 ```
 
-## ⚠️ Cross-Compilation Notes:
-{cross_compilation_notes}
-
 ## 🌐 Network Dependencies:
 - Binary includes enhanced error handling for network issues
 - Will provide helpful messages if DNS resolution fails
@@ -782,39 +620,22 @@ except ImportError:
 - Consider pre-downloading models/data for offline usage
 
 ## 🧪 Testing:
-{f'You can test the Windows executable on Linux using wine:' if output_extension == '.exe' else 'Run directly on compatible Linux systems:'}
+Run directly on compatible Linux systems:
 ```bash
-{f'wine {binary_basename}' if output_extension == '.exe' else f'./{binary_basename}'}
+./{binary_basename}
 ```
 
 ## 🔧 Technical Details:
-{technical_details}
-
-## ✅ Version Parsing Solution:
-```bash
-# The wrapper script now handles:
-# Input:  "gcc (GCC) 12-win32"
-# Output: "12.0.0"
-# 
-# Regex patterns used:
-# - ([0-9]+)\.([0-9]+)\.?([0-9]*) for x.y.z versions
-# - ([0-9]+)[^0-9] for single major versions
-# - Fallback: "12.0.0" for unparseable versions
-```"""
+- Native compilation optimized for compatibility
+- Network error handling added for better runtime diagnostics
+- Enhanced error messages for common issues"""
             
             if progress_callback:
-                progress_callback(1.0, f"Compilation successful! Version parsing fixed! Created {arch_info} executable 🎉")
+                progress_callback(1.0, f"Compilation successful! Created {arch_info} executable 🎉")
             
             if log_queue:
                 log_queue.put("✅ Compilation completed successfully!\n")
-                log_queue.put("🔧 VERSION PARSING ISSUE FIXED!\n")
-                if output_extension == ".exe":
-                    log_queue.put(f"🍷 You can test the Windows {arch_info} executable with: wine " + binary_basename + "\n")
-                    log_queue.put(f"✅ Verified {arch_info} Windows executable created\n")
-                    if arch_info == "64-bit":
-                        log_queue.put("🎯 SUCCESS: Achieved 64-bit Windows compilation with fixed version parsing!\n")
-                    else:
-                        log_queue.put(f"⚠️ Note: Created {arch_info} executable instead of 64-bit\n")
+                log_queue.put("🔧 Enhanced with network error handling!\n")
                 
             return result_summary, binary_path, compile_output, True
         else:
@@ -824,7 +645,7 @@ except ImportError:
 ## Error Details:
 - **Exit Code**: {process.returncode}
 - **Mode Attempted**: {mode_name}
-- **Target**: {'Windows (via MinGW-w64)' if output_extension == '.exe' else 'Linux'}
+- **Target**: Linux
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -835,26 +656,11 @@ except ImportError:
 {compile_output}
 ```
 
-## Environment Setup:
-{f'''- Cross-compiler variables: {len([k for k in env.keys() if k.startswith(('CC', 'CXX', 'TARGET', 'CROSS'))])} set
-- Main compiler: {env.get('CC', 'not set')}
-- Architecture target: {env.get('TARGET_ARCH', 'not set')}
-- Cross-compile prefix: {env.get('CROSS_COMPILE', 'not set')}
-- Wrapper scripts: Created for version parsing''' if output_extension == '.exe' else '- Native GCC compilation'}
-
-## Version Parsing Status:
-{f'''- Wrapper scripts created: {os.path.exists(os.path.join(output_dir, "mingw_wrappers"))}
-- PATH modified: {("mingw_wrappers" in env.get("PATH", ""))}
-- Version handling: Improved regex-based parsing''' if output_extension == '.exe' else '- Native version parsing used'}
-
 ## Possible Solutions:
 1. Check your code for syntax errors
 2. Ensure all imports are available in requirements.txt
 3. Try a different compilation mode
 4. Review the compilation logs above
-{f"5. Verify MinGW-w64 installation and cross-compiler availability" if output_extension == '.exe' else ''}
-{f"6. The version parsing issue should now be resolved with wrapper scripts" if output_extension == '.exe' else ''}
-{f"7. Some packages may not support Windows cross-compilation" if output_extension == '.exe' else ''}
 
 ## Missing Dependencies:
 {', '.join(missing_deps) if missing_deps else 'None detected'}
@@ -862,10 +668,7 @@ except ImportError:
 ## Environment Info:
 - **Nuitka Version**: {nuitka_version}
 - **Python Version**: {current_python}
-- **Platform**: {platform.platform()}
-{f"- **Cross-compiler**: {env.get('CC', 'Not set')}" if output_extension == '.exe' else ''}
-{f"- **Target Architecture**: {env.get('TARGET_ARCH', 'Not set')}" if output_extension == '.exe' else ''}
-{f"- **Version Fix Applied**: Wrapper scripts with regex parsing" if output_extension == '.exe' else ''}"""
+- **Platform**: {platform.platform()}"""
             if progress_callback:
                 progress_callback(1.0, "Compilation failed ❌")
             
@@ -892,18 +695,11 @@ except ImportError:
 - **Python Version**: {current_python}
 - **Working Directory**: {os.getcwd()}
 
-## Version Parsing Fix:
-- Improved wrapper scripts implemented
-- Regex patterns for robust version detection
-- Fallback mechanisms for unknown formats
-
 ## Troubleshooting Steps:
 1. Check if Nuitka is properly installed
 2. Verify your code syntax
 3. Check available disk space
-4. Try with simpler code first
-{f"5. The version parsing issue has been addressed" if output_extension == '.exe' else ''}
-{f"6. Wrapper scripts should handle '12-win32' formats" if output_extension == '.exe' else ''}"""
+4. Try with simpler code first"""
         if progress_callback:
             progress_callback(1.0, "Error occurred ❌")
             
@@ -918,106 +714,8 @@ def run_compiled_binary(binary_path):
         return "❌ No binary available to run."
     
     try:
-        # Check if it's a Windows exe on Linux
-        if binary_path.endswith('.exe'):
-            # Verify architecture first
-            file_process = subprocess.run(["file", binary_path], capture_output=True, text=True)
-            if file_process.returncode == 0:
-                file_output = file_process.stdout
-                if "PE32+" in file_output or "x86-64" in file_output:
-                    arch_info = "64-bit"
-                elif "PE32" in file_output and "PE32+" not in file_output:
-                    arch_info = "32-bit"
-                else:
-                    arch_info = "unknown"
-            else:
-                arch_info = "unknown"
-            
-            # Try to run with wine first
-            wine_result = subprocess.run(["which", "wine"], capture_output=True)
-            if wine_result.returncode == 0:
-                return f"""🍷 **Running Windows {arch_info} executable with Wine**
-
-## Execution:
-```bash
-wine {os.path.basename(binary_path)}
-```
-
-## Binary Information:
-- **Architecture**: {arch_info}
-- **File**: {file_output.strip() if 'file_output' in locals() else 'Windows PE executable'}
-- **Version Fix**: Compiled with improved version parsing
-
-## ⚠️ Network Error Handling:
-This executable includes enhanced error handling. If you see:
-- "DNS Resolution Error" - indicates network connectivity issues
-- Exit code 6 - means the application couldn't resolve huggingface.co
-- Network timeout messages - suggests firewall or DNS problems
-
-## Solutions for Network Issues:
-1. **Enable internet access** for the executable
-2. **Pre-download models** if using Hugging Face
-3. **Use offline mode** if available in your libraries
-4. **Check firewall settings** that might block the executable
-
-## To run on Windows:
-1. Download the .exe file
-2. Transfer it to a Windows machine
-3. Run it by double-clicking or from command prompt
-
-```cmd
-# On Windows command prompt:
-{os.path.basename(binary_path)}
-```
-
-## Note:
-- Wine is available on this system for basic testing
-- This executable is compiled for Windows {arch_info}
-- Full compatibility requires running on actual Windows
-- Some features may not work correctly in wine
-- Version parsing issue has been resolved in compilation"""
-            else:
-                return f"""❌ Cannot run Windows .exe file on Linux system (wine not available).
-
-## Binary Information:
-- **Architecture**: {arch_info}
-- **Type**: Windows PE executable
-- **Version Fix**: Compiled with improved version parsing
-
-## Network Error Handling Included:
-This executable includes enhanced error handling for network issues:
-- Will show helpful messages if DNS resolution fails
-- Exits with code 6 for network errors (matching original issue)
-- Provides guidance on handling offline scenarios
-
-## To run this binary:
-1. Download the .exe file
-2. Transfer it to a Windows machine
-3. Run it by double-clicking or from command prompt
-
-```cmd
-# On Windows command prompt:
-cd /path/to/downloaded/file
-{os.path.basename(binary_path)}
-```
-
-## Note:
-- This executable is compiled for Windows {arch_info}
-- Compatible with appropriate Windows systems
-- Includes better error messages for network issues
-- Version parsing issue has been resolved
-
-## Alternative:
-Install wine to test Windows executables on Linux:
-```bash
-sudo apt update
-sudo apt install wine
-wine {os.path.basename(binary_path)}
-```"""
-        
-        # Make the binary executable (for non-Windows)
-        if not binary_path.endswith('.exe'):
-            os.chmod(binary_path, 0o755)
+        # Make the binary executable
+        os.chmod(binary_path, 0o755)
         
         # Run the binary with timeout
         process = subprocess.run(
@@ -1055,14 +753,13 @@ wine {os.path.basename(binary_path)}
         return f"❌ **Error running the binary:**\n\n```\n{str(e)}\n```"
 
 # Create Gradio interface
-with gr.Blocks(title="Nuitka Python Compiler (Fixed Version Parsing)", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🚀 Nuitka Python Compiler (Fixed Version Parsing)")
-    gr.Markdown("Convert your Python code into portable executables using Nuitka, with **FIXED version parsing** and enhanced network error handling.")
+with gr.Blocks(title="Nuitka Python Compiler for Linux", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🚀 Nuitka Python Compiler")
+    gr.Markdown("Convert your Python code into portable Linux executables using Nuitka, with enhanced network error handling.")
     
     # Check environment status
     has_static = check_static_libpython()
     missing_deps = check_dependencies()
-    missing_mingw, available_mingw = check_mingw_installation()
     
     if "nuitka" in missing_deps:
         gr.Markdown("⚠️ **Nuitka is not installed!** Add 'nuitka' to your requirements.txt file.")
@@ -1072,41 +769,27 @@ with gr.Blocks(title="Nuitka Python Compiler (Fixed Version Parsing)", theme=gr.
     else:
         gr.Markdown("🔧 **Using alternative portable options.** Static libpython not available.")
     
-    if available_mingw:
-        gr.Markdown(f"✅ **MinGW-w64 Available!** Found {len(available_mingw)} compilers.")
-        with gr.Accordion("Available MinGW-w64 Compilers", open=False):
-            for compiler, arch in available_mingw:
-                gr.Markdown(f"- {compiler} ({arch})")
-        gr.Markdown("🔧 **VERSION PARSING FIXED!** Improved wrapper scripts handle version detection.")
-    
-    if missing_mingw:
-        gr.Markdown(f"⚠️ **Some MinGW-w64 Components Missing:** {len(missing_mingw)} compilers not found.")
-        with gr.Accordion("Missing MinGW-w64 Compilers", open=False):
-            for compiler, arch in missing_mingw:
-                gr.Markdown(f"- {compiler} ({arch})")
-        gr.Markdown("📝 **For Windows .exe generation**, MinGW-w64 should be pre-installed in the environment.")
+    if [dep for dep in missing_deps if dep != "nuitka"]:
+        gr.Markdown(f"⚠️ **Other missing dependencies:** {', '.join([dep for dep in missing_deps if dep != 'nuitka'])}")
     
-    if [dep for dep in missing_deps if dep != "nuitka" and dep != "mingw-w64"]:
-        gr.Markdown(f"⚠️ **Other missing dependencies:** {', '.join([dep for dep in missing_deps if dep != 'nuitka' and dep != 'mingw-w64'])}")
-    
-    # Version parsing fix information
+    # Enhanced features information
     gr.Markdown("""
-    > 🔧 **Version Parsing Issue FIXED!**: 
-    > - **Problem**: MinGW compilers returning "12-win32" instead of "12.0.0"
-    > - **Solution**: Improved wrapper scripts with regex parsing
-    > - **Result**: Clean conversion to valid version numbers  
-    > - **Bonus**: Enhanced network error handling for runtime issues
+    > ℹ️ **Enhanced Linux Binary Compilation + Network Error Handling**: 
+    > - Native Linux compilation with maximum compatibility options
+    > - **Enhanced network error handling** for runtime issues
+    > - Intelligent error messages for common problems
+    > - **Exit code 6 handling** for DNS resolution failures
     """)
     
     with gr.Tabs():
         with gr.TabItem("🔧 Compiler"):
             with gr.Row():
-                with gr.Column(scale=2):
+                with gr.Column(scale=3):  # Changed scale to make code area larger
+                    gr.Markdown("### 📝 Python Code")
                     code_input = gr.Code(
                         value="""# Your Python code here
 print('Hello from compiled Python!')
-print('This cross-platform binary was created with Nuitka!')
-print('Version parsing issues have been FIXED!')
+print('This portable binary was created with Nuitka!')
 
 # This will work with automatic compatibility detection
 import os, sys
@@ -1114,18 +797,33 @@ print(f'Running from: {os.getcwd()}')
 print(f'Python executable: {sys.executable}')
 print(f'Platform: {sys.platform}')
 
-# Simple example with user input
-name = input('What is your name? ')
-print(f'Hello, {name}!')
-
-# Wait for user before closing (helpful for Windows .exe)
-input('Press Enter to exit...')""",
+# Example with user input
+try:
+    name = input('What is your name? ')
+    print(f'Hello, {name}!')
+except KeyboardInterrupt:
+    print('\\nOperation cancelled by user')
+    sys.exit(0)
+
+# Simple calculation
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+
+print(f'Fibonacci of 10: {fibonacci(10)}')
+
+# Wait for user before closing
+input('\\nPress Enter to exit...')""",
                         language="python",
-                        label="Your Python Code",
-                        lines=20
+                        label="Enter your Python code",
+                        lines=28,  # Increased number of visible lines
+                        show_label=False
                     )
                 
                 with gr.Column(scale=1):
+                    gr.Markdown("### ⚙️ Configuration")
+                    
                     with gr.Tabs():
                         with gr.TabItem("Python Requirements"):
                             requirements_input = gr.Textbox(
@@ -1137,63 +835,61 @@ input('Press Enter to exit...')""",
 # matplotlib
 # pillow
 
-# Note: Some packages may not work with Windows cross-compilation""",
+# Keep dependencies minimal for better compatibility""",
                                 lines=8,
                                 label="requirements.txt content"
                             )
                         
                         with gr.TabItem("System Packages"):
                             gr.Markdown("⚠️ **System packages cannot be installed in HF Spaces**")
-                            gr.Markdown("📝 **For MinGW-w64**, it should be pre-installed in the Docker image")
                             packages_input = gr.Textbox(
                                 placeholder="""# System packages (for reference only)
 # These should be pre-installed in HF Spaces
-# mingw-w64
-# gcc-mingw-w64-x86-64
-# g++-mingw-w64-x86-64""",
+# Example:
+# build-essential
+# libssl-dev""",
                                 lines=8,
                                 label="System packages (Reference Only)",
                                 interactive=True
                             )
                     
-                    # Fixed dropdown choices
-                    compilation_mode = gr.Dropdown(
-                        choices=[
-                            "Maximum Compatibility (Recommended)",
-                            "Portable Binary",
-                            "Standalone Binary"
-                        ],
-                        value="Maximum Compatibility (Recommended)",
-                        label="Compilation Mode"
-                    )
-                    
-                    output_extension = gr.Dropdown(
-                        choices=[".bin", ".sh", ".exe"],
-                        value=".bin",
-                        label="Output File Extension"
-                    )
-                    
-                    gr.Markdown("### 🔧 Environment Status")
-                    gr.Markdown(f"📍 **Python Version**: {get_current_python_version()}")
-                    gr.Markdown(f"🚀 **Nuitka Version**: {get_nuitka_version()}")
-                    
-                    if available_mingw:
-                        has_64bit = any("x86_64" in comp for comp, arch in available_mingw)
-                        has_32bit = any("i686" in comp for comp, arch in available_mingw)
-                        gr.Markdown(f"✅ **MinGW-w64**: Available ({'64-bit' if has_64bit else ''}{'/' if has_64bit and has_32bit else ''}{'32-bit' if has_32bit else ''})")
-                        gr.Markdown("🔧 **Version parsing**: FIXED with wrapper scripts")
-                    else:
-                        gr.Markdown("⚠️ **MinGW-w64**: Not available")
-                    
-                    if check_static_libpython():
-                        gr.Markdown("🔗 **Static libpython will be used for Linux targets!**")
-                    else:
-                        gr.Markdown("🔧 **Using portable compilation flags**")
+                    # Compilation options section
+                    with gr.Group():
+                        gr.Markdown("### 🛠️ Compilation Options")
+                        
+                        compilation_mode = gr.Dropdown(
+                            choices=[
+                                "Maximum Compatibility (Recommended)",
+                                "Portable Binary",
+                                "Standalone Binary"
+                            ],
+                            value="Maximum Compatibility (Recommended)",
+                            label="Compilation Mode",
+                            info="Choose the type of binary to create"
+                        )
+                        
+                        output_extension = gr.Dropdown(
+                            choices=[".bin", ".sh"],
+                            value=".bin",
+                            label="Output File Extension",
+                            info="File extension for the compiled binary"
+                        )
                     
-                    # Add enhanced fix notice
-                    gr.Markdown("🏗️ **Enhanced**: Version parsing + network error handling")
+                    # Environment status section
+                    with gr.Group():
+                        gr.Markdown("### 📊 Environment Status")
+                        gr.Markdown(f"📍 **Python Version**: {get_current_python_version()}")
+                        gr.Markdown(f"🚀 **Nuitka Version**: {get_nuitka_version()}")
+                        
+                        if check_static_libpython():
+                            gr.Markdown("🔗 **Static libpython available for maximum portability!**")
+                        else:
+                            gr.Markdown("🔧 **Using portable compilation flags**")
+                        
+                        gr.Markdown("🌐 **Enhanced**: Network error handling included")
                     
-                    compile_btn = gr.Button("🚀 Compile with Nuitka (Fixed)", variant="primary")
+                    # Compile button
+                    compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary", size="lg")
             
             # Progress Bar Section
             with gr.Column(visible=False) as progress_section:
@@ -1217,7 +913,7 @@ input('Press Enter to exit...')""",
                     result_summary = gr.Markdown()
                 with gr.Accordion("📜 Complete Compilation Logs", open=False):
                     compile_logs = gr.Textbox(label="Complete Compilation Output", lines=15)
-                download_file = gr.File(label="📥 Download Compiled Binary")
+                download_file = gr.File(label="📥 Download Compiled Binary", visible=False)
                 
                 # Test run section
                 with gr.Row():
@@ -1279,10 +975,10 @@ input('Press Enter to exit...')""",
                     # Progress simulation with log updates
                     progress_steps = [
                         (0.1, "Checking Nuitka installation..."),
-                        (0.15, f"Creating improved wrapper scripts..." if extension == ".exe" else "Checking environment..."),
+                        (0.15, "Checking environment..."),
                         (0.2, "Adding network error handling..."),
                         (0.3, "Installing requirements..."),
-                        (0.4, f"Starting {'64-bit Windows ' if extension == '.exe' else ''}compilation with fixed version parsing..."),
+                        (0.4, "Starting compilation..."),
                         (0.5, "Processing imports..."),
                         (0.6, "Optimizing code..."),
                         (0.7, f"Creating {extension} binary..."),
@@ -1327,16 +1023,9 @@ input('Press Enter to exit...')""",
                     # Get compilation result
                     summary, binary_path, logs, success = compilation_result[0]
                     
-                    # Final progress update with version fix notice
-                    final_status = "✅ Compilation successful with version fix!" if success else "❌ Compilation failed"
-                    if success and extension == ".exe":
-                        # Try to determine architecture from logs
-                        if "64-bit" in current_logs or "PE32+" in current_logs:
-                            final_status += " (Windows 64-bit .exe)"
-                        elif "32-bit" in current_logs:
-                            final_status += " (Windows 32-bit .exe)"
-                        else:
-                            final_status += " (Windows .exe)"
+                    # Final progress update
+                    final_status = "✅ Compilation successful!" if success else "❌ Compilation failed"
+                    if success:
                         final_status += " + Network Error Handling"
                     
                     yield (
@@ -1362,7 +1051,7 @@ input('Press Enter to exit...')""",
                         # Final update with download file
                         yield (
                             gr.update(visible=True),  # progress_section
-                            gr.update(value=create_progress_bar(1.0, f"✅ {extension} compilation successful with version fix! Ready to download.")),  # progress_bar
+                            gr.update(value=create_progress_bar(1.0, f"✅ {extension} compilation successful! Ready to download.")),  # progress_bar
                             gr.update(visible=True),  # logs_section
                             gr.update(value=current_logs),  # real_time_logs
                             gr.update(visible=True),  # results_section
@@ -1435,73 +1124,56 @@ input('Press Enter to exit...')""",
         
         with gr.TabItem("📖 How to Use"):
             gr.Markdown("""
-            ## 🎯 Enhanced Compilation with Fixed Version Parsing
+            ## 🎯 Enhanced Linux Compilation with Network Error Handling
             
-            **Solution for MinGW Version Issues + Network Error Handling**
+            **Native Linux Binary Creation + Network Error Solutions**
             
-            This app has been updated to fix the critical version parsing issue:
-            - **Problem**: MinGW compilers returning "12-win32" 
-            - **Solution**: Improved wrapper scripts with regex parsing
-            - **Result**: Clean conversion to valid version numbers (e.g., "12.0.0")
-            - **Bonus**: Enhanced network error handling for runtime issues
+            This app creates portable Linux binaries with enhanced error handling:
+            - **Native compilation** for maximum compatibility on Linux
+            - **Enhanced network error handling** for runtime DNS issues
+            - **Exit code 6 handling** (matching your original issue)
+            - **Intelligent error messages** for common problems
             
-            **New Version Parsing Features:**
-            ```bash
-            # Before (causing error):
-            gcc --version → "gcc (GCC) 12-win32"
-            int("12-win32") → ValueError!
-            
-            # After (fixed with wrapper):
-            gcc --version → "12.0.0" 
-            int("12") → Success!
+            **Network Error Handling Features:**
+            ```python
+            # Automatic error handling for network operations
+            # DNS resolution failure detection
+            # Exit code 6 for network issues
+            # Helpful error messages and guidance
             ```
             
             ## 📋 Usage Instructions
             
             ### 1. Write Your Code
-            - Enter your Python code in the code editor
+            - Enter your Python code in the large editor area
+            - The editor is now larger for better code visibility
             - Add Python package requirements in the requirements tab
-            - For Windows .exe, consider adding `input('Press Enter to exit...')`
-            
-            ### 2. Compilation Process
-            - **Linux (.bin)**: Native compilation with network handling
-            - **Windows (.exe)**: 64-bit cross-compilation with fixed version parsing
-            - The system automatically creates wrapper scripts for version detection
-            
-            ### 3. Network Considerations
+            - Consider adding error handling for user input
+            
+            ### 2. Configuration
+            - **Python Requirements**: Add pip-installable packages
+            - **Compilation Mode**: Choose based on your needs
+              - Maximum Compatibility: Best for distribution
+              - Portable Binary: Smaller but still compatible
+              - Standalone Binary: Self-contained
+            - **Output Extension**: Choose .bin or .sh
+            
+            ### 3. Compilation Process
+            - Click "Compile with Nuitka" to start
+            - Monitor real-time progress and logs
+            - Download the compiled binary when complete
+            
+            ### 4. Network Considerations
             If your code uses online services (like Hugging Face):
             - **Development**: Works normally with internet access
             - **Compiled binary**: Includes enhanced error handling
             - **Error messages**: Provide clear guidance on failures
             
-            ## 🔧 Version Parsing Fix Details
-            
-            **What's Fixed:**
-            ```python
-            # Wrapper script with regex patterns:
-            if [[ $version_output =~ ([0-9]+)\.([0-9]+)\.?([0-9]*) ]]; then
-                # Standard x.y.z format
-                echo "${major}.${minor}.${patch}"
-            elif [[ $version_output =~ ([0-9]+)[^0-9] ]]; then  
-                # Just major version (like "12-win32")
-                echo "${major}.0.0"
-            else
-                # Fallback for any unparseable format
-                echo "12.0.0"
-            fi
-            ```
-            
-            **Benefits:**
-            1. Handles all MinGW version formats
-            2. Converts problematic strings like "12-win32"
-            3. Provides fallback for edge cases
-            4. Ensures Nuitka gets parseable version numbers
-            
-            ## 🌐 Network Error Handling
+            ## 🌐 Network Error Handling Details
             
-            **Enhanced for Runtime:**
+            **What's Enhanced:**
             ```python
-            # Automatic network error detection
+            # Automatic urllib error wrapping
             try:
                 urllib.request.urlopen(url)
             except urllib.error.URLError as e:
@@ -1516,35 +1188,19 @@ input('Press Enter to exit...')""",
             3. **Error Guidance**: Suggestions for offline operation
             4. **Debugging Info**: Shows exact error cause
             
-            ## 🎯 Complete Solution Summary
-            
-            **Compilation Issues Fixed:**
-            - ✅ Version parsing: "12-win32" → "12.0.0"
-            - ✅ Wrapper scripts: Handle all MinGW formats
-            - ✅ Error prevention: No more ValueError exceptions
-            - ✅ Robust fallbacks: Unknown formats handled gracefully
-            
-            **Runtime Issues Addressed:**
-            - ✅ Network error handling: DNS resolution detection
-            - ✅ Exit code consistency: Code 6 for network failures
-            - ✅ User guidance: Helpful error messages
-            - ✅ Offline strategies: Clear recommendations
-            
-            ## 📊 Error Code Reference
+            ## 🔧 Best Practices
             
-            | Exit Code | Meaning | Solution |
-            |-----------|---------|----------|
-            | 0 | Success | Normal operation |
-            | 6 | Network Error | DNS resolution failed |
-            | Other | Various Errors | Check error message |
+            **For Code Organization:**
+            1. Use the larger code editor for better visibility
+            2. Keep functions organized and well-commented
+            3. Handle user input gracefully (try/except blocks)
+            4. Add proper error handling throughout your code
             
-            ## ⚠️ Best Practices
-            
-            **For Compilation:**
-            1. The version parsing issue is now automatically handled
-            2. Wrapper scripts are created transparently
-            3. No manual intervention needed for MinGW version formats
-            4. All MinGW tools are properly wrapped
+            **For Dependencies:**
+            1. Keep requirements minimal for better compatibility
+            2. Use specific versions where needed
+            3. Test with minimal dependencies first
+            4. Consider offline alternatives for network-dependent packages
             
             **For Network-Dependent Applications:**
             1. Always handle network errors gracefully
@@ -1553,43 +1209,71 @@ input('Press Enter to exit...')""",
             4. Use offline modes where available
             5. Display helpful error messages to users
             
-            **For Windows .exe Distribution:**
-            1. Test compiled binary on clean Windows system
-            2. Verify network error handling works
-            3. Include instructions for users about network requirements
-            4. Consider bundling required data with executable
+            ## 📊 Compilation Options Explained
+            
+            **Maximum Compatibility (Recommended):**
+            - Single standalone file
+            - Includes all dependencies
+            - Works on most Linux systems
+            - Larger file size but maximum portability
+            
+            **Portable Binary:**
+            - Requires compatible system libraries
+            - Smaller file size
+            - Good for similar environments
+            - May need dependency installation
+            
+            **Standalone Binary:**
+            - Self-contained executable
+            - Medium file size
+            - Independent of Python installation
+            - Good balance of size and portability
+            
+            ## 🚀 Tips for Success
+            
+            1. **Start Simple**: Test with basic code first
+            2. **Check Dependencies**: Verify all imports are in requirements.txt
+            3. **Test Locally**: Run your code successfully before compiling
+            4. **Handle Errors**: Include proper error handling
+            5. **Monitor Logs**: Watch the compilation logs for issues
+            6. **Test Binary**: Always test the compiled binary
+            
+            ## ⚠️ Common Issues and Solutions
+            
+            **If compilation fails:**
+            1. Check the compilation logs for specific errors
+            2. Verify your code syntax
+            3. Ensure all dependencies are listed
+            4. Try a different compilation mode
+            
+            **If the binary crashes:**
+            1. Run with verbose output to see errors
+            2. Check for missing dependencies
+            3. Verify network connectivity if needed
+            4. Look for exit code 6 (network issues)
+            
+            **If network errors occur:**
+            1. The binary will show helpful error messages
+            2. Exit code 6 indicates DNS resolution failure
+            3. Consider pre-downloading data if possible
+            4. Use offline modes in your libraries
             """)
         
         with gr.TabItem("ℹ️ About"):
             gr.Markdown(f"""
-            ## 🧠 Complete Solution: Version Parsing + Runtime Errors
+            ## 🧠 Native Linux Compilation + Network Error Handling
             
             **Technical Implementation:**
             
-            ### 1. Version Parsing Fix
-            ```bash
-            # Created wrapper scripts in mingw_wrappers/ directory
-            # Each tool (gcc, g++, ar, etc.) gets a wrapper that:
-            # 1. Intercepts --version calls
-            # 2. Parses output with robust regex patterns  
-            # 3. Returns clean version numbers
-            # 4. Passes all other commands through normally
-            ```
+            ### 1. Enhanced Compilation
+            - **Native Linux targeting** with maximum compatibility
+            - **Nuitka optimization** for performance
+            - **Static linking** when available
+            - **Dependency resolution** with fallbacks
             
-            ### 2. Environment Setup
+            ### 2. Network Error Enhancements
             ```python
-            # PATH manipulation ensures wrappers are used first
-            env["PATH"] = wrapper_dir + ":" + env["PATH"]
-            
-            # Compiler environment uses wrapper paths
-            env["CC"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-gcc")
-            env["CXX"] = os.path.join(wrapper_dir, "x86_64-w64-mingw32-g++")
-            # ... etc for all tools
-            ```
-            
-            ### 3. Network Error Handling
-            ```python
-            # Automatic urllib patching in compiled code
+            # Automatic urllib patching in compiled binaries
             def enhanced_urlopen(url, *args, **kwargs):
                 try:
                     return original_urlopen(url, *args, **kwargs)
@@ -1600,20 +1284,26 @@ input('Press Enter to exit...')""",
                     raise
             ```
             
-            ## ✅ Comprehensive Fix Results
+            ### 3. User Experience Improvements
+            - **Larger code editor** for better code visibility
+            - **Progressive status updates** during compilation
+            - **Real-time log streaming** for transparency
+            - **Clear error messages** for troubleshooting
+            
+            ## ✅ Comprehensive Solution
             
-            **Version Parsing:**
-            - ✅ **Regex patterns**: Handle all known formats
-            - ✅ **Wrapper scripts**: Transparent to Nuitka
-            - ✅ **PATH manipulation**: Ensures wrappers are used
-            - ✅ **Fallback handling**: Unknown formats → "12.0.0"
-            - ✅ **Tool coverage**: All MinGW tools wrapped
+            **Compilation Features:**
+            - ✅ **Native Linux compilation** with Nuitka
+            - ✅ **Multiple output formats** (.bin, .sh)
+            - ✅ **Dependency handling** with pip integration
+            - ✅ **Progress monitoring** with real-time logs
+            - ✅ **Error detection** and helpful feedback
             
-            **Network Handling:**
-            - ✅ **DNS error detection**: Catches resolution failures
-            - ✅ **Exit code 6**: Consistent with your issue
-            - ✅ **Helpful messages**: Guide users to solutions
-            - ✅ **Offline strategies**: Recommendations included
+            **Runtime Features:**
+            - ✅ **Network error detection** for DNS failures
+            - ✅ **Exit code 6** for network issues (matching your original problem)
+            - ✅ **Helpful error messages** for users
+            - ✅ **Offline operation guidance** when network fails
             
             ## ☁️ Environment Status
             
@@ -1623,16 +1313,10 @@ input('Press Enter to exit...')""",
             Python Version: {get_current_python_version()}
             Nuitka Version: {get_nuitka_version()}
             
-            Version Parsing Fix:
-            ✅ Wrapper scripts: Will be created during compilation
-            ✅ Regex patterns: Handle "12-win32" format
-            ✅ PATH modification: Wrappers take precedence 
-            ✅ Tool coverage: All MinGW utilities wrapped
-            
-            Cross-Compilation:
-            {('✅ 64-bit MinGW-w64: Available + Fixed' if any('x86_64' in comp for comp, arch in available_mingw) else '❌ 64-bit Missing') if available_mingw else '❌ No MinGW-w64 found'}
-            {('✅ Version parsing: Robust wrapper system' if any('x86_64' in comp for comp, arch in available_mingw) else '')}
-            {('✅ Regex handling: "X-winYY" → "X.0.0"' if any('x86_64' in comp for comp, arch in available_mingw) else '')}
+            Compilation Target: Native Linux
+            ✅ GCC compilation: Available
+            ✅ Static linking: {'Available' if check_static_libpython() else 'Using alternatives'}
+            ✅ Package management: pip integration
             
             Network Handling:
             ✅ DNS error detection: Enabled
@@ -1643,62 +1327,62 @@ input('Press Enter to exit...')""",
             
             ## 📋 Technical Specifications
             
-            **Version Parsing Regex:**
-            ```bash
-            # Pattern 1: Standard versions (e.g., "12.3.0")
-            ([0-9]+)\.([0-9]+)\.?([0-9]*)
-            
-            # Pattern 2: Major version only (e.g., "12-win32")  
-            ([0-9]+)[^0-9]
+            **Compilation Process:**
+            1. **Code Enhancement**: Automatic network error handling injection
+            2. **Dependency Resolution**: pip install with requirements.txt
+            3. **Nuitka Compilation**: Native binary creation
+            4. **Optimization**: Maximum compatibility settings
+            5. **Verification**: Binary testing and size reporting
             
-            # Fallback: Always return "12.0.0" if nothing matches
+            **Network Error Handling:**
+            ```python
+            # Enhanced error handling workflow:
+            # 1. urllib operations are intercepted
+            # 2. DNS resolution errors are detected
+            # 3. Helpful error messages are displayed
+            # 4. Exit code 6 is returned for consistency
+            # 5. Offline operation suggestions are provided
             ```
             
-            **Wrapper Script Features:**
-            ```bash
-            #!/bin/bash
-            # Advanced wrapper for x86_64-w64-mingw32-gcc
-            
-            if [ "$1" = "--version" ]; then
-                # Extract version with regex
-                # Convert to standard format
-                # Return clean version number
-            else
-                # Pass through to real compiler
-                exec /usr/bin/x86_64-w64-mingw32-gcc "$@"
-            fi
-            ```
+            ## 🔧 Advanced Features
             
-            ## 🔧 Implementation Details
+            **Code Editor Improvements:**
+            - Larger editing area (3:1 ratio with configuration)
+            - Syntax highlighting for Python
+            - 28 visible lines by default
+            - Better example code with error handling
             
-            **Problem Solving Process:**
+            **Configuration Options:**
+            - Streamlined interface without Windows options
+            - Focus on Linux-specific features
+            - Clear explanations for each option
+            - Real-time environment status
             
-            1. **Root Cause**: MinGW version strings like "12-win32"
-            2. **Analysis**: Nuitka expects "X.Y.Z" format only  
-            3. **Solution**: Regex-based wrapper scripts
-            4. **Implementation**: PATH manipulation + environment setup
-            5. **Testing**: Architecture verification for success
-            6. **Enhancement**: Network error handling added
+            **Progress Tracking:**
+            - Visual progress bar with percentages
+            - Real-time log streaming
+            - Clear status messages
+            - Detailed error reporting
             
             ## 🚀 Success Indicators
             
             **During Compilation:**
-            1. **Wrapper creation**: See "Creating improved wrapper scripts..."
-            2. **Clean version detection**: No ValueError exceptions
-            3. **Correct architecture**: PE32+ for 64-bit Windows
-            4. **Environment logs**: Show wrapper script usage
+            1. **Progress bar** shows smooth advancement
+            2. **Real-time logs** show Nuitka activity
+            3. **No version parsing errors** (Linux-native)
+            4. **Clean binary creation** with size reporting
             
             **In Compiled Binary:**
-            1. **Network handling**: Graceful DNS error management
-            2. **Exit code 6**: Consistent with original issue
-            3. **User guidance**: Helpful offline suggestions
-            4. **Robust operation**: Handles connectivity issues
+            1. **Network handling** works automatically
+            2. **Exit code 6** for DNS resolution failures
+            3. **User-friendly messages** for common errors
+            4. **Consistent behavior** with your original issue
             
-            This ensures **complete solution** for both compilation and runtime issues - no more version parsing errors and better network error handling.
+            This ensures a **complete solution** for creating portable Linux binaries with intelligent network error handling - no more version parsing issues and better runtime error management.
             """)
     
     gr.Markdown("---")
-    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + MinGW-w64 | ✅ Fixed Version Parsing + Network Handling")
+    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka | 🐧 Linux Native + Network Error Handling")
 
 if __name__ == "__main__":
     # Create necessary directories on startup
@@ -1709,30 +1393,13 @@ if __name__ == "__main__":
     if "nuitka" in check_dependencies():
         print("WARNING: Nuitka is not installed. Please add 'nuitka' to your requirements.txt file.")
     
-    # Check MinGW-w64 status
-    missing_mingw, available_mingw = check_mingw_installation()
-    if available_mingw:
-        print(f"INFO: Found {len(available_mingw)} MinGW-w64 compilers:")
-        for compiler, arch in available_mingw:
-            print(f"  - {compiler} ({arch})")
-        
-        # Check for 64-bit compiler specifically
-        has_64bit = any("x86_64" in comp for comp, arch in available_mingw)
-        if has_64bit:
-            print("INFO: x86_64-w64-mingw32-gcc detected - 64-bit compilation will be enforced")
-            print("INFO: Version parsing issue will be fixed with wrapper scripts")
-            print("INFO: Comprehensive environment variables will be set for guaranteed 64-bit output")
-            print("INFO: Network error handling will be added to compiled binaries")
-        else:
-            print("WARNING: No 64-bit MinGW-w64 compiler found - may fall back to 32-bit")
-    if missing_mingw:
-        print(f"WARNING: Missing {len(missing_mingw)} MinGW-w64 compilers:")
-        for compiler, arch in missing_mingw:
-            print(f"  - {compiler} ({arch})")
-    
-    print("\n🔧 VERSION PARSING FIX READY!")
-    print("This app will automatically handle MinGW version parsing issues")
-    print("Wrapper scripts will convert '12-win32' to '12.0.0' and similar transformations")
-    print("No manual intervention required - the fix is built-in!")
+    print("\n🐧 LINUX NATIVE COMPILATION READY!")
+    print("This app creates portable Linux binaries with enhanced network error handling")
+    print("Features:")
+    print("- Larger code editor for better visibility")
+    print("- Native Linux compilation only (no Windows cross-compilation)")
+    print("- Enhanced network error handling with exit code 6")
+    print("- Real-time compilation logs and progress")
+    print("- Multiple output formats (.bin, .sh)")
     
     app.launch()