Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/MainProgram.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* The main program for a compiled program.
  *
  * It needs to prepare the interpreter and then loads and executes
@@ -23,7 +8,7 @@
  * For multiprocessing, joblib, loky there is things here that will
  * allow them to fork properly with their intended entry points.
  *
- * spell-checker: ignore joblib loky
+ * spell-checker: ignore joblib loky anyio platlibdir
  *
  */
 
@@ -47,10 +32,10 @@
 #define SYSFLAG_BYTES_WARNING 0
 #define SYSFLAG_UTF8 0
 #define SYSFLAG_UNBUFFERED 0
-#endif
-
-#ifndef NUITKA_MAIN_MODULE_NAME
+#define SYSFLAG_DONTWRITEBYTECODE 0
 #define NUITKA_MAIN_MODULE_NAME "__main__"
+#define NUITKA_MAIN_IS_PACKAGE_BOOL false
+#define _NUITKA_ATTACH_CONSOLE_WINDOW 1
 #endif
 
 // It doesn't work for MinGW64 to update the standard output handles early on,
@@ -65,7 +50,11 @@
 #define NUITKA_STANDARD_HANDLES_EARLY 0
 #endif
 
-extern PyCodeObject *codeobj_main;
+#if defined(_WIN32) && (defined(_NUITKA_ATTACH_CONSOLE_WINDOW) || defined(_NUITKA_HIDE_CONSOLE_WINDOW))
+#include "HelpersConsole.c"
+#endif
+
+extern PyCodeObject *code_objects_main;
 
 /* For later use in "Py_GetArgcArgv" we expose the needed value  */
 #if PYTHON_VERSION >= 0x300
@@ -79,13 +68,13 @@ static int orig_argc;
 extern void copyFrozenModulesTo(struct _frozen *destination);
 
 // The original frozen modules list.
-#if PYTHON_VERSION < 0x340
+#if PYTHON_VERSION < 0x300
 static struct _frozen *old_frozen = NULL;
 #else
 static struct _frozen const *old_frozen = NULL;
 #endif
 
-static void prepareFrozenModules() {
+static void prepareFrozenModules(void) {
     // Tell the CPython library to use our pre-compiled modules as frozen
     // modules. This for those modules/packages like "encoding" that will be
     // loaded during "Py_Initialize" already, for the others they may be
@@ -118,112 +107,7 @@ static void prepareFrozenModules() {
 }
 #endif
 
-#if SYSFLAG_NO_RANDOMIZATION == 1 || SYSFLAG_UNBUFFERED == 1 || defined(_NUITKA_STANDALONE)
-
-#if defined(_WIN32)
-#define environment_char_t wchar_t
-
-static environment_char_t const *getEnvironmentVariable(char const *name) {
-    // Max size for environment variables according to docs.
-    wchar_t buffer[32768];
-    buffer[0] = 0;
-
-    wchar_t name_wide[40];
-    name_wide[0] = 0;
-    appendStringSafeW(name_wide, name, sizeof(name_wide) / sizeof(wchar_t));
-
-    // Size must be in bytes apparently, not in characters. Cannot be larger anyway.
-    DWORD res = GetEnvironmentVariableW(name_wide, buffer, 65536);
-
-    if (res == 0 || res > sizeof(buffer)) {
-        return NULL;
-    }
-
-    return wcsdup(buffer);
-}
-
-static void setEnvironmentVariable(char const *name, environment_char_t const *value) {
-    assert(name != NULL);
-    assert(value != NULL);
-
-    wchar_t name_wide[40];
-    name_wide[0] = 0;
-    appendStringSafeW(name_wide, name, sizeof(name_wide) / sizeof(wchar_t));
-
-    DWORD res = SetEnvironmentVariableW(name_wide, value);
-    assert(wcscmp(getEnvironmentVariable(name), value) == 0);
-
-    assert(res != 0);
-}
-
-static void unsetEnvironmentVariable(char const *name) {
-    wchar_t name_wide[40];
-    name_wide[0] = 0;
-    appendStringSafeW(name_wide, name, sizeof(name_wide) / sizeof(wchar_t));
-
-    DWORD res = SetEnvironmentVariableW(name_wide, NULL);
-
-    assert(res != 0);
-}
-
-#define makeEnvironmentLiteral(x) L##x
-
-#else
-#define environment_char_t char
-
-#define makeEnvironmentLiteral(x) x
-
-static environment_char_t const *getEnvironmentVariable(char const *name) { return getenv(name); }
-
-static void setEnvironmentVariable(char const *name, environment_char_t const *value) { setenv(name, value, 1); }
-
-static void unsetEnvironmentVariable(char const *name) { unsetenv(name); }
-
-#endif
-
-static void undoEnvironmentVariable(PyThreadState *tstate, char const *variable_name,
-                                    environment_char_t const *old_value) {
-    PyObject *os_module = IMPORT_HARD_OS();
-    CHECK_OBJECT(os_module);
-
-    PyObject *os_environ = PyObject_GetAttrString(os_module, "environ");
-    CHECK_OBJECT(os_environ);
-
-    PyObject *variable_name_str = Nuitka_String_FromString(variable_name);
-    CHECK_OBJECT(variable_name_str);
-
-    if (old_value) {
-        setEnvironmentVariable(variable_name, old_value);
-
-#ifdef _WIN32
-        PyObject *env_value = NuitkaUnicode_FromWideChar(old_value, -1);
-#else
-        PyObject *env_value = Nuitka_String_FromString(old_value);
-#endif
-        CHECK_OBJECT(env_value);
-
-        int res = PyObject_SetItem(os_environ, variable_name_str, env_value);
-
-        if (unlikely(res != 0)) {
-            PyErr_PrintEx(1);
-            Py_Exit(1);
-        }
-
-        Py_DECREF(env_value);
-    } else {
-        unsetEnvironmentVariable(variable_name);
-
-        int res = PyObject_DelItem(os_environ, variable_name_str);
-
-        if (unlikely(res != 0)) {
-            CLEAR_ERROR_OCCURRED(tstate);
-        }
-    }
-
-    Py_DECREF(variable_name_str);
-    Py_DECREF(os_environ);
-}
-#endif
+#include "nuitka/environment_variables.h"
 
 #ifdef _NUITKA_STANDALONE
 
@@ -313,7 +197,7 @@ extern void _initCompiledFrameType();
 static wchar_t **convertCommandLineParameters(int argc, char **argv) {
     // Originally taken from CPython3: There seems to be no sane way to use
     static wchar_t **argv_copy;
-    argv_copy = (wchar_t **)PyMem_MALLOC(sizeof(wchar_t *) * argc);
+    argv_copy = (wchar_t **)malloc(sizeof(wchar_t *) * argc);
 
     // Temporarily disable locale for conversions to not use it.
     char *old_locale = strdup(setlocale(LC_ALL, NULL));
@@ -344,6 +228,11 @@ static void PRINT_REFCOUNTS(void) {
 
     PRINT_STRING("REFERENCE counts at program end:\n");
     PRINT_STRING("active | allocated | released\n");
+    PRINT_FORMAT("Compiled Functions: %d | %d | %d (module/class ownership may occur)\n",
+                 count_active_Nuitka_Function_Type, count_allocated_Nuitka_Function_Type,
+                 count_released_Nuitka_Function_Type);
+    PRINT_FORMAT("Compiled Generators: %d | %d | %d\n", count_active_Nuitka_Generator_Type,
+                 count_allocated_Nuitka_Generator_Type, count_released_Nuitka_Generator_Type);
 #if PYTHON_VERSION >= 0x350
     PRINT_FORMAT("Compiled Coroutines: %d | %d | %d\n", count_active_Nuitka_Coroutine_Type,
                  count_allocated_Nuitka_Coroutine_Type, count_released_Nuitka_Coroutine_Type);
@@ -366,6 +255,8 @@ static void PRINT_REFCOUNTS(void) {
 
     PRINT_FORMAT("Compiled Frames: %d | %d | %d (cache usage may occur)\n", count_active_Nuitka_Frame_Type,
                  count_allocated_Nuitka_Frame_Type, count_released_Nuitka_Frame_Type);
+    PRINT_FORMAT("Compiled Cells: %d | %d | %d (function ownership may occur)\n", count_active_Nuitka_Cell_Type,
+                 count_allocated_Nuitka_Cell_Type, count_released_Nuitka_Cell_Type);
     PRINT_STRING("CACHED counts at program end:\n");
     PRINT_STRING("active | allocated | released | hits\n");
     PRINT_FORMAT("Cached Frames: %d | %d | %d | %d\n", count_active_frame_cache_instances,
@@ -374,17 +265,16 @@ static void PRINT_REFCOUNTS(void) {
 }
 #endif
 
-static int HANDLE_PROGRAM_EXIT(void) {
+static int HANDLE_PROGRAM_EXIT(PyThreadState *tstate) {
 #if _DEBUG_REFCOUNTS
     PRINT_REFCOUNTS();
 #endif
 
     int exit_code;
 
-    PyThreadState *tstate = PyThreadState_GET();
-
     if (HAS_ERROR_OCCURRED(tstate)) {
-#if PYTHON_VERSION >= 0x300
+        // TODO: Clarify which versions this applies to still
+#if PYTHON_VERSION >= 0x300 && PYTHON_VERSION < 0x3c0
         /* Remove the frozen importlib traceback part, which would not be compatible. */
 
         while (tstate->curexc_traceback) {
@@ -402,6 +292,7 @@ static int HANDLE_PROGRAM_EXIT(void) {
             break;
         }
 #endif
+        NUITKA_FINALIZE_PROGRAM(tstate);
 
         PyErr_PrintEx(0);
 
@@ -413,13 +304,10 @@ static int HANDLE_PROGRAM_EXIT(void) {
     return exit_code;
 }
 
-static PyObject *EXECUTE_MAIN_MODULE(char const *module_name) {
+static PyObject *EXECUTE_MAIN_MODULE(PyThreadState *tstate, char const *module_name, bool is_package) {
     NUITKA_INIT_PROGRAM_LATE(module_name);
 
-    PyThreadState *tstate = PyThreadState_GET();
-
-#if NUITKA_MAIN_PACKAGE_MODE
-    {
+    if (is_package) {
         char const *w = module_name;
 
         for (;;) {
@@ -442,25 +330,27 @@ static PyObject *EXECUTE_MAIN_MODULE(char const *module_name) {
             }
         }
     }
-#endif
 
     return IMPORT_EMBEDDED_MODULE(tstate, module_name);
 }
 
-#ifdef _NUITKA_PLUGIN_WINDOWS_SERVICE_ENABLED
+#if _NUITKA_PLUGIN_WINDOWS_SERVICE_ENABLED
 #include "nuitka_windows_service.h"
 
 // Callback from Windows Service logic.
-bool SvcStartPython(void) {
-    EXECUTE_MAIN_MODULE(NUITKA_MAIN_MODULE_NAME);
-
+void SvcStartPython(void) {
     PyThreadState *tstate = PyThreadState_GET();
 
-    if (HAS_ERROR_OCCURRED(tstate)) {
-        return true;
-    } else {
-        return false;
-    }
+    EXECUTE_MAIN_MODULE(tstate, NUITKA_MAIN_MODULE_NAME, NUITKA_MAIN_IS_PACKAGE_BOOL);
+
+    NUITKA_PRINT_TIMING("SvcStartPython() Python exited.")
+
+    int exit_code = HANDLE_PROGRAM_EXIT(tstate);
+
+    // TODO: Log exception and call ReportSvcStatus
+
+    NUITKA_PRINT_TIMING("SvcStartPython(): Calling Py_Exit.");
+    Py_Exit(exit_code);
 }
 
 void SvcStopPython(void) { PyErr_SetInterrupt(); }
@@ -473,107 +363,127 @@ static bool is_multiprocessing_fork = false;
 static int multiprocessing_resource_tracker_arg = -1;
 
 // This is a joblib loky fork
+#ifdef _WIN32
+static bool is_joblib_popen_loky_win32 = false;
+static int loky_joblib_pipe_handle_arg = 0;
+static int loky_joblib_parent_pid_arg = 0;
+#else
 static bool is_joblib_popen_loky_posix = false;
+#endif
+
 // This is a joblib resource tracker if not -1
 static int loky_resource_tracker_arg = -1;
 
-// Parse the command line parameters and provide it to "sys" built-in module,
-// as well as decide if it's a multiprocessing usage.
+// This is a "anyio.to_process" fork
+static bool is_anyio_to_process = false;
+
+// Parse the command line parameters to decide if it's a multiprocessing usage
+// or something else special.
 #if _NUITKA_NATIVE_WCHAR_ARGV == 0
-static void setCommandLineParameters(int argc, char **argv, bool initial) {
+static void setCommandLineParameters(int argc, char **argv) {
 #else
-static void setCommandLineParameters(int argc, wchar_t **argv, bool initial) {
+static void setCommandLineParameters(int argc, wchar_t **argv) {
 #endif
-    if (initial) {
 #ifdef _NUITKA_EXPERIMENTAL_DEBUG_SELF_FORKING
 #if _NUITKA_NATIVE_WCHAR_ARGV == 0
-        printf("Commandline: ");
-        for (int i = 0; i < argc; i++) {
-            if (i != 0) {
-                printf(" ");
-            }
-            printf("'%s'", argv[i]);
+    printf("Command line: ");
+    for (int i = 0; i < argc; i++) {
+        if (i != 0) {
+            printf(" ");
         }
-        printf("\n");
+        printf("'%s'", argv[i]);
+    }
+    printf("\n");
 #else
-        wprintf(L"Commandline: '%lS' %d\n", GetCommandLineW(), argc);
+    wprintf(L"Command line: '%lS' %d\n", GetCommandLineW(), argc);
 #endif
 #endif
 
-        // We might need to handle special parameters from plugins that are
-        // very deeply woven into command line handling. These are right now
-        // multiprocessing, which indicates that it's forking via extra
+    // We might need to handle special parameters from plugins that are
+    // very deeply woven into command line handling. These are right now
+    // multiprocessing, which indicates that it's forking via extra
 
-        // command line argument. And Windows Service indicates need to
-        //   install and exit here too.
+    // command line argument. And Windows Service indicates need to
+    //   install and exit here too.
 
-        for (int i = 1; i < argc; i++) {
-            if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "--multiprocessing-fork")) == 0) {
-                is_multiprocessing_fork = true;
-                break;
-            }
+    for (int i = 1; i < argc; i++) {
+        if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "--multiprocessing-fork")) == 0) {
+            is_multiprocessing_fork = true;
+            break;
+        }
 
-            if ((i + 1 < argc) &&
-                (strcmpFilename(argv[i], FILENAME_EMPTY_STR "--multiprocessing-resource-tracker")) == 0) {
+        if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "--multiprocessing-resource-tracker")) == 0) {
 #if _NUITKA_NATIVE_WCHAR_ARGV == 0
-                multiprocessing_resource_tracker_arg = atoi(argv[i + 1]);
+            multiprocessing_resource_tracker_arg = atoi(argv[i + 1]);
 #else
-                multiprocessing_resource_tracker_arg = _wtoi(argv[i + 1]);
+            multiprocessing_resource_tracker_arg = _wtoi(argv[i + 1]);
 #endif
-                break;
-            }
+            break;
+        }
 
-            if (i == 1) {
-#ifdef _NUITKA_PLUGIN_WINDOWS_SERVICE_ENABLED
-                if (strcmpFilename(argv[i], FILENAME_EMPTY_STR "install") == 0) {
-                    NUITKA_PRINT_TRACE("main(): Calling plugin SvcInstall().");
+        if (i == 1) {
+#if _NUITKA_PLUGIN_WINDOWS_SERVICE_ENABLED
+            if (strcmpFilename(argv[i], FILENAME_EMPTY_STR "install") == 0) {
+                NUITKA_PRINT_TRACE("main(): Calling plugin SvcInstall().");
 
-                    SvcInstall();
-                    NUITKA_CANNOT_GET_HERE("SvcInstall must not return");
-                }
+                SvcInstall();
+                NUITKA_CANNOT_GET_HERE("main(): SvcInstall must not return");
+            }
 #endif
+        }
+
+        if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-c") == 0)) {
+            // The joblib loky resource tracker is launched like this.
+            if (scanFilename(argv[i + 1],
+                             FILENAME_EMPTY_STR
+                             "from joblib.externals.loky.backend.resource_tracker import main; main(%i, False)",
+                             &loky_resource_tracker_arg)) {
+                break;
             }
 
-            if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-c") == 0)) {
-                // The joblib loky resource tracker is launched like this.
-#if _NUITKA_NATIVE_WCHAR_ARGV == 0
-                int res = sscanf(argv[i + 1],
-                                 "from joblib.externals.loky.backend.resource_tracker import main; main(%i, False)",
-                                 &loky_resource_tracker_arg);
-#else
-                int res = swscanf(argv[i + 1],
-                                  L"from joblib.externals.loky.backend.resource_tracker import main; main(%i, False)",
-                                  &loky_resource_tracker_arg);
-#endif
-                if (res == 1) {
-                    break;
-                }
+#if defined(_WIN32)
+            if (strcmpFilename(argv[i + 1], FILENAME_EMPTY_STR
+                               "from joblib.externals.loky.backend.popen_loky_win32 import main; main()") == 0) {
+                is_joblib_popen_loky_win32 = true;
+                break;
             }
 
-            if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-m") == 0)) {
-                // The joblib loky posix popen is launching like this.
-                if (strcmpFilename(argv[i + 1], FILENAME_EMPTY_STR "joblib.externals.loky.backend.popen_loky_posix") ==
-                    0) {
-                    is_joblib_popen_loky_posix = true;
-                    break;
-                }
+            if (scanFilename(argv[i + 1],
+                             FILENAME_EMPTY_STR "from joblib.externals.loky.backend.popen_loky_win32 import main; "
+                                                "main(pipe_handle=%i, parent_pid=%i)",
+                             &loky_joblib_pipe_handle_arg, &loky_joblib_parent_pid_arg)) {
+                is_joblib_popen_loky_win32 = true;
+                break;
             }
 
-#if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_SELF_EXECUTION)
-            if ((strcmpFilename(argv[i], FILENAME_EMPTY_STR "-c") == 0) ||
-                (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-m") == 0)) {
-                fprintf(stderr,
-                        "Error, the program tried to call itself with '" FILENAME_FORMAT_STR "' argument. Disable with "
-                        "'--no-deployment-flag=self-execution'.\n",
-                        argv[i]);
-                exit(2);
+#endif
+        }
+
+        if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-m") == 0)) {
+#if !defined(_WIN32)
+            // The joblib loky posix popen is launching like this.
+            if (strcmpFilename(argv[i + 1], FILENAME_EMPTY_STR "joblib.externals.loky.backend.popen_loky_posix") == 0) {
+                is_joblib_popen_loky_posix = true;
+                break;
             }
 #endif
+
+            // The anyio.to_process module is launching like this.
+            if (strcmpFilename(argv[i + 1], FILENAME_EMPTY_STR "anyio.to_process") == 0) {
+                is_anyio_to_process = true;
+                break;
+            }
         }
 
-#ifdef _NUITKA_EXPERIMENTAL_DEBUG_SELF_FORKING
-        assert(argc == 1 || is_multiprocessing_fork || is_joblib_popen_loky_posix || loky_resource_tracker_arg != -1 ||
-               multiprocessing_resource_tracker_arg != -1);
+#if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_SELF_EXECUTION)
+        if ((strcmpFilename(argv[i], FILENAME_EMPTY_STR "-c") == 0) ||
+            (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-m") == 0)) {
+            fprintf(stderr,
+                    "Error, the program tried to call itself with '" FILENAME_FORMAT_STR "' argument. Disable with "
+                    "'--no-deployment-flag=self-execution'.\n",
+                    argv[i]);
+            exit(2);
+        }
 #endif
     }
 }
@@ -826,6 +736,10 @@ static bool shallSetOutputHandleToNull(char const *name) {
     if (strcmp(name, "stderr") == 0) {
         return true;
     }
+#elif defined(NUITKA_FORCED_STDERR_PATH) || defined(NUITKA_FORCED_STDERR_NONE_BOOL)
+    if (strcmp(name, "stderr") == 0) {
+        return false;
+    }
 #endif
 
     PyObject *sys_std_handle = Nuitka_SysGetObject(name);
@@ -909,44 +823,51 @@ static void setInputOutputHandles(PyThreadState *tstate) {
 // better, and force it to utf-8, it often becomes platform IO for no good
 // reason.
 #if NUITKA_STANDARD_HANDLES_EARLY == 1 && PYTHON_VERSION >= 0x370
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Early handles.");
 #if defined(NUITKA_FORCED_STDOUT_PATH) || defined(NUITKA_FORCED_STDERR_PATH)
-    PyObject *args = MAKE_DICT_EMPTY();
+    PyObject *args = MAKE_DICT_EMPTY(tstate);
 
     DICT_SET_ITEM(args, const_str_plain_encoding, Nuitka_String_FromString("utf-8"));
     DICT_SET_ITEM(args, const_str_plain_line_buffering, Py_True);
 
 #if defined(NUITKA_FORCED_STDOUT_PATH)
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forced stdout update.");
     {
         PyObject *sys_stdout = Nuitka_SysGetObject("stdout");
 
         PyObject *method = LOOKUP_ATTRIBUTE(tstate, sys_stdout, const_str_plain_reconfigure);
         CHECK_OBJECT(method);
 
-        PyObject *result = CALL_FUNCTION_WITH_KEYARGS(tstate, method, args);
+        PyObject *result = CALL_FUNCTION_WITH_KW_ARGS(tstate, method, args);
         CHECK_OBJECT(result);
     }
 #endif
 
 #if defined(NUITKA_FORCED_STDERR_PATH)
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forced stderr update.");
     {
         PyObject *sys_stderr = Nuitka_SysGetObject("stderr");
+        if (sys_stderr != Py_None) {
+            PyObject *method = LOOKUP_ATTRIBUTE(tstate, sys_stderr, const_str_plain_reconfigure);
+            CHECK_OBJECT(method);
 
-        PyObject *method = LOOKUP_ATTRIBUTE(tstate, sys_stderr, const_str_plain_reconfigure);
-        CHECK_OBJECT(method);
-
-        PyObject *result = CALL_FUNCTION_WITH_KEYARGS(tstate, method, args);
-        CHECK_OBJECT(result);
+            PyObject *result = CALL_FUNCTION_WITH_KW_ARGS(tstate, method, args);
+            CHECK_OBJECT(result);
+        }
     }
 #endif
 
     Py_DECREF(args);
 #endif
+
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Done with early handles.");
 #endif
 
 #if NUITKA_STANDARD_HANDLES_EARLY == 0
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Late handles.");
 #if defined(NUITKA_FORCED_STDOUT_PATH)
     {
-#ifdef _WIN32
+#if defined(_WIN32)
         PyObject *filename = getExpandedTemplatePath(L"" NUITKA_FORCED_STDOUT_PATH);
 #else
         PyObject *filename = getExpandedTemplatePath(NUITKA_FORCED_STDOUT_PATH);
@@ -957,7 +878,7 @@ static void setInputOutputHandles(PyThreadState *tstate) {
             Py_Exit(1);
         }
 
-        setStdoutHandle(stdout_file);
+        setStdoutHandle(tstate, stdout_file);
     }
 #endif
 
@@ -974,7 +895,7 @@ static void setInputOutputHandles(PyThreadState *tstate) {
             Py_Exit(1);
         }
 
-        setStderrHandle(stderr_file);
+        setStderrHandle(tstate, stderr_file);
     }
 #endif
 #endif
@@ -986,22 +907,37 @@ static void setInputOutputHandles(PyThreadState *tstate) {
         PyObject *devnull_filename = Nuitka_String_FromString("/dev/null");
 #endif
 
+        NUITKA_PRINT_TRACE("setInputOutputHandles(): Considering stdin.");
+
         if (shallSetOutputHandleToNull("stdin")) {
+            NUITKA_PRINT_TRACE("setInputOutputHandles(): Set stdin to NULL file.");
+
             // CPython core requires stdin to be buffered due to methods usage, and it won't matter
             // here much.
             PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "r", true, encoding);
+            CHECK_OBJECT(stdin_file);
 
             setStdinHandle(tstate, stdin_file);
         }
 
+        NUITKA_PRINT_TRACE("setInputOutputHandles(): Considering stdout.");
+
         if (shallSetOutputHandleToNull("stdout")) {
+            NUITKA_PRINT_TRACE("setInputOutputHandles(): Set stdout to NULL file.");
+
             PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding);
+            CHECK_OBJECT(stdout_file);
 
             setStdoutHandle(tstate, stdout_file);
         }
 
+        NUITKA_PRINT_TRACE("setInputOutputHandles(): Considering stderr.");
+
         if (shallSetOutputHandleToNull("stderr")) {
+            NUITKA_PRINT_TRACE("setInputOutputHandles(): Set stderr to NULL file.");
+
             PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding);
+            CHECK_OBJECT(stderr_file);
 
             setStderrHandle(tstate, stderr_file);
         }
@@ -1010,27 +946,36 @@ static void setInputOutputHandles(PyThreadState *tstate) {
     }
 
 #if NUITKA_FORCED_STDOUT_NONE_BOOL
-    setStdoutHandle(Py_None);
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forcing stdout to None.");
+    setStdoutHandle(tstate, Py_None);
 #endif
 
 #if NUITKA_FORCED_STDERR_NONE_BOOL
-    setStderrHandle(Py_None);
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forcing stderr to None.");
+    setStderrHandle(tstate, Py_None);
 #endif
 
     Py_XDECREF(encoding);
 }
 
 static void Nuitka_Py_Initialize(void) {
+#if PYTHON_VERSION > 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+    initNuitkaAllocators();
+#endif
+
 #if PYTHON_VERSION < 0x380 || defined(_NUITKA_EXPERIMENTAL_OLD_PY_INITIALIZE)
     Py_Initialize();
 #else
+#if PYTHON_VERSION < 0x3d0
     PyStatus status = _PyRuntime_Initialize();
     if (unlikely(status._type != 0)) {
         Py_ExitStatusException(status);
     }
-    _PyRuntimeState *runtime = &_PyRuntime;
-
+    NUITKA_MAY_BE_UNUSED _PyRuntimeState *runtime = &_PyRuntime;
     assert(!runtime->initialized);
+#else
+    PyStatus status;
+#endif
 
     PyConfig config;
     _PyConfig_InitCompatConfig(&config);
@@ -1059,6 +1004,25 @@ static void Nuitka_Py_Initialize(void) {
     config.module_search_paths_set = 1;
 #endif
 
+    // Need to disable frozen modules, Nuitka can handle them better itself.
+#if PYTHON_VERSION >= 0x3b0
+#ifdef _NUITKA_STANDALONE
+    config.use_frozen_modules = 0;
+#else
+// Emulate PYTHON_FROZEN_MODULES for accelerated mode, it is only added in 3.13,
+// but we need to control it for controlling things for accelerated binaries
+// too.
+#if PYTHON_VERSION >= 0x3b0 && PYTHON_VERSION <= 0x3d0
+    environment_char_t const *frozen_modules_env = getEnvironmentVariable("PYTHON_FROZEN_MODULES");
+
+    if (frozen_modules_env == NULL ||
+        (compareEnvironmentString(frozen_modules_env, makeEnvironmentLiteral("off")) == 0)) {
+        config.use_frozen_modules = 0;
+    }
+#endif
+#endif
+#endif
+
     config.install_signal_handlers = 1;
 
     NUITKA_PRINT_TIMING("Nuitka_Py_Initialize(): Calling Py_InitializeFromConfig.");
@@ -1089,23 +1053,13 @@ static void Nuitka_Py_Initialize(void) {
 static void changeStandardHandleTarget(int std_handle_id, FILE *std_handle, filename_char_t const *template_path) {
     filename_char_t filename_buffer[1024];
 
-    // TODO: We should only have one that works with filename_char_t rather than having
-    // to make a difference here.
-#ifdef _WIN32
-    bool res = expandTemplatePathW(filename_buffer, template_path, sizeof(filename_buffer) / sizeof(filename_char_t));
-
-    if (res == false) {
-        wprintf(L"Error, couldn't expand pattern '%lS'\n", template_path);
-        abort();
-    }
-#else
-    bool res = expandTemplatePath(filename_buffer, template_path, sizeof(filename_buffer) / sizeof(filename_char_t));
+    bool res =
+        expandTemplatePathFilename(filename_buffer, template_path, sizeof(filename_buffer) / sizeof(filename_char_t));
 
     if (res == false) {
-        printf("Error, couldn't expand pattern: '%s'\n", template_path);
+        printf("Error, couldn't expand pattern '" FILENAME_FORMAT_STR "'\n", template_path);
         abort();
     }
-#endif
 
     if (GetStdHandle(std_handle_id) == 0) {
         FILE *file_handle;
@@ -1154,12 +1108,11 @@ static void changeStandardHandleTarget(int std_handle_id, FILE *std_handle, file
             abort();
         }
 
-        int int_res = dup2(os_handle, fileno(std_handle));
+        int _int_res = dup2(os_handle, fileno(std_handle));
 
-        // Without a console, this is normal.
-        if (int_res == -1) {
-            perror("_open_osfhandle");
-            abort();
+        if (_int_res == -1) {
+            // Note: Without a console, this is normal to get no file number to
+            // work with.
         }
 
         close(os_handle);
@@ -1195,6 +1148,41 @@ static void changeStandardHandleTarget(FILE *std_handle, filename_char_t const *
 #endif
 #endif
 
+#if defined(_NUITKA_EXPERIMENTAL_SHOW_STARTUP_TIME)
+static void Nuitka_at_exit(void) { NUITKA_PRINT_TIMING("Nuitka_at_exit(): Called by C exit()"); }
+#endif
+
+#if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_SEGFAULT)
+#include <signal.h>
+static void nuitka_segfault_handler(int sig) {
+    puts("Nuitka: A segmentation fault has occurred. This is highly unusual and can");
+    puts("have multiple reasons. Please check https://nuitka.net/info/segfault.html");
+    puts("for solutions.");
+
+    signal(SIGSEGV, SIG_DFL);
+    raise(SIGSEGV);
+}
+#endif
+
+#if _NUITKA_NATIVE_WCHAR_ARGV == 1
+extern wchar_t const *getBinaryFilenameWideChars(bool resolve_symlinks);
+#else
+extern char const *getBinaryFilenameHostEncoded(bool resolve_symlinks);
+#endif
+
+// No longer in header files, but still usable.
+#if PYTHON_VERSION >= 0x3d0
+PyAPI_FUNC(void) PySys_AddWarnOption(const wchar_t *s);
+#endif
+
+// Preserve and provide the original argv[0] as recorded by the bootstrap stage.
+static environment_char_t const *original_argv0 = NULL;
+
+PyObject *getOriginalArgv0Object(void) {
+    assert(original_argv0 != NULL);
+    return Nuitka_String_FromFilename(original_argv0);
+}
+
 #ifdef _NUITKA_WINMAIN_ENTRY_POINT
 int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lpCmdLine, int nCmdShow) {
     /* MSVC, MINGW64 */
@@ -1203,12 +1191,35 @@ int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lp
 #else
 #if defined(_WIN32)
 int wmain(int argc, wchar_t **argv) {
+#if defined(_NUITKA_HIDE_CONSOLE_WINDOW)
+    hideConsoleIfSpawned();
+#endif
 #else
 int main(int argc, char **argv) {
 #endif
 #endif
 
-    // First things, set up stdout/stderr according to user specification.
+    // Installer a segfault handler that outputs a helpful message.
+#if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_SEGFAULT)
+    signal(SIGSEGV, nuitka_segfault_handler);
+#endif
+
+#ifdef _NUITKA_EXPERIMENTAL_DUMP_C_TRACEBACKS
+    INIT_C_BACKTRACES();
+    DUMP_C_BACKTRACE();
+#endif
+    // Trace when the process exits.
+#if defined(_NUITKA_EXPERIMENTAL_SHOW_STARTUP_TIME)
+    atexit(Nuitka_at_exit);
+#endif
+
+    // Attach to the parent console respecting redirection only, otherwise we
+    // cannot even output traces.
+#if defined(_WIN32) && defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
+    inheritAttachedConsole();
+#endif
+
+    // Set up stdout/stderr according to user specification.
 #if NUITKA_STANDARD_HANDLES_EARLY == 1
 #if defined(NUITKA_FORCED_STDOUT_PATH)
 #ifdef _WIN32
@@ -1239,6 +1250,8 @@ int main(int argc, char **argv) {
     setbuf(stderr, (char *)NULL);
 
 #if PYTHON_VERSION >= 0x300
+    // spell-checker: ignore PYTHONUNBUFFERED
+
     environment_char_t const *old_env_unbuffered = getEnvironmentVariable("PYTHONUNBUFFERED");
     setEnvironmentVariable("PYTHONUNBUFFERED", makeEnvironmentLiteral("1"));
 #endif
@@ -1248,7 +1261,8 @@ int main(int argc, char **argv) {
     NUITKA_INIT_PROGRAM_EARLY(argc, argv);
 
 #ifdef __FreeBSD__
-    /* FP exceptions run in "no stop" mode by default */
+    // FP exceptions run in "no stop" mode by default
+    // spell-checker: ignore fpgetmask,fpsetmask
 
     fp_except_t m;
 
@@ -1259,11 +1273,10 @@ int main(int argc, char **argv) {
 #ifdef _NUITKA_STANDALONE
     NUITKA_PRINT_TIMING("main(): Prepare standalone environment.");
     prepareStandaloneEnvironment();
-#else
-
 #endif
 
 #if _NUITKA_FROZEN > 0
+    NUITKA_PRINT_TIMING("main(): Preparing frozen modules.");
     prepareFrozenModules();
 #endif
 
@@ -1278,7 +1291,7 @@ int main(int argc, char **argv) {
     Py_InspectFlag = 0;
     Py_InteractiveFlag = 0;
     Py_OptimizeFlag = SYSFLAG_OPTIMIZE;
-    Py_DontWriteBytecodeFlag = 0;
+    Py_DontWriteBytecodeFlag = SYSFLAG_DONTWRITEBYTECODE;
     Py_NoUserSiteDirectory = SYSFLAG_NO_SITE;
     Py_IgnoreEnvironmentFlag = 0;
     Py_VerboseFlag = SYSFLAG_VERBOSE;
@@ -1305,6 +1318,7 @@ int main(int argc, char **argv) {
 #endif
 
 #ifdef NUITKA_PYTHON_STATIC
+    NUITKA_PRINT_TIMING("main(): Preparing static modules.");
     Py_InitStaticModules();
 #endif
 
@@ -1319,13 +1333,40 @@ int main(int argc, char **argv) {
 
     /* Initial command line handling only. */
 
+// Make sure, we use the absolute program path for argv[0]
+#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 0
+    original_argv0 = argv[0];
+    argv[0] = (char *)getBinaryFilenameHostEncoded(false);
+#endif
+
+#if defined(_NUITKA_ONEFILE_MODE)
+    {
+        environment_char_t const *parent_original_argv0 = getEnvironmentVariable("NUITKA_ORIGINAL_ARGV0");
+
+        if (parent_original_argv0 != NULL) {
+            original_argv0 = strdupFilename(parent_original_argv0);
+
+            unsetEnvironmentVariable("NUITKA_ORIGINAL_ARGV0");
+        }
+    }
+#endif
+
 #if PYTHON_VERSION >= 0x300 && _NUITKA_NATIVE_WCHAR_ARGV == 0
     NUITKA_PRINT_TRACE("main(): Calling convertCommandLineParameters.");
     orig_argv = convertCommandLineParameters(argc, argv);
 #elif PYTHON_VERSION < 0x300 && _NUITKA_NATIVE_WCHAR_ARGV == 1
+    NUITKA_PRINT_TRACE("main(): Calling getCommandLineToArgvA.");
     orig_argv = getCommandLineToArgvA(GetCommandLineA());
 #else
 orig_argv = argv;
+#endif
+
+// Make sure, we use the absolute program path for argv[0]
+#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 1
+    original_argv0 = argv[0];
+#if PYTHON_VERSION >= 0x300
+    orig_argv[0] = (wchar_t *)getBinaryFilenameWideChars(false);
+#endif
 #endif
 
     // Make sure the compiled path of Python is replaced.
@@ -1334,8 +1375,8 @@ orig_argv = argv;
     orig_argc = argc;
 
     // Early command line parsing.
-    NUITKA_PRINT_TRACE("main(): Calling initial setCommandLineParameters.");
-    setCommandLineParameters(argc, argv, true);
+    NUITKA_PRINT_TRACE("main(): Calling setCommandLineParameters.");
+    setCommandLineParameters(argc, argv);
 
     /* For Python installations that need the home set, we inject it back here. */
 #if defined(PYTHON_HOME_PATH)
@@ -1371,7 +1412,7 @@ orig_argv = argv;
 #endif
 
 // Workaround older Python not handling stream setup on redirected files properly.
-#if PYTHON_VERSION >= 0x340 && PYTHON_VERSION < 0x380
+#if PYTHON_VERSION >= 0x300 && PYTHON_VERSION < 0x380
     {
         char const *encoding = NULL;
 
@@ -1397,6 +1438,24 @@ orig_argv = argv;
 #ifdef _NUITKA_STANDALONE
     NUITKA_PRINT_TRACE("main(): Restore standalone environment.");
     restoreStandaloneEnvironment();
+#else
+    {
+        environment_char_t const *python_path_cstr = getEnvironmentVariable("NUITKA_PYTHONPATH");
+
+        if (python_path_cstr != NULL) {
+            PyObject *python_path_str = Nuitka_String_FromFilename(python_path_cstr);
+#ifdef _WIN32
+            PyObject *python_path_list = PyObject_CallMethod(python_path_str, (char *)"split", (char *)"s", ";");
+#else
+            PyObject *python_path_list = PyObject_CallMethod(python_path_str, (char *)"split", (char *)"s", ":");
+#endif
+            Py_DECREF(python_path_str);
+
+            PySys_SetObject("path", python_path_list);
+
+            unsetEnvironmentVariable("NUITKA_PYTHONPATH");
+        }
+    }
 #endif
 
     /* Lie about it, believe it or not, there are "site" files, that check
@@ -1405,9 +1464,6 @@ orig_argv = argv;
     Py_NoSiteFlag = SYSFLAG_NO_SITE;
 
     /* Set the command line parameters for run time usage. */
-    NUITKA_PRINT_TRACE("main(): Calling setCommandLineParameters.");
-    setCommandLineParameters(argc, argv, false);
-
     PySys_SetArgv(argc, orig_argv);
 // Empty "sys.path" again, the above adds program directory to it.
 #if SYSFLAG_ISOLATED
@@ -1477,6 +1533,57 @@ orig_argv = argv;
     }
 #endif
 
+#if defined(_WIN32) && defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
+    if (needs_stdout_attaching) {
+        PyObject *filename = Nuitka_String_FromString("CONOUT$");
+        // This defaults to "utf-8" internally. We may add an argument of use
+        // platform ones in the future.
+        PyObject *encoding = NULL;
+
+        PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding);
+        if (unlikely(stdout_file == NULL)) {
+            PyErr_PrintEx(1);
+            Py_Exit(1);
+        }
+
+        Py_DECREF(filename);
+
+        Nuitka_SysSetObject("stdout", stdout_file);
+    }
+
+    if (needs_stderr_attaching) {
+        PyObject *filename = Nuitka_String_FromString("CONOUT$");
+        // This defaults to "utf-8" internally. We may add an argument of use
+        // platform ones in the future.
+        PyObject *encoding = NULL;
+
+        PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding);
+        if (unlikely(stderr_file == NULL)) {
+            PyErr_PrintEx(1);
+            Py_Exit(1);
+        }
+
+        Py_DECREF(filename);
+
+        Nuitka_SysSetObject("stderr", stderr_file);
+    }
+
+    if (needs_stdin_attaching) {
+        PyObject *filename = Nuitka_String_FromString("CONIN$");
+        // This defaults to "utf-8" internally. We may add an argument of use
+        // platform ones in the future.
+        PyObject *encoding = NULL;
+
+        // CPython core requires stdin to be buffered due to methods usage, and it won't matter
+        // here much.
+        PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "r", true, encoding);
+
+        Py_DECREF(filename);
+
+        Nuitka_SysSetObject("stdin", stdin_file);
+    }
+#endif
+
     NUITKA_PRINT_TRACE("main(): Setting Python input/output handles.");
     setInputOutputHandles(tstate);
 
@@ -1485,8 +1592,10 @@ orig_argv = argv;
 #if PYTHON_VERSION >= 0x300
     // Make sure the importlib fully bootstraps as we couldn't load it with the
     // standard loader.
-    PyObject *importlib_module = getImportLibBootstrapModule();
-    CHECK_OBJECT(importlib_module);
+    {
+        NUITKA_MAY_BE_UNUSED PyObject *importlib_module = getImportLibBootstrapModule();
+        CHECK_OBJECT(importlib_module);
+    }
 #endif
 
     NUITKA_PRINT_TRACE("main(): Calling setEarlyFrozenModulesFileAttribute().");
@@ -1503,12 +1612,14 @@ orig_argv = argv;
     /* Enable meta path based loader. */
     setupMetaPathBasedLoader(tstate);
 
+#if PYTHON_VERSION < 0x3d0
     /* Initialize warnings module. */
     _PyWarnings_Init();
+#endif
 
 #if NO_PYTHON_WARNINGS && PYTHON_VERSION >= 0x342 && PYTHON_VERSION < 0x3a0 && defined(_NUITKA_FULL_COMPAT)
     // For full compatibility bump the warnings registry version,
-    // otherwise modules "__warningsregistry__" will mismatch.
+    // otherwise modules "__warningregistry__" will mismatch.
     PyObject *warnings_module = PyImport_ImportModule("warnings");
     PyObject *meth = PyObject_GetAttrString(warnings_module, "_filters_mutated");
 
@@ -1521,8 +1632,13 @@ orig_argv = argv;
 
 #if PYTHON_VERSION >= 0x300
     NUITKA_PRINT_TRACE("main(): Calling patchInspectModule().");
+
+// TODO: Python3.13 NoGIL: This is causing errors during bytecode import
+// that are unexplained.
+#if !defined(Py_GIL_DISABLED)
     patchInspectModule(tstate);
 #endif
+#endif
 
 #if PYTHON_VERSION >= 0x300 && SYSFLAG_NO_RANDOMIZATION == 1
     NUITKA_PRINT_TRACE("main(): Reverting to initial 'PYTHONHASHSEED' value.");
@@ -1558,16 +1674,52 @@ orig_argv = argv;
 #ifdef _NUITKA_PLUGIN_MULTIPROCESSING_ENABLED
     if (unlikely(is_multiprocessing_fork)) {
         NUITKA_PRINT_TRACE("main(): Calling __parents_main__.");
-        EXECUTE_MAIN_MODULE("__parents_main__");
+        EXECUTE_MAIN_MODULE(tstate, "__parents_main__", false);
 
-        int exit_code = HANDLE_PROGRAM_EXIT();
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
         NUITKA_PRINT_TRACE("main(): Calling __parents_main__ Py_Exit.");
         Py_Exit(exit_code);
+#if defined(_WIN32)
+    } else if (unlikely(is_joblib_popen_loky_win32)) {
+        NUITKA_PRINT_TRACE("main(): Calling joblib.externals.loky.backend.popen_loky_win32.");
+        PyObject *joblib_popen_loky_win32_module =
+            EXECUTE_MAIN_MODULE(tstate, "joblib.externals.loky.backend.popen_loky_win32", true);
+
+        // Remove the "-c" and options part like CPython would do as well.
+        PyObject *argv_list = Nuitka_SysGetObject("argv");
+        Py_ssize_t size = PyList_Size(argv_list);
+
+        // Negative indexes are not supported by this function.
+        int res = PyList_SetSlice(argv_list, 1, size - 2, const_tuple_empty);
+        assert(res == 0);
+
+        PyObject *main_function = PyObject_GetAttrString(joblib_popen_loky_win32_module, "main");
+        CHECK_OBJECT(main_function);
+
+        if (loky_joblib_pipe_handle_arg == 0) {
+            CALL_FUNCTION_NO_ARGS(tstate, main_function);
+        } else {
+            char const *kw_keys[] = {"pipe_handle", "parent_pid"};
+            PyObject *kw_values[] = {
+                Nuitka_PyLong_FromLong(loky_joblib_pipe_handle_arg),
+                Nuitka_PyLong_FromLong(loky_joblib_parent_pid_arg),
+            };
+
+            PyObject *kw_args = MAKE_DICT_X_CSTR(kw_keys, kw_values, sizeof(kw_values) / sizeof(PyObject *));
+
+            CALL_FUNCTION_WITH_KW_ARGS(tstate, main_function, kw_args);
+        }
+
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
+
+        NUITKA_PRINT_TRACE("main(): Calling 'joblib.externals.loky.backend.popen_loky_posix' Py_Exit.");
+        Py_Exit(exit_code);
+#else
     } else if (unlikely(is_joblib_popen_loky_posix)) {
         NUITKA_PRINT_TRACE("main(): Calling joblib.externals.loky.backend.popen_loky_posix.");
         PyObject *joblib_popen_loky_posix_module =
-            EXECUTE_MAIN_MODULE("joblib.externals.loky.backend.popen_loky_posix");
+            EXECUTE_MAIN_MODULE(tstate, "joblib.externals.loky.backend.popen_loky_posix", true);
 
         // Remove the "-m" like CPython would do as well.
         int res = PyList_SetSlice(Nuitka_SysGetObject("argv"), 0, 2, const_tuple_empty);
@@ -1578,35 +1730,51 @@ orig_argv = argv;
 
         CALL_FUNCTION_NO_ARGS(tstate, main_function);
 
-        int exit_code = HANDLE_PROGRAM_EXIT();
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
-        NUITKA_PRINT_TRACE("main(): Calling joblib.externals.loky.backend.popen_loky_posix Py_Exit.");
+        NUITKA_PRINT_TRACE("main(): Calling 'joblib.externals.loky.backend.popen_loky_posix' Py_Exit.");
         Py_Exit(exit_code);
+#endif
     } else if (unlikely(multiprocessing_resource_tracker_arg != -1)) {
         NUITKA_PRINT_TRACE("main(): Launching as 'multiprocessing.resource_tracker'.");
-        PyObject *resource_tracker_module = EXECUTE_MAIN_MODULE("multiprocessing.resource_tracker");
+        PyObject *resource_tracker_module = EXECUTE_MAIN_MODULE(tstate, "multiprocessing.resource_tracker", true);
 
         PyObject *main_function = PyObject_GetAttrString(resource_tracker_module, "main");
         CHECK_OBJECT(main_function);
 
-        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function, PyInt_FromLong(multiprocessing_resource_tracker_arg));
+        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function,
+                                      Nuitka_PyInt_FromLong(multiprocessing_resource_tracker_arg));
 
-        int exit_code = HANDLE_PROGRAM_EXIT();
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
-        NUITKA_PRINT_TRACE("main(): Calling resource_tracker Py_Exit.");
+        NUITKA_PRINT_TRACE("main(): Calling 'multiprocessing.resource_tracker' Py_Exit.");
         Py_Exit(exit_code);
     } else if (unlikely(loky_resource_tracker_arg != -1)) {
         NUITKA_PRINT_TRACE("main(): Launching as 'joblib.externals.loky.backend.resource_tracker'.");
-        PyObject *resource_tracker_module = EXECUTE_MAIN_MODULE("joblib.externals.loky.backend.resource_tracker");
+        PyObject *resource_tracker_module =
+            EXECUTE_MAIN_MODULE(tstate, "joblib.externals.loky.backend.resource_tracker", true);
+        CHECK_OBJECT(resource_tracker_module);
 
         PyObject *main_function = PyObject_GetAttrString(resource_tracker_module, "main");
         CHECK_OBJECT(main_function);
 
-        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function, PyInt_FromLong(loky_resource_tracker_arg));
+        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function, Nuitka_PyInt_FromLong(loky_resource_tracker_arg));
+
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
+
+        NUITKA_PRINT_TRACE("main(): Calling 'joblib.externals.loky.backend.resource_tracker' Py_Exit.");
+        Py_Exit(exit_code);
+    } else if (unlikely(is_anyio_to_process)) {
+        PyObject *anyio_module = EXECUTE_MAIN_MODULE(tstate, "anyio.to_process", false);
+
+        PyObject *main_function = PyObject_GetAttrString(anyio_module, "process_worker");
+        CHECK_OBJECT(main_function);
+
+        CALL_FUNCTION_NO_ARGS(tstate, main_function);
 
-        int exit_code = HANDLE_PROGRAM_EXIT();
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
-        NUITKA_PRINT_TRACE("main(): Calling resource_tracker Py_Exit.");
+        NUITKA_PRINT_TRACE("main(): Calling 'anyio.to_process' Py_Exit.");
         Py_Exit(exit_code);
     } else {
 #endif
@@ -1623,6 +1791,7 @@ orig_argv = argv;
         }
 #endif
         PyDict_DelItemString(Nuitka_GetSysModules(), NUITKA_MAIN_MODULE_NAME);
+        DROP_ERROR_OCCURRED(tstate);
 
 #if _NUITKA_PLUGIN_WINDOWS_SERVICE_ENABLED
         NUITKA_PRINT_TRACE("main(): Calling plugin SvcLaunchService() entry point.");
@@ -1630,7 +1799,7 @@ orig_argv = argv;
 #else
     /* Execute the "__main__" module. */
     NUITKA_PRINT_TIMING("main(): Calling " NUITKA_MAIN_MODULE_NAME ".");
-    EXECUTE_MAIN_MODULE(NUITKA_MAIN_MODULE_NAME);
+    EXECUTE_MAIN_MODULE(tstate, NUITKA_MAIN_MODULE_NAME, NUITKA_MAIN_IS_PACKAGE_BOOL);
     NUITKA_PRINT_TIMING("main(): Exited from " NUITKA_MAIN_MODULE_NAME ".");
 
 #endif
@@ -1651,13 +1820,13 @@ orig_argv = argv;
     checkGlobalConstants();
 
     /* TODO: Walk over all loaded compiled modules, and make this kind of checks. */
-#if !NUITKA_MAIN_PACKAGE_MODE
+#if !NUITKA_MAIN_IS_PACKAGE_BOOL
     checkModuleConstants___main__(tstate);
 #endif
 
 #endif
 
-    int exit_code = HANDLE_PROGRAM_EXIT();
+    int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
     NUITKA_PRINT_TIMING("main(): Calling Py_Exit.");
     Py_Exit(exit_code);
@@ -1710,3 +1879,18 @@ int Py_Main(int argc, char **argv) { return 0; }
 }
 #endif
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.