diff --git a/.clang-format b/.clang-format
index e0958e5..6214c59 100644
--- a/.clang-format
+++ b/.clang-format
@@ -10,3 +10,4 @@ QualifierOrder: [
   'const',
   'type',
 ]
+SpaceInEmptyBraces: Block
diff --git a/.clang-tidy b/.clang-tidy
index 143d361..336ba04 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -2,7 +2,7 @@ Checks: >
         -*,
         clang-diagnostic-*,
         clang-analyzer-optin.*,
-        llvm-*,-llvm-header-guard,
+        llvm-*,-llvm-header-guard,-llvm-prefer-static-over-anonymous-namespace,
         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,
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index af40f50..fcee63c 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -61,8 +61,12 @@ jobs:
             gtest-dev
       - name: Fixup environment
         run: |
+          # add missing final symlink for Lua library
           ln -s liblua-5.2.so.0 /usr/lib/liblua-5.2.so
+          # use ninja-build as ninja binary (alternative: install samurai instead)
           ln -s /usr/lib/ninja-build/bin/ninja /usr/bin/ninja
+          # patch Boost.process to not use ::close_range() since Alpine's musl implementation does not provide it
+          sed -i 's/#define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1/\/\/#define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1\n#include <dirent.h>/g' /usr/include/boost/process/v2/posix/detail/close_handles.ipp
         shell: alpine.sh --root {0}
 
       - name: Prepare
@@ -92,7 +96,7 @@ jobs:
           retention-days: 5
 
   unittest:
-    name: "unittest"
+    name: "unittests"
     needs: build
     runs-on: ubuntu-latest
     strategy:
@@ -151,7 +155,7 @@ jobs:
           retention-days: 3
 
   ctest:
-    name: "ctest"
+    name: "cmake tests"
     needs: build
     runs-on: ubuntu-latest
     steps:
@@ -179,8 +183,12 @@ jobs:
             gtest-dev
       - name: Fixup environment
         run: |
-          ln -s /usr/lib/ninja-build/bin/ninja /usr/bin/ninja
+          # add missing final symlink for Lua library
           ln -s liblua-5.2.so.0 /usr/lib/liblua-5.2.so
+          # use ninja-build as ninja binary (alternative: install samurai instead)
+          ln -s /usr/lib/ninja-build/bin/ninja /usr/bin/ninja
+          # patch Boost.process to not use ::close_range() since Alpine's musl implementation does not provide it
+          sed -i 's/#define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1/\/\/#define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1\n#include <dirent.h>/g' /usr/include/boost/process/v2/posix/detail/close_handles.ipp
         shell: alpine.sh --root {0}
 
       - name: Run cmake tests
diff --git a/.github/workflows/cpp-lint.yml b/.github/workflows/cpp-lint.yml
index b0f2164..b5d96ec 100644
--- a/.github/workflows/cpp-lint.yml
+++ b/.github/workflows/cpp-lint.yml
@@ -47,8 +47,12 @@ jobs:
             clang19-extra-tools
       - name: Fixup environment
         run: |
+          # add missing final symlink for Lua library
           ln -s liblua-5.2.so.0 /usr/lib/liblua-5.2.so
+          # use ninja-build as ninja binary (alternative: install samurai instead)
           ln -s /usr/lib/ninja-build/bin/ninja /usr/bin/ninja
+          # patch Boost.process to not use ::close_range() since Alpine's musl implementation does not provide it
+          sed -i 's/#define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1/\/\/#define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1\n#include <dirent.h>/g' /usr/include/boost/process/v2/posix/detail/close_handles.ipp
         shell: alpine.sh --root {0}
 
       - name: Generate compile_commands.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7b49739..509c807 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,7 +24,16 @@ option(PPPLUGIN_ENABLE_UNDEFINED_SANITIZE
 option(PPPLUGIN_ENABLE_UNREACHABLE_SANITIZE
        "Enable compilation with unreachable sanitize flags" OFF)
 
+# required Boost header-only components: dll, algorithm, asio, process, uuid;
+# Boost.filesystem is only required because of Boost.dll
 find_package(Boost 1.70.0 REQUIRED CONFIG COMPONENTS headers filesystem)
+if(${Boost_VERSION} VERSION_GREATER_EQUAL 1.85.0)
+  # Boost.process was header-only until 1.84; requires linking in >= 1.85
+  find_package(Boost REQUIRED CONFIG COMPONENTS process)
+else()
+  # add dummy target so that this check is only necessary once
+  add_library(Boost::process ALIAS Boost::headers)
+endif()
 find_package(Python 3.0 REQUIRED COMPONENTS Development)
 find_package(Lua 5.2 REQUIRED)
 
diff --git a/cmake/ppplugin-config.cmake.in b/cmake/ppplugin-config.cmake.in
index 9d24d6b..5e89629 100644
--- a/cmake/ppplugin-config.cmake.in
+++ b/cmake/ppplugin-config.cmake.in
@@ -1,12 +1,18 @@
 @PACKAGE_INIT@
 
 include(CMakeFindDependencyMacro)
-find_dependency(Boost @Boost_VERSION_MAJOR@ COMPONENTS headers filesystem
-                python)
+find_dependency(Boost @Boost_VERSION_MAJOR@ CONFIG COMPONENTS headers filesystem)
+if(@Boost_VERSION@ VERSION_GREATER_EQUAL 1.85.0)
+  # Boost.process was header-only until 1.84; requires linking in >= 1.85
+  find_dependency(Boost CONFIG COMPONENTS process)
+else()
+  # add dummy target so that this check is only necessary once
+  add_library(Boost::process ALIAS Boost::headers)
+endif()
 find_dependency(Python @Python_VERSION_MAJOR@ COMPONENTS Development)
 find_dependency(Lua @LUA_VERSION_MAJOR@)
 
-if(${PPPLUGIN_ENABLE_CPP17_COMPATIBILITY})
+if(@PPPLUGIN_ENABLE_CPP17_COMPATIBILITY@)
   find_dependency(fmt @fmt_VERSION_MAJOR@)
 endif()
 
diff --git a/include/ppplugin.cpp b/include/ppplugin.cpp
new file mode 100644
index 0000000..8460ca8
--- /dev/null
+++ b/include/ppplugin.cpp
@@ -0,0 +1,39 @@
+// this source file includes all header files of the library;
+// it allows the language server to infer the correct compilation flags for header
+// files that do not have a corresponding source file; additionally, this will
+// cause the compiler to compile check them in the compilation process, even if
+// they are not used elsewhere in the library (external interface)
+
+#include "ppplugin/errors.h"
+#include "ppplugin/expected.h"
+#include "ppplugin/noop_plugin.h"
+#include "ppplugin/plugin.h"
+#include "ppplugin/plugin_manager.h"
+
+#include "ppplugin/c/plugin.h"
+
+#include "ppplugin/cpp/plugin.h"
+
+#include "ppplugin/lua/lua_helpers.h"
+#include "ppplugin/lua/lua_script.h"
+#include "ppplugin/lua/lua_state.h"
+#include "ppplugin/lua/plugin.h"
+
+#include "ppplugin/shell/plugin.h"
+#include "ppplugin/shell/shell_session.h"
+
+#include "ppplugin/python/plugin.h"
+#include "ppplugin/python/python_exception.h"
+#include "ppplugin/python/python_forward_defs.h"
+#include "ppplugin/python/python_guard.h"
+#include "ppplugin/python/python_interpreter.h"
+#include "ppplugin/python/python_object.h"
+#include "ppplugin/python/python_tuple.h"
+
+#include "ppplugin/detail/boost_dll_loader.h"
+#include "ppplugin/detail/compatibility_utils.h"
+#include "ppplugin/detail/compiler_info.h"
+#include "ppplugin/detail/function_details.h"
+#include "ppplugin/detail/scope_guard.h"
+#include "ppplugin/detail/string_utils.h"
+#include "ppplugin/detail/template_helpers.h"
diff --git a/include/ppplugin/c/plugin.h b/include/ppplugin/c/plugin.h
index 94f8ac9..9cd0c7c 100644
--- a/include/ppplugin/c/plugin.h
+++ b/include/ppplugin/c/plugin.h
@@ -44,22 +44,26 @@ CallResult<ReturnValue> CPlugin::call(const std::string& function_name, Args&&..
 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());
+    auto result_pointer = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (result_pointer.hasValue()) {
+        // raw type casting necessary due to lack of type information in shared library
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        return *reinterpret_cast<VariableType*>(result_pointer.value().value());
     }
-    return { p.error().value() };
+    return { result_pointer.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);
+    auto result_pointer = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (result_pointer.hasValue()) {
+        // raw type casting necessary due to lack of type information in shared library
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        *reinterpret_cast<VariableType*>(result_pointer.value().value()) = std::forward<VariableType>(new_value);
         return {};
     }
-    return { p.error().value() };
+    return { result_pointer.error().value() };
 }
 } // namespace ppplugin
 
diff --git a/include/ppplugin/cpp/plugin.h b/include/ppplugin/cpp/plugin.h
index 867b3db..723c2d7 100644
--- a/include/ppplugin/cpp/plugin.h
+++ b/include/ppplugin/cpp/plugin.h
@@ -48,22 +48,26 @@ CallResult<ReturnValue> CppPlugin::call(const std::string& function_name, 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());
+    auto result_pointer = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (result_pointer.hasValue()) {
+        // raw type casting necessary due to lack of type information in shared library
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        return *reinterpret_cast<VariableType*>(result_pointer.value().value());
     }
-    return { p.error().value() };
+    return { result_pointer.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);
+    auto result_pointer = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (result_pointer.hasValue()) {
+        // raw type casting necessary due to lack of type information in shared library
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        *reinterpret_cast<VariableType*>(result_pointer.value().value()) = std::forward<VariableType>(new_value);
         return {};
     }
-    return { p.error().value() };
+    return { result_pointer.error().value() };
 }
 } // namespace ppplugin
 
diff --git a/include/ppplugin/detail/scope_guard.h b/include/ppplugin/detail/scope_guard.h
index c2cd92d..d33b52f 100644
--- a/include/ppplugin/detail/scope_guard.h
+++ b/include/ppplugin/detail/scope_guard.h
@@ -8,7 +8,7 @@ class ScopeGuard final {
     template <typename Func,
         typename = std::enable_if_t<!std::is_same_v<Func, ScopeGuard>>>
     explicit ScopeGuard(Func&& func)
-        : function_ { func }
+        : function_ { std::forward<Func>(func) }
     {
     }
     ~ScopeGuard() { call(); }
@@ -40,8 +40,7 @@ class ScopeGuard final {
     void cancel() { function_ = {}; }
 
 private:
-    std::function<void()>
-        function_;
+    std::function<void()> function_;
 };
 } // namespace ppplugin::detail
 
diff --git a/include/ppplugin/detail/string_utils.h b/include/ppplugin/detail/string_utils.h
new file mode 100644
index 0000000..caf41af
--- /dev/null
+++ b/include/ppplugin/detail/string_utils.h
@@ -0,0 +1,36 @@
+#ifndef PPPLUGIN_DETAIL_STRING_UTILS_H
+#define PPPLUGIN_DETAIL_STRING_UTILS_H
+
+#include "template_helpers.h"
+
+#include <charconv>
+#include <optional>
+#include <string_view>
+
+namespace ppplugin::detail {
+template <typename T>
+constexpr auto IsStringlikeV = // NOLINT(readability-identifier-naming)
+    templates::IsAnyOfV<T, std::string, std::string_view, const char*>;
+
+[[nodiscard]] inline bool endsWith(std::string_view string, std::string_view end)
+{
+    if (string.size() < end.size()) {
+        return false;
+    }
+    auto result = string.compare(string.size() - end.size(), end.size(), end);
+    return result == 0;
+}
+
+template <typename Integer>
+[[nodiscard]] inline std::optional<Integer> toInteger(std::string_view string)
+{
+    int value {};
+    auto result = std::from_chars(string.begin(), string.end(), value);
+    if (result.ec == std::errc {} && result.ptr == string.end()) {
+        return value;
+    }
+    return std::nullopt;
+}
+} // namespace ppplugin::detail
+
+#endif // PPPLUGIN_DETAIL_STRING_UTILS_H
diff --git a/include/ppplugin/detail/template_helpers.h b/include/ppplugin/detail/template_helpers.h
index b09f224..90d619f 100644
--- a/include/ppplugin/detail/template_helpers.h
+++ b/include/ppplugin/detail/template_helpers.h
@@ -185,6 +185,9 @@ struct IsSpecialization : std::false_type { };
 template <template <typename...> typename ExpectedType, typename... Ts>
 struct IsSpecialization<ExpectedType<Ts...>, ExpectedType> : std::true_type { };
 
+/**
+ * Check if first type is template instantiation of second type.
+ */
 template <typename ActualType, template <typename...> typename ExpectedType>
 constexpr bool IsSpecializationV = // NOLINT(readability-identifier-naming)
     IsSpecialization<ActualType, ExpectedType>::value;
@@ -192,6 +195,13 @@ constexpr bool IsSpecializationV = // NOLINT(readability-identifier-naming)
 template <typename T>
 using IsStdTuple = IsSpecialization<T, std::tuple>;
 
+/**
+ * Check if first type is any of the following types.
+ */
+template <typename ActualType, typename... Types>
+constexpr bool IsAnyOfV = // NOLINT(readability-identifier-naming)
+    (std::is_same_v<ActualType, Types> || ...);
+
 /**
  * C++17 compatible version of std::remove_cvref_t.
  */
diff --git a/include/ppplugin/errors.h b/include/ppplugin/errors.h
index 8a85b5c..00cbdb0 100644
--- a/include/ppplugin/errors.h
+++ b/include/ppplugin/errors.h
@@ -4,6 +4,7 @@
 #include "ppplugin/detail/compatibility_utils.h"
 #include "ppplugin/expected.h"
 
+#include <cstdint>
 #ifndef PPPLUGIN_CPP17_COMPATIBILITY
 #include <source_location>
 #endif // PPPLUGIN_CPP17_COMPATIBILITY
@@ -13,7 +14,7 @@
 namespace ppplugin {
 class CallError {
 public:
-    enum class Code {
+    enum class Code : std::uint8_t {
         unknown,
         notLoaded,
         symbolNotFound,
@@ -92,7 +93,7 @@ class CallError {
     }
 }
 
-enum class LoadError {
+enum class LoadError : std::uint8_t {
     unknown,
     fileNotFound,
     fileInvalid,
diff --git a/include/ppplugin/expected.h b/include/ppplugin/expected.h
index 36a4ca4..eabf041 100644
--- a/include/ppplugin/expected.h
+++ b/include/ppplugin/expected.h
@@ -459,17 +459,33 @@ template <typename F>
 constexpr auto Expected<T, E>::andThen(F&& func) const&
 {
     if constexpr (std::is_invocable_v<F, T>) {
-        using ReturnType = AndThenReturnType<std::invoke_result_t<F, T>>;
+        using InvokeResultType = std::invoke_result_t<F, T>;
+        using ReturnType = AndThenReturnType<InvokeResultType>;
         if (!hasValue()) {
             return static_cast<ReturnType>(uncheckedError());
         }
-        return static_cast<ReturnType>(std::forward<F>(func)(uncheckedValue()));
+        if constexpr (std::is_void_v<InvokeResultType>) {
+            // cannot cast void function return type to result type;
+            // thus, handle separately here
+            std::forward<F>(func)(uncheckedValue());
+            return ReturnType {};
+        } else {
+            return static_cast<ReturnType>(std::forward<F>(func)(uncheckedValue()));
+        }
     } else if constexpr (std::is_invocable_v<F>) {
-        using ReturnType = AndThenReturnType<std::invoke_result_t<F>>;
+        using InvokeResultType = std::invoke_result_t<F>;
+        using ReturnType = AndThenReturnType<InvokeResultType>;
         if (!hasValue()) {
             return static_cast<ReturnType>(uncheckedError());
         }
-        return static_cast<ReturnType>(std::forward<F>(func)());
+        if constexpr (std::is_void_v<InvokeResultType>) {
+            // cannot cast void function return type to result type;
+            // thus, handle separately here
+            std::forward<F>(func)();
+            return ReturnType {};
+        } else {
+            return static_cast<ReturnType>(std::forward<F>(func)());
+        }
     } else {
         static_assert(std::is_invocable_v<F>,
             "Given function has to be invocable!");
@@ -658,10 +674,18 @@ template <typename E>
 template <typename F>
 constexpr auto Expected<void, E>::andThen(F&& func) &&
 {
+    using FunctionReturnType = std::invoke_result_t<F>;
+    using ReturnType = Expected<FunctionReturnType, E>;
+
     if (error_) {
-        return std::move(*error_);
+        return ReturnType { std::move(*error_) };
+    }
+    if constexpr (std::is_void_v<FunctionReturnType>) {
+        func();
+        return ReturnType {};
+    } else {
+        return ReturnType { std::forward<F>(func)() };
     }
-    return std::forward<F>(func)();
 }
 template <typename E>
 constexpr void Expected<void, E>::operator*() const
diff --git a/include/ppplugin/plugin.h b/include/ppplugin/plugin.h
index 472868f..da3735e 100644
--- a/include/ppplugin/plugin.h
+++ b/include/ppplugin/plugin.h
@@ -7,6 +7,7 @@
 #include "ppplugin/lua/plugin.h"
 #include "ppplugin/noop_plugin.h"
 #include "ppplugin/python/plugin.h"
+#include "ppplugin/shell/plugin.h"
 
 #include "ppplugin/detail/template_helpers.h"
 
@@ -68,7 +69,7 @@ class GenericPlugin {
     detail::templates::UniqueVariant<Plugins...> plugin_;
 };
 
-using Plugin = GenericPlugin<CPlugin, CppPlugin, LuaPlugin, PythonPlugin, NoopPlugin>;
+using Plugin = GenericPlugin<CPlugin, CppPlugin, LuaPlugin, PythonPlugin, ShellPlugin, NoopPlugin>;
 
 template <typename... Plugins>
 template <typename P,
diff --git a/include/ppplugin/python/python_forward_defs.h b/include/ppplugin/python/python_forward_defs.h
index 54663e7..944e213 100644
--- a/include/ppplugin/python/python_forward_defs.h
+++ b/include/ppplugin/python/python_forward_defs.h
@@ -4,9 +4,12 @@
 // TODO: these types is not a part of the official API;
 //       consider alternatives like storing void* and casting to actual
 //       type in source file (via helper function)
-struct _ts; // NOLINT(bugprone-reserved-identifier); Python defines this type name
+
+// NOLINTNEXTLINE(bugprone-reserved-identifier,readability-identifier-naming)
+struct _ts; // Python defines this type name
 using PyThreadState = _ts;
-struct _object; // NOLINT(bugprone-reserved-identifier); Python defines this type name
+// NOLINTNEXTLINE(bugprone-reserved-identifier,readability-identifier-naming)
+struct _object; // Python defines this type name
 using PyObject = _object;
 
 #endif // PPPLUGIN_PYTHON_FORWARD_DEFS_H
diff --git a/include/ppplugin/python/python_interpreter.h b/include/ppplugin/python/python_interpreter.h
index 264e7b8..6d451bc 100644
--- a/include/ppplugin/python/python_interpreter.h
+++ b/include/ppplugin/python/python_interpreter.h
@@ -63,7 +63,7 @@ class PythonInterpreter {
 template <typename ReturnValue, typename... Args>
 CallResult<ReturnValue> PythonInterpreter::call(const std::string& function_name, Args&&... args)
 {
-    PythonGuard python_guard { state() };
+    const PythonGuard python_guard { state() };
     PythonTuple args_tuple { std::forward<Args>(args)... };
 
     return internalCall(function_name, args_tuple.pyObject()).andThen([](PythonObject&& result) -> CallResult<ReturnValue> {
@@ -81,7 +81,7 @@ CallResult<ReturnValue> PythonInterpreter::call(const std::string& function_name
 template <typename VariableType>
 CallResult<VariableType> PythonInterpreter::global(const std::string& variable_name)
 {
-    PythonGuard python_guard { state() };
+    const PythonGuard python_guard { state() };
     return internalGlobal(variable_name).andThen([](PythonObject&& object) -> CallResult<VariableType> {
         if (auto result = std::move(object).template as<VariableType>()) {
             return *result;
@@ -93,7 +93,7 @@ CallResult<VariableType> PythonInterpreter::global(const std::string& variable_n
 template <typename VariableType>
 CallResult<void> PythonInterpreter::global(const std::string& variable_name, VariableType&& new_value)
 {
-    PythonGuard python_guard { state() };
+    const PythonGuard python_guard { state() };
     return internalGlobal(variable_name, PythonObject::from(std::forward<VariableType>(new_value)));
 }
 } // namespace ppplugin
diff --git a/include/ppplugin/python/python_object.h b/include/ppplugin/python/python_object.h
index be777a4..f63243b 100644
--- a/include/ppplugin/python/python_object.h
+++ b/include/ppplugin/python/python_object.h
@@ -109,12 +109,12 @@ class PythonObject {
 };
 
 template <typename K, typename V>
-PythonObject PythonObject::from(const std::map<K, V>& dict)
+PythonObject PythonObject::from(const std::map<K, V>& value)
 {
     PythonObject object { initDict() };
-    for (auto&& [key, value] : dict) {
-        auto py_key = PythonObject::from(key);
-        auto py_value = PythonObject::from(value);
+    for (auto&& [item_key, item_value] : value) {
+        auto py_key = PythonObject::from(item_key);
+        auto py_value = PythonObject::from(item_value);
         object.setDictItem(py_key.pyObject(), py_value.pyObject());
     }
     return object;
diff --git a/include/ppplugin/shell/plugin.h b/include/ppplugin/shell/plugin.h
new file mode 100644
index 0000000..5a27887
--- /dev/null
+++ b/include/ppplugin/shell/plugin.h
@@ -0,0 +1,85 @@
+#ifndef PPPLUGIN_SHELL_PLUGIN_H
+#define PPPLUGIN_SHELL_PLUGIN_H
+
+#include "ppplugin/errors.h"
+#include "shell_session.h"
+
+#include <filesystem>
+#include <string>
+
+namespace ppplugin {
+class ShellPlugin {
+public:
+    [[nodiscard]] static Expected<ShellPlugin, LoadError> load(
+        const std::filesystem::path& plugin_library_path);
+
+    ~ShellPlugin() = default;
+    ShellPlugin(const ShellPlugin&) = delete;
+    ShellPlugin(ShellPlugin&&) = default;
+    ShellPlugin& operator=(const ShellPlugin&) = delete;
+    ShellPlugin& operator=(ShellPlugin&&) = default;
+
+    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
+    operator bool() { return shell_.isRunning(); }
+    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
+    operator bool() const { return shell_.isRunning(); }
+
+    /**
+     * Accepted types are:
+     * - void
+     * - bool
+     * - int
+     * - double
+     * - std::string
+     * - const char*
+     * - std::tuple
+     */
+    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:
+    explicit ShellPlugin()
+        // : shell_ { "/tmp/a.out" }
+        : shell_ { "/bin/sh" }
+    {
+    }
+
+private:
+    ShellSession shell_;
+};
+
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> ShellPlugin::call(const std::string& function_name, Args&&... args)
+{
+    if constexpr (!((detail::IsStringlikeV<Args>) || ...)) {
+        // TODO: compile-time error requires changes to GenericPlugin
+        return CallError { CallError::Code::incorrectType, "shell functions can only accept strings as arguments" };
+    } else if constexpr (std::is_void_v<ReturnValue>) {
+        return shell_.callWithoutResult(function_name, { std::forward<Args>(args)... });
+    } else if constexpr (std::is_same_v<ReturnValue, std::string>) {
+        return shell_.callWithResult(function_name, { std::forward<Args>(args)... });
+    } else {
+        // TODO: compile-time error requires changes to GenericPlugin
+        return CallError { CallError::Code::incorrectType, "shell functions can only return a string" };
+    }
+}
+
+template <typename VariableType>
+CallResult<VariableType> ShellPlugin::global(const std::string& variable_name)
+{
+    return shell_.environmentVariable(variable_name);
+}
+
+template <typename VariableType>
+CallResult<void> ShellPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    return shell_.environmentVariable(variable_name, std::forward<VariableType>(new_value));
+}
+} // namespace ppplugin
+
+#endif // PPPLUGIN_SHELL_PLUGIN_H
diff --git a/include/ppplugin/shell/shell_session.h b/include/ppplugin/shell/shell_session.h
new file mode 100644
index 0000000..765c1f1
--- /dev/null
+++ b/include/ppplugin/shell/shell_session.h
@@ -0,0 +1,183 @@
+#ifndef PPPLUGIN_SHELL_SESSION_H
+#define PPPLUGIN_SHELL_SESSION_H
+
+#include "ppplugin/detail/string_utils.h"
+#include "ppplugin/errors.h"
+
+#include <chrono>
+#include <iostream>
+#include <string>
+#include <thread>
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/asio.hpp>
+#include <boost/version.hpp>
+#if BOOST_VERSION >= 108800
+#include <boost/process.hpp>
+#else
+#include <boost/process/v2.hpp>
+#endif // BOOST_VERSION
+#include <boost/uuid/random_generator.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+namespace ppplugin {
+class ShellSession {
+public:
+    explicit ShellSession(const std::string& shell_binary)
+        : context_ { std::make_unique<boost::asio::io_context>() }
+        , stdin_pipe_ { *context_ }
+        , stdout_pipe_ { std::make_unique<decltype(stdout_pipe_)::element_type>(boost::asio::readable_pipe { *context_ }) }
+        , stderr_pipe_ { *context_ }
+        , io_ { stdin_pipe_, *stdout_pipe_, stderr_pipe_ }
+        , shell_process_ { *context_, shell_binary, {}, io_ }
+        , is_running_ { std::make_unique<decltype(is_running_)::element_type>(true) }
+    {
+        thread_ = std::thread { [context = context_.get()]() { assert(context); runContextLoop(*context); } };
+
+        // TODO: make movable across threads
+        shell_process_.async_wait(
+            [stdout_pipe = stdout_pipe_.get(), is_running = is_running_.get()](const boost::system::error_code& /*exit_status*/, int /*exit_code*/) {
+                assert(stdout_pipe);
+                stdout_pipe->cancel();
+                assert(is_running);
+                is_running->store(false);
+            });
+    }
+    ~ShellSession()
+    {
+        if (shell_process_.running()) {
+            // TODO? use shell_process_.request_exit() first?
+            shell_process_.terminate();
+        }
+        if (context_) {
+            context_->stop();
+        }
+        if (thread_.joinable()) {
+            thread_.join();
+        }
+    }
+    ShellSession(const ShellSession&) = delete;
+    ShellSession(ShellSession&&) noexcept = default;
+    ShellSession& operator=(const ShellSession&) = delete;
+    ShellSession& operator=(ShellSession&&) noexcept = default;
+
+    [[nodiscard]] CallResult<void> callWithoutResult(const std::string& function_name, const std::vector<std::string>& arguments)
+    {
+        auto result = callWithResult(function_name, arguments);
+        return result.andThen([]() { });
+    }
+    [[nodiscard]] CallResult<std::string> callWithResult(const std::string& function_name, const std::vector<std::string>& arguments)
+    {
+        if (!shell_process_.running()) {
+            return CallError { CallError::Code::unknown, "Shell is not running!" };
+        }
+        auto command_line = '\'' + function_name + '\'';
+        for (auto&& argument : arguments) {
+            // TODO: escape quotes in arguments
+            command_line += " '";
+            auto escaped_argument = argument;
+            boost::replace_all(escaped_argument, "'", "\\'");
+            command_line += argument;
+            command_line += "'";
+        }
+        auto end_marker = boost::uuids::to_string(boost::uuids::random_generator()()) + '\n';
+        command_line += " ; echo :$?" + end_marker;
+
+        boost::asio::write(stdin_pipe_, boost::asio::buffer(command_line));
+
+        std::string result;
+        // use future with empty handler to avoid blocking read() syscall;
+        // this allows cancellation of pipe in case shell process dies
+        boost::asio::async_read_until(*stdout_pipe_,
+            boost::asio::dynamic_buffer(result),
+            end_marker, boost::asio::use_future([](auto&&...) { }))
+            .wait();
+
+        if (!shell_process_.running()) {
+            is_running_->store(false);
+            return CallError { CallError::Code::unknown, "shell ended prematurely" };
+        }
+
+        if (!detail::endsWith(result, end_marker)) {
+            return CallError { CallError::Code::unknown, "failed to get command output" };
+        }
+        // remove end marker
+        result.resize(result.size() - end_marker.size());
+
+        auto exit_code_pos = result.find_last_of(':');
+        assert(exit_code_pos != std::string::npos);
+        auto exit_code = detail::toInteger<int>(result.substr(exit_code_pos + 1)).value_or(std::numeric_limits<int>::max());
+        if (exit_code != 0) {
+            return CallError { CallError::Code::unknown, std::to_string(exit_code) };
+        }
+        // remove colon and exit code
+        result.resize(exit_code_pos);
+
+        return result;
+    }
+
+    [[nodiscard]] CallResult<std::string> environmentVariable(const std::string& variable_name)
+    {
+        return callWithResult("printenv", { variable_name }).andThen([](auto&& result) {
+            assert(!result.empty());
+            assert(result.back() == '\n');
+            result.pop_back();
+            return result;
+        });
+    }
+
+    [[nodiscard]] CallResult<void> environmentVariable(const std::string& variable_name, const std::string& new_value)
+    {
+        const std::string variable_assignment = variable_name + "='" + new_value + '\'';
+        return callWithoutResult("export", { variable_assignment });
+    }
+
+    [[nodiscard]] bool isRunning()
+    {
+        // if a non-const object is available, return actual status
+        return shell_process_.running();
+    }
+
+    [[nodiscard]] bool isRunning() const
+    {
+        // return cached state because boost::process::v2::process::running()
+        // is not const since it modifies its internal state
+        return is_running_->load();
+    }
+
+private:
+    static void runContextLoop(boost::asio::io_context& context)
+    {
+        while (true) {
+            try {
+                auto work = boost::asio::make_work_guard(context);
+                context.run();
+                break;
+            } catch (const std::exception& exception) {
+                assert(false);
+            } catch (...) {
+                assert(false);
+            }
+        }
+    }
+
+private:
+    static constexpr std::chrono::milliseconds SHELL_SHUTDOWN_TIMEOUT { 10 };
+
+private:
+    // thread for running io_context
+    std::thread thread_;
+    std::unique_ptr<boost::asio::io_context> context_;
+    boost::asio::writable_pipe stdin_pipe_;
+    std::unique_ptr<boost::asio::readable_pipe> stdout_pipe_;
+    boost::asio::readable_pipe stderr_pipe_;
+    boost::process::v2::process_stdio io_;
+    boost::process::v2::process shell_process_;
+    std::unique_ptr<std::atomic<bool>> is_running_;
+
+    // TODO: explore possibility to import/export variables and functions for each call
+};
+} // namespace ppplugin
+
+#endif // PPPLUGIN_SHELL_SESSION_H
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index eccba01..6713cbf 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,30 +1,33 @@
-set(LIBRARY_SOURCES ppplugin.cpp)
-
 set(LIBRARY_SOURCES
+    "${CMAKE_SOURCE_DIR}/include/ppplugin.cpp"
     "boost_dll_loader.cpp"
-    "c_plugin.cpp"
-    "cpp_plugin.cpp"
-    "lua_plugin.cpp"
-    "lua_state.cpp"
-    "lua_script.cpp"
-    "python_plugin.cpp"
-    "python_interpreter.cpp"
-    "python_exception.cpp"
-    "python_tuple.cpp"
-    "python_object.cpp"
-    "python_guard.cpp")
+    "c/plugin.cpp"
+    "cpp/plugin.cpp"
+    "lua/plugin.cpp"
+    "lua/lua_state.cpp"
+    "lua/lua_script.cpp"
+    "python/plugin.cpp"
+    "python/python_interpreter.cpp"
+    "python/python_exception.cpp"
+    "python/python_tuple.cpp"
+    "python/python_object.cpp"
+    "python/python_guard.cpp"
+    "shell/plugin.cpp"
+    "shell/shell_session.cpp")
+
+file(GLOB_RECURSE LIBRARY_HEADERS ${CMAKE_SOURCE_DIR}/include/**/*.h)
 
-add_library(${LIBRARY_TARGET} ${LIBRARY_SOURCES})
+add_library(${LIBRARY_TARGET} ${LIBRARY_SOURCES} ${LIBRARY_HEADERS})
 target_link_libraries(
   ${LIBRARY_TARGET}
   PRIVATE ${LUA_LIBRARIES}
-  PUBLIC Boost::filesystem Python::Python
+  PUBLIC Boost::headers Boost::filesystem Boost::process Python::Python
          $<$<BOOL:${PPPLUGIN_ENABLE_CPP17_COMPATIBILITY}>:fmt::fmt>)
 target_include_directories(
   ${LIBRARY_TARGET}
   PRIVATE ${LUA_INCLUDE_DIR}
   PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
-         $<INSTALL_INTERFACE:include/${PROJECT_NAME}>)
+         $<INSTALL_INTERFACE:include>)
 target_compile_definitions(
   ${LIBRARY_TARGET}
   PUBLIC
@@ -38,8 +41,7 @@ set_target_properties(
              SOVERSION ${ppplugin_VERSION_MAJOR})
 
 set(TARGETS_EXPORT_NAME "${PROJECT_NAME}-targets")
-install(DIRECTORY "${CMAKE_SOURCE_DIR}/include/"
-        DESTINATION "include/${LIBRARY_NAME}")
+install(DIRECTORY "${CMAKE_SOURCE_DIR}/include/" DESTINATION "include/")
 install(
   TARGETS ${LIBRARY_TARGET}
   EXPORT "${TARGETS_EXPORT_NAME}"
diff --git a/src/c_plugin.cpp b/src/c/plugin.cpp
similarity index 100%
rename from src/c_plugin.cpp
rename to src/c/plugin.cpp
diff --git a/src/cpp_plugin.cpp b/src/cpp/plugin.cpp
similarity index 100%
rename from src/cpp_plugin.cpp
rename to src/cpp/plugin.cpp
diff --git a/src/lua_script.cpp b/src/lua/lua_script.cpp
similarity index 100%
rename from src/lua_script.cpp
rename to src/lua/lua_script.cpp
diff --git a/src/lua_state.cpp b/src/lua/lua_state.cpp
similarity index 100%
rename from src/lua_state.cpp
rename to src/lua/lua_state.cpp
diff --git a/src/lua_plugin.cpp b/src/lua/plugin.cpp
similarity index 100%
rename from src/lua_plugin.cpp
rename to src/lua/plugin.cpp
diff --git a/src/python_plugin.cpp b/src/python/plugin.cpp
similarity index 100%
rename from src/python_plugin.cpp
rename to src/python/plugin.cpp
index 3c11c85..0e7c99c 100644
--- a/src/python_plugin.cpp
+++ b/src/python/plugin.cpp
@@ -1,6 +1,6 @@
+#include "ppplugin/python/plugin.h"
 #include "ppplugin/errors.h"
 #include "ppplugin/expected.h"
-#include "ppplugin/python/plugin.h"
 
 #include <filesystem>
 
diff --git a/src/python_exception.cpp b/src/python/python_exception.cpp
similarity index 100%
rename from src/python_exception.cpp
rename to src/python/python_exception.cpp
diff --git a/src/python_guard.cpp b/src/python/python_guard.cpp
similarity index 100%
rename from src/python_guard.cpp
rename to src/python/python_guard.cpp
diff --git a/src/python_interpreter.cpp b/src/python/python_interpreter.cpp
similarity index 100%
rename from src/python_interpreter.cpp
rename to src/python/python_interpreter.cpp
diff --git a/src/python/python_list.cpp b/src/python/python_list.cpp
new file mode 100644
index 0000000..845c82f
--- /dev/null
+++ b/src/python/python_list.cpp
@@ -0,0 +1,25 @@
+#include "ppplugin/python/python_list.h"
+
+#include <cassert>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h> // NOLINT(misc-include-cleaner)
+
+namespace ppplugin {
+PyObject* PythonList::initList(int size)
+{
+    if (size < 0) {
+        return nullptr;
+    }
+    auto* new_list = PyList_New(size);
+    assert(new_list);
+    return new_list;
+}
+
+void PythonList::setListItem(int index, PyObject* value)
+{
+    // PyList_SetItem will steal this reference, so claim ownership first
+    assert(value);
+    assert(PyList_SetItem(object(), index, value) == 0);
+}
+} // namespace ppplugin
diff --git a/src/python_object.cpp b/src/python/python_object.cpp
similarity index 100%
rename from src/python_object.cpp
rename to src/python/python_object.cpp
diff --git a/src/python_tuple.cpp b/src/python/python_tuple.cpp
similarity index 100%
rename from src/python_tuple.cpp
rename to src/python/python_tuple.cpp
diff --git a/src/shell/plugin.cpp b/src/shell/plugin.cpp
new file mode 100644
index 0000000..1627ce2
--- /dev/null
+++ b/src/shell/plugin.cpp
@@ -0,0 +1,17 @@
+#include "ppplugin/shell/plugin.h"
+
+#include "ppplugin/errors.h"
+#include "ppplugin/expected.h"
+
+namespace ppplugin {
+Expected<ShellPlugin, LoadError> ShellPlugin::load(
+    const std::filesystem::path& plugin_library_path)
+{
+    ShellPlugin plugin;
+    auto result = plugin.call<void>(".", plugin_library_path.string());
+    if (result.hasValue()) {
+        return plugin;
+    }
+    return LoadError::unknown;
+}
+} // namespace ppplugin
diff --git a/src/shell/shell_session.cpp b/src/shell/shell_session.cpp
new file mode 100644
index 0000000..16b30c1
--- /dev/null
+++ b/src/shell/shell_session.cpp
@@ -0,0 +1 @@
+#include "ppplugin/shell/shell_session.h"
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 5f7aae4..fd1281b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -9,6 +9,7 @@ target_link_libraries(${TESTS_NAME} PRIVATE GTest::GTest GTest::Main gmock
                                             Threads::Threads ${LIBRARY_TARGET})
 
 add_subdirectory(lua_tests)
+add_subdirectory(shell_tests)
 add_subdirectory(python_tests)
 
 gtest_discover_tests(${TESTS_NAME})
diff --git a/test/shell_tests/CMakeLists.txt b/test/shell_tests/CMakeLists.txt
new file mode 100644
index 0000000..eeef6e7
--- /dev/null
+++ b/test/shell_tests/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(${TESTS_NAME} PRIVATE shell_tests.cpp)
+
+add_custom_target(shell_tests ALL COMMENT "Shell test files")
+add_custom_command(
+  TARGET shell_tests
+  POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/test.sh
+          ${CMAKE_CURRENT_BINARY_DIR}/test.sh
+  COMMENT "Copying POSIX shell plugins to output directory...")
diff --git a/test/shell_tests/shell_tests.cpp b/test/shell_tests/shell_tests.cpp
new file mode 100644
index 0000000..dcbb59f
--- /dev/null
+++ b/test/shell_tests/shell_tests.cpp
@@ -0,0 +1,76 @@
+#include "test_helper.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <ppplugin/shell/plugin.h>
+
+class ShellTest : public testing::Test {
+protected:
+    void SetUp() override
+    {
+        auto load_result = ppplugin::ShellPlugin::load("./shell_tests/test.sh");
+        ASSERT_TRUE(load_result.hasValue());
+
+        plugin = std::make_unique<ppplugin::ShellPlugin>(std::move(load_result.valueRef()->get()));
+    }
+
+protected:
+    std::unique_ptr<ppplugin::ShellPlugin> plugin;
+};
+
+TEST(ShellTestStandalone, failToLoadNonexistentFile)
+{
+    auto plugin = ppplugin::ShellPlugin::load("./path/that/does/not/exist.sh");
+    EXPECT_FALSE(plugin);
+}
+
+TEST_F(ShellTest, getEnvironmentVariable)
+{
+    auto result = plugin->global<std::string>("env_var");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.valueOr(""), "abc");
+}
+
+TEST_F(ShellTest, setEnvironmentVariable)
+{
+    auto original_result = plugin->global<std::string>("env_var");
+    auto set_result = plugin->global("env_var", "xyz");
+    auto changed_result = plugin->global<std::string>("env_var");
+
+    ASSERT_TRUE(original_result.hasValue()) << ppplugin::test::errorOutput(original_result);
+    ASSERT_TRUE(set_result.hasValue()) << ppplugin::test::errorOutput(set_result);
+    ASSERT_TRUE(changed_result.hasValue()) << ppplugin::test::errorOutput(changed_result);
+
+    EXPECT_NE(original_result.valueOr(""), changed_result.valueOr(""));
+    EXPECT_EQ(changed_result.valueOr(""), "xyz");
+}
+
+TEST_F(ShellTest, callFunction)
+{
+    auto result = plugin->call<void>("print_first", "qwertz");
+
+    EXPECT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+}
+
+TEST_F(ShellTest, callFunctionWithStringResult)
+{
+    auto result = plugin->call<std::string>("print_first", "qwerty");
+
+    ASSERT_TRUE(result.hasValue()) << ppplugin::test::errorOutput(result);
+    EXPECT_EQ(result.value().value(), "qwerty\n");
+}
+
+TEST_F(ShellTest, moveToOtherThread)
+{
+    auto result = plugin->global("some_var", "some_value");
+    EXPECT_TRUE(result) << ppplugin::test::errorOutput(result);
+
+    std::thread thread { [moved_plugin = std::move(*plugin)]() mutable {
+        auto result = moved_plugin.global<std::string>("some_var");
+        EXPECT_TRUE(result) << ppplugin::test::errorOutput(result);
+        EXPECT_EQ(result.value().value(), "some_value");
+    } };
+    thread.join();
+}
diff --git a/test/shell_tests/test.sh b/test/shell_tests/test.sh
new file mode 100644
index 0000000..6e85bbf
--- /dev/null
+++ b/test/shell_tests/test.sh
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+export env_var="abc"
+
+echo "source"
+
+print_first()
+{
+    echo a > /tmp/a
+    echo "${1}"
+}
+
+print_env_var()
+{
+    var_name="${1}"
+    eval echo "\${${var_name}}"
+}
+
+change_environment()
+{
+    env_var="xyz"
+}
+
+exit_shell()
+{
+    exit
+}