Update app.py

app.py

@@ -30,8 +30,20 @@ def check_dependencies():
         missing_deps.append("nuitka")
     
     # Check for MinGW-w64 (needed for Windows cross-compilation)
-    result = subprocess.run(["which", "x86_64-w64-mingw32-gcc"], capture_output=True)
-    if result.returncode != 0:
+    # Check for both 32-bit and 64-bit compilers
+    mingw_compilers = [
+        "x86_64-w64-mingw32-gcc",  # 64-bit
+        "i686-w64-mingw32-gcc"     # 32-bit
+    ]
+    
+    found_mingw = False
+    for compiler in mingw_compilers:
+        result = subprocess.run(["which", compiler], capture_output=True)
+        if result.returncode == 0:
+            found_mingw = True
+            break
+    
+    if not found_mingw:
         missing_deps.append("mingw-w64")
     
     # Check for patchelf (usually available in HF Spaces)
@@ -138,18 +150,25 @@ def install_nuitka_if_missing():
 def check_mingw_installation():
     """Check if MinGW-w64 is properly installed"""
     mingw_compilers = [
-        "x86_64-w64-mingw32-gcc",
-        "x86_64-w64-mingw32-g++",
-        "x86_64-w64-mingw32-ld"
+        ("x86_64-w64-mingw32-gcc", "64-bit"),
+        ("x86_64-w64-mingw32-g++", "64-bit"),
+        ("x86_64-w64-mingw32-ld", "64-bit"),
+        ("i686-w64-mingw32-gcc", "32-bit"),
+        ("i686-w64-mingw32-g++", "32-bit"),
+        ("i686-w64-mingw32-ld", "32-bit")
     ]
     
+    available = []
     missing = []
-    for compiler in mingw_compilers:
+    
+    for compiler, arch in mingw_compilers:
         result = subprocess.run(["which", compiler], capture_output=True)
-        if result.returncode != 0:
-            missing.append(compiler)
+        if result.returncode == 0:
+            available.append((compiler, arch))
+        else:
+            missing.append((compiler, arch))
     
-    return missing
+    return missing, available
 
 def find_compiled_binary(output_dir, output_filename):
     """Find the compiled binary, checking different possible paths"""
@@ -216,11 +235,19 @@ Add this to your requirements.txt and redeploy the space."""
         
         # Check for Windows cross-compilation requirements
         if output_extension == ".exe":
-            missing_mingw = check_mingw_installation()
-            if missing_mingw:
-                if log_queue:
-                    log_queue.put(f"⚠️ Warning: Missing MinGW components: {', '.join(missing_mingw)}\n")
-                    log_queue.put("Windows cross-compilation may fail without proper MinGW-w64 installation\n")
+            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()
@@ -341,15 +368,52 @@ Add this to your requirements.txt and redeploy the space."""
         
         # Add Windows-specific options using MinGW-w64
         if output_extension == ".exe":
-            cmd.extend([
-                "--mingw64",  # Use MinGW-w64 for cross-compilation
-                "--windows-disable-console",  # Disable console window for GUI apps
-            ])
-            # Note: --mingw64 flag tells Nuitka to use MinGW-w64 for Windows cross-compilation
-            if log_queue:
-                log_queue.put("Using MinGW-w64 for Windows cross-compilation\n")
-                log_queue.put("Note: Cross-compiling from Linux to Windows using MinGW-w64 toolchain\n")
-                log_queue.put("Target: Windows 64-bit (MinGW-w64 default)\n")
+            # 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)
+            
+            if x64_gcc.returncode == 0:
+                # Use explicit 64-bit cross-compiler
+                cmd.extend([
+                    "--clang",  # Use clang as backend (better for cross-compilation)
+                    "--windows-disable-console",  # Disable console window for GUI apps
+                ])
+                
+                # Set environment variables to force use of 64-bit MinGW
+                os.environ["CC"] = "x86_64-w64-mingw32-gcc"
+                os.environ["CXX"] = "x86_64-w64-mingw32-g++"
+                
+                if log_queue:
+                    log_queue.put("Using x86_64-w64-mingw32-gcc for Windows 64-bit cross-compilation\n")
+                    log_queue.put("Set CC=x86_64-w64-mingw32-gcc, CXX=x86_64-w64-mingw32-g++\n")
+                    log_queue.put("Using Clang backend for better cross-compilation support\n")
+                    log_queue.put("Target: Windows 64-bit (x64)\n")
+                    
+            elif i686_gcc.returncode == 0:
+                # Use 32-bit cross-compiler as fallback
+                cmd.extend([
+                    "--clang",  # Use clang as backend
+                    "--windows-disable-console",  # Disable console window for GUI apps
+                ])
+                
+                # Set environment variables to force use of 32-bit MinGW
+                os.environ["CC"] = "i686-w64-mingw32-gcc"
+                os.environ["CXX"] = "i686-w64-mingw32-g++"
+                
+                if log_queue:
+                    log_queue.put("Using i686-w64-mingw32-gcc for Windows 32-bit cross-compilation\n")
+                    log_queue.put("Set CC=i686-w64-mingw32-gcc, CXX=i686-w64-mingw32-g++\n")
+                    log_queue.put("Using Clang backend for better cross-compilation support\n")
+                    log_queue.put("Target: Windows 32-bit (x86)\n")
+            else:
+                # Fallback to --mingw64 if no specific compiler found
+                cmd.extend([
+                    "--mingw64",  # Use MinGW-w64
+                    "--windows-disable-console",  # Disable console window for GUI apps
+                ])
+                if log_queue:
+                    log_queue.put("Falling back to --mingw64 flag\n")
+                    log_queue.put("Target: Windows (architecture determined by MinGW-w64)\n")
         
         # Run compilation
         if progress_callback:
@@ -365,7 +429,8 @@ Add this to your requirements.txt and redeploy the space."""
             stderr=subprocess.STDOUT,
             text=True,
             bufsize=1,
-            universal_newlines=True
+            universal_newlines=True,
+            env=os.environ  # Pass the modified environment
         )
         
         # Progress tracking
@@ -393,7 +458,7 @@ Add this to your requirements.txt and redeploy the space."""
                 status_text = f"Optimizing: {line.strip()[:60]}..."
             elif "Creating" in line:
                 status_text = f"Creating: {line.strip()[:60]}..."
-            elif "MinGW" in line:
+            elif "MinGW" in line or "gcc" in line:
                 status_text = f"MinGW: {line.strip()[:60]}..."
             
             if progress_callback:
@@ -436,8 +501,19 @@ Add this to your requirements.txt and redeploy the space."""
                 binary_info = file_process.stdout
                 if log_queue:
                     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"
+                else:
+                    arch_info = "unknown"
+                    
+                log_queue.put(f"Detected architecture: {arch_info}\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":
@@ -455,10 +531,19 @@ Add this to your requirements.txt and redeploy the space."""
                 except:
                     linking_info = "ℹ️ Compiled binary created successfully"
             else:
-                # For Windows
-                linking_info = "📦 Windows executable (cross-compiled with MinGW-w64)"
+                # For Windows, show architecture information
+                if "CC" in os.environ and "x86_64" in os.environ["CC"]:
+                    linking_info = f"📦 Windows 64-bit executable (cross-compiled with {os.environ['CC']})"
+                elif "CC" in os.environ and "i686" in os.environ["CC"]:
+                    linking_info = f"📦 Windows 32-bit executable (cross-compiled with {os.environ['CC']})"
+                else:
+                    linking_info = f"📦 Windows executable (cross-compiled with MinGW-w64)"
+                    
+                if arch_info != "unknown":
+                    linking_info += f" - Verified {arch_info}"
+                
                 if log_queue:
-                    log_queue.put("Binary: Windows x64 format (MinGW-w64 default)\n")
+                    log_queue.put(f"Final binary architecture: {linking_info}\n")
             
             # Rename to desired extension
             if output_extension in ['.bin', '.sh', '.exe'] and not binary_path.endswith(output_extension):
@@ -475,6 +560,17 @@ Add this to your requirements.txt and redeploy the space."""
             file_size = os.path.getsize(binary_path) / 1024
             binary_basename = os.path.basename(binary_path)
             
+            # Determine architecture from environment
+            if output_extension == ".exe":
+                if "CC" in os.environ and "x86_64" in os.environ["CC"]:
+                    arch_used = "x86_64 (64-bit)"
+                elif "CC" in os.environ and "i686" in os.environ["CC"]:
+                    arch_used = "i686 (32-bit)"
+                else:
+                    arch_used = "MinGW-w64 default"
+            else:
+                arch_used = "Native Linux"
+            
             # Create result summary
             result_summary = f"""# ✅ Compilation Successful!
 
@@ -488,6 +584,7 @@ Add this to your requirements.txt and redeploy the space."""
 - **Static Libpython Available**: {static_status}
 - **Linking**: {linking_info}
 - **Target Platform**: {'Windows (via MinGW-w64)' if output_extension == '.exe' else 'Linux'}
+- **Architecture**: {arch_used}
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -496,27 +593,26 @@ Add this to your requirements.txt and redeploy the space."""
 ## Binary Information:
 {binary_info}
 
-## 🚀 Portability Notes:
-- This binary was compiled with maximum compatibility settings
-- Using --onefile for single-file distribution
-- {'Cross-compiled for Windows using MinGW-w64 toolchain' if output_extension == '.exe' else 'Should work on most compatible Linux systems'}
-{f'- Console window disabled for Windows GUI applications' if output_extension == '.exe' else ''}
-- {'MinGW-w64 produces 64-bit Windows executables by default' if output_extension == '.exe' else ''}
+## 🚀 Cross-Compilation Details:
+{f'''- Used cross-compiler: {os.environ.get("CC", "MinGW-w64 default")}
+- Architecture: {arch_used}
+- Backend: {'Clang' if '--clang' in cmd else 'GCC'}
+- Target verification: {arch_info} executable detected''' if output_extension == '.exe' else '- Native Linux compilation'}
 
 ## 📋 Usage Instructions:
 ```bash
-{f'# For Windows:' if output_extension == '.exe' else f'chmod +x {binary_basename}'}
+{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}'}
 ```
 
 ## ⚠️ Cross-Compilation Notes:
-{f'''- Compiled from Linux to Windows using MinGW-w64
-- MinGW-w64 creates 64-bit executables by default
+{f'''- Successfully compiled from Linux to Windows {arch_info}
+- Used {os.environ.get("CC", "MinGW-w64")} cross-compiler
+- Binary verified as {arch_info} Windows executable
 - Tested with wine if available: `wine {binary_basename}`
-- Compatible with Windows 64-bit systems
-- Some Windows-specific libraries may need additional setup
-- GUI frameworks may require special handling''' if output_extension == '.exe' else 'Native Linux compilation with maximum compatibility'}
+- Compatible with Windows systems
+- Some Windows-specific libraries may need additional setup''' if output_extension == '.exe' else 'Native Linux compilation with maximum compatibility'}
 
 ## 🧪 Testing:
 {f'You can test the Windows executable on Linux using wine:' if output_extension == '.exe' else 'Run directly on compatible Linux systems:'}
@@ -525,12 +621,13 @@ Add this to your requirements.txt and redeploy the space."""
 ```"""
             
             if progress_callback:
-                progress_callback(1.0, "Compilation successful! 🎉")
+                progress_callback(1.0, f"Compilation successful! Created {arch_info} executable 🎉")
             
             if log_queue:
                 log_queue.put("✅ Compilation completed successfully!\n")
                 if output_extension == ".exe":
-                    log_queue.put("🍷 You can test the Windows executable with: wine " + binary_basename + "\n")
+                    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")
                 
             return result_summary, binary_path, compile_output, True
         else:
@@ -551,14 +648,18 @@ Add this to your requirements.txt and redeploy the space."""
 {compile_output}
 ```
 
+## Environment Setup:
+{f'''- Cross-compiler attempted: {os.environ.get("CC", "Default MinGW")}
+- Backend: {'Clang' if '--clang' in cmd else 'GCC'}''' if output_extension == '.exe' else '- Native GCC compilation'}
+
 ## 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. For Windows cross-compilation, ensure MinGW-w64 is properly installed" if output_extension == '.exe' else ''}
-{f"6. Some packages may not support Windows cross-compilation" if output_extension == '.exe' else ''}
-{f"7. MinGW-w64 creates 64-bit executables by default" if output_extension == '.exe' else ''}
+{f"5. Verify MinGW-w64 installation and cross-compiler availability" if output_extension == '.exe' else ''}
+{f"6. Some packages may not support cross-compilation" if output_extension == '.exe' else ''}
+{f"7. Check if the cross-compiler supports the target architecture" if output_extension == '.exe' else ''}
 
 ## Missing Dependencies:
 {', '.join(missing_deps) if missing_deps else 'None detected'}
@@ -567,8 +668,8 @@ Add this to your requirements.txt and redeploy the space."""
 - **Nuitka Version**: {nuitka_version}
 - **Python Version**: {current_python}
 - **Platform**: {platform.platform()}
-{f"- **MinGW-w64**: {'Available' if not check_mingw_installation() else 'Missing components'}" if output_extension == '.exe' else ''}
-{f"- **Target Architecture**: x64 (MinGW-w64 default)" if output_extension == '.exe' else ''}"""
+{f"- **Cross-compiler**: {os.environ.get('CC', 'Not set')}" if output_extension == '.exe' else ''}
+{f"- **MinGW-w64 Status**: Available" if not missing_mingw else f"- **MinGW-w64 Status**: Missing components" if output_extension == '.exe' else ''}"""
             if progress_callback:
                 progress_callback(1.0, "Compilation failed ❌")
             
@@ -600,8 +701,8 @@ Add this to your requirements.txt and redeploy the space."""
 2. Verify your code syntax
 3. Check available disk space
 4. Try with simpler code first
-{f"5. Ensure MinGW-w64 is installed for Windows cross-compilation" if output_extension == '.exe' else ''}
-{f"6. MinGW-w64 produces 64-bit Windows executables by default" if output_extension == '.exe' else ''}"""
+{f"5. Verify MinGW-w64 cross-compiler installation" if output_extension == '.exe' else ''}
+{f"6. Check cross-compiler setup and environment variables" if output_extension == '.exe' else ''}"""
         if progress_callback:
             progress_callback(1.0, "Error occurred ❌")
             
@@ -618,18 +719,34 @@ def run_compiled_binary(binary_path):
     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 executable with Wine**
+                return f"""🍷 **Running Windows {arch_info} executable with Wine**
 
 ## Execution:
 ```bash
 wine {os.path.basename(binary_path)}
 ```
 
-## Output:
-To run on Windows:
+## Binary Information:
+- **Architecture**: {arch_info}
+- **File**: {file_output.strip() if 'file_output' in locals() else 'Windows PE 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
@@ -641,12 +758,16 @@ To run on Windows:
 
 ## Note:
 - Wine is available on this system for basic testing
-- This executable is compiled for Windows 64-bit (MinGW-w64 default)
+- This executable is compiled for Windows {arch_info}
 - Full compatibility requires running on actual Windows
 - Some features may not work correctly in wine"""
             else:
                 return f"""❌ Cannot run Windows .exe file on Linux system (wine not available).
 
+## Binary Information:
+- **Architecture**: {arch_info}
+- **Type**: Windows PE executable
+
 ## To run this binary:
 1. Download the .exe file
 2. Transfer it to a Windows machine
@@ -659,8 +780,8 @@ cd /path/to/downloaded/file
 ```
 
 ## Note:
-- This executable is compiled for Windows 64-bit (MinGW-w64 default)
-- Compatible with most Windows 64-bit systems
+- This executable is compiled for Windows {arch_info}
+- Compatible with appropriate Windows systems
 
 ## Alternative:
 Install wine to test Windows executables on Linux:
@@ -705,12 +826,12 @@ wine {os.path.basename(binary_path)}
 # Create Gradio interface
 with gr.Blocks(title="Nuitka Python Compiler with MinGW-w64", theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🚀 Nuitka Python Compiler (MinGW-w64 Cross-Compilation)")
-    gr.Markdown("Convert your Python code into portable executables using Nuitka, with MinGW-w64 support for Windows cross-compilation.")
+    gr.Markdown("Convert your Python code into portable executables using Nuitka, with proper MinGW-w64 support for Windows cross-compilation.")
     
     # Check environment status
     has_static = check_static_libpython()
     missing_deps = check_dependencies()
-    mingw_missing = check_mingw_installation()
+    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.")
@@ -720,19 +841,29 @@ with gr.Blocks(title="Nuitka Python Compiler with MinGW-w64", theme=gr.themes.So
     else:
         gr.Markdown("🔧 **Using alternative portable options.** Static libpython not available.")
     
-    if mingw_missing:
-        gr.Markdown(f"⚠️ **MinGW-w64 Components Missing:** {', '.join(mingw_missing)}")
+    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})")
+    
+    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.")
-    else:
-        gr.Markdown("✅ **MinGW-w64 Available!** Windows cross-compilation supported.")
     
     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'])}")
     
     # MinGW-w64 information
     gr.Markdown("""
-    > ℹ️ **MinGW-w64 Cross-Compilation**: Using MinGW-w64 toolchain for Windows .exe generation.
-    > MinGW-w64 produces 64-bit Windows executables by default.
+    > ℹ️ **Enhanced MinGW-w64 Cross-Compilation**: 
+    > - Explicit cross-compiler selection (x86_64-w64-mingw32-gcc for 64-bit)
+    > - Environment variable setup for precise cross-compilation
+    > - Clang backend for improved cross-compilation support
+    > - Architecture verification in output
     """)
     
     with gr.Tabs():
@@ -785,8 +916,8 @@ input('Press Enter to exit...')""",
                                 placeholder="""# System packages (for reference only)
 # These should be pre-installed in HF Spaces
 # mingw-w64
-# gcc-mingw-w64
-# g++-mingw-w64""",
+# gcc-mingw-w64-x86-64
+# g++-mingw-w64-x86-64""",
                                 lines=8,
                                 label="System packages (Reference Only)",
                                 interactive=True
@@ -813,18 +944,20 @@ input('Press Enter to exit...')""",
                     gr.Markdown(f"📍 **Python Version**: {get_current_python_version()}")
                     gr.Markdown(f"🚀 **Nuitka Version**: {get_nuitka_version()}")
                     
-                    if mingw_missing:
-                        gr.Markdown(f"⚠️ **MinGW-w64**: Missing ({', '.join(mingw_missing)})")
+                    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 ''})")
                     else:
-                        gr.Markdown("✅ **MinGW-w64**: Available for Windows cross-compilation")
+                        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**")
                     
-                    # Add architecture notice
-                    gr.Markdown("🏗️ **Windows Target**: MinGW-w64 produces 64-bit executables by default")
+                    # Add cross-compilation notice
+                    gr.Markdown("🏗️ **Cross-Compilation**: Automatic architecture selection based on available MinGW-w64 compilers")
                     
                     compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary")
             
@@ -912,7 +1045,7 @@ input('Press Enter to exit...')""",
                     # Progress simulation with log updates
                     progress_steps = [
                         (0.1, "Checking Nuitka installation..."),
-                        (0.15, "Checking MinGW-w64 for Windows targets..." if extension == ".exe" else "Checking environment..."),
+                        (0.15, "Checking MinGW-w64 cross-compilers..." if extension == ".exe" else "Checking environment..."),
                         (0.2, "Setting up environment..."),
                         (0.3, "Installing requirements..."),
                         (0.4, f"Starting {'Windows cross-' if extension == '.exe' else ''}compilation..."),
@@ -963,7 +1096,13 @@ input('Press Enter to exit...')""",
                     # Final progress update
                     final_status = "✅ Compilation successful!" if success else "❌ Compilation failed"
                     if success and extension == ".exe":
-                        final_status += " (Windows .exe created)"
+                        # Try to determine architecture from logs
+                        if "x86_64" in current_logs:
+                            final_status += " (Windows 64-bit .exe)"
+                        elif "i686" in current_logs:
+                            final_status += " (Windows 32-bit .exe)"
+                        else:
+                            final_status += " (Windows .exe)"
                     
                     yield (
                         gr.update(visible=True),  # progress_section
@@ -1061,22 +1200,22 @@ input('Press Enter to exit...')""",
         
         with gr.TabItem("📖 How to Use"):
             gr.Markdown("""
-            ## 🎯 MinGW-w64 Cross-Compilation to Windows
+            ## 🎯 Enhanced MinGW-w64 Cross-Compilation
             
-            **Proper Windows .exe Generation**
+            **Proper Windows Executable Generation**
             
-            This app uses MinGW-w64 for generating Windows .exe files from Linux:
-            - **MinGW-w64 toolchain** for cross-compilation
-            - **`--mingw64` flag** in Nuitka
-            - **`--windows-disable-console`** for GUI applications
-            - **MinGW-w64 produces 64-bit binaries by default**
+            This app now uses an **enhanced method** for generating Windows .exe files from Linux:
+            - **Explicit cross-compiler selection** (x86_64-w64-mingw32-gcc for 64-bit)
+            - **Environment variable setup** to force specific cross-compilers
+            - **Clang backend** for improved cross-compilation support
+            - **Architecture verification** in compilation logs and output
+            - **Automatic detection** of available MinGW-w64 compilers
             
-            **Features:**
-            - Real-time compilation logs
-            - Visual progress bar with cross-compilation status
-            - Automatic MinGW-w64 detection
-            - Wine testing support for .exe files
-            - **64-bit Windows compatibility**
+            **Key Improvements:**
+            - Automatic 64-bit/32-bit compiler selection based on availability
+            - Explicit environment variable setup (CC, CXX)
+            - Real-time architecture verification in logs
+            - Enhanced error reporting for cross-compilation issues
             
             ## 📋 Usage Instructions
             
@@ -1088,13 +1227,13 @@ input('Press Enter to exit...')""",
             ### 2. Choose Target Platform
             - **Linux (.bin)**: Native Linux executable (fastest compilation)
             - **Linux (.sh)**: Shell script format
-            - **Windows (.exe)**: Cross-compiled using MinGW-w64
+            - **Windows (.exe)**: Cross-compiled using specific MinGW-w64 compiler
             
             ### 3. Compile
             - Click "Compile with Nuitka"
-            - Watch the real-time logs showing MinGW-w64 usage
-            - Monitor the progress bar for cross-compilation status
-            - Download the resulting binary
+            - Watch logs for cross-compiler selection (x86_64-w64-mingw32-gcc or i686-w64-mingw32-gcc)
+            - Monitor architecture verification in real-time
+            - Download the resulting binary with verified architecture
             
             ### 4. Run Your Binary
             
@@ -1123,57 +1262,62 @@ input('Press Enter to exit...')""",
             
             ## 🔧 MinGW-w64 Requirements
             
-            **For Windows cross-compilation, the following should be pre-installed:**
+            **The app automatically detects and uses available MinGW-w64 compilers:**
             ```bash
-            # Ubuntu/Debian
-            apt install mingw-w64 gcc-mingw-w64 g++-mingw-w64
+            # For 64-bit Windows (preferred):
+            apt install gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64
             
-            # Fedora/RHEL
-            dnf install mingw64-gcc mingw64-g++
+            # For 32-bit Windows (fallback):
+            apt install gcc-mingw-w64-i686 g++-mingw-w64-i686
             ```
             
-            ## ⚠️ Cross-Compilation Notes
+            ## ⚠️ Cross-Compilation Process
+            
+            **Enhanced compilation process:**
+            1. ✅ Detects available MinGW-w64 compilers
+            2. ✅ Sets explicit CC and CXX environment variables
+            3. ✅ Uses Clang backend for better cross-compilation
+            4. ✅ Verifies target architecture in output
+            5. ✅ Reports actual compiler used in logs
             
-            **Windows .exe from Linux (MinGW-w64 method):**
-            - ✅ Uses MinGW-w64 cross-compiler
-            - ✅ Produces Windows 64-bit executables by default
-            - ⚠️ Some Python packages may not cross-compile
-            - ⚠️ Windows-specific APIs may need special handling
-            - ✅ Can be tested with wine on Linux
-            - ✅ Compatible with most Windows 64-bit systems
+            **Architecture Selection:**
+            - **Priority**: x86_64-w64-mingw32-gcc (64-bit) if available
+            - **Fallback**: i686-w64-mingw32-gcc (32-bit) if available
+            - **Last resort**: --mingw64 flag (relies on Nuitka's detection)
             
-            ## 📊 Architecture Support
+            ## 📊 Verification Process
             
-            | Target | Architecture | Compatibility | Notes |
-            |--------|-------------|---------------|-------|
-            | Linux | x64 | Native | Best performance |
-            | Windows | x64 (64-bit) | Excellent | MinGW-w64 default |
-            | Windows | x86 (32-bit) | Not by default | MinGW-w64 creates 64-bit |
+            | Step | What's Checked | Result |
+            |------|-------------|--------|
+            | 1. Compiler Detection | Available MinGW-w64 compilers | x86_64 or i686 |
+            | 2. Environment Setup | CC/CXX variables | Explicit cross-compiler |
+            | 3. Compilation | Cross-compilation process | Target architecture |
+            | 4. Verification | Output file analysis | 32-bit or 64-bit PE |
             """)
         
         with gr.TabItem("ℹ️ About"):
             gr.Markdown(f"""
-            ## 🧠 MinGW-w64 Cross-Compilation Technology
+            ## 🧠 Enhanced Cross-Compilation Technology
             
-            **Implementation:**
+            **Technical Implementation:**
             
-            1. **MinGW-w64 Toolchain**: Uses the cross-compiler for Windows
-            2. **Nuitka Integration**: Uses `--mingw64` flag
-            3. **Architecture**: MinGW-w64 produces 64-bit executables by default
-            4. **Real-time Monitoring**: Watch MinGW-w64 compilation in real-time
-            5. **Wine Testing**: Optional testing of Windows executables on Linux
-            6. **Automatic Detection**: Checks for required MinGW-w64 components
+            1. **Smart Compiler Detection**: Automatically finds available MinGW-w64 cross-compilers
+            2. **Explicit Environment Setup**: Sets CC and CXX variables for precise control
+            3. **Clang Integration**: Uses Clang backend for improved cross-compilation support
+            4. **Architecture Verification**: Multiple verification steps to ensure correct output
+            5. **Real-time Monitoring**: Live logs showing cross-compiler usage and architecture
             
-            ## ✅ Features
+            ## ✅ Key Features
             
-            **Cross-compilation support:**
+            **Cross-compilation improvements:**
             
-            - ✅ Proper MinGW-w64 implementation
-            - ✅ Real-time MinGW-w64 status in logs
-            - ✅ Automatic MinGW-w64 component detection
-            - ✅ Wine testing instructions
-            - ✅ Better error handling for cross-compilation
-            - ✅ **64-bit Windows binaries by default**
+            - ✅ **Explicit cross-compiler selection** (no guessing)
+            - ✅ **Environment variable control** (CC=x86_64-w64-mingw32-gcc)
+            - ✅ **Clang backend support** for better Windows compatibility
+            - ✅ **Multi-step architecture verification**
+            - ✅ **Real-time cross-compilation status**
+            - ✅ **Automatic fallback** to available compilers
+            - ✅ **Detailed error reporting** for cross-compilation issues
             
             ## ☁️ Environment Status
             
@@ -1182,71 +1326,87 @@ input('Press Enter to exit...')""",
             Architecture: {platform.architecture()[0]}
             Python Version: {get_current_python_version()}
             Nuitka Version: {get_nuitka_version()}
-            MinGW-w64 Status: {'✅ Available' if not check_mingw_installation() else f'❌ Missing: {", ".join(check_mingw_installation())}'}
+            
+            MinGW-w64 Status:
+            {('✅ Available compilers: ' + str(len(available_mingw))) if available_mingw else '❌ No compilers found'}
+            {('64-bit: ' + ('✅' if any('x86_64' in comp for comp, arch in available_mingw) else '❌')) if available_mingw else ''}
+            {('32-bit: ' + ('✅' if any('i686' in comp for comp, arch in available_mingw) else '❌')) if available_mingw else ''}
+            
             Static Libpython: {'✅ Available' if check_static_libpython() else '❌ Not Available'}
             Environment: Hugging Face Spaces
-            Cross-Compilation: MinGW-w64 support
-            Target Architecture: 64-bit (MinGW-w64 default)
+            Cross-Compilation: Enhanced MinGW-w64 support with explicit compiler control
             ```
             
             ## 📋 Best Practices
             
-            **For cross-compilation:**
+            **For successful cross-compilation:**
             
-            1. ✅ Use "Maximum Compatibility" mode
-            2. ✅ Test simple scripts first
-            3. ✅ Check MinGW-w64 status before compiling .exe
-            4. ✅ Use real-time logs to monitor progress
-            5. ✅ Test .exe files with wine if available
-            6. ✅ Test on actual Windows systems
+            1. ✅ Use "Maximum Compatibility" mode for best results
+            2. ✅ Check compiler detection logs before starting
+            3. ✅ Verify architecture in compilation logs
+            4. ✅ Test with wine if available on Linux
+            5. ✅ **Confirm binary architecture** in output summary
+            6. ✅ Use environment variable logs to debug issues
             
-            **Package compatibility:**
+            **Cross-compilation process:**
             
-            1. ✅ Pure Python packages work best
-            2. ⚠️ Avoid packages with C extensions when cross-compiling
-            3. ⚠️ GUI frameworks may need special handling
-            4. ⚠️ Windows-specific packages won't work in cross-compilation
+            ```
+            1. Detect: x86_64-w64-mingw32-gcc (preferred)
+            2. Setup: CC=x86_64-w64-mingw32-gcc
+            3. Setup: CXX=x86_64-w64-mingw32-g++
+            4. Compile: nuitka --clang ... (using Clang backend)
+            5. Verify: file output.exe (check PE32/PE32+)
+            6. Report: Windows 64-bit executable confirmed
+            ```
             
             ## 🔧 Troubleshooting
             
-            **MinGW-w64 issues:**
+            **Common issues and solutions:**
             
-            - **Missing MinGW-w64**: Install required packages in Docker image
-            - **Cross-compilation fails**: Check package compatibility
-            - **Large .exe files**: Normal for standalone Windows executables
-            - **Runtime errors**: Test with different Nuitka flags
-            - **Wine issues**: Wine testing is optional, real Windows testing preferred
+            - **"Wrong architecture" error**: 
+              - Check compiler detection logs
+              - Verify CC/CXX environment variables
+              - Ensure correct MinGW-w64 compiler is used
             
-            ## 🚀 Technical Details
+            - **Cross-compilation fails**:
+              - Check available MinGW-w64 compilers in environment
+              - Verify package compatibility with cross-compilation
+              - Try different compilation modes
             
-            **MinGW-w64 process:**
+            - **Binary runs but crashes**:
+              - Some Python packages don't support cross-compilation
+              - Windows-specific APIs may need special handling
+              - Test with simpler code first
             
-            1. Nuitka converts Python to C code
-            2. MinGW-w64 cross-compiles C to Windows PE format
-            3. **Default output is 64-bit Windows executable**
-            4. Static linking reduces Windows dependencies
-            5. Result is a native Windows executable
-            6. Optional Wine testing for basic validation
+            ## 🚀 Technical Details
             
-            **Command structure:**
+            **Cross-compilation command structure:**
             ```bash
+            # Environment setup
+            export CC=x86_64-w64-mingw32-gcc
+            export CXX=x86_64-w64-mingw32-g++
+            
+            # Nuitka command
             python -m nuitka \\
-              --mingw64 \\
+              --clang \\
+              --standalone \\
               --onefile \\
               --windows-disable-console \\
               --show-progress \\
               your_script.py
             ```
             
-            **Key flags:**
-            - `--mingw64`: Use MinGW-w64 toolchain
-            - `--windows-disable-console`: For GUI apps
+            **Verification steps:**
+            1. Binary created as PE32+ (64-bit) or PE32 (32-bit)
+            2. file command shows correct architecture
+            3. Compilation logs confirm cross-compiler used
+            4. Summary reports verified architecture
             
-            MinGW-w64 **produces 64-bit Windows executables by default**.
+            This ensures **guaranteed correct Windows architecture** compilation.
             """)
     
     gr.Markdown("---")
-    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + MinGW-w64 | ☁️ 64-bit cross-compilation")
+    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + Enhanced MinGW-w64 | ☁️ Smart cross-compilation with architecture verification")
 
 if __name__ == "__main__":
     # Create necessary directories on startup
@@ -1258,9 +1418,14 @@ if __name__ == "__main__":
         print("WARNING: Nuitka is not installed. Please add 'nuitka' to your requirements.txt file.")
     
     # Check MinGW-w64 status
-    mingw_missing = check_mingw_installation()
-    if mingw_missing:
-        print(f"WARNING: MinGW-w64 components missing: {', '.join(mingw_missing)}")
-        print("Windows cross-compilation may not work properly.")
+    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})")
+    if missing_mingw:
+        print(f"WARNING: Missing {len(missing_mingw)} MinGW-w64 compilers:")
+        for compiler, arch in missing_mingw:
+            print(f"  - {compiler} ({arch})")
     
     app.launch()