diff --git a/plugins/builtin/CMakeLists.txt b/plugins/builtin/CMakeLists.txt
index 59a7573d1..c920116f8 100644
--- a/plugins/builtin/CMakeLists.txt
+++ b/plugins/builtin/CMakeLists.txt
@@ -2,11 +2,6 @@ cmake_minimum_required(VERSION 3.16)
 
 include(ImHexPlugin)
 
-find_file(DEFAULT_MAGIC_FILE_PATH magic.mgc HINTS ${LIBMAGIC_INCLUDE_DIR}/../share/misc)
-if (DEFAULT_MAGIC_FILE_PATH)
-    add_romfs_resource(${DEFAULT_MAGIC_FILE_PATH} always_auto_extract/magic/magic.mgc)
-endif ()
-
 add_imhex_plugin(
     NAME
         builtin
@@ -126,6 +121,11 @@ add_imhex_plugin(
         LLVMDemangle
 )
 
+find_file(DEFAULT_MAGIC_FILE_PATH magic.mgc HINTS ${LIBMAGIC_INCLUDE_DIR}/../share/misc)
+if (DEFAULT_MAGIC_FILE_PATH)
+    add_romfs_resource(${DEFAULT_MAGIC_FILE_PATH} always_auto_extract/magic/magic.mgc)
+endif ()
+
 if (WIN32)
     target_link_libraries(builtin PRIVATE setupapi)
 endif ()
\ No newline at end of file
diff --git a/plugins/decompress/source/plugin_decompress.cpp b/plugins/decompress/source/plugin_decompress.cpp
index 9f6262800..15cba2ff9 100644
--- a/plugins/decompress/source/plugin_decompress.cpp
+++ b/plugins/decompress/source/plugin_decompress.cpp
@@ -15,10 +15,10 @@ using namespace hex;
 using namespace hex::plugin::decompress;
 
 IMHEX_PLUGIN_FEATURES() {
-    { "bzip2 Support",      IMHEX_FEATURE_ENABLED(BZIP2)      },
-    { "zlib Support",       IMHEX_FEATURE_ENABLED(ZLIB)       },
-    { "LZMA Support",       IMHEX_FEATURE_ENABLED(LIBLZMA)    },
-    { "zstd Support",       IMHEX_FEATURE_ENABLED(ZSTD)       },
+    { "bzip2",      IMHEX_FEATURE_ENABLED(BZIP2)      },
+    { "zlib",       IMHEX_FEATURE_ENABLED(ZLIB)       },
+    { "LZMA",       IMHEX_FEATURE_ENABLED(LIBLZMA)    },
+    { "zstd",       IMHEX_FEATURE_ENABLED(ZSTD)       },
 };
 
 IMHEX_PLUGIN_SETUP("Decompressing", "WerWolv", "Support for decompressing data") {
diff --git a/plugins/script_loader/CMakeLists.txt b/plugins/script_loader/CMakeLists.txt
index 88625d3e7..18213e3aa 100644
--- a/plugins/script_loader/CMakeLists.txt
+++ b/plugins/script_loader/CMakeLists.txt
@@ -1,24 +1,11 @@
 cmake_minimum_required(VERSION 3.16)
 
 include(ImHexPlugin)
+
 find_package(CoreClrEmbed)
-
-add_imhex_plugin(
-    NAME
-        script_loader
-
-    SOURCES
-        source/plugin_script_loader.cpp
-
-    INCLUDES
-        include
-
-    LIBRARIES
-        fonts
-        ui
-)
-
 if (CoreClrEmbed_FOUND)
+    set(IMHEX_DOTNET_SCRIPT_SUPPORT ON)
+
     add_library(nethost SHARED IMPORTED)
     target_include_directories(nethost INTERFACE "${CoreClrEmbed_INCLUDE_DIRS}")
     get_filename_component(CoreClrEmbed_FOLDER ${CoreClrEmbed_SHARED_LIBRARIES} DIRECTORY)
@@ -29,25 +16,71 @@ if (CoreClrEmbed_FOUND)
             BUILD_RPATH         ${CoreClrEmbed_FOLDER}
             INSTALL_RPATH       ${CoreClrEmbed_FOLDER})
 
-    target_link_directories(script_loader PRIVATE ${CoreClrEmbed_FOLDER})
-    target_include_directories(script_loader PRIVATE ${CoreClrEmbed_INCLUDE_DIRS})
-    target_compile_definitions(script_loader PRIVATE DOTNET_PLUGINS=1)
-    target_sources(script_loader PRIVATE
-            source/loaders/dotnet/dotnet_loader.cpp
-
-            source/script_api/v1/mem.cpp
-            source/script_api/v1/bookmarks.cpp
-            source/script_api/v1/ui.cpp
-            source/script_api/v1/logger.cpp
-    )
-
     set(EXTRA_BUNDLE_LIBRARY_PATHS "${CoreClrEmbed_FOLDER}" PARENT_SCOPE)
 
     if (IMHEX_BUNDLE_DOTNET)
         install(FILES ${CoreClrEmbed_SHARED_LIBRARIES} DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif ()
+    endif()
+endif()
 
-    add_subdirectory(dotnet)
+find_package(Python3 COMPONENTS Interpreter Development.Embed)
+if (Python3_FOUND)
+    set(IMHEX_PYTHON_SCRIPT_SUPPORT ON)
+
+    add_romfs_resource(${CMAKE_CURRENT_SOURCE_DIR}/support/python/imhex.py "python/imhex.py")
+endif()
+
+
+add_imhex_plugin(
+    NAME
+        script_loader
+
+    SOURCES
+        source/plugin_script_loader.cpp
+
+        source/script_api/v1/mem.cpp
+        source/script_api/v1/bookmarks.cpp
+        source/script_api/v1/ui.cpp
+        source/script_api/v1/logger.cpp
+    INCLUDES
+        include
+
+    LIBRARIES
+        fonts
+        ui
+    FEATURES
+        DOTNET
+        PYTHON
+)
+
+if (IMHEX_DOTNET_SCRIPT_SUPPORT)
+    message(STATUS "Enabling .NET Scripting support!")
+
+    target_link_directories(script_loader PRIVATE ${CoreClrEmbed_FOLDER})
+    target_include_directories(script_loader PRIVATE ${CoreClrEmbed_INCLUDE_DIRS})
+    target_compile_definitions(script_loader PRIVATE IMHEX_DOTNET_SCRIPT_SUPPORT=1)
+    target_sources(script_loader PRIVATE
+            source/loaders/dotnet/dotnet_loader.cpp
+    )
+
+    add_subdirectory(support/dotnet)
     add_dependencies(script_loader AssemblyLoader)
+    enable_plugin_feature(DOTNET)
+endif()
 
-endif ()
\ No newline at end of file
+if (IMHEX_PYTHON_SCRIPT_SUPPORT)
+    message(STATUS "Enabling Python Scripting support!")
+
+    target_compile_definitions(script_loader PRIVATE IMHEX_PYTHON_SCRIPT_SUPPORT=1)
+    target_sources(script_loader PRIVATE
+            source/loaders/python/python_loader.cpp
+            source/loaders/python/library_wrapper.cpp
+    )
+
+    get_target_property(PYTHON_LIBRARY Python3::Python IMPORTED_LOCATION)
+    get_target_property(PYTHON_INCLUDE_DIR Python3::Python INTERFACE_INCLUDE_DIRECTORIES)
+
+    target_include_directories(script_loader PRIVATE ${PYTHON_INCLUDE_DIR})
+    target_compile_definitions(script_loader PRIVATE PYTHON_LIBRARY_PATH="${PYTHON_LIBRARY}")
+    enable_plugin_feature(PYTHON)
+endif()
\ No newline at end of file
diff --git a/plugins/script_loader/include/loaders/dotnet/dotnet_loader.hpp b/plugins/script_loader/include/loaders/dotnet/dotnet_loader.hpp
index b3159916b..f0cb3467f 100644
--- a/plugins/script_loader/include/loaders/dotnet/dotnet_loader.hpp
+++ b/plugins/script_loader/include/loaders/dotnet/dotnet_loader.hpp
@@ -10,7 +10,7 @@ namespace hex::script::loader {
 
     class DotNetLoader : public ScriptLoader {
     public:
-        DotNetLoader() = default;
+        DotNetLoader() : ScriptLoader(".NET") {}
         ~DotNetLoader() override = default;
 
         bool initialize() override;
diff --git a/plugins/script_loader/include/loaders/loader.hpp b/plugins/script_loader/include/loaders/loader.hpp
index 47483096f..ee2ce5f5f 100644
--- a/plugins/script_loader/include/loaders/loader.hpp
+++ b/plugins/script_loader/include/loaders/loader.hpp
@@ -3,30 +3,44 @@
 #include <functional>
 #include <string>
 #include <vector>
+#include <hex/helpers/utils.hpp>
+
+#if defined(OS_WINDOWS)
+    #include <Windows.h>
+#else
+    #include <dlfcn.h>
+#endif
 
 namespace hex::script::loader {
 
+    class ScriptLoader;
+
     struct Script {
         std::string name;
         std::function<void()> entryPoint;
+        const ScriptLoader *loader;
     };
 
     class ScriptLoader {
     public:
-        ScriptLoader() = default;
+        ScriptLoader(std::string typeName) : m_typeName(std::move(typeName)) {}
         virtual ~ScriptLoader() = default;
 
         virtual bool initialize() = 0;
         virtual bool loadAll() = 0;
 
         void addScript(std::string name, std::function<void()> entryPoint) {
-            m_scripts.emplace_back(std::move(name), std::move(entryPoint));
+            m_scripts.emplace_back(std::move(name), std::move(entryPoint), this);
         }
 
         const auto& getScripts() const {
             return m_scripts;
         }
 
+        const std::string& getTypeName() const {
+            return m_typeName;
+        }
+
     protected:
         void clearScripts() {
             m_scripts.clear();
@@ -34,6 +48,49 @@ namespace hex::script::loader {
 
     private:
         std::vector<Script> m_scripts;
+        std::string m_typeName;
     };
 
+#if defined(OS_WINDOWS)
+    inline void *loadLibrary(const wchar_t *path) {
+        try {
+            HMODULE h = ::LoadLibraryW(path);
+            return h;
+        } catch (...) {
+            return nullptr;
+        }
+    }
+
+    inline void *loadLibrary(const char *path) {
+        try {
+            auto utf16Path = hex::utf8ToUtf16(path);
+            HMODULE h = ::LoadLibraryW(utf16Path.c_str());
+            return h;
+        } catch (...) {
+            return nullptr;
+        }
+    }
+
+    template<typename T>
+    T getExport(void *h, const char *name) {
+        try {
+            FARPROC f = ::GetProcAddress(static_cast<HMODULE>(h), name);
+            return reinterpret_cast<T>(reinterpret_cast<uintptr_t>(f));
+        } catch (...) {
+            return nullptr;
+        }
+    }
+#else
+    inline void *loadLibrary(const char *path) {
+        void *h = dlopen(path, RTLD_LAZY);
+        return h;
+    }
+
+    template<typename T>
+    T getExport(void *h, const char *name) {
+        void *f = dlsym(h, name);
+        return reinterpret_cast<T>(f);
+    }
+#endif
+
 }
\ No newline at end of file
diff --git a/plugins/script_loader/include/loaders/python/python_loader.hpp b/plugins/script_loader/include/loaders/python/python_loader.hpp
new file mode 100644
index 000000000..1fc2fbc5e
--- /dev/null
+++ b/plugins/script_loader/include/loaders/python/python_loader.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <loaders/loader.hpp>
+
+#include <wolv/io/fs.hpp>
+
+#include <functional>
+
+namespace hex::script::loader {
+
+    class PythonLoader : public ScriptLoader {
+    public:
+        PythonLoader() : ScriptLoader("Python") {}
+        ~PythonLoader() override = default;
+
+        bool initialize() override;
+        bool loadAll() override;
+
+    private:
+        struct Script {
+            void *module;
+            void *mainFunction;
+        };
+
+        std::vector<Script> m_scripts;
+    };
+
+}
\ No newline at end of file
diff --git a/plugins/script_loader/source/loaders/dotnet/dotnet_loader.cpp b/plugins/script_loader/source/loaders/dotnet/dotnet_loader.cpp
index e8437694e..417eba5c9 100644
--- a/plugins/script_loader/source/loaders/dotnet/dotnet_loader.cpp
+++ b/plugins/script_loader/source/loaders/dotnet/dotnet_loader.cpp
@@ -3,10 +3,8 @@
 #include <stdexcept>
 
 #if defined(OS_WINDOWS)
-    #include <Windows.h>
     #define STRING(str) L##str
 #else
-    #include <dlfcn.h>
     #define STRING(str) str
 #endif
 
@@ -34,38 +32,6 @@ namespace hex::script::loader {
 
         using get_hostfxr_path_fn = int(*)(char_t * buffer, size_t * buffer_size, const get_hostfxr_parameters *parameters);
 
-        #if defined(OS_WINDOWS)
-            void *loadLibrary(const char_t *path) {
-                try {
-                    HMODULE h = ::LoadLibraryW(path);
-                    return h;
-                } catch (...) {
-                    return nullptr;
-                }
-            }
-
-            template<typename T>
-            T getExport(void *h, const char *name) {
-                try {
-                    FARPROC f = ::GetProcAddress(static_cast<HMODULE>(h), name);
-                    return reinterpret_cast<T>(reinterpret_cast<uintptr_t>(f));
-                } catch (...) {
-                    return nullptr;
-                }
-            }
-        #else
-            void *loadLibrary(const char_t *path) {
-                void *h = dlopen(path, RTLD_LAZY);
-                return h;
-            }
-
-            template<typename T>
-            T getExport(void *h, const char *name) {
-                void *f = dlsym(h, name);
-                return reinterpret_cast<T>(f);
-            }
-        #endif
-
         hostfxr_initialize_for_runtime_config_fn hostfxr_initialize_for_runtime_config  = nullptr;
         hostfxr_get_runtime_delegate_fn hostfxr_get_runtime_delegate = nullptr;
         hostfxr_close_fn hostfxr_close = nullptr;
diff --git a/plugins/script_loader/source/loaders/python/library_wrapper.cpp b/plugins/script_loader/source/loaders/python/library_wrapper.cpp
new file mode 100644
index 000000000..415b01170
--- /dev/null
+++ b/plugins/script_loader/source/loaders/python/library_wrapper.cpp
@@ -0,0 +1,105 @@
+#if defined(__declspec)
+    #undef __declspec
+    #define __declspec(x)
+#endif
+#include <Python.h>
+
+#include <loaders/loader.hpp>
+
+#define FUNCTION_DEFINITION(ret, name, args1, args2) \
+    decltype(name) *name##Func = nullptr;   \
+    extern "C" ret name args1 {     \
+        return name##Func args2;     \
+    }
+#define INIT_FUNCTION(name) name##Func = hex::script::loader::getExport<decltype(name##Func)>(pythonLibrary, #name)
+
+FUNCTION_DEFINITION(void, PyPreConfig_InitPythonConfig, (PyPreConfig *config), (config))
+FUNCTION_DEFINITION(PyStatus, Py_PreInitialize, (const PyPreConfig *src_config), (src_config))
+FUNCTION_DEFINITION(int, PyStatus_Exception, (PyStatus err), (err))
+FUNCTION_DEFINITION(void, Py_Initialize, (), ())
+FUNCTION_DEFINITION(void, Py_Finalize, (), ())
+FUNCTION_DEFINITION(PyInterpreterState *, PyInterpreterState_Get, (), ())
+FUNCTION_DEFINITION(PyThreadState *, PyEval_SaveThread, (), ())
+FUNCTION_DEFINITION(void, PyEval_RestoreThread, (PyThreadState * state), (state))
+FUNCTION_DEFINITION(void, PyErr_Fetch, (PyObject **ptype, PyObject **pvalue, PyObject **ptraceback), (ptype, pvalue, ptraceback))
+FUNCTION_DEFINITION(void, PyErr_NormalizeException, (PyObject **ptype, PyObject **pvalue, PyObject **ptraceback), (ptype, pvalue, ptraceback))
+FUNCTION_DEFINITION(PyObject *, PyUnicode_FromString, (const char *u), (u))
+FUNCTION_DEFINITION(PyObject *, PyImport_Import, (PyObject *name), (name))
+FUNCTION_DEFINITION(void, _Py_Dealloc, (PyObject *pobj), (pobj))
+FUNCTION_DEFINITION(PyObject *, PyModule_GetDict, (PyObject *pobj), (pobj))
+FUNCTION_DEFINITION(PyObject *, PyDict_GetItemString, (PyObject *dp, const char *key), (dp, key))
+FUNCTION_DEFINITION(int, PyCallable_Check, (PyObject *dp), (dp))
+FUNCTION_DEFINITION(PyObject *, PyTuple_New, (Py_ssize_t len), (len))
+FUNCTION_DEFINITION(int, PyTuple_SetItem, (PyObject *p, Py_ssize_t pos, PyObject *o), (p, pos, o))
+FUNCTION_DEFINITION(PyObject *, PyObject_CallObject, (PyObject *callable, PyObject *args), (callable, args))
+FUNCTION_DEFINITION(PyObject *, PyUnicode_Join, (PyObject *separator, PyObject *iterable), (separator, iterable))
+FUNCTION_DEFINITION(const char *, PyUnicode_AsUTF8, (PyObject *unicode), (unicode))
+FUNCTION_DEFINITION(void, PyErr_Clear, (), ())
+FUNCTION_DEFINITION(int, PyModule_AddStringConstant, (PyObject *module, const char *name, const char *value), (module, name, value))
+FUNCTION_DEFINITION(PyObject *, PyEval_GetBuiltins, (), ())
+FUNCTION_DEFINITION(int, PyDict_SetItemString, (PyObject *dp, const char *key, PyObject *item), (dp, key, item))
+FUNCTION_DEFINITION(PyObject *, PyRun_StringFlags, (const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags), (str, start, globals, locals, flags))
+FUNCTION_DEFINITION(void, PyThreadState_Clear, (PyThreadState *tstate), (tstate))
+FUNCTION_DEFINITION(void, PyThreadState_DeleteCurrent, (), ())
+FUNCTION_DEFINITION(PyThreadState *, PyThreadState_New, (PyInterpreterState *interp), (interp))
+FUNCTION_DEFINITION(PyObject *, PyImport_AddModule, (const char *name), (name))
+FUNCTION_DEFINITION(PyObject *, PyModule_New, (const char *name), (name))
+
+
+bool initPythonLoader() {
+    void *pythonLibrary = nullptr;
+    for (const std::fs::path &path : { std::fs::path(PYTHON_LIBRARY_PATH), std::fs::path(PYTHON_LIBRARY_PATH).filename() }) {
+        pythonLibrary = hex::script::loader::loadLibrary(path.c_str());
+        if (pythonLibrary != nullptr) {
+            break;
+        }
+    }
+
+    if (pythonLibrary == nullptr)
+        return false;
+
+    INIT_FUNCTION(PyPreConfig_InitPythonConfig);
+    INIT_FUNCTION(Py_PreInitialize);
+    INIT_FUNCTION(Py_Initialize);
+    INIT_FUNCTION(Py_Finalize);
+
+    INIT_FUNCTION(PyEval_SaveThread);
+    INIT_FUNCTION(PyEval_RestoreThread);
+    INIT_FUNCTION(PyEval_GetBuiltins);
+    INIT_FUNCTION(PyRun_StringFlags);
+
+    INIT_FUNCTION(PyErr_Fetch);
+    INIT_FUNCTION(PyErr_NormalizeException);
+    INIT_FUNCTION(PyErr_Clear);
+    INIT_FUNCTION(PyStatus_Exception);
+
+    INIT_FUNCTION(PyThreadState_Clear);
+    INIT_FUNCTION(PyThreadState_DeleteCurrent);
+    INIT_FUNCTION(PyThreadState_New);
+    INIT_FUNCTION(PyInterpreterState_Get);
+
+    INIT_FUNCTION(PyUnicode_FromString);
+    INIT_FUNCTION(PyUnicode_Join);
+    INIT_FUNCTION(PyUnicode_AsUTF8);
+
+    INIT_FUNCTION(PyTuple_New);
+    INIT_FUNCTION(PyTuple_SetItem);
+
+    INIT_FUNCTION(PyImport_Import);
+    INIT_FUNCTION(PyImport_AddModule);
+
+    INIT_FUNCTION(PyModule_New);
+    INIT_FUNCTION(PyModule_AddStringConstant);
+    INIT_FUNCTION(PyModule_GetDict);
+
+    INIT_FUNCTION(PyDict_GetItemString);
+    INIT_FUNCTION(PyDict_SetItemString);
+
+    INIT_FUNCTION(PyCallable_Check);
+    INIT_FUNCTION(PyObject_CallObject);
+
+    INIT_FUNCTION(_Py_Dealloc);
+
+
+    return true;
+}
\ No newline at end of file
diff --git a/plugins/script_loader/source/loaders/python/python_loader.cpp b/plugins/script_loader/source/loaders/python/python_loader.cpp
new file mode 100644
index 000000000..0370e2b21
--- /dev/null
+++ b/plugins/script_loader/source/loaders/python/python_loader.cpp
@@ -0,0 +1,147 @@
+#include <loaders/python/python_loader.hpp>
+
+#include <hex/helpers/fs.hpp>
+#include <hex/helpers/logger.hpp>
+#include <wolv/io/file.hpp>
+#include <wolv/utils/guards.hpp>
+#include <wolv/utils/string.hpp>
+
+#include <hex/helpers/utils.hpp>
+#include <romfs/romfs.hpp>
+
+#if defined(__declspec)
+    #undef __declspec
+    #define __declspec(x)
+#endif
+#include <Python.h>
+
+bool initPythonLoader();
+
+namespace hex::script::loader {
+
+    static PyInterpreterState *mainThreadState;
+
+    bool PythonLoader::initialize() {
+        if (!initPythonLoader())
+            return false;
+
+        PyPreConfig preconfig;
+        PyPreConfig_InitPythonConfig(&preconfig);
+
+        preconfig.utf8_mode = 1;
+
+        auto status = Py_PreInitialize(&preconfig);
+        if (PyStatus_Exception(status)) {
+            return false;
+        }
+
+        Py_Initialize();
+        mainThreadState = PyInterpreterState_Get();
+        PyEval_SaveThread();
+        return true;
+    }
+
+    std::string getCurrentTraceback() {
+        PyObject *ptype, *pvalue, *ptraceback;
+        PyErr_Fetch(&ptype, &pvalue, &ptraceback);
+        PyErr_NormalizeException(&ptype, &pvalue, &ptraceback);
+
+        PyObject *pModuleName = PyUnicode_FromString("traceback");
+        PyObject *pModule = PyImport_Import(pModuleName);
+        Py_DECREF(pModuleName);
+
+        if (pModule != nullptr) {
+            PyObject *pDict = PyModule_GetDict(pModule);
+            PyObject *pFunc = PyDict_GetItemString(pDict, "format_exception");
+
+            if (pFunc && PyCallable_Check(pFunc)) {
+                PyObject *pArgs = PyTuple_New(3);
+                PyTuple_SetItem(pArgs, 0, ptype);
+                PyTuple_SetItem(pArgs, 1, pvalue);
+                PyTuple_SetItem(pArgs, 2, ptraceback);
+
+                PyObject *pResult = PyObject_CallObject(pFunc, pArgs);
+                Py_DECREF(pArgs);
+
+                if (pResult != NULL) {
+                    const char *errorMessage = PyUnicode_AsUTF8(PyUnicode_Join(PyUnicode_FromString(""), pResult));
+                    Py_DECREF(pResult);
+                    Py_DECREF(pModule);
+                    return errorMessage;
+                }
+            }
+            Py_DECREF(pModule);
+        }
+
+        PyErr_Clear();
+        return "";
+    }
+
+    void populateModule(PyObject *pyModule, const std::string &sourceCode) {
+        PyModule_AddStringConstant(pyModule, "__file__", "");
+
+        PyObject *localDict = PyModule_GetDict(pyModule);
+        PyObject *builtins = PyEval_GetBuiltins();
+
+        PyDict_SetItemString(localDict, "__builtins__", builtins);
+
+        PyErr_Clear();
+        PyObject *pyValue = PyRun_String(sourceCode.c_str(), Py_file_input, localDict, localDict);
+        if (pyValue != nullptr) {
+            Py_DECREF(pyValue);
+        } else {
+            log::error("{}", getCurrentTraceback());
+        }
+    }
+
+    bool PythonLoader::loadAll() {
+        this->clearScripts();
+
+        for (const auto &imhexPath : hex::fs::getDefaultPaths(hex::fs::ImHexPath::Scripts)) {
+            auto directoryPath = imhexPath / "custom" / "python";
+            if (!wolv::io::fs::exists(directoryPath))
+                wolv::io::fs::createDirectories(directoryPath);
+
+            if (!wolv::io::fs::exists(directoryPath))
+                continue;
+
+            for (const auto &entry : std::fs::directory_iterator(directoryPath)) {
+                if (!entry.is_directory())
+                    continue;
+
+                const auto scriptPath = entry.path() / "main.py";
+                if (!std::fs::exists(scriptPath))
+                    continue;
+
+                auto pathString = wolv::util::toUTF8String(scriptPath);
+                wolv::io::File scriptFile(pathString, wolv::io::File::Mode::Read);
+                if (!scriptFile.isValid())
+                    continue;
+
+                this->addScript(entry.path().stem().string(), [pathString, scriptContent = scriptFile.readString()] {
+                    PyThreadState* ts = PyThreadState_New(mainThreadState);
+                    PyEval_RestoreThread(ts);
+
+                    ON_SCOPE_EXIT {
+                        PyThreadState_Clear(ts);
+                        PyThreadState_DeleteCurrent();
+                    };
+                    PyObject *libraryModule = PyImport_AddModule("imhex");
+
+                    PyModule_AddStringConstant(libraryModule, "__script_loader__", hex::format("{}", (u64)hex::getContainingModule((void*)&getCurrentTraceback)).c_str());
+                    populateModule(libraryModule, romfs::get("python/imhex.py").data<const char>());
+
+
+                    PyObject *mainModule = PyModule_New(pathString.c_str());
+                    populateModule(mainModule, scriptContent);
+
+                    Py_DECREF(mainModule);
+                });
+
+            }
+        }
+
+        return true;
+    }
+
+}
diff --git a/plugins/script_loader/source/plugin_script_loader.cpp b/plugins/script_loader/source/plugin_script_loader.cpp
index addb4f729..ff47638df 100644
--- a/plugins/script_loader/source/plugin_script_loader.cpp
+++ b/plugins/script_loader/source/plugin_script_loader.cpp
@@ -7,6 +7,7 @@
 #include <hex/ui/imgui_imhex_extensions.h>
 
 #include <loaders/dotnet/dotnet_loader.hpp>
+#include <loaders/python/python_loader.hpp>
 
 #include <romfs/romfs.hpp>
 #include <nlohmann/json.hpp>
@@ -15,8 +16,11 @@ using namespace hex;
 using namespace hex::script::loader;
 
 using ScriptLoaders = std::tuple<
-    #if defined(DOTNET_PLUGINS)
-        DotNetLoader
+    #if defined(IMHEX_DOTNET_SCRIPT_SUPPORT)
+        DotNetLoader,
+    #endif
+    #if defined(IMHEX_PYTHON_SCRIPT_SUPPORT)
+        PythonLoader
     #endif
 >;
 
@@ -91,9 +95,9 @@ namespace {
                 }
 
                 for (const auto &script : scripts) {
-                    const auto &[name, entryPoint] = *script;
+                    const auto &[name, entryPoint, loader] = *script;
 
-                    if (ImGui::MenuItem(name.c_str())) {
+                    if (ImGui::MenuItem(name.c_str(), loader->getTypeName().c_str())) {
                         runnerTask = TaskManager::createTask("Running script...", TaskManager::NoProgress, [entryPoint](auto&) {
                             entryPoint();
                         });
@@ -115,6 +119,11 @@ namespace {
 
 }
 
+IMHEX_PLUGIN_FEATURES() {
+    { ".NET",         IMHEX_FEATURE_ENABLED(DOTNET)   },
+    { "Python",       IMHEX_FEATURE_ENABLED(PYTHON)   },
+};
+
 IMHEX_PLUGIN_SETUP("Script Loader", "WerWolv", "Script Loader plugin") {
     hex::log::debug("Using romfs: '{}'", romfs::name());
     for (auto &path : romfs::list("lang"))
@@ -123,4 +132,4 @@ IMHEX_PLUGIN_SETUP("Script Loader", "WerWolv", "Script Loader plugin") {
     if (initializeAllLoaders()) {
         addScriptsMenu();
     }
-}
+}
\ No newline at end of file
diff --git a/plugins/script_loader/dotnet/AssemblyLoader/.gitignore b/plugins/script_loader/support/dotnet/AssemblyLoader/.gitignore
similarity index 100%
rename from plugins/script_loader/dotnet/AssemblyLoader/.gitignore
rename to plugins/script_loader/support/dotnet/AssemblyLoader/.gitignore
diff --git a/plugins/script_loader/dotnet/AssemblyLoader/AssemblyLoader.csproj b/plugins/script_loader/support/dotnet/AssemblyLoader/AssemblyLoader.csproj
similarity index 100%
rename from plugins/script_loader/dotnet/AssemblyLoader/AssemblyLoader.csproj
rename to plugins/script_loader/support/dotnet/AssemblyLoader/AssemblyLoader.csproj
diff --git a/plugins/script_loader/dotnet/AssemblyLoader/Program.cs b/plugins/script_loader/support/dotnet/AssemblyLoader/Program.cs
similarity index 100%
rename from plugins/script_loader/dotnet/AssemblyLoader/Program.cs
rename to plugins/script_loader/support/dotnet/AssemblyLoader/Program.cs
diff --git a/plugins/script_loader/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml b/plugins/script_loader/support/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml
similarity index 100%
rename from plugins/script_loader/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml
rename to plugins/script_loader/support/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml
diff --git a/plugins/script_loader/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml.user b/plugins/script_loader/support/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml.user
similarity index 100%
rename from plugins/script_loader/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml.user
rename to plugins/script_loader/support/dotnet/AssemblyLoader/Properties/PublishProfiles/FolderProfile.pubxml.user
diff --git a/plugins/script_loader/dotnet/CMakeLists.txt b/plugins/script_loader/support/dotnet/CMakeLists.txt
similarity index 100%
rename from plugins/script_loader/dotnet/CMakeLists.txt
rename to plugins/script_loader/support/dotnet/CMakeLists.txt
diff --git a/plugins/script_loader/support/python/imhex.py b/plugins/script_loader/support/python/imhex.py
new file mode 100644
index 000000000..d91ee7a7f
--- /dev/null
+++ b/plugins/script_loader/support/python/imhex.py
@@ -0,0 +1,9 @@
+import ctypes
+
+script_loader = ctypes.CDLL("Script Loader", ctypes.DEFAULT_MODE, int(__script_loader__))
+
+
+class UI:
+    @staticmethod
+    def show_message_box(message: str):
+        script_loader.showMessageBoxV1(ctypes.create_string_buffer(message.encode("utf-8")))