diff --git a/.clang-tidy b/.clang-tidy
index 932a5be..143d361 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -6,13 +6,13 @@ Checks: >
         google-*,-google-readability-todo,-google-readability-braces-around-statements,
         hicpp-*,-hicpp-braces-around-statements,-hicpp-use-emplace,-hicpp-named-parameter,
           -hicpp-no-array-decay,-hicpp-uppercase-literal-suffix,
-        misc-*,-misc-no-recursion,
+        misc-*,-misc-include-cleaner,-misc-no-recursion,
         bugprone-*,
         boost-*,
         cert-*,-cert-dcl16-c,-cert-dcl51-cpp,-cert-dcl37-c,
         concurrency-*,
         cppcoreguidelines-*,-cppcoreguidelines-avoid-magic-numbers,
-        modernize-*,-modernize-use-trailing-return-type,-modernize-use-emplace,
+        modernize-*,-modernize-use-trailing-return-type,-modernize-use-emplace,-modernize-use-designated-initializers,
         performance-*,-performance-noexcept-move-constructor,
         portability-*,
         readability-*,-readability-redundant-access-specifiers
diff --git a/.github/workflows/cpp-format.yml b/.github/workflows/cpp-format.yml
index df59907..5fc5c62 100644
--- a/.github/workflows/cpp-format.yml
+++ b/.github/workflows/cpp-format.yml
@@ -28,9 +28,9 @@ jobs:
       - uses: actions/checkout@v3
       - uses: jirutka/setup-alpine@v1
         with:
-          branch: v3.19
+          branch: v3.21
           packages: >
-            clang-extra-tools
+            clang19-extra-tools
 
       # Check all source and header C++ files; ignore files in hidden directories
       - name: Execute clang-format
diff --git a/.github/workflows/cpp-lint.yml b/.github/workflows/cpp-lint.yml
index 65a0aaf..b0f2164 100644
--- a/.github/workflows/cpp-lint.yml
+++ b/.github/workflows/cpp-lint.yml
@@ -32,7 +32,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: jirutka/setup-alpine@v1
         with:
-          branch: v3.19
+          branch: v3.21
           packages: >
             cmake
             ninja-build
@@ -44,7 +44,7 @@ jobs:
             python3-dev
             fmt-dev
             gtest-dev
-            clang-extra-tools
+            clang19-extra-tools
       - name: Fixup environment
         run: |
           ln -s liblua-5.2.so.0 /usr/lib/liblua-5.2.so
diff --git a/examples/configurable_plugin/configurable_plugin_manager.cpp b/examples/configurable_plugin/configurable_plugin_manager.cpp
index 14856cd..8efe1f3 100644
--- a/examples/configurable_plugin/configurable_plugin_manager.cpp
+++ b/examples/configurable_plugin/configurable_plugin_manager.cpp
@@ -32,12 +32,10 @@ int main(int argc, char* argv[])
         if (!a_1 || !a_2) {
             return 2;
         }
-        auto unwrapped_a_1 = *a_1;
-        auto unwrapped_a_2 = *a_2;
 
         std::atomic<bool> stop_signal { false };
-        std::thread thread_1([plugin = unwrapped_a_1, &stop_signal]() { plugin->loop(stop_signal); });
-        std::thread thread_2([plugin = unwrapped_a_2, &stop_signal]() { plugin->loop(stop_signal); });
+        std::thread thread_1([plugin = *a_1, &stop_signal]() { plugin->loop(stop_signal); });
+        std::thread thread_2([plugin = *a_2, &stop_signal]() { plugin->loop(stop_signal); });
         std::this_thread::sleep_for(std::chrono::seconds { 5 });
         stop_signal.store(true);
         thread_1.join();
diff --git a/examples/multi_language_plugin/multi_language_plugin_manager.cpp b/examples/multi_language_plugin/multi_language_plugin_manager.cpp
index dd98d88..aded76e 100644
--- a/examples/multi_language_plugin/multi_language_plugin_manager.cpp
+++ b/examples/multi_language_plugin/multi_language_plugin_manager.cpp
@@ -40,12 +40,12 @@ int main(int argc, char* argv[])
             plugins.push_back(std::move(*plugin));
         }
         plugins.push_back(manager.loadCPlugin(non_existant_lib_path)
-                              .andThen([](const auto& plugin) {
-                                  // convert to generic plugin
-                                  return ppplugin::Plugin { plugin };
-                              })
-                              // silently fail and use no-op plugin instead
-                              .valueOr(ppplugin::NoopPlugin {}));
+                .andThen([](const auto& plugin) {
+                    // convert to generic plugin
+                    return ppplugin::Plugin { plugin };
+                })
+                // silently fail and use no-op plugin instead
+                .valueOr(ppplugin::NoopPlugin {}));
         for (auto& plugin : plugins) {
             plugin.call<void>("initialize").valueOrElse([](const ppplugin::CallError& error) {
                 std::cerr << "Initialize Error: " << error.what() << '\n';
@@ -54,7 +54,7 @@ int main(int argc, char* argv[])
         for (int counter {}; counter < std::numeric_limits<int>::max(); ++counter) {
             for (auto& plugin : plugins) {
                 // explicit cast to int to avoid passing by reference
-                plugin.call<void>("loop", static_cast<int>(counter))
+                plugin.call<void>("loop", static_cast<int>(counter)) // NOLINT(readability-redundant-casting)
                     .valueOrElse([](const ppplugin::CallError& error) {
                         std::cerr << "Loop Error: " << error.what() << '\n';
                     });
diff --git a/examples/multi_language_plugin/plugins/cpp_plugin.cpp b/examples/multi_language_plugin/plugins/cpp_plugin.cpp
index d84aa12..76d8d3a 100644
--- a/examples/multi_language_plugin/plugins/cpp_plugin.cpp
+++ b/examples/multi_language_plugin/plugins/cpp_plugin.cpp
@@ -2,7 +2,7 @@
 
 #include <boost/dll/alias.hpp>
 
-void initialize()
+extern void initialize()
 {
     std::cout << "C++ initialize" << '\n';
 }
diff --git a/examples/simple_plugin/simple_plugin_manager.cpp b/examples/simple_plugin/simple_plugin_manager.cpp
index 1d5d170..c99a594 100644
--- a/examples/simple_plugin/simple_plugin_manager.cpp
+++ b/examples/simple_plugin/simple_plugin_manager.cpp
@@ -4,7 +4,6 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <string_view>
 #include <thread>
 
 #include "ppplugin/cpp/plugin.h"
@@ -13,43 +12,25 @@
 
 #include "simple_plugin.h"
 
-void printError(std::string_view function_name, const ppplugin::CallError& error)
-{
-    const std::string_view error_string = error == ppplugin::CallError::Code::symbolNotFound ? "not found"
-        : error == ppplugin::CallError::Code::notLoaded                                      ? "not loaded"
-        : error == ppplugin::CallError::Code::unknown                                        ? "unknown error"
-                                                                                             : "other error";
-    std::cerr << "Unable to call '" << function_name << "' ('" << error_string
-              << "')!\n";
-}
-
-void printError(std::string_view plugin_name, ppplugin::LoadError error)
-{
-    using ppplugin::LoadError;
-    const std::string_view error_string = error == LoadError::fileNotFound ? "not found"
-        : error == LoadError::fileInvalid                                  ? "invalid"
-        : error == LoadError::unknown                                      ? "unknown error"
-                                                                           : "other error";
-    std::cerr << "Unable to load '" << plugin_name << "' ('" << error_string
-              << "')!\n";
-}
-
+namespace {
 template <typename ClassType>
 std::thread initializeAndLoop(ppplugin::CppPlugin& plugin, const std::string& function_name)
 {
-    auto plugin_a = plugin.call<std::shared_ptr<ClassType>>(function_name);
-    if (plugin_a) {
-        auto& plugin = *plugin_a;
+    auto result = plugin.call<std::shared_ptr<ClassType>>(function_name);
+    if (result) {
+        auto& plugin = *result;
         plugin->initialize();
         return std::thread { [plugin]() {
             plugin->loop();
         } };
     }
     // NOLINTNEXTLINE(bugprone-unchecked-optional-access); checked in previous if
-    return std::thread { [function_name, error = *plugin_a.error()]() {
-        printError(function_name, error);
+    return std::thread { [function_name, error = *result.error()]() {
+        std::cerr << "Unable to call '" << function_name
+                  << "' ('" << ppplugin::codeToString(error.code()) << "')!\n";
     } };
 }
+} // namespace
 
 int main(int argc, char* argv[])
 {
@@ -59,14 +40,14 @@ int main(int argc, char* argv[])
         }
         auto executable_dir = std::filesystem::path { argv[0] }.parent_path();
         auto library_path = executable_dir / "libsimple_plugin.so";
-        // setup manager - has to stay alive for as long as you want to use the
-        // plugins
+        // setup manager - has to stay alive for as long as you want to use the plugins
         ppplugin::GenericPluginManager<SimplePluginInterface> manager;
         // load plugin library and exit on error
-        auto plugin_library = manager.loadCppPlugin(std::filesystem::path { library_path }).valueOrElse([](const auto& error) -> ppplugin::CppPlugin {
-            printError("simple_plugin_a", error);
-            std::exit(1); // NOLINT(concurrency-mt-unsafe)
-        });
+        auto plugin_library = manager.loadCppPlugin(std::filesystem::path { library_path })
+                                  .valueOrElse([](const auto& error) -> ppplugin::CppPlugin {
+                                      std::cerr << "Unable to load plugin: " << ppplugin::codeToString(error);
+                                      std::exit(1); // NOLINT(concurrency-mt-unsafe)
+                                  });
 
         auto thread_a = initializeAndLoop<SimplePluginA>(plugin_library, "create_a");
         auto thread_b = initializeAndLoop<SimplePluginInterface>(plugin_library, "create_b");
diff --git a/include/ppplugin/c/plugin.h b/include/ppplugin/c/plugin.h
index faf1c07..94f8ac9 100644
--- a/include/ppplugin/c/plugin.h
+++ b/include/ppplugin/c/plugin.h
@@ -7,29 +7,18 @@
 namespace ppplugin {
 class CPlugin {
 public:
-    static Expected<CPlugin, LoadError> load(
-        const std::filesystem::path& plugin_library_path)
-    {
-        if (auto shared_library = detail::boost_dll::loadSharedLibrary(plugin_library_path)) {
-            CPlugin new_plugin;
-            new_plugin.plugin_ = *shared_library;
-            return new_plugin;
-        }
-        return LoadError::unknown;
-    }
+    [[nodiscard]] static Expected<CPlugin, LoadError> load(const std::filesystem::path& plugin_library_path);
+
+    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
+    operator bool() const;
 
     template <typename ReturnValue, typename... Args>
-    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args)
-    {
-        static_assert(!std::is_reference_v<ReturnValue>,
-            "C does not support references for its return value!");
-        static_assert(!(std::is_reference_v<Args> || ...),
-            "C does not support references for its arguments! "
-            "Consider passing the argument with an explicit cast to the desired type.");
-
-        return detail::boost_dll::call<false, ReturnValue>(
-            plugin_, function_name, std::forward<Args>(args)...);
-    }
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
 
 private:
     CPlugin() = default;
@@ -37,6 +26,41 @@ class CPlugin {
 private:
     boost::dll::shared_library plugin_;
 };
+
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> CPlugin::call(const std::string& function_name, Args&&... args)
+{
+    static_assert(!std::is_reference_v<ReturnValue>,
+        "C does not support references for its return value!");
+    static_assert(!(std::is_reference_v<Args> || ...),
+        "C does not support references for its arguments! "
+        "Consider passing the argument with an explicit cast to the desired type.");
+
+    return detail::boost_dll::call<false, ReturnValue>(
+        plugin_, function_name, std::forward<Args>(args)...);
+}
+
+// TODO: remove code duplication here and in C++ plugin
+template <typename VariableType>
+CallResult<VariableType> CPlugin::global(const std::string& variable_name)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        return *reinterpret_cast<VariableType*>(p.value().value());
+    }
+    return { p.error().value() };
+}
+
+template <typename VariableType>
+CallResult<void> CPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        *reinterpret_cast<VariableType*>(p.value().value()) = std::forward<VariableType>(new_value);
+        return {};
+    }
+    return { p.error().value() };
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_C_PLUGIN_H
diff --git a/include/ppplugin/cpp/object_plugin.h b/include/ppplugin/cpp/object_plugin.h
deleted file mode 100644
index 6673b3a..0000000
--- a/include/ppplugin/cpp/object_plugin.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef PPPLUGIN_CPP_OBJECT_PLUGIN_H
-#define PPPLUGIN_CPP_OBJECT_PLUGIN_H
-
-namespace ppplugin {
-/**
- * Plugin that has a creator function that creates an object
- * of a known base class.
- */
-template <typename P>
-class CppObjectPlugin {
-public:
-    // TODO
-};
-} // namespace ppplugin
-
-#endif // PPPLUGIN_CPP_OBJECT_PLUGIN_H
diff --git a/include/ppplugin/cpp/plugin.h b/include/ppplugin/cpp/plugin.h
index e06eddd..867b3db 100644
--- a/include/ppplugin/cpp/plugin.h
+++ b/include/ppplugin/cpp/plugin.h
@@ -12,16 +12,7 @@
 namespace ppplugin {
 class CppPlugin {
 public:
-    static Expected<CppPlugin, LoadError> load(
-        const std::filesystem::path& plugin_library_path)
-    {
-        if (auto shared_library = detail::boost_dll::loadSharedLibrary(plugin_library_path)) {
-            CppPlugin new_plugin;
-            new_plugin.plugin_ = *shared_library;
-            return new_plugin;
-        }
-        return LoadError::unknown;
-    }
+    [[nodiscard]] static Expected<CppPlugin, LoadError> load(const std::filesystem::path& plugin_library_path);
 
     ~CppPlugin() = default;
     CppPlugin(const CppPlugin&) = default;
@@ -30,17 +21,15 @@ class CppPlugin {
     CppPlugin& operator=(CppPlugin&&) = default;
 
     // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
-    operator bool() const
-    {
-        return plugin_.is_loaded();
-    }
+    operator bool() const;
 
     template <typename ReturnValue, typename... Args>
-    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args)
-    {
-        return detail::boost_dll::call<true, ReturnValue>(
-            plugin_, function_name, std::forward<Args>(args)...);
-    }
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
 
 private:
     CppPlugin() = default;
@@ -48,6 +37,34 @@ class CppPlugin {
 private:
     boost::dll::shared_library plugin_;
 };
+
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> CppPlugin::call(const std::string& function_name, Args&&... args)
+{
+    return detail::boost_dll::call<true, ReturnValue>(
+        plugin_, function_name, std::forward<Args>(args)...);
+}
+
+template <typename VariableType>
+CallResult<VariableType> CppPlugin::global(const std::string& variable_name)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        return *reinterpret_cast<VariableType*>(p.value().value());
+    }
+    return { p.error().value() };
+}
+
+template <typename VariableType>
+CallResult<void> CppPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        *reinterpret_cast<VariableType*>(p.value().value()) = std::forward<VariableType>(new_value);
+        return {};
+    }
+    return { p.error().value() };
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_CPP_PLUGIN_H
diff --git a/include/ppplugin/detail/boost_dll_loader.h b/include/ppplugin/detail/boost_dll_loader.h
index 7bb7b42..2e85ce3 100644
--- a/include/ppplugin/detail/boost_dll_loader.h
+++ b/include/ppplugin/detail/boost_dll_loader.h
@@ -20,6 +20,7 @@ namespace ppplugin::detail::boost_dll {
 
 [[nodiscard]] CallResult<void*> getFunctionSymbol(const boost::dll::shared_library& library, const std::string& function_name);
 [[nodiscard]] CallResult<void*> getFunctionPointerSymbol(const boost::dll::shared_library& library, const std::string& function_name);
+[[nodiscard]] CallResult<void**> getSymbol(const boost::dll::shared_library& library, const std::string& function_name);
 
 template <bool isPointer, typename ReturnValue, typename... Args>
 [[nodiscard]] CallResult<ReturnValue> call(const boost::dll::shared_library& library, const std::string& function_name, Args&&... args)
diff --git a/include/ppplugin/detail/template_helpers.h b/include/ppplugin/detail/template_helpers.h
index f21c8f7..b09f224 100644
--- a/include/ppplugin/detail/template_helpers.h
+++ b/include/ppplugin/detail/template_helpers.h
@@ -99,6 +99,23 @@ struct FirstOr<DefaultType> {
 template <typename DefaultType, typename... Types>
 using FirstOrT = typename FirstOr<DefaultType, Types...>::Type;
 
+/**
+ * Get second template parameter of given class.
+ * If the class does not have any or sufficient template parameters,
+ * return given DefaultType.
+ */
+template <typename DefaultType, typename>
+struct SecondTemplateParameterOr {
+    using Type = DefaultType;
+};
+template <typename DefaultType, template <typename...> typename T,
+    typename U, typename V, typename... Ts>
+struct SecondTemplateParameterOr<DefaultType, T<U, V, Ts...>> {
+    using Type = V;
+};
+template <typename... Ts>
+using SecondTemplateParameterOrT = typename SecondTemplateParameterOr<Ts...>::Type;
+
 /**
  * Wrap types into given type "Wrapper" (which has to accept exactly one template argument,
  * but can have more defaulted template parameters) and puts them into the first given type
@@ -168,9 +185,18 @@ struct IsSpecialization : std::false_type { };
 template <template <typename...> typename ExpectedType, typename... Ts>
 struct IsSpecialization<ExpectedType<Ts...>, ExpectedType> : std::true_type { };
 
+template <typename ActualType, template <typename...> typename ExpectedType>
+constexpr bool IsSpecializationV = // NOLINT(readability-identifier-naming)
+    IsSpecialization<ActualType, ExpectedType>::value;
+
 template <typename T>
 using IsStdTuple = IsSpecialization<T, std::tuple>;
 
+/**
+ * C++17 compatible version of std::remove_cvref_t.
+ */
+template <typename T>
+using RemoveCvrefT = std::remove_cv_t<std::remove_reference_t<T>>;
 } // namespace ppplugin::detail::templates
 
 #endif // PPPLUGIN_DETAIL_TEMPLATE_HELPERS_H
diff --git a/include/ppplugin/errors.h b/include/ppplugin/errors.h
index c23d4e1..8a85b5c 100644
--- a/include/ppplugin/errors.h
+++ b/include/ppplugin/errors.h
@@ -8,6 +8,7 @@
 #include <source_location>
 #endif // PPPLUGIN_CPP17_COMPATIBILITY
 #include <string>
+#include <string_view>
 
 namespace ppplugin {
 class CallError {
@@ -16,6 +17,7 @@ class CallError {
         unknown,
         notLoaded,
         symbolNotFound,
+        incorrectType,
     };
 
     // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
@@ -46,7 +48,7 @@ class CallError {
     {
     }
 
-    [[nodiscard]] CallError error() const { return error_; }
+    [[nodiscard]] Code code() const { return error_; }
     [[nodiscard]] const std::string& what() const { return what_; }
 #ifndef PPPLUGIN_CPP17_COMPATIBILITY
     [[nodiscard]] const std::source_location& location() const
@@ -75,6 +77,21 @@ class CallError {
 #endif // PPPLUGIN_CPP17_COMPATIBILITY
 };
 
+[[nodiscard]] static constexpr std::string_view codeToString(CallError::Code code)
+{
+    switch (code) {
+    case CallError::Code::incorrectType:
+        return "incorrect type";
+    case CallError::Code::notLoaded:
+        return "not loaded";
+    case CallError::Code::symbolNotFound:
+        return "symbol not found";
+    case CallError::Code::unknown:
+    default:
+        return "unknown";
+    }
+}
+
 enum class LoadError {
     unknown,
     fileNotFound,
@@ -82,6 +99,21 @@ enum class LoadError {
     fileNotReadable,
 };
 
+[[nodiscard]] static constexpr std::string_view codeToString(LoadError code)
+{
+    switch (code) {
+    case LoadError::fileNotReadable:
+        return "file not readable";
+    case LoadError::fileInvalid:
+        return "file invalid";
+    case LoadError::fileNotFound:
+        return "file not found";
+    case LoadError::unknown:
+    default:
+        return "unknown";
+    }
+}
+
 template <typename ReturnType>
 using CallResult = Expected<ReturnType, CallError>;
 
diff --git a/include/ppplugin/expected.h b/include/ppplugin/expected.h
index 2fbf6ca..36a4ca4 100644
--- a/include/ppplugin/expected.h
+++ b/include/ppplugin/expected.h
@@ -1,6 +1,8 @@
 #ifndef PPPLUGIN_EXPECTED_H
 #define PPPLUGIN_EXPECTED_H
 
+#include "detail/template_helpers.h"
+
 #include <cassert>
 #include <optional>
 #include <variant>
@@ -112,6 +114,17 @@ class Expected {
     template <typename, typename>
     friend class Expected;
 
+    // andThen wraps the result of the function into an Expected, except if the function
+    // returns an Expected which has an error matching the error type of the current instance.
+    template <typename InvokeResult>
+    using AndThenReturnType = std::conditional_t<
+        detail::templates::IsSpecialization<detail::templates::RemoveCvrefT<InvokeResult>, Expected>::value,
+        std::conditional_t<
+            std::is_same_v<detail::templates::SecondTemplateParameterOrT<void, detail::templates::RemoveCvrefT<InvokeResult>>, E>,
+            InvokeResult,
+            Expected<InvokeResult, E>>,
+        Expected<InvokeResult, E>>;
+
     // actually, these functions also have a check, but will throw on error
     [[nodiscard]] constexpr T& uncheckedValue() & { return std::get<T>(value_); }
     [[nodiscard]] constexpr const T& uncheckedValue() const& { return std::get<T>(value_); }
@@ -446,13 +459,13 @@ template <typename F>
 constexpr auto Expected<T, E>::andThen(F&& func) const&
 {
     if constexpr (std::is_invocable_v<F, T>) {
-        using ReturnType = Expected<std::invoke_result_t<F, T>, E>;
+        using ReturnType = AndThenReturnType<std::invoke_result_t<F, T>>;
         if (!hasValue()) {
             return static_cast<ReturnType>(uncheckedError());
         }
         return static_cast<ReturnType>(std::forward<F>(func)(uncheckedValue()));
     } else if constexpr (std::is_invocable_v<F>) {
-        using ReturnType = Expected<std::invoke_result_t<F>, E>;
+        using ReturnType = AndThenReturnType<std::invoke_result_t<F>>;
         if (!hasValue()) {
             return static_cast<ReturnType>(uncheckedError());
         }
@@ -467,7 +480,7 @@ template <typename F>
 constexpr auto Expected<T, E>::andThen(F&& func) &&
 {
     if constexpr (std::is_invocable_v<F, T>) {
-        using ReturnType = Expected<std::invoke_result_t<F, T>, E>;
+        using ReturnType = AndThenReturnType<std::invoke_result_t<F, T>>;
         if (!hasValue()) {
             return static_cast<ReturnType>(std::move(*this).uncheckedError());
         }
@@ -479,7 +492,7 @@ constexpr auto Expected<T, E>::andThen(F&& func) &&
                 std::move(*this).uncheckedValue()));
         }
     } else if constexpr (std::is_invocable_v<F>) {
-        using ReturnType = Expected<std::invoke_result_t<F>, E>;
+        using ReturnType = AndThenReturnType<std::invoke_result_t<F>>;
         if (!hasValue()) {
             return static_cast<ReturnType>(std::move(*this).uncheckedError());
         }
diff --git a/include/ppplugin/lua/lua_script.h b/include/ppplugin/lua/lua_script.h
index 5a456b1..5ceefe4 100644
--- a/include/ppplugin/lua/lua_script.h
+++ b/include/ppplugin/lua/lua_script.h
@@ -28,45 +28,26 @@ class LuaScript {
     LuaScript& operator=(LuaScript&&) noexcept = default;
 
     template <typename ReturnValue, typename... Args>
-    CallResult<ReturnValue> call(const std::string& function_name, Args&&... args)
-    {
-        if (state_.pushGlobal(function_name)) {
-            if (auto function = state_.top<ReturnValue(Args...)>()) {
-                return (*function)(std::forward<Args>(args)...);
-            }
-            return CallError { CallError::Code::unknown, "Symbol does not match given type" };
-        }
-        return { CallError::Code::symbolNotFound };
-    }
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    void global(const std::string& variable_name, VariableType&& new_value);
 
 private:
     LuaScript();
 
-    bool run();
+    [[nodiscard]] bool run();
 
-    std::optional<LoadError> loadFile(const std::filesystem::path& lua_file, bool auto_run);
+    [[nodiscard]] std::optional<LoadError> loadFile(const std::filesystem::path& lua_file, bool auto_run);
 
     static void pcall();
 
     template <typename... Args>
-    void push(Args&&... args)
-    {
-        if constexpr (sizeof...(Args) > 0) {
-            state_.push(std::forward<Args>(args)...);
-        }
-    }
+    void push(Args&&... args);
 
-    /**
-     * Can be used to define global variables or functions for usage in Lua script.
-     */
-    template <typename T>
-    void setGlobal(const std::string& variable_name, T&& value)
-    {
-        push(std::forward<T>(value));
-        state_.markGlobal(variable_name);
-    }
-
-    static std::string errorToString(int error_code);
+    [[nodiscard]] static std::string errorToString(int error_code);
 
     struct StackContext {
         // TODO: push error handling function to stack
@@ -81,6 +62,44 @@ class LuaScript {
     LuaState state_;
 };
 
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> LuaScript::call(const std::string& function_name, Args&&... args)
+{
+    if (state_.pushGlobal(function_name)) {
+        if (auto function = state_.top<ReturnValue(Args...)>()) {
+            return (*function)(std::forward<Args>(args)...);
+        }
+        return CallError { CallError::Code::unknown, "Symbol does not match given type" };
+    }
+    return { CallError::Code::symbolNotFound };
+}
+
+template <typename VariableType>
+CallResult<VariableType> LuaScript::global(const std::string& variable_name)
+{
+    if (state_.pushGlobal(variable_name)) {
+        if (auto value = state_.pop<VariableType>()) {
+            return value.value();
+        }
+        return { CallError::Code::incorrectType };
+    }
+    return { CallError::Code::symbolNotFound };
+}
+template <typename VariableType>
+void LuaScript::global(const std::string& variable_name, VariableType&& new_value)
+{
+    push(std::forward<VariableType>(new_value));
+    state_.markGlobal(variable_name);
+}
+
+template <typename... Args>
+void LuaScript::push(Args&&... args)
+{
+    if constexpr (sizeof...(Args) > 0) {
+        state_.push(std::forward<Args>(args)...);
+    }
+}
+
 } // namespace ppplugin
 
 #endif // PPPLUGIN_LUA_SCRIPT_H
diff --git a/include/ppplugin/lua/lua_state.h b/include/ppplugin/lua/lua_state.h
index 17c8555..d040f2d 100644
--- a/include/ppplugin/lua/lua_state.h
+++ b/include/ppplugin/lua/lua_state.h
@@ -4,24 +4,17 @@
 #include "lua_helpers.h"
 #include "ppplugin/detail/compatibility_utils.h"
 #include "ppplugin/detail/function_details.h"
+#include "ppplugin/detail/template_helpers.h"
 #include "ppplugin/errors.h"
 
 #include <functional>
+#include <map>
 #include <memory>
 #include <optional>
 
 struct lua_State;
 
 namespace ppplugin {
-enum class LuaType {
-    none = -1,
-    nil = 0,
-    boolean = 1,
-    number = 3,
-    string = 4,
-    function = 6,
-};
-
 class LuaState {
 public:
     LuaState();
@@ -30,7 +23,7 @@ class LuaState {
      * Wrap given state in a LuaState and allow access to methods,
      * but do not claim ownership of the state.
      */
-    static LuaState wrap(lua_State* state) { return LuaState(state); }
+    [[nodiscard]] static LuaState wrap(lua_State* state) { return LuaState(state); }
 
     [[nodiscard]] lua_State* state() { return state_.get(); }
     [[nodiscard]] const lua_State* state() const { return state_.get(); }
@@ -54,22 +47,22 @@ class LuaState {
      * @return top-most stack value or std::nullopt if given type does not match
      */
     template <typename T, std::enable_if_t<!std::is_function_v<T>, bool> = true>
-    std::optional<T> pop(bool always_pop = false);
+    [[nodiscard]] std::optional<T> pop(bool always_pop = false);
     /**
      * Pop upmost element of type function from Lua stack.
      *
      * @return std::function wrapped in optional of given function type.
      */
     template <typename T, std::enable_if_t<std::is_function_v<T>, bool> = true>
-    auto pop(bool always_pop = false);
+    [[nodiscard]] auto pop(bool always_pop = false);
 
     /**
      * Get top-most stack value.
      */
     template <typename T, std::enable_if_t<!std::is_function_v<T>, bool> = true>
-    std::optional<T> top();
+    [[nodiscard]] std::optional<T> top();
     template <typename T, std::enable_if_t<std::is_function_v<T>, bool> = true>
-    auto top();
+    [[nodiscard]] auto top();
 
     /**
      * Mark top-most stack value as global variable with given name.
@@ -81,30 +74,44 @@ class LuaState {
      *
      * @return true if global of given name exists, otherwise false
      */
-    bool pushGlobal(const std::string& variable_name);
+    [[nodiscard]] bool pushGlobal(const std::string& variable_name);
 
     /**
      * Check if top-most stack value is of type bool.
      */
-    bool isBool();
+    [[nodiscard]] bool isBool();
     /**
      * Check if top-most stack value is of type number.
      */
-    bool isNumber();
+    [[nodiscard]] bool isNumber();
     /**
      * Check if top-most stack value is of type string.
      */
-    bool isString();
+    [[nodiscard]] bool isString();
     /**
      * Check if top-most stack value is of type function.
      */
-    bool isFunction();
+    [[nodiscard]] bool isFunction();
+    /**
+     * Check if top-most stack value is of type table (either array or map).
+     */
+    [[nodiscard]] bool isTable();
 
     /**
      * Register function handler to be called in case of a Lua panic.
      */
     void registerPanicHandler(LuaCFunction handler);
 
+    /**
+     * Dump stack between given indices to stream.
+     */
+    void dumpStack(std::ostream& out, int start_index = 1, int end_index = -1
+#ifndef PPPLUGIN_CPP17_COMPATIBILITY
+        ,
+        const std::source_location& location = std::source_location::current()
+#endif // PPPLUGIN_CPP17_COMPATIBILITY
+    );
+
 private:
     /**
      * Create non-owning LuaState instance of given state.
@@ -117,13 +124,17 @@ class LuaState {
     [[nodiscard]] std::optional<int> topInt();
     [[nodiscard]] std::optional<double> topDouble();
     template <typename T>
-    auto topFunction();
-    const void* topPointer();
+    [[nodiscard]] auto topFunction();
+    [[nodiscard]] const void* topPointer();
+    template <typename T>
+    [[nodiscard]] std::optional<T> topMap();
+    template <typename T>
+    [[nodiscard]] std::optional<T> topArray();
 
     /**
      * Check if top-most stack value is of type nil.
      */
-    bool isNil();
+    [[nodiscard]] bool isNil();
 
     /**
      * Pop top-most value if it is a function.
@@ -150,19 +161,53 @@ class LuaState {
     void pushOne(std::nullptr_t);
     void pushOne(LuaCFunction func);
 
+    // TODO: support additional container types
+    template <typename T>
+    void pushOne(const std::vector<T>& value);
+    template <typename K, typename V>
+    void pushOne(const std::map<K, V>& value);
+
+    /**
+     * Start creation of table.
+     * All following push() calls will be used alternating as key and value.
+     *
+     * @return index of table which must be passed to endTable() to complete table creation
+     */
+    int startTable(std::size_t size_hint, bool is_array);
+
+    /**
+     * Finalize table.
+     * Stack must contain as many (key, value) pairs as the given table size indicates and
+     * no other elements are allowed on the stack in-between.
+     */
+    void endTable(int table_index, std::size_t table_size);
+
     /**
      * Call function on stack with given number of arguments from stack.
      * The function has to be in right below the arguments on the stack.
      *
      * @return 0 on success, non-zero value on error
      */
-    int pcall(std::size_t argument_count, std::size_t return_count);
+    [[nodiscard]] int pcall(std::size_t argument_count, std::size_t return_count);
 
     /**
      * Discard top-most stack value.
      */
     void discardTop();
 
+    /**
+     * Push next table item (first key, second value) to stack.
+     * Before first call, top-most stack value must be of type table.
+     * Before next call, pop the value (top element of stack).
+     * To abort iteration, remove both key and value from stack.
+     *
+     * @param is_first_iteration Must be true to start the iteration process
+     *
+     * @return true if the next key/value was pushed to the stack,
+     *         false if there are no more elements in the table
+     */
+    bool pushNextTableItem(bool is_first_iteration);
+
 private:
     std::unique_ptr<lua_State, void (*)(lua_State*)> state_;
 };
@@ -172,7 +217,7 @@ void LuaState::push(T&& arg, Args&&... args)
 {
     pushOne(std::forward<T>(arg));
     if constexpr (sizeof...(Args) > 0) {
-        push(std::forward<Args...>(args...));
+        push(std::forward<Args>(args)...);
     }
 }
 
@@ -200,7 +245,7 @@ auto LuaState::pop(bool always_pop)
 template <typename T, std::enable_if_t<!std::is_function_v<T>, bool>>
 std::optional<T> LuaState::top()
 {
-    using PlainT = std::remove_cv_t<std::remove_reference_t<T>>;
+    using PlainT = detail::templates::RemoveCvrefT<T>;
     if constexpr (std::is_same_v<PlainT, double>) {
         return topDouble();
     } else if constexpr (std::is_same_v<PlainT, int>) {
@@ -209,6 +254,10 @@ std::optional<T> LuaState::top()
         return topBool();
     } else if constexpr (std::is_same_v<PlainT, std::string>) {
         return topString();
+    } else if constexpr (detail::templates::IsSpecializationV<T, std::map>) {
+        return topMap<T>();
+    } else if constexpr (detail::templates::IsSpecializationV<T, std::vector>) {
+        return topArray<T>();
     } else {
         static_assert(!sizeof(T), "Unsupported type!");
     }
@@ -237,7 +286,7 @@ auto LuaState::topFunction()
             push(std::forward<decltype(args)>(args)...);
         }
         auto error = pcall(sizeof...(args), RETURN_TYPE_COUNT);
-        // TODO
+        // TODO: proper error checking
         if (error != 0) {
             return CallError {
                 CallError::Code::unknown,
@@ -268,6 +317,77 @@ auto LuaState::topFunction()
     }
     return std::optional<decltype(top_function)> { std::nullopt };
 }
+
+template <typename T>
+std::optional<T> LuaState::topMap()
+{
+    if (isTable()) {
+        T result;
+
+        bool is_first_iteration = true;
+        while (pushNextTableItem(is_first_iteration)) {
+            is_first_iteration = false;
+
+            // pop value but keep key to iterate to next element
+            auto value = pop<typename T::mapped_type>(true);
+            auto key = top<typename T::key_type>();
+
+            if (key.has_value() && value.has_value()) {
+                result.emplace(*std::move(key), *std::move(value));
+            } else {
+                discardTop(); // abort iteration by discarding key
+                // key or value have wrong type
+                return std::nullopt;
+            }
+        }
+        return result;
+    }
+    return std::nullopt;
+}
+
+template <typename T>
+std::optional<T> LuaState::topArray()
+{
+    // retrieve table as sorted map first since iteration is not guaranteed to
+    // be in correct order
+    auto array_map = topMap<std::map<int, typename T::value_type>>();
+    if (!array_map.has_value()) {
+        // not a table or does not match given type
+        return std::nullopt;
+    }
+
+    T result;
+    for (auto& [index, value] : *array_map) {
+        if (index - 1 != static_cast<int>(result.size())) { // Lua indices start at 1
+            // keys not continuous, thus it cannot be turned into an array
+            return std::nullopt;
+        }
+        result.push_back(std::move(value));
+    }
+    return result;
+}
+
+template <typename T>
+void LuaState::pushOne(const std::vector<T>& value)
+{
+    auto table_index = startTable(value.size(), true);
+    for (std::size_t index = 0; index < value.size(); ++index) {
+        pushOne(index + 1); // Lua arrays start at 1
+        push(value[index]);
+    }
+    endTable(table_index, value.size());
+}
+
+template <typename K, typename V>
+void LuaState::pushOne(const std::map<K, V>& value)
+{
+    auto table_index = startTable(value.size(), false);
+    for (auto&& [key, element] : value) {
+        pushOne(key);
+        push(element);
+    }
+    endTable(table_index, value.size());
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_LUA_STATE_H
diff --git a/include/ppplugin/lua/plugin.h b/include/ppplugin/lua/plugin.h
index 23bacba..2cafd73 100644
--- a/include/ppplugin/lua/plugin.h
+++ b/include/ppplugin/lua/plugin.h
@@ -9,15 +9,8 @@
 namespace ppplugin {
 class LuaPlugin {
 public:
-    static Expected<LuaPlugin, LoadError> load(
-        const std::filesystem::path& plugin_library_path, bool auto_run = true)
-    {
-        return LuaScript::load(plugin_library_path, auto_run)
-            .andThen([](auto script) {
-                LuaPlugin new_plugin { std::move(script) };
-                return new_plugin;
-            });
-    }
+    [[nodiscard]] static Expected<LuaPlugin, LoadError> load(
+        const std::filesystem::path& plugin_library_path, bool auto_run = true);
 
     ~LuaPlugin() = default;
     LuaPlugin(const LuaPlugin&) = delete;
@@ -42,10 +35,12 @@ class LuaPlugin {
      * - std::tuple
      */
     template <typename ReturnValue, typename... Args>
-    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args)
-    {
-        return script_.call<ReturnValue>(function_name, std::forward<Args>(args)...);
-    }
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
 
 private:
     explicit LuaPlugin(LuaScript&& script)
@@ -57,6 +52,26 @@ class LuaPlugin {
     LuaScript script_;
 };
 
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> LuaPlugin::call(const std::string& function_name, Args&&... args)
+{
+    return script_.call<ReturnValue>(function_name, std::forward<Args>(args)...);
+}
+
+template <typename VariableType>
+CallResult<VariableType> LuaPlugin::global(const std::string& variable_name)
+{
+    return script_.global<VariableType>(variable_name);
+}
+
+template <typename VariableType>
+CallResult<void> LuaPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    script_.global(variable_name, std::forward<VariableType>(new_value));
+    // cannot fail in Lua; new value will be assigned regardless of previous type
+    // and variable will be created if it does not exist yet
+    return {};
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_LUA_PLUGIN_H
diff --git a/include/ppplugin/noop_plugin.h b/include/ppplugin/noop_plugin.h
index 5a41d5c..5b0c240 100644
--- a/include/ppplugin/noop_plugin.h
+++ b/include/ppplugin/noop_plugin.h
@@ -14,19 +14,33 @@ class NoopPlugin {
     operator bool() const { return true; }
 
     template <typename ReturnValue, typename... Args>
-    CallResult<ReturnValue> call(std::string_view /*function_name*/, Args&&... /*args*/)
+    [[nodiscard]] CallResult<ReturnValue> call(std::string_view /*function_name*/, Args&&... /*args*/);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& /*variable_name*/)
     {
-        if constexpr (!std::is_void_v<ReturnValue>) {
-            if constexpr (std::is_default_constructible_v<ReturnValue>) {
-                return ReturnValue {};
-            } else {
-                static_assert(!sizeof(ReturnValue),
-                    "Return value of noop function must be default constructible!");
-            }
-        }
-        return CallResult<ReturnValue> {};
+        return VariableType {};
+    }
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& /*variable_name*/, VariableType&& /*new_value*/)
+    {
+        return {};
     }
 };
+
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> NoopPlugin::call(std::string_view /*function_name*/, Args&&... /*args*/)
+{
+    if constexpr (!std::is_void_v<ReturnValue>) {
+        if constexpr (std::is_default_constructible_v<ReturnValue>) {
+            return ReturnValue {};
+        } else {
+            static_assert(!sizeof(ReturnValue),
+                "Return value of noop function must be default constructible!");
+        }
+    }
+    return CallResult<ReturnValue> {};
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_NOOP_PLUGIN_H
diff --git a/include/ppplugin/plugin.h b/include/ppplugin/plugin.h
index 05a6950..472868f 100644
--- a/include/ppplugin/plugin.h
+++ b/include/ppplugin/plugin.h
@@ -15,7 +15,6 @@
 #ifndef PPPLUGIN_CPP17_COMPATIBILITY
 #include <concepts>
 #endif // PPPLUGIN_CPP17_COMPATIBILITY
-#include <filesystem>
 #include <optional>
 #include <utility>
 #include <variant>
@@ -42,7 +41,7 @@ class GenericPlugin {
 
     GenericPlugin() = default;
     template <typename P,
-        std::enable_if_t<(std::is_base_of_v<Plugins, std::remove_cv_t<std::remove_reference_t<P>>> || ...), bool> = true>
+        std::enable_if_t<(std::is_base_of_v<Plugins, detail::templates::RemoveCvrefT<P>> || ...), bool> = true>
     GenericPlugin(P&& plugin); // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
 
     ~GenericPlugin() = default;
@@ -57,8 +56,13 @@ class GenericPlugin {
     template <typename ReturnValue, typename... Args>
     [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
 
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
+
     template <typename P>
-    std::optional<std::reference_wrapper<P>> plugin();
+    [[nodiscard]] std::optional<std::reference_wrapper<P>> plugin();
 
 private:
     detail::templates::UniqueVariant<Plugins...> plugin_;
@@ -68,7 +72,7 @@ using Plugin = GenericPlugin<CPlugin, CppPlugin, LuaPlugin, PythonPlugin, NoopPl
 
 template <typename... Plugins>
 template <typename P,
-    std::enable_if_t<(std::is_base_of_v<Plugins, std::remove_cv_t<std::remove_reference_t<P>>> || ...), bool>>
+    std::enable_if_t<(std::is_base_of_v<Plugins, detail::templates::RemoveCvrefT<P>> || ...), bool>>
 // NOLINTNEXTLINE(bugprone-forwarding-reference-overload); enable_if condition prevents hiding copy/move ctors
 GenericPlugin<Plugins...>::GenericPlugin(P&& plugin)
     : plugin_(std::forward<P>(plugin))
@@ -98,6 +102,28 @@ CallResult<ReturnValue> GenericPlugin<Plugins...>::call(
         plugin_);
 }
 
+template <typename... Plugins>
+template <typename VariableType>
+CallResult<VariableType> GenericPlugin<Plugins...>::global(const std::string& variable_name)
+{
+    return std::visit(
+        [&variable_name](auto& plugin) -> CallResult<VariableType> {
+            return plugin.template global<VariableType>(variable_name);
+        },
+        plugin_);
+}
+
+template <typename... Plugins>
+template <typename VariableType>
+CallResult<void> GenericPlugin<Plugins...>::global(const std::string& variable_name, VariableType&& new_value)
+{
+    return std::visit(
+        [&variable_name, &new_value](auto& plugin) {
+            plugin.global(variable_name, std::forward<VariableType>(new_value));
+        },
+        plugin_);
+}
+
 template <typename... Plugins>
 template <typename P>
 std::optional<std::reference_wrapper<P>> GenericPlugin<Plugins...>::plugin()
diff --git a/include/ppplugin/plugin_manager.h b/include/ppplugin/plugin_manager.h
index 9fb84dc..a330807 100644
--- a/include/ppplugin/plugin_manager.h
+++ b/include/ppplugin/plugin_manager.h
@@ -36,7 +36,7 @@ class GenericPluginManager {
     /**
      * Load Lua script from given path.
      */
-    Expected<LuaPlugin, LoadError> loadLuaPlugin(
+    [[nodiscard]] Expected<LuaPlugin, LoadError> loadLuaPlugin(
         const std::filesystem::path& plugin_library_path)
     {
         return LuaPlugin::load(plugin_library_path);
@@ -45,7 +45,7 @@ class GenericPluginManager {
     /**
      * Load Python script from given path.
      */
-    Expected<PythonPlugin, LoadError> loadPythonPlugin(
+    [[nodiscard]] Expected<PythonPlugin, LoadError> loadPythonPlugin(
         const std::filesystem::path& plugin_library_path)
     {
         return PythonPlugin::load(plugin_library_path);
@@ -60,7 +60,7 @@ class GenericPluginManager {
      *            created by the plugin are fully destroyed.
      *            Failure to do so will result in a SEGFAULT.
      */
-    Expected<CppPlugin, LoadError> loadCppPlugin(
+    [[nodiscard]] Expected<CppPlugin, LoadError> loadCppPlugin(
         const std::filesystem::path& plugin_library_path)
     {
         return CppPlugin::load(plugin_library_path);
@@ -70,7 +70,7 @@ class GenericPluginManager {
      * This plugin can call any C function or C++ functions that were marked
      * as 'extern "C"'.
      */
-    Expected<CPlugin, LoadError> loadCPlugin(
+    [[nodiscard]] Expected<CPlugin, LoadError> loadCPlugin(
         const std::filesystem::path& plugin_library_path)
     {
         return CPlugin::load(plugin_library_path);
diff --git a/include/ppplugin/python/plugin.h b/include/ppplugin/python/plugin.h
index bf9fb16..a29b837 100644
--- a/include/ppplugin/python/plugin.h
+++ b/include/ppplugin/python/plugin.h
@@ -1,7 +1,6 @@
 #ifndef PPPLUGIN_PYTHON_PLUGIN_H
 #define PPPLUGIN_PYTHON_PLUGIN_H
 
-#include "ppplugin/detail/function_details.h"
 #include "ppplugin/errors.h"
 #include "ppplugin/expected.h"
 #include "ppplugin/python/python_interpreter.h"
@@ -27,6 +26,11 @@ class PythonPlugin {
     template <typename ReturnValue, typename... Args>
     [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
 
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
+
 private:
     PythonPlugin() = default;
 
@@ -39,6 +43,17 @@ CallResult<ReturnValue> PythonPlugin::call(const std::string& function_name, Arg
 {
     return interpreter_.call<ReturnValue>(function_name, std::forward<Args>(args)...);
 }
+
+template <typename VariableType>
+CallResult<VariableType> PythonPlugin::global(const std::string& variable_name)
+{
+    return interpreter_.global<VariableType>(variable_name);
+}
+template <typename VariableType>
+CallResult<void> PythonPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    return interpreter_.global(variable_name, std::forward<VariableType>(new_value));
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_PYTHON_PLUGIN_H
diff --git a/include/ppplugin/python/python_guard.h b/include/ppplugin/python/python_guard.h
index 52fefd9..e8a9147 100644
--- a/include/ppplugin/python/python_guard.h
+++ b/include/ppplugin/python/python_guard.h
@@ -12,6 +12,9 @@ struct PythonGuard final {
     PythonGuard& operator=(const PythonGuard&) = delete;
     PythonGuard& operator=(PythonGuard&&) = delete;
 
+    static void lock(PyThreadState* state);
+    static void unlock(PyThreadState* state);
+
 private:
     PyThreadState* state_;
 };
diff --git a/include/ppplugin/python/python_interpreter.h b/include/ppplugin/python/python_interpreter.h
index 592ff9d..264e7b8 100644
--- a/include/ppplugin/python/python_interpreter.h
+++ b/include/ppplugin/python/python_interpreter.h
@@ -14,21 +14,50 @@ namespace ppplugin {
 class PythonInterpreter {
 public:
     PythonInterpreter();
-    // TODO: call Py_Finalize()
+    ~PythonInterpreter();
+    PythonInterpreter(const PythonInterpreter&) = delete;
+    PythonInterpreter(PythonInterpreter&&) = default;
+    PythonInterpreter& operator=(const PythonInterpreter&) = delete;
+    PythonInterpreter& operator=(PythonInterpreter&&) = default;
 
-    std::optional<LoadError> load(const std::string& file_name);
+    [[nodiscard]] std::optional<LoadError> load(const std::string& file_name);
     template <typename ReturnValue, typename... Args>
-    CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
 
 private:
-    PyThreadState* state() { return state_.get(); }
-    PyObject* mainModule() { return main_module_.get(); }
+    [[nodiscard]] PyThreadState* state() { return state_.get(); }
+    [[nodiscard]] PyObject* mainModule() { return main_module_.get(); }
+
+    /**
+     * Call function with given arguments.
+     * Arguments must be wrapped in a python tuple.
+     *
+     * @note the GIL must be held
+     */
+    [[nodiscard]] CallResult<PythonObject> internalCall(const std::string& function_name, PyObject* args);
 
-    CallResult<PythonObject> internalCall(const std::string& function_name, PyObject* args);
+    /**
+     * Return value of global variable for given name.
+     *
+     * @note the GIL must be held
+     */
+    [[nodiscard]] CallResult<PythonObject> internalGlobal(const std::string& variable_name);
+    /**
+     * Set value of global variable for given name.
+     * Will create the global variable if it does not exist yet.
+     *
+     * @note the GIL must be held
+     */
+    [[nodiscard]] CallResult<void> internalGlobal(const std::string& variable_name, PythonObject new_value);
 
 private:
-    std::unique_ptr<PyObject, std::function<void(PyObject*)>> main_module_;
     std::unique_ptr<PyThreadState, void (*)(PyThreadState*)> state_;
+    std::unique_ptr<PyObject, std::function<void(PyObject*)>> main_module_;
 };
 
 template <typename ReturnValue, typename... Args>
@@ -37,14 +66,36 @@ CallResult<ReturnValue> PythonInterpreter::call(const std::string& function_name
     PythonGuard python_guard { state() };
     PythonTuple args_tuple { std::forward<Args>(args)... };
 
-    return internalCall(function_name, args_tuple.pyObject()).andThen([](const PythonObject& result) {
+    return internalCall(function_name, args_tuple.pyObject()).andThen([](PythonObject&& result) -> CallResult<ReturnValue> {
         if constexpr (std::is_void_v<ReturnValue>) {
-            return;
+            return {};
         } else {
-            return result.as<ReturnValue>();
+            if (auto return_value = std::move(result).as<ReturnValue>()) {
+                return *return_value;
+            }
+            return CallError { CallError::Code::incorrectType, "Unable to convert result to return type!" };
+        }
+    });
+}
+
+template <typename VariableType>
+CallResult<VariableType> PythonInterpreter::global(const std::string& variable_name)
+{
+    PythonGuard python_guard { state() };
+    return internalGlobal(variable_name).andThen([](PythonObject&& object) -> CallResult<VariableType> {
+        if (auto result = std::move(object).template as<VariableType>()) {
+            return *result;
         }
+        return { CallError::Code::incorrectType };
     });
 }
+
+template <typename VariableType>
+CallResult<void> PythonInterpreter::global(const std::string& variable_name, VariableType&& new_value)
+{
+    PythonGuard python_guard { state() };
+    return internalGlobal(variable_name, PythonObject::from(std::forward<VariableType>(new_value)));
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_PYTHON_INTERPRETER_H
diff --git a/include/ppplugin/python/python_object.h b/include/ppplugin/python/python_object.h
index c8a06ed..be777a4 100644
--- a/include/ppplugin/python/python_object.h
+++ b/include/ppplugin/python/python_object.h
@@ -1,11 +1,14 @@
 #ifndef PPPLUGIN_PYTHON_OBJECT_H
 #define PPPLUGIN_PYTHON_OBJECT_H
 
+#include "ppplugin/detail/template_helpers.h"
 #include "python_forward_defs.h"
 
+#include <map>
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace ppplugin {
 class PythonObject {
@@ -13,43 +16,121 @@ class PythonObject {
     PythonObject();
     explicit PythonObject(PyObject* object);
 
+    [[nodiscard]] static PythonObject from(double value);
+    // NOLINTBEGIN(google-runtime-int)
+    [[nodiscard]] static PythonObject from(unsigned int value);
+    [[nodiscard]] static PythonObject from(int value);
+    [[nodiscard]] static PythonObject from(unsigned long value);
+    [[nodiscard]] static PythonObject from(long value);
+    [[nodiscard]] static PythonObject from(unsigned long long value);
+    [[nodiscard]] static PythonObject from(long long value);
+    // NOLINTEND(google-runtime-int)
+    [[nodiscard]] static PythonObject from(char value);
+    [[nodiscard]] static PythonObject from(const char* value);
+    [[nodiscard]] static PythonObject from(std::string_view value);
+    [[nodiscard]] static PythonObject from(const std::string& value);
+    [[nodiscard]] static PythonObject from(bool value);
+    [[nodiscard]] static PythonObject from(std::nullptr_t);
+    template <typename K, typename V>
+    [[nodiscard]] static PythonObject from(const std::map<K, V>& value);
+    template <typename T>
+    [[nodiscard]] static PythonObject from(const std::vector<T>& value);
+    // TODO: also make adding function (via function pointer) possible?
+
     /**
      * Wrap given PyObject into PythonObject without claiming
      * ownership (no Py_DECREF at end of lifetime).
-     * Use this to access member functions for non-owning PyObjects.
+     * Use this to access member functions for non-owned PyObjects.
      */
-    static PythonObject wrap(PyObject* object);
+    [[nodiscard]] static PythonObject wrap(PyObject* object);
 
-    PyObject* pyObject() { return object(); }
+    [[nodiscard]] PyObject* pyObject() { return object(); }
+    /**
+     * Release owned reference and returned internal PyObject.
+     * This will make this instance an empty PythonObject and no
+     * Py_DECREF will be called for any previously managed object.
+     */
+    [[nodiscard]] PyObject* release() { return object_.release(); }
 
     explicit operator bool()
     {
         return object() != nullptr;
     }
 
+    /**
+     * Get current value as given type.
+     */
     template <typename T>
-    std::optional<T> as();
+    [[nodiscard]] std::optional<T> as();
 
+    /**
+     * Cast current value to given type.
+     */
     template <typename T>
-    std::optional<T> to();
+    [[nodiscard]] std::optional<T> to();
 
 private:
     PyObject* object() { return object_.get(); }
 
     // TODO: use explicit template instantiations instead?
-    std::optional<int> asInt();
+    [[nodiscard]] std::optional<int> asInt();
     // NOLINTNEXTLINE(google-runtime-int)
-    std::optional<long long> asLongLong();
-    std::optional<double> asDouble();
-    std::optional<bool> asBool();
-    std::optional<std::string> asString();
+    [[nodiscard]] std::optional<long long> asLongLong();
+    [[nodiscard]] std::optional<double> asDouble();
+    [[nodiscard]] std::optional<bool> asBool();
+    [[nodiscard]] std::optional<char> asChar();
+    [[nodiscard]] std::optional<std::string> asString();
+    template <typename T>
+    [[nodiscard]] std::optional<T> asMap();
+    template <typename T>
+    [[nodiscard]] std::optional<T> asArray();
 
-    std::optional<std::string> toString();
+    [[nodiscard]] std::optional<std::string> toString();
+
+    [[nodiscard]] bool isInt();
+    [[nodiscard]] bool isDouble();
+    [[nodiscard]] bool isBool();
+    [[nodiscard]] bool isString();
+    [[nodiscard]] bool isBytes();
+    [[nodiscard]] bool isDict();
+    [[nodiscard]] bool isList();
+
+    [[nodiscard]] static PyObject* initList(int size);
+    [[nodiscard]] static PyObject* initDict();
+
+    void setListItem(int index, PyObject* value);
+    void setDictItem(PyObject* key, PyObject* value);
+
+    [[nodiscard]] PythonObject getItem(int index);
+    [[nodiscard]] PythonObject getNextItem(PythonObject& iterator);
 
 private:
     std::unique_ptr<PyObject, void (*)(PyObject*)> object_;
 };
 
+template <typename K, typename V>
+PythonObject PythonObject::from(const std::map<K, V>& dict)
+{
+    PythonObject object { initDict() };
+    for (auto&& [key, value] : dict) {
+        auto py_key = PythonObject::from(key);
+        auto py_value = PythonObject::from(value);
+        object.setDictItem(py_key.pyObject(), py_value.pyObject());
+    }
+    return object;
+}
+
+template <typename T>
+PythonObject PythonObject::from(const std::vector<T>& value)
+{
+    PythonObject object { initList(value.size()) };
+    for (std::size_t i = 0; i < value.size(); ++i) {
+        auto element = PythonObject::from(value[i]);
+        object.setListItem(i, element.pyObject());
+    }
+    return object;
+}
+
 template <typename T>
 std::optional<T> PythonObject::as()
 {
@@ -59,10 +140,16 @@ std::optional<T> PythonObject::as()
         return asDouble();
     } else if constexpr (std::is_same_v<T, bool>) {
         return asBool();
+    } else if constexpr (std::is_same_v<T, char>) {
+        return asChar();
     } else if constexpr (std::is_same_v<T, std::string>) {
         return asString();
     } else if constexpr (std::is_integral_v<T>) {
         return asLongLong();
+    } else if constexpr (detail::templates::IsSpecializationV<T, std::vector>) {
+        return asArray<T>();
+    } else if constexpr (detail::templates::IsSpecializationV<T, std::map>) {
+        return asMap<T>();
     } else {
         static_assert(sizeof(T), "Cannot interpret PythonObject as given type!");
     }
@@ -79,6 +166,52 @@ std::optional<T> PythonObject::to()
     }
     return std::nullopt;
 }
+
+template <typename T>
+std::optional<T> PythonObject::asMap()
+{
+    if (!isDict()) {
+        return std::nullopt;
+    }
+
+    using KeyType = typename T::key_type;
+    using ValueType = typename T::mapped_type;
+
+    T result;
+    PythonObject iterator;
+    PythonObject item;
+    while ((item = getNextItem(iterator))) {
+        auto key = item.getItem(0).as<KeyType>();
+        auto value = item.getItem(1).as<ValueType>();
+        if (key && value) {
+            result.emplace(std::move(*key), std::move(*value));
+        } else {
+            return std::nullopt;
+        }
+    }
+    return result;
+}
+
+template <typename T>
+std::optional<T> PythonObject::asArray()
+{
+    if (!isList()) {
+        return std::nullopt;
+    }
+
+    using ValueType = typename T::value_type;
+
+    T result;
+    PythonObject iterator;
+    while (auto item = getNextItem(iterator)) {
+        if (auto value = item.as<ValueType>()) {
+            result.push_back(std::move(*value));
+        } else {
+            return std::nullopt;
+        }
+    }
+    return result;
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_PYTHON_OBJECT_H
diff --git a/include/ppplugin/python/python_tuple.h b/include/ppplugin/python/python_tuple.h
index a31837c..4721406 100644
--- a/include/ppplugin/python/python_tuple.h
+++ b/include/ppplugin/python/python_tuple.h
@@ -4,43 +4,24 @@
 #include "python_forward_defs.h"
 #include "python_object.h"
 
-#include <cstddef>
-#include <string>
-#include <string_view>
-
 namespace ppplugin {
 class PythonTuple {
 public:
     template <typename... Args>
     explicit PythonTuple(Args&&... args);
 
-    PyObject* pyObject() { return object(); }
+    [[nodiscard]] PyObject* pyObject() { return object(); }
 
 private:
-    PyObject* object() { return object_.pyObject(); }
+    [[nodiscard]] PyObject* object() { return object_.pyObject(); }
 
-    static PyObject* initTuple(int size);
+    [[nodiscard]] static PyObject* initTuple(int size);
 
     template <typename T, typename... Args>
     void fillTuple(int start_index, T&& arg, Args&&... args);
 
-    // NOLINTBEGIN(bugprone-easily-swappable-parameters)
-    // NOLINTBEGIN(google-runtime-int)
-    void setTupleItem(int index, double value);
-    void setTupleItem(int index, unsigned int value);
-    void setTupleItem(int index, int value);
-    void setTupleItem(int index, unsigned long value);
-    void setTupleItem(int index, long value);
-    void setTupleItem(int index, unsigned long long value);
-    void setTupleItem(int index, long long value);
-    void setTupleItem(int index, const char* value);
-    void setTupleItem(int index, std::string_view value);
-    void setTupleItem(int index, const std::string& value);
-    void setTupleItem(int index, bool value);
-    void setTupleItem(int index, std::nullptr_t);
-    // NOLINTEND(google-runtime-int)
-    // NOLINTEND(bugprone-easily-swappable-parameters)
-    // TODO: also make adding function (via function pointer) possible?
+    void setTupleItem(int index, PythonObject value);
+    [[nodiscard]] PythonObject getTupleItem(int index);
 
 private:
     PythonObject object_;
@@ -58,7 +39,9 @@ PythonTuple::PythonTuple(Args&&... args)
 template <typename T, typename... Args>
 void PythonTuple::fillTuple(int start_index, T&& arg, Args&&... args)
 {
-    setTupleItem(start_index, std::forward<T>(arg));
+    auto element = PythonObject::from(std::forward<T>(arg));
+    setTupleItem(start_index, std::move(element));
+
     if constexpr (sizeof...(Args) > 0) {
         fillTuple(start_index + 1, std::forward<Args>(args)...);
     }
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index bc5d063..eccba01 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,8 +1,10 @@
 set(LIBRARY_SOURCES ppplugin.cpp)
 
 set(LIBRARY_SOURCES
-    "ppplugin.cpp"
     "boost_dll_loader.cpp"
+    "c_plugin.cpp"
+    "cpp_plugin.cpp"
+    "lua_plugin.cpp"
     "lua_state.cpp"
     "lua_script.cpp"
     "python_plugin.cpp"
diff --git a/src/boost_dll_loader.cpp b/src/boost_dll_loader.cpp
index 3921253..e2994c0 100644
--- a/src/boost_dll_loader.cpp
+++ b/src/boost_dll_loader.cpp
@@ -1,3 +1,4 @@
+#include "ppplugin/detail/boost_dll_loader.h"
 #include "ppplugin/errors.h"
 
 #include <exception>
@@ -10,7 +11,7 @@
 #include <boost/filesystem/path.hpp>
 
 namespace {
-std::optional<ppplugin::CallError> isCallable(const boost::dll::shared_library& library, const std::string& function_name)
+[[nodiscard]] std::optional<ppplugin::CallError> isCallable(const boost::dll::shared_library& library, const std::string& function_name)
 {
     if (!library.is_loaded()) {
         return ppplugin::CallError::Code::notLoaded;
@@ -25,7 +26,7 @@ std::optional<ppplugin::CallError> isCallable(const boost::dll::shared_library&
 } // namespace
 
 namespace ppplugin::detail::boost_dll {
-[[nodiscard]] CallResult<void*> getFunctionSymbol(const boost::dll::shared_library& library, const std::string& function_name)
+CallResult<void*> getFunctionSymbol(const boost::dll::shared_library& library, const std::string& function_name)
 {
     if (auto error = isCallable(library, function_name)) {
         return { *error };
@@ -41,14 +42,29 @@ namespace ppplugin::detail::boost_dll {
     return { CallError::Code::unknown };
 }
 
-[[nodiscard]] CallResult<void*> getFunctionPointerSymbol(const boost::dll::shared_library& library, const std::string& function_name)
+CallResult<void*> getFunctionPointerSymbol(const boost::dll::shared_library& library, const std::string& function_name)
+{
+    if (auto error = isCallable(library, function_name)) {
+        return { *error };
+    }
+    try {
+        if (auto* symbol = library.get<void*>(function_name)) {
+            return symbol;
+        }
+    } catch (const std::exception& exception) {
+        return CallError { CallError::Code::unknown, exception.what() };
+    }
+    return { CallError::Code::unknown };
+}
+
+CallResult<void**> getSymbol(const boost::dll::shared_library& library, const std::string& function_name)
 {
     if (auto error = isCallable(library, function_name)) {
         return { *error };
     }
     try {
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        if (auto* symbol = reinterpret_cast<void*>(library.get<void*>(function_name))) {
+        if (auto** symbol = &library.get<void*>(function_name)) {
             return symbol;
         }
     } catch (const std::exception& exception) {
@@ -57,13 +73,7 @@ namespace ppplugin::detail::boost_dll {
     return { CallError::Code::unknown };
 }
 
-/**
- * Attempt to load shared library from given path.
- *
- * Returned library object is not necessarily loaded, check
- * boost::dll::shared_library::is_loaded().
- */
-[[nodiscard]] std::optional<boost::dll::shared_library> loadSharedLibrary(
+std::optional<boost::dll::shared_library> loadSharedLibrary(
     const std::filesystem::path& plugin_library_path)
 {
     if (!std::filesystem::exists(plugin_library_path)) {
diff --git a/src/c_plugin.cpp b/src/c_plugin.cpp
new file mode 100644
index 0000000..4a4fc24
--- /dev/null
+++ b/src/c_plugin.cpp
@@ -0,0 +1,18 @@
+#include "ppplugin/c/plugin.h"
+
+namespace ppplugin {
+Expected<CPlugin, LoadError> CPlugin::load(const std::filesystem::path& plugin_library_path)
+{
+    if (auto shared_library = detail::boost_dll::loadSharedLibrary(plugin_library_path)) {
+        CPlugin new_plugin;
+        new_plugin.plugin_ = *shared_library;
+        return new_plugin;
+    }
+    return LoadError::unknown;
+}
+
+CPlugin::operator bool() const
+{
+    return plugin_.is_loaded();
+}
+} // namespace ppplugin
diff --git a/src/cpp_plugin.cpp b/src/cpp_plugin.cpp
new file mode 100644
index 0000000..c96c742
--- /dev/null
+++ b/src/cpp_plugin.cpp
@@ -0,0 +1,18 @@
+#include "ppplugin/cpp/plugin.h"
+
+namespace ppplugin {
+Expected<CppPlugin, LoadError> CppPlugin::load(const std::filesystem::path& plugin_library_path)
+{
+    if (auto shared_library = detail::boost_dll::loadSharedLibrary(plugin_library_path)) {
+        CppPlugin new_plugin;
+        new_plugin.plugin_ = *shared_library;
+        return new_plugin;
+    }
+    return LoadError::unknown;
+}
+
+CppPlugin::operator bool() const
+{
+    return plugin_.is_loaded();
+}
+} // namespace ppplugin
diff --git a/src/lua_plugin.cpp b/src/lua_plugin.cpp
new file mode 100644
index 0000000..24b9ff0
--- /dev/null
+++ b/src/lua_plugin.cpp
@@ -0,0 +1,12 @@
+#include "ppplugin/lua/plugin.h"
+
+namespace ppplugin {
+Expected<LuaPlugin, LoadError> LuaPlugin::load(const std::filesystem::path& plugin_library_path, bool auto_run)
+{
+    return LuaScript::load(plugin_library_path, auto_run)
+        .andThen([](auto script) {
+            LuaPlugin new_plugin { std::move(script) };
+            return new_plugin;
+        });
+}
+} // namespace ppplugin
diff --git a/src/lua_state.cpp b/src/lua_state.cpp
index b2be374..c209e0e 100644
--- a/src/lua_state.cpp
+++ b/src/lua_state.cpp
@@ -2,6 +2,7 @@
 
 #include <cstddef>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <string_view>
 
@@ -23,7 +24,7 @@ LuaState::LuaState()
 }
 
 LuaState::LuaState(lua_State* state)
-    : state_ { state, [](lua_State*) {} }
+    : state_ { state, [](lua_State*) { } }
 {
 }
 
@@ -133,6 +134,11 @@ bool LuaState::isNil()
     return lua_type(state(), -1) == LUA_TNIL;
 }
 
+bool LuaState::isTable()
+{
+    return lua_type(state(), -1) == LUA_TTABLE;
+}
+
 void LuaState::registerPanicHandler(LuaCFunction handler)
 {
     lua_atpanic(state(), handler);
@@ -158,4 +164,61 @@ bool LuaState::pushGlobal(const std::string& variable_name)
     }
     return true;
 }
+
+int LuaState::startTable(std::size_t size_hint, bool is_array)
+{
+    const int array_size = is_array ? static_cast<int>(size_hint) : 0;
+    const int map_size = is_array ? 0 : static_cast<int>(size_hint);
+    lua_createtable(state(), array_size, map_size);
+
+    return lua_gettop(state());
+}
+
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+void LuaState::endTable(int table_index, std::size_t table_size)
+{
+    assert(static_cast<std::size_t>(lua_gettop(state())) > table_size * 2);
+    for (std::size_t i = 0; i < table_size; ++i) {
+        lua_settable(state(), table_index);
+    }
+}
+
+bool LuaState::pushNextTableItem(bool is_first_iteration)
+{
+    if (is_first_iteration) {
+        assert(isTable());
+        pushOne(nullptr);
+    }
+
+    // table is below key (or nil for first iteration) which is on the stack
+    auto table_index = lua_gettop(state()) - 1;
+    assert(table_index >= 1);
+
+    // if finished, lua_next will push nothing and return 0
+    return lua_next(state(), table_index) != 0;
+}
+
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+void LuaState::dumpStack(std::ostream& out, int start_index, int end_index
+#ifndef PPPLUGIN_CPP17_COMPATIBILITY
+    ,
+    const std::source_location& location
+#endif // PPPLUGIN_CPP17_COMPATIBILITY
+)
+{
+    auto top_index = lua_gettop(state());
+    out << "Lua Stack (size " << top_index << ")"
+#ifndef PPPLUGIN_CPP17_COMPATIBILITY
+        << " at " << location.file_name() << ":" << location.line()
+#endif // PPPLUGIN_CPP17_COMPATIBILITY
+        << ":\n";
+
+    end_index = end_index < 0 ? top_index : end_index;
+    for (int i = start_index; i <= end_index; ++i) {
+        auto type = lua_type(state(), i);
+        const auto* type_name = lua_typename(state(), type);
+
+        out << i << ": (" << type_name << ")\n";
+    }
+}
 } // namespace ppplugin
diff --git a/src/ppplugin.cpp b/src/ppplugin.cpp
deleted file mode 100644
index e69de29..0000000
diff --git a/src/python_exception.cpp b/src/python_exception.cpp
index aa9f02c..2a80bd5 100644
--- a/src/python_exception.cpp
+++ b/src/python_exception.cpp
@@ -12,8 +12,6 @@
 #include <import.h>
 #include <listobject.h>
 #include <object.h>
-#include <pyerrors.h>
-#include <pytypedefs.h>
 
 namespace ppplugin {
 std::optional<PythonException> PythonException::latest()
diff --git a/src/python_guard.cpp b/src/python_guard.cpp
index 4b68bda..c3d3caf 100644
--- a/src/python_guard.cpp
+++ b/src/python_guard.cpp
@@ -9,10 +9,23 @@ namespace ppplugin {
 PythonGuard::PythonGuard(PyThreadState* state)
     : state_ { state }
 {
-    PyEval_AcquireThread(state_); // aquire GIL
+    lock(state_);
 }
+
 PythonGuard::~PythonGuard()
 {
-    PyEval_ReleaseThread(state_); // release GIL
+    unlock(state_);
+}
+
+void PythonGuard::lock(PyThreadState* state)
+{
+    assert(state != nullptr);
+    PyEval_AcquireThread(state); // aquire GIL
+}
+
+void PythonGuard::unlock(PyThreadState* state)
+{
+    assert(state != nullptr);
+    PyEval_ReleaseThread(state); // release GIL
 }
 } // namespace ppplugin
diff --git a/src/python_interpreter.cpp b/src/python_interpreter.cpp
index c71a642..2862559 100644
--- a/src/python_interpreter.cpp
+++ b/src/python_interpreter.cpp
@@ -16,20 +16,6 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h> // NOLINT(misc-include-cleaner)
-#include <abstract.h>
-#include <bytesobject.h>
-#include <ceval.h>
-#include <compile.h>
-#include <cpython/initconfig.h>
-#include <dictobject.h>
-#include <import.h>
-#include <listobject.h>
-#include <moduleobject.h>
-#include <object.h>
-#include <pylifecycle.h>
-#include <pystate.h>
-#include <pythonrun.h>
-#include <unicodeobject.h>
 
 namespace {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -58,20 +44,30 @@ std::once_flag python_initialization_done; // this is fine because Python
     Py_DECREF(keys);
     return result;
 }
+
+#if PY_VERSION_HEX >= 0x030c0000 // Python 3.12 or newer
+/**
+ * Create interpreter configuration struct for new Python sub-interpreter.
+ */
+PyInterpreterConfig createInterpreterConfig()
+{
+    PyInterpreterConfig config {};
+    config.use_main_obmalloc = 0;
+    config.allow_fork = 0;
+    config.allow_exec = 0;
+    config.allow_threads = 1;
+    config.allow_daemon_threads = 0;
+    config.check_multi_interp_extensions = 1;
+    config.gil = PyInterpreterConfig_OWN_GIL;
+    return config;
+}
+#endif // PY_VERSION_HEX
 } // namespace
 
 namespace ppplugin {
 PythonInterpreter::PythonInterpreter()
-    : main_module_ { nullptr, [this](auto* main_module) {
-                        if (!state()) {
-                            // TODO: handle this failure
-                            return;
-                        }
-                        const PythonGuard python_guard { state() };
-                        Py_DECREF(main_module);
-                    } }
-    , state_ { nullptr, [](auto* state) {
-                  const PythonGuard python_guard { state };
+    : state_ { nullptr, [](auto* state) {
+                  PythonGuard::lock(state);
                   Py_EndInterpreter(state);
               } }
 {
@@ -95,7 +91,7 @@ PythonInterpreter::PythonInterpreter()
     PyGILState_Ensure();
 #if PY_VERSION_HEX >= 0x030c0000 // Python 3.12 or newer
     PyThreadState* new_state = nullptr;
-    PyInterpreterConfig config = _PyInterpreterConfig_INIT;
+    const auto config = createInterpreterConfig();
     auto status = Py_NewInterpreterFromConfig(&new_state, &config);
     if (PyStatus_IsError(status) == 0) {
         state_.reset(new_state);
@@ -107,11 +103,27 @@ PythonInterpreter::PythonInterpreter()
     // Python will exit application on error
     state_.reset(Py_NewInterpreter());
 #endif // PY_VERSION_HEX
-    main_module_.reset(PyImport_AddModule("__main__"));
+    main_module_ = { PyImport_AddModule("__main__"),
+        [state = state_.get()](auto* main_module) {
+            if (state) {
+                const PythonGuard guard { state };
+                Py_DECREF(main_module);
+            }
+        } };
     // release GIL of sub-interpreter
     PyEval_ReleaseThread(state());
 }
 
+PythonInterpreter::~PythonInterpreter()
+{
+    // main_module_ must be destructed before state_ since it will access the
+    // state object in its deleter
+    main_module_.reset();
+    state_.reset();
+
+    // TODO: call Py_Finalize()?
+}
+
 std::optional<LoadError> PythonInterpreter::load(const std::string& file_name)
 {
     const std::unique_ptr<FILE, void (*)(FILE*)> file {
@@ -141,8 +153,6 @@ std::optional<LoadError> PythonInterpreter::load(const std::string& file_name)
 
 CallResult<PythonObject> PythonInterpreter::internalCall(const std::string& function_name, PyObject* args)
 {
-    // TODO: find uniform way to manage guards (here: already locked in PythonPlugin::call)
-    // PythonGuard python_guard { state() };
     auto* function = PyObject_GetAttrString(mainModule(), function_name.c_str());
     if ((function == nullptr) || (PyCallable_Check(function) == 0)) {
         Py_XDECREF(function);
@@ -175,4 +185,35 @@ CallResult<PythonObject> PythonInterpreter::internalCall(const std::string& func
     return result;
 }
 
+CallResult<PythonObject> PythonInterpreter::internalGlobal(const std::string& variable_name)
+{
+    auto* variable = PyObject_GetAttrString(mainModule(), variable_name.c_str());
+    if (variable == nullptr) {
+        if (PythonException::occurred()) {
+            if (auto exception = PythonException::latest()) {
+                return CallError {
+                    CallError::Code::symbolNotFound,
+                    exception->toString()
+                };
+            }
+            return CallError { CallError::Code::symbolNotFound };
+        }
+        return { CallError::Code::unknown };
+    }
+    return PythonObject { variable };
+}
+
+CallResult<void> PythonInterpreter::internalGlobal(const std::string& variable_name, PythonObject new_value)
+{
+    PythonObject attribute_name { PyUnicode_FromString(variable_name.c_str()) };
+    auto result = PyObject_SetAttr(mainModule(), attribute_name.pyObject(), new_value.pyObject());
+    if (result < 0) {
+        auto exception = PythonException::latest();
+        return CallError {
+            CallError::Code::unknown,
+            exception.value_or(PythonException {}).toString()
+        };
+    }
+    return {};
+}
 } // namespace ppplugin
diff --git a/src/python_object.cpp b/src/python_object.cpp
index a858fd8..b7658b9 100644
--- a/src/python_object.cpp
+++ b/src/python_object.cpp
@@ -1,17 +1,12 @@
 #include "ppplugin/python/python_object.h"
+#include "ppplugin/python/python_exception.h"
 
 #include <optional>
 #include <string>
+#include <string_view>
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h> // NOLINT(misc-include-cleaner)
-#include <boolobject.h>
-#include <bytesobject.h>
-#include <floatobject.h>
-#include <longobject.h>
-#include <object.h>
-#include <pytypedefs.h>
-#include <unicodeobject.h>
 
 namespace ppplugin {
 PythonObject::PythonObject()
@@ -30,15 +25,86 @@ PythonObject::PythonObject(PyObject* object)
 PythonObject PythonObject::wrap(PyObject* object)
 {
     PythonObject new_object;
-    new_object.object_ = { object, [](auto*) {} };
+    new_object.object_ = { object, [](auto*) { } };
     return new_object;
 }
+// NOLINTBEGIN(google-runtime-int)
+PythonObject PythonObject::from(double value)
+{
+    return PythonObject { PyFloat_FromDouble(value) };
+}
+
+PythonObject PythonObject::from(unsigned int value)
+{
+    return PythonObject::from(static_cast<unsigned long>(value));
+}
+
+PythonObject PythonObject::from(int value)
+{
+    return PythonObject::from(static_cast<long>(value));
+}
+
+PythonObject PythonObject::from(unsigned long value)
+{
+    return PythonObject { PyLong_FromUnsignedLong(value) };
+}
+
+PythonObject PythonObject::from(long value)
+{
+    return PythonObject { PyLong_FromLong(value) };
+}
+
+PythonObject PythonObject::from(unsigned long long value)
+{
+    return PythonObject { PyLong_FromUnsignedLongLong(value) };
+}
+
+PythonObject PythonObject::from(long long value)
+{
+    return PythonObject { PyLong_FromLongLong(value) };
+}
+// NOLINTEND(google-runtime-int)
+
+PythonObject PythonObject::from(char value)
+{
+    // Python does not have a character class, only strings of length 1
+    return PythonObject::from(std::string_view { &value, 1 });
+}
+
+PythonObject PythonObject::from(const char* value)
+{
+    return PythonObject { PyUnicode_FromString(value) };
+}
+
+PythonObject PythonObject::from(std::string_view value)
+{
+    return PythonObject { PyUnicode_FromStringAndSize(
+        value.data(), static_cast<Py_ssize_t>(value.size())) };
+}
+
+PythonObject PythonObject::from(const std::string& value)
+{
+    return PythonObject::from(std::string_view { value });
+}
+
+PythonObject PythonObject::from(bool value)
+{
+    return PythonObject { PyBool_FromLong(static_cast<int>(value)) };
+}
+
+PythonObject PythonObject::from(std::nullptr_t)
+{
+    return PythonObject::wrap(Py_None);
+}
 
 std::optional<int> PythonObject::asInt()
 {
-    if (PyLong_Check(object()) != 0) {
-        // TODO: PyErr_Occurred check necessary
-        return PyLong_AsLong(object());
+    if (isInt()) {
+        auto result = PyLong_AsLong(object());
+        if (result == -1 && PythonException::occurred()) {
+            return std::nullopt;
+        }
+        return result;
     }
     return std::nullopt;
 }
@@ -46,35 +112,51 @@ std::optional<int> PythonObject::asInt()
 // NOLINTNEXTLINE(google-runtime-int)
 std::optional<long long> PythonObject::asLongLong()
 {
+    if (!isInt()) {
+        return std::nullopt;
+    }
+
     int overflow {};
     auto result = PyLong_AsLongLongAndOverflow(object(), &overflow);
-    if (overflow == 0) {
-        // TODO: PyErr_Occurred check necessary
-        return result;
+    if ((result == -1 && PythonException::occurred()) || overflow != 0) {
+        // overflow or other error occurred
+        return std::nullopt;
     }
-    return std::nullopt;
+    return result;
 }
 
 std::optional<double> PythonObject::asDouble()
 {
-    if (PyFloat_Check(object()) != 0) {
-        // TODO: PyErr_Occurred check necessary
-        return PyFloat_AsDouble(object());
+    if (isDouble()) {
+        auto result = PyFloat_AsDouble(object());
+        if (result == -1.0 && PythonException::occurred()) {
+            return std::nullopt;
+        }
+        return result;
     }
     return std::nullopt;
 }
 
 std::optional<bool> PythonObject::asBool()
 {
-    if (PyBool_Check(object()) != 0) {
+    if (isBool()) {
         return object() == Py_True;
     }
     return std::nullopt;
 }
 
+std::optional<char> PythonObject::asChar()
+{
+    if (auto string = asString();
+        string.has_value() && string->size() == 1) {
+        return string->at(0);
+    }
+    return std::nullopt;
+}
+
 std::optional<std::string> PythonObject::asString()
 {
-    if (PyUnicode_Check(object()) != 0) {
+    if (isString()) {
         PythonObject utf8_object { PyUnicode_AsUTF8String(object()) };
         if (!utf8_object) {
             return std::nullopt;
@@ -82,12 +164,13 @@ std::optional<std::string> PythonObject::asString()
         std::string result { PyBytes_AsString(utf8_object.pyObject()) };
         return result;
     }
-    if (PyBytes_Check(object()) != 0) {
-        auto* result = PyBytes_AsString(object());
+    if (isBytes()) {
+        const auto* result = PyBytes_AsString(object());
         if (result == nullptr) {
             return std::nullopt;
         }
-        return std::string { result };
+        auto length = PyBytes_Size(object());
+        return std::string { result, static_cast<std::string::size_type>(length) };
     }
     return std::nullopt;
 }
@@ -96,4 +179,101 @@ std::optional<std::string> PythonObject::toString()
 {
     return PythonObject { PyObject_Str(object()) }.asString();
 }
+
+bool PythonObject::isInt()
+{
+    return object() != nullptr && PyLong_Check(object()) != 0;
+}
+
+bool PythonObject::isDouble()
+{
+    return object() != nullptr && PyFloat_Check(object()) != 0;
+}
+
+bool PythonObject::isBool()
+{
+    return object() != nullptr && PyBool_Check(object()) != 0;
+}
+
+bool PythonObject::isString()
+{
+    return object() != nullptr && PyUnicode_Check(object()) != 0;
+}
+
+bool PythonObject::isBytes()
+{
+    return object() != nullptr && PyBytes_Check(object()) != 0;
+}
+
+bool PythonObject::isDict()
+{
+    return object() != nullptr && PyDict_Check(object()) != 0;
+}
+
+bool PythonObject::isList()
+{
+    return object() != nullptr && PyList_Check(object()) != 0;
+}
+
+PyObject* PythonObject::initList(int size)
+{
+    if (size < 0) {
+        return nullptr;
+    }
+    auto* new_list = PyList_New(size);
+    assert(new_list);
+    return new_list;
+}
+
+PyObject* PythonObject::initDict()
+{
+    auto* new_dict = PyDict_New();
+    assert(new_dict);
+    return new_dict;
+}
+
+void PythonObject::setListItem(int index, PyObject* value)
+{
+    // PyList_SetItem will steal this reference, so claim ownership first
+    assert(value);
+    Py_INCREF(value);
+
+    assert(isList());
+    assert(PyList_SetItem(object(), index, value) == 0);
+}
+
+void PythonObject::setDictItem(PyObject* key, PyObject* value)
+{
+    assert(key);
+    assert(value);
+
+    assert(isDict());
+    assert(PyDict_SetItem(object(), key, value) == 0);
+}
+
+PythonObject PythonObject::getItem(int index)
+{
+    return PythonObject { PySequence_GetItem(object(), index) };
+}
+
+PythonObject PythonObject::getNextItem(PythonObject& iterator)
+{
+    if (!iterator) {
+        PythonObject py_object;
+        if (isDict()) {
+            // if dictionary, iterate over items (key/value tuples)
+            py_object = PythonObject { PyDict_Items(object()) };
+        } else {
+            // otherwise, iterate over all elements directly
+            py_object = PythonObject::wrap(object());
+        }
+        auto new_iterator = PythonObject { PyObject_GetIter(py_object.object()) };
+        if (!new_iterator) {
+            return {};
+        }
+        iterator = std::move(new_iterator);
+    }
+
+    return PythonObject { PyIter_Next(iterator.object()) };
+}
 } // namespace ppplugin
diff --git a/src/python_tuple.cpp b/src/python_tuple.cpp
index f8114a7..31bbdb3 100644
--- a/src/python_tuple.cpp
+++ b/src/python_tuple.cpp
@@ -2,19 +2,9 @@
 #include "ppplugin/python/python_forward_defs.h"
 
 #include <cassert>
-#include <cstddef>
-#include <string>
-#include <string_view>
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h> // NOLINT(misc-include-cleaner)
-#include <boolobject.h>
-#include <floatobject.h>
-#include <longobject.h>
-#include <object.h>
-#include <pyport.h>
-#include <tupleobject.h>
-#include <unicodeobject.h>
 
 namespace ppplugin {
 
@@ -29,84 +19,19 @@ PyObject* PythonTuple::initTuple(int size)
     return new_tuple;
 }
 
-// NOLINTBEGIN(bugprone-easily-swappable-parameters)
-// NOLINTBEGIN(google-runtime-int)
-void PythonTuple::setTupleItem(int index, double value)
+void PythonTuple::setTupleItem(int index, PythonObject value)
 {
-    auto* py_value = PyFloat_FromDouble(value);
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-
-void PythonTuple::setTupleItem(int index, unsigned int value)
-{
-    setTupleItem(index, static_cast<unsigned long>(value));
-}
+    // PyTuple_SetItem will steal this reference, so claim ownership first
+    assert(value);
+    auto* released_value = value.release();
 
-void PythonTuple::setTupleItem(int index, int value)
-{
-    setTupleItem(index, static_cast<long>(value));
-}
-
-void PythonTuple::setTupleItem(int index, unsigned long value)
-{
-    auto* py_value = PyLong_FromUnsignedLong(value);
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-
-void PythonTuple::setTupleItem(int index, long value)
-{
-    auto* py_value = PyLong_FromLong(value);
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-
-void PythonTuple::setTupleItem(int index, unsigned long long value)
-{
-    auto* py_value = PyLong_FromUnsignedLongLong(value);
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-
-void PythonTuple::setTupleItem(int index, long long value)
-{
-    auto* py_value = PyLong_FromLongLong(value);
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-// NOLINTEND(google-runtime-int)
-// NOLINTEND(bugprone-easily-swappable-parameters)
-
-void PythonTuple::setTupleItem(int index, const char* value)
-{
-    auto* py_value = PyUnicode_FromString(value);
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-
-void PythonTuple::setTupleItem(int index, std::string_view value)
-{
-    auto* py_value = PyUnicode_FromStringAndSize(
-        value.data(), static_cast<Py_ssize_t>(value.size()));
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
-}
-
-void PythonTuple::setTupleItem(int index, const std::string& value)
-{
-    setTupleItem(index, std::string_view { value });
-}
-
-void PythonTuple::setTupleItem(int index, bool value)
-{
-    auto* py_value = PyBool_FromLong(static_cast<int>(value));
-    assert(py_value);
-    assert(PyTuple_SetItem(object(), index, py_value) == 0);
+    assert(PyTuple_SetItem(object(), index, released_value) == 0);
 }
 
-void PythonTuple::setTupleItem(int index, std::nullptr_t)
+PythonObject PythonTuple::getTupleItem(int index)
 {
-    assert(PyTuple_SetItem(object(), index, Py_None) == 0);
+    auto* item = PyTuple_GetItem(object(), index);
+    Py_XINCREF(item); // claim strong reference to item
+    return PythonObject { item };
 }
 } // namespace ppplugin
diff --git a/test/.clang-tidy b/test/.clang-tidy
index b580f6f..07a2fee 100644
--- a/test/.clang-tidy
+++ b/test/.clang-tidy
@@ -11,4 +11,6 @@ Checks: >
         -bugprone-unchecked-optional-access,
         -hicpp-noexcept-move,
         -cppcoreguidelines-noexcept-move-operations,
-        -cppcoreguidelines-init-variables
+        -cppcoreguidelines-init-variables,
+        -cppcoreguidelines-non-private-member-variables-in-classes,
+        -misc-non-private-member-variables-in-classes
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index c143f8b..5f7aae4 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -4,11 +4,13 @@ set(TESTS_NAME "tests")
 
 add_executable(${TESTS_NAME} detail_templates_tests.cpp expected_tests.cpp
                              scope_guard_tests.cpp)
-
-target_include_directories(${TESTS_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/include)
+target_include_directories(${TESTS_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(${TESTS_NAME} PRIVATE GTest::GTest GTest::Main gmock
                                             Threads::Threads ${LIBRARY_TARGET})
 
+add_subdirectory(lua_tests)
+add_subdirectory(python_tests)
+
 gtest_discover_tests(${TESTS_NAME})
 
 add_test(
diff --git a/test/expected_tests.cpp b/test/expected_tests.cpp
index 40401dd..3af0f50 100644
--- a/test/expected_tests.cpp
+++ b/test/expected_tests.cpp
@@ -354,3 +354,45 @@ TEST(Expected, comparisonEqual)
     },
         e1, e2);
 }
+
+TEST(Expected, andThenReturnRawValue)
+{
+    const Expected<const char*, int> v { "test" };
+
+    auto result = v.andThen([]() { return 2.0; });
+
+    EXPECT_TRUE(result.hasValue());
+    EXPECT_EQ(result.value().value_or(0.0), 2.0);
+}
+
+TEST(Expected, andThenReturnValueInExpected)
+{
+    const Expected<const char*, int> v { "test" };
+
+    auto result = v.andThen([]() -> Expected<double, int> { return 3.0; });
+
+    EXPECT_TRUE(result.hasValue());
+    EXPECT_EQ(result.value().value_or(0.0), 3.0);
+}
+
+TEST(Expected, andThenReturnError)
+{
+    const Expected<const char*, int> v { "test" };
+
+    auto result = v.andThen([]() -> decltype(v) { return 1; });
+
+    // static_assert(std::is_same_v<const decltype(result), decltype(v)>);
+
+    EXPECT_FALSE(result.hasValue());
+    EXPECT_EQ(result.error().value_or(-1), 1);
+}
+
+TEST(Expected, andThenError)
+{
+    const Expected<const char*, int> e { 5 };
+
+    auto result = e.andThen([]() { return "abc"; });
+
+    EXPECT_FALSE(result.hasValue());
+    EXPECT_EQ(result.error().value_or(-1), 5);
+}
diff --git a/test/lua_tests/CMakeLists.txt b/test/lua_tests/CMakeLists.txt
new file mode 100644
index 0000000..a02178c
--- /dev/null
+++ b/test/lua_tests/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(${TESTS_NAME} PRIVATE lua_tests.cpp)
+
+add_custom_target(lua_tests ALL COMMENT "Lua test files")
+add_custom_command(
+  TARGET lua_tests
+  POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/test.lua
+          ${CMAKE_CURRENT_BINARY_DIR}/test.lua
+  COMMENT "Copying Lua plugins to output directory...")
diff --git a/test/lua_tests/lua_tests.cpp b/test/lua_tests/lua_tests.cpp
new file mode 100644
index 0000000..24d5549
--- /dev/null
+++ b/test/lua_tests/lua_tests.cpp
@@ -0,0 +1,95 @@
+#include "test_helper.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <ppplugin/lua/plugin.h>
+
+class LuaTest : public testing::Test {
+protected:
+    void SetUp() override
+    {
+        auto load_result = ppplugin::LuaPlugin::load("./lua_tests/test.lua");
+        ASSERT_TRUE(load_result.hasValue());
+
+        plugin = std::make_unique<ppplugin::LuaPlugin>(std::move(load_result.valueRef()->get()));
+    }
+
+protected:
+    std::unique_ptr<ppplugin::LuaPlugin> plugin;
+};
+
+TEST_F(LuaTest, callFunctionWithDifferentArguments)
+{
+    auto result_1 = plugin->call<bool>("accept_number_string_bool", 12, "abc", true);
+    auto result_2 = plugin->call<bool>("accept_number_string_bool", 2.0, "def", false);
+
+    EXPECT_TRUE(result_1.valueOr(false));
+    EXPECT_TRUE(result_2.valueOr(false));
+}
+
+TEST_F(LuaTest, callFunctionWithWrongArguments)
+{
+    auto result_1 = plugin->call<bool>("accept_number_string_bool", "def", false);
+    auto result_2 = plugin->call<bool>("accept_number_string_bool", 1, 2, 3, 4);
+
+    ASSERT_TRUE(result_1.hasValue()) << ppplugin::test::errorOutput(result_1);
+    ASSERT_TRUE(result_2.hasValue()) << ppplugin::test::errorOutput(result_2);
+    EXPECT_FALSE(result_1.valueOr(true));
+    EXPECT_FALSE(result_2.valueOr(true));
+}
+
+TEST_F(LuaTest, callFunctionWithArrayArgument)
+{
+    auto result = plugin->call<std::string>("serialize_array", std::vector<std::string> { "a", "b", "c" });
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(""), "1:a,2:b,3:c,");
+}
+
+TEST_F(LuaTest, callFunctionWithMapArgument)
+{
+    const auto example_map = std::map<std::string, int> { { "a", 1 }, { "b", 2 }, { "c", 3 }, { "d", 0 } };
+
+    auto result_a = plugin->call<int>("access_table", example_map, "a");
+    auto result_c = plugin->call<int>("access_table", example_map, "c");
+    auto result_d = plugin->call<int>("access_table", example_map, "d");
+
+    EXPECT_EQ(result_a.valueOr(-1), 1);
+    EXPECT_EQ(result_c.valueOr(-1), 3);
+    EXPECT_EQ(result_d.valueOr(-1), 0);
+}
+
+TEST_F(LuaTest, callFunctionWithArrayResult)
+{
+    auto result = plugin->call<std::vector<std::string>>("return_array");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_THAT(result.valueOr(std::vector<std::string> {}), testing::ElementsAre("a", "b", "c"));
+}
+
+TEST_F(LuaTest, callFunctionWithMapResult)
+{
+    using ResultType = std::map<std::string, int>;
+    const ResultType expected { { "a", 1 }, { "b", 2 }, { "c", 3 }, { "d", 4 } };
+
+    auto result = plugin->call<ResultType>("return_map");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(ResultType {}), expected);
+}
+
+TEST_F(LuaTest, nestedTable)
+{
+    using ResultType = std::map<std::vector<std::string>, std::map<int, int>>;
+    const ResultType value = {
+        { { "a", "b" }, { { 1, 2 }, { 0, 0 } } },
+        { { "c" }, {} },
+        { { "x" }, { { -1, 5 } } },
+    };
+
+    auto result = plugin->call<ResultType>("identity", value);
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(ResultType {}), value);
+}
diff --git a/test/lua_tests/test.lua b/test/lua_tests/test.lua
new file mode 100644
index 0000000..33f10ae
--- /dev/null
+++ b/test/lua_tests/test.lua
@@ -0,0 +1,41 @@
+function accept_number_string_bool(n, s, b)
+    local is_number = type(n) == "number"
+    local is_string = type(s) == "string"
+    local is_bool = type(b) == "boolean"
+
+    return is_number and is_string and is_bool
+end
+
+function serialize_array(t)
+    local result = ""
+    table.sort(t)
+    for i, v in ipairs(t) do
+        result = result .. tostring(i) .. ":" .. tostring(v) .. ","
+    end
+    return result
+end
+
+function access_table(t, key)
+    return t[key]
+end
+
+function return_array()
+    return { "a", "b", "c" }
+end
+
+function return_map()
+    return {
+        a = 1,
+        b = 2,
+        c = 3,
+        d = 4,
+    }
+end
+
+function return_empty_table()
+    return {}
+end
+
+function identity(x)
+    return x
+end
diff --git a/test/python_tests/CMakeLists.txt b/test/python_tests/CMakeLists.txt
new file mode 100644
index 0000000..de79f95
--- /dev/null
+++ b/test/python_tests/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(${TESTS_NAME} PRIVATE python_tests.cpp)
+
+add_custom_target(python_tests ALL COMMENT "Python test files")
+add_custom_command(
+  TARGET python_tests
+  POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/test.py
+          ${CMAKE_CURRENT_BINARY_DIR}/test.py
+  COMMENT "Copying Python plugins to output directory...")
diff --git a/test/python_tests/python_tests.cpp b/test/python_tests/python_tests.cpp
new file mode 100644
index 0000000..d87bbdb
--- /dev/null
+++ b/test/python_tests/python_tests.cpp
@@ -0,0 +1,153 @@
+#include "test_helper.h"
+
+#include <gtest/gtest.h>
+
+#include <ppplugin/python/plugin.h>
+
+class PythonTest : public testing::Test {
+protected:
+    void SetUp() override
+    {
+        auto load_result = ppplugin::PythonPlugin::load("./python_tests/test.py");
+        ASSERT_TRUE(load_result.hasValue());
+
+        plugin = std::make_unique<ppplugin::PythonPlugin>(std::move(load_result.valueRef()->get()));
+    }
+
+protected:
+    std::unique_ptr<ppplugin::PythonPlugin> plugin;
+};
+
+TEST_F(PythonTest, callFunctionWithDifferentArguments)
+{
+    auto result_1 = plugin->call<bool>("accept_int_string_bool_float", 12, "abc", true, 2.0F);
+    auto result_2 = plugin->call<bool>("accept_int_string_bool_float", 2UL, "def", false, 12.0);
+
+    EXPECT_TRUE(result_1.valueOr(false));
+    EXPECT_TRUE(result_2.valueOr(false));
+}
+
+TEST_F(PythonTest, callFunctionWithWrongArguments)
+{
+    auto result_1 = plugin->call<bool>("accept_int_string_bool_float", "def", false, false, false);
+    auto result_2 = plugin->call<bool>("accept_int_string_bool_float", 1, 2, 3, 4);
+
+    // successful since Python is dynamically typed and can accept any argument type
+    ASSERT_TRUE(result_1.hasValue()) << ppplugin::test::errorOutput(result_1);
+    ASSERT_TRUE(result_2.hasValue()) << ppplugin::test::errorOutput(result_2);
+    EXPECT_FALSE(result_1.valueOr(true));
+    EXPECT_FALSE(result_2.valueOr(true));
+}
+
+TEST_F(PythonTest, callFunctionWithDict)
+{
+    auto result = plugin->call<int>("accept_dict", std::map<std::string, int> {
+                                                       { "", 1 },
+                                                       { "a", 2 },
+                                                       { "b", 3 },
+                                                       { "c", 4 },
+                                                   },
+        "c");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(0), 4);
+}
+
+TEST_F(PythonTest, callFunctionWithList)
+{
+    auto result = plugin->call<std::string>("accept_list", std::vector<char> { 'a', 'b', 'c' });
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(""), "a,b,c,");
+}
+
+TEST_F(PythonTest, nestedDict)
+{
+    using ResultType = std::map<std::string, std::vector<std::map<int, int>>>;
+    const ResultType expected = {
+        { "", {} },
+        { "a", { { { 1, 1 }, { 2, 2 } }, { { 0, 0 } } } },
+        { "b", { { { 1, 1 } } } }
+    };
+
+    auto result = plugin->call<ResultType>("identity", expected);
+
+    EXPECT_EQ(result.valueOr(ResultType {}), expected);
+}
+
+TEST_F(PythonTest, getGlobalString)
+{
+    auto result = plugin->global<std::string>("string_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(""), "abc");
+}
+
+TEST_F(PythonTest, getGlobalChar)
+{
+    auto result = plugin->global<char>("char_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(' '), 'a');
+}
+
+TEST_F(PythonTest, getGlobalBool)
+{
+    auto result = plugin->global<bool>("bool_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(true), false);
+}
+
+TEST_F(PythonTest, getGlobalInt)
+{
+    auto result = plugin->global<int>("int_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(0), 12);
+}
+
+TEST_F(PythonTest, getGlobalFloat)
+{
+    auto result = plugin->global<float>("float_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_DOUBLE_EQ(result.valueOr(0.0), 42.0);
+}
+
+TEST_F(PythonTest, getGlobalList)
+{
+    using ResultType = std::vector<std::vector<int>>;
+    const ResultType expected { {}, { 0 }, { 0, 0 } };
+
+    auto result = plugin->global<ResultType>("list_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(ResultType {}), expected);
+}
+
+TEST_F(PythonTest, getGlobalDict)
+{
+    using ResultType = std::map<std::string, int>;
+    const ResultType expected { { "a", 1 }, { "b", 2 } };
+
+    auto result = plugin->global<ResultType>("dict_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(ResultType {}), expected);
+}
+
+TEST_F(PythonTest, setGlobalDict)
+{
+    using ResultType = std::map<std::string, int>;
+    const ResultType expected { { "x", 10 } };
+
+    auto set_result = plugin->global("dict_global", expected);
+
+    EXPECT_TRUE(set_result.hasValue()) << ppplugin::test::errorOutput(set_result);
+
+    auto result = plugin->call<ResultType>("get_global", "dict_global");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(*result, expected);
+}
diff --git a/test/python_tests/test.py b/test/python_tests/test.py
new file mode 100644
index 0000000..0771001
--- /dev/null
+++ b/test/python_tests/test.py
@@ -0,0 +1,35 @@
+string_global = "abc"
+int_global = 12
+float_global = 42.0
+bool_global = False
+char_global = "a"
+dict_global = {"a": 1, "b": 2}
+list_global = [[], [0], [0, 0]]
+
+
+def get_global(name):
+    return globals()[name]
+
+
+def accept_int_string_bool_float(i, s, b, f):
+    is_int = type(i) is int
+    is_string = type(s) is str
+    is_bool = type(b) is bool
+    is_float = type(f) is float
+
+    return is_int and is_string and is_bool and is_float
+
+
+def accept_dict(d, key):
+    return d[key]
+
+
+def accept_list(l):
+    result = ""
+    for e in l:
+        result += e + ","
+    return result
+
+
+def identity(x):
+    return x
diff --git a/test/scope_guard_tests.cpp b/test/scope_guard_tests.cpp
index 7a0b1cc..9dc600c 100644
--- a/test/scope_guard_tests.cpp
+++ b/test/scope_guard_tests.cpp
@@ -29,7 +29,7 @@ TEST(ScopeGuard, moveSourceCalled)
 {
     bool guard_called { false };
     {
-        ScopeGuard first_guard { []() {} };
+        ScopeGuard first_guard { []() { } };
         {
             ScopeGuard second_guard {
                 [&guard_called]() {
@@ -51,7 +51,7 @@ TEST(ScopeGuard, moveTargetCalled)
             guard_called = true;
         } };
         {
-            ScopeGuard second_guard { []() {} };
+            ScopeGuard second_guard { []() { } };
             first_guard = std::move(second_guard);
             EXPECT_TRUE(guard_called);
         }
diff --git a/test/test_helper.h b/test/test_helper.h
index bc36203..42ce823 100644
--- a/test/test_helper.h
+++ b/test/test_helper.h
@@ -2,8 +2,12 @@
 #define PPPLUGIN_TEST_HELPER_H
 
 #include <array>
+#include <string>
 #include <tuple>
 
+#include <ppplugin/detail/compatibility_utils.h>
+#include <ppplugin/expected.h>
+
 namespace ppplugin::test {
 namespace detail {
     template <std::size_t outerIndex, std::size_t innerIndex,
@@ -20,7 +24,6 @@ namespace detail {
                     std::forward<TupleTwo>(inner_args));
             }
         } else if constexpr (outerIndex < OUTER_SIZE) {
-
             auto&& a = std::get<outerIndex>(outer_args);
             auto&& b = std::get<innerIndex>(inner_args);
             using A = decltype(a);
@@ -56,6 +59,25 @@ constexpr void forEachCombination(Func&& func, Args&&... args)
             std::make_tuple(std::forward<Args>(args)...));
     }
 }
+
+template <typename T, typename E>
+[[nodiscard]] static std::string errorOutput(const ppplugin::Expected<T, E>& expected)
+{
+    auto error = *expected.error();
+
+    std::string output;
+#ifndef PPPLUGIN_CPP17_COMPATIBILITY
+    output += error.where();
+    output += " - ";
+#endif // PPPLUGIN_CPP17_COMPATIBILITY
+
+    output += error.what();
+    output += " (";
+    output += codeToString(error.code());
+    output += ")";
+
+    return output;
+}
 } // namespace ppplugin::test
 
 #endif // PPPLUGIN_TEST_HELPER_H