diff --git a/src/cli/CommandKill.hpp b/src/cli/CommandKill.hpp
index 899d6289..b826c011 100644
--- a/src/cli/CommandKill.hpp
+++ b/src/cli/CommandKill.hpp
@@ -42,7 +42,7 @@ class CommandKill : public Command {
                                        "kill", containerName, "SIGHUP"};
 
     // execute runc
-    auto status = libsarus::forkExecWait(args);
+    auto status = libsarus::process::forkExecWait(args);
 
     if (status != 0) {
       auto message = boost::format("%s exited with code %d") % args % status;
@@ -87,4 +87,4 @@ class CommandKill : public Command {
 } // namespace cli
 } // namespace sarus
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/cli/CommandPs.hpp b/src/cli/CommandPs.hpp
index f5462f89..87a103d5 100644
--- a/src/cli/CommandPs.hpp
+++ b/src/cli/CommandPs.hpp
@@ -39,7 +39,7 @@ class CommandPs : public Command {
                                        "list"};
 
     // execute runc
-    auto status = libsarus::forkExecWait(args);
+    auto status = libsarus::process::forkExecWait(args);
 
     if (status != 0) {
       auto message = boost::format("%s exited with code %d") % args % status;
@@ -66,4 +66,4 @@ class CommandPs : public Command {
 } // namespace cli
 } // namespace sarus
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/cli/CommandPull.hpp b/src/cli/CommandPull.hpp
index cfb1d726..3ca36e2d 100644
--- a/src/cli/CommandPull.hpp
+++ b/src/cli/CommandPull.hpp
@@ -174,9 +174,9 @@ class CommandPull : public Command {
     std::string readPasswordFromStdin() {
         auto password = std::string{};
 
-        libsarus::setStdinEcho(false);  // disable echo
+        libsarus::process::setStdinEcho(false);  // disable echo
         std::getline(std::cin, password);
-        libsarus::setStdinEcho(true);   // enable echo
+        libsarus::process::setStdinEcho(true);   // enable echo
 
         if(password.empty()) {
             SARUS_THROW_ERROR("Failed to read password from stdin: empty value provided");
diff --git a/src/cli/CommandRun.hpp b/src/cli/CommandRun.hpp
index a422ca90..3a4de882 100644
--- a/src/cli/CommandRun.hpp
+++ b/src/cli/CommandRun.hpp
@@ -286,7 +286,7 @@ class CommandRun : public Command {
 
             std::string key, value;
             try {
-                std::tie(key, value) = libsarus::parseKeyValuePair(annotation);
+                std::tie(key, value) = libsarus::string::parseKeyValuePair(annotation);
             }
             catch(std::exception& e) {
                 auto message = boost::format("Error parsing annotation from CLI '%s': %s")
@@ -336,7 +336,7 @@ class CommandRun : public Command {
             }
             else {
                 try {
-                    std::tie(name, value) = libsarus::parseEnvironmentVariable(variable);
+                    std::tie(name, value) = libsarus::environment::parseVariable(variable);
                 }
                 catch(std::exception& e) {
                     auto message = boost::format("Error parsing environment variable requested from CLI '%s': %s")
@@ -366,7 +366,7 @@ class CommandRun : public Command {
             parser = libsarus::MountParser{conf->getRootfsDirectory(), conf->userIdentity, conf->json["userMounts"]};
         }
         for (const auto& mountString : conf->commandRun.userMounts) {
-            auto map = libsarus::parseMap(mountString);
+            auto map = libsarus::string::parseMap(mountString);
             conf->commandRun.mounts.push_back(parser.parseMountRequest(map));
         }
     }
@@ -480,10 +480,10 @@ class CommandRun : public Command {
         cli::utility::printLog( "Checking that the user has SSH keys",
                                 libsarus::LogLevel::INFO);
 
-        libsarus::setEnvironmentVariable("HOOK_BASE_DIR", conf->json["localRepositoryBaseDir"].GetString());
+        libsarus::environment::setVariable("HOOK_BASE_DIR", conf->json["localRepositoryBaseDir"].GetString());
 
         auto passwdFile = boost::filesystem::path{ conf->json["prefixDir"].GetString() } / "etc/passwd";
-        libsarus::setEnvironmentVariable("PASSWD_FILE", passwdFile.string());
+        libsarus::environment::setVariable("PASSWD_FILE", passwdFile.string());
 
         auto args = libsarus::CLIArguments{
             std::string{ conf->json["prefixDir"].GetString() } + "/bin/ssh_hook",
@@ -510,7 +510,7 @@ class CommandRun : public Command {
             }
         };
 
-        return libsarus::forkExecWait(args, std::function<void()>{setUserIdentity}) == 0;
+        return libsarus::process::forkExecWait(args, std::function<void()>{setUserIdentity}) == 0;
     }
 
     void verifyThatImageIsAvailable() const {
@@ -520,7 +520,7 @@ class CommandRun : public Command {
         //   - we can access images on root_squashed filesystems
         //   - we do not create/update local repo files (e.g. repo metadata and lockfiles) with root ownership
         auto rootIdentity = libsarus::UserIdentity{};
-        libsarus::switchIdentity(conf->userIdentity);
+        libsarus::process::switchIdentity(conf->userIdentity);
 
         try {
             auto imageStore = image_manager::ImageStore(conf);
@@ -542,7 +542,7 @@ class CommandRun : public Command {
             SARUS_RETHROW_ERROR(e, "Failed to verify that image is available");
         }
 
-        libsarus::switchIdentity(rootIdentity);
+        libsarus::process::switchIdentity(rootIdentity);
 
         cli::utility::printLog(boost::format("Successfully verified that image %s is available") % conf->imageReference,
                                libsarus::LogLevel::INFO);
diff --git a/src/cli/CommandSshKeygen.hpp b/src/cli/CommandSshKeygen.hpp
index d00eecc7..845142e9 100644
--- a/src/cli/CommandSshKeygen.hpp
+++ b/src/cli/CommandSshKeygen.hpp
@@ -39,11 +39,11 @@ class CommandSshKeygen : public Command {
     }
 
     void execute() override {
-        libsarus::setEnvironmentVariable("HOOK_BASE_DIR", conf->json["localRepositoryBaseDir"].GetString());
+        libsarus::environment::setVariable("HOOK_BASE_DIR", conf->json["localRepositoryBaseDir"].GetString());
         auto passwdFile = boost::filesystem::path{ conf->json["prefixDir"].GetString() } / "etc/passwd";
-        libsarus::setEnvironmentVariable("PASSWD_FILE", passwdFile.string());
+        libsarus::environment::setVariable("PASSWD_FILE", passwdFile.string());
         auto dropbearDir = boost::filesystem::path{ conf->json["prefixDir"].GetString() } / "dropbear";
-        libsarus::setEnvironmentVariable("DROPBEAR_DIR", dropbearDir.string());
+        libsarus::environment::setVariable("DROPBEAR_DIR", dropbearDir.string());
 
         auto sshHook = boost::filesystem::path{conf->json["prefixDir"].GetString()} / "bin/ssh_hook";
         auto args = libsarus::CLIArguments{sshHook.string(), "keygen"};
@@ -56,7 +56,7 @@ class CommandSshKeygen : public Command {
         else if(libsarus::Logger::getInstance().getLevel() == libsarus::LogLevel::DEBUG) {
             args.push_back("--debug");
         }
-        libsarus::forkExecWait(args);
+        libsarus::process::forkExecWait(args);
     }
 
     bool requiresRootPrivileges() const override {
diff --git a/src/cli/test/test_CLI.cpp b/src/cli/test/test_CLI.cpp
index aca25b81..b126e5c6 100644
--- a/src/cli/test/test_CLI.cpp
+++ b/src/cli/test/test_CLI.cpp
@@ -143,7 +143,7 @@ TEST(CLITestGroup, generated_config_for_CommandLoad) {
     // temp dir
     {
         auto customTempDir = libsarus::PathRAII("/tmp/sarus-utest-temp-dir");
-        libsarus::createFoldersIfNecessary(customTempDir.getPath());
+        libsarus::filesystem::createFoldersIfNecessary(customTempDir.getPath());
 
         auto conf = generateConfig(
             {"load", "--temp-dir="+customTempDir.getPath().string(), "archive.tar", "library/image:tag"});
@@ -188,7 +188,7 @@ TEST(CLITestGroup, generated_config_for_CommandPull) {
     // temp-dir option and custom server
     {
         auto customTempDir = libsarus::PathRAII("/tmp/sarus-utest-temp-dir");
-        libsarus::createFoldersIfNecessary(customTempDir.getPath());
+        libsarus::filesystem::createFoldersIfNecessary(customTempDir.getPath());
 
         auto conf = generateConfig(
             {"pull",
@@ -487,8 +487,8 @@ TEST (CLITestGroup, device_mounts_for_CommandRun)  {
 IGNORE_TEST(CLITestGroup, device_mounts_for_CommandRun) {
 #endif
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "CLI-test-deviceMounts-CommandRun"));
-    libsarus::createFoldersIfNecessary(testDir.getPath());
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "CLI-test-deviceMounts-CommandRun"));
+    libsarus::filesystem::createFoldersIfNecessary(testDir.getPath());
     auto siteDevice = testDir.getPath() / "siteDevice";
     auto siteDeviceMajorID = 511u;
     auto siteDeviceMinorID = 511u;
diff --git a/src/common/Config.cpp b/src/common/Config.cpp
index ee3d9eb2..b93788a6 100644
--- a/src/common/Config.cpp
+++ b/src/common/Config.cpp
@@ -27,7 +27,7 @@ Config::Config(const boost::filesystem::path& sarusInstallationPrefixDir)
 
 Config::Config(const boost::filesystem::path& configFilename,
                const boost::filesystem::path& configSchemaFilename)
-    : json{ libsarus::readAndValidateJSON(configFilename, configSchemaFilename) }
+    : json{ libsarus::json::readAndValidate(configFilename, configSchemaFilename) }
 {}
 
 void Config::Directories::initialize(bool useCentralizedRepository, const common::Config& config) {
@@ -36,20 +36,20 @@ void Config::Directories::initialize(bool useCentralizedRepository, const common
                             libsarus::LogLevel::DEBUG);
         repository = config.getCentralizedRepositoryDirectory();
         images = repository / "images";
-        libsarus::createFoldersIfNecessary(images,config.userIdentity.uid, config.userIdentity.gid);
+        libsarus::filesystem::createFoldersIfNecessary(images,config.userIdentity.uid, config.userIdentity.gid);
     }
     else {
         libsarus::logMessage( boost::format("initializing CLI config's directories for local repository"),
                             libsarus::LogLevel::DEBUG);
         repository = config.getLocalRepositoryDirectory();
         images = repository / "images";
-        libsarus::createFoldersIfNecessary(images, config.userIdentity.uid, config.userIdentity.gid);
+        libsarus::filesystem::createFoldersIfNecessary(images, config.userIdentity.uid, config.userIdentity.gid);
     }
 
     cache = repository / "cache";
-    libsarus::createFoldersIfNecessary(cache, config.userIdentity.uid, config.userIdentity.gid);
-    libsarus::createFoldersIfNecessary(cache / "ociImages", config.userIdentity.uid, config.userIdentity.gid);
-    libsarus::createFoldersIfNecessary(cache / "blobs", config.userIdentity.uid, config.userIdentity.gid);
+    libsarus::filesystem::createFoldersIfNecessary(cache, config.userIdentity.uid, config.userIdentity.gid);
+    libsarus::filesystem::createFoldersIfNecessary(cache / "ociImages", config.userIdentity.uid, config.userIdentity.gid);
+    libsarus::filesystem::createFoldersIfNecessary(cache / "blobs", config.userIdentity.uid, config.userIdentity.gid);
 
     bool tempDirWasSpecifiedThroughCLI = !tempFromCLI.empty();
     if(tempDirWasSpecifiedThroughCLI) {
diff --git a/src/common/ImageMetadata.cpp b/src/common/ImageMetadata.cpp
index e1aeff7e..3a656920 100644
--- a/src/common/ImageMetadata.cpp
+++ b/src/common/ImageMetadata.cpp
@@ -32,16 +32,16 @@ ImageMetadata::ImageMetadata(const boost::filesystem::path& path, const libsarus
     auto rootIdentity = libsarus::UserIdentity{};
     try {
         // switch to user identity to make sure we can access files on root_squashed filesystems
-        libsarus::setFilesystemUid(identity);
+        libsarus::process::setFilesystemUid(identity);
 
-        auto json = libsarus::readJSON(path);
+        auto json = libsarus::json::read(path);
 
-        libsarus::setFilesystemUid(rootIdentity);
+        libsarus::process::setFilesystemUid(rootIdentity);
 
         parseJSON(json);
     }
     catch (const libsarus::Error& e) {
-        libsarus::setFilesystemUid(rootIdentity);
+        libsarus::process::setFilesystemUid(rootIdentity);
         auto message = boost::format("Error creating image metadata from file %s") % path;
         SARUS_RETHROW_ERROR(e, message.str());
     }
@@ -109,7 +109,7 @@ void ImageMetadata::write(const boost::filesystem::path& path) const {
         }
     }
 
-    libsarus::writeJSON(json, path);
+    libsarus::json::write(json, path);
 
     logMessage("Successfully written image metadata file", libsarus::LogLevel::INFO);
 }
@@ -146,7 +146,7 @@ void ImageMetadata::parseJSON(const rapidjson::Value& json) {
         for (const auto& v : json["Env"].GetArray()) {
             std::string variable = v.GetString();
             std::string key, value;
-            std::tie(key, value) = libsarus::parseEnvironmentVariable(variable);
+            std::tie(key, value) = libsarus::environment::parseVariable(variable);
             env[key] = value;
         }
     }
diff --git a/src/common/test/test_GroupDB.cpp b/src/common/test/test_GroupDB.cpp
index fa260130..1590c184 100644
--- a/src/common/test/test_GroupDB.cpp
+++ b/src/common/test/test_GroupDB.cpp
@@ -26,7 +26,7 @@ TEST_GROUP(GroupDBTestGroup) {
 
 TEST(GroupDBTestGroup, testRead) {
     // create file
-    auto path = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("./test-etc-group-file")};
+    auto path = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("./test-etc-group-file")};
     const auto& file = path.getPath();
     std::ofstream of{file.c_str()};
     of  << "groupName0:x:0:" << std::endl
@@ -63,7 +63,7 @@ TEST(GroupDBTestGroup, testRead) {
 }
 
 TEST(GroupDBTestGroup, testWrite) {
-    auto path = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("./test-etc-group-file")};
+    auto path = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("./test-etc-group-file")};
     const auto& file = path.getPath();
 
     // create entry
diff --git a/src/common/test/test_ImageMetadata.cpp b/src/common/test/test_ImageMetadata.cpp
index 86eab2c0..0cf8b4ce 100644
--- a/src/common/test/test_ImageMetadata.cpp
+++ b/src/common/test/test_ImageMetadata.cpp
@@ -36,7 +36,7 @@ TEST(ImageMetadataTestGroup, write_read_from_file) {
         {"labelKey1", "labelValue1"}
     };
 
-    auto file = libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-imagemetadata");
+    auto file = libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-imagemetadata");
     writtenMetadata.write(file);
     auto readMetadata = common::ImageMetadata{file, libsarus::UserIdentity{}};
 
diff --git a/src/hooks/amdgpu/AmdGpuHook.cpp b/src/hooks/amdgpu/AmdGpuHook.cpp
index afb762f6..4919910d 100644
--- a/src/hooks/amdgpu/AmdGpuHook.cpp
+++ b/src/hooks/amdgpu/AmdGpuHook.cpp
@@ -32,16 +32,16 @@ std::unordered_map<std::string, std::string> mapDevicesIdToRenderD(
 
   fs::path byPath(path + "/by-path");
   for (fs::directory_iterator itr(byPath); itr != end_itr; ++itr) {
-    if (!libsarus::isSymlink(itr->path()) ||
+    if (!libsarus::filesystem::isSymlink(itr->path()) ||
         itr->path().string().find("card") == std::string::npos)
       continue;
 
     cardId = fs::path(fs::read_symlink(itr->path())).filename().string();
 
-    libsarus::replaceString(cardId, "card", "");
+    libsarus::string::replace(cardId, "card", "");
 
     auto renderNName{itr->path().string()};
-    libsarus::replaceString(renderNName, "card", "render");
+    libsarus::string::replace(renderNName, "card", "render");
     auto renderNPath{fs::path(renderNName)};
 
     try {
@@ -112,7 +112,7 @@ void AmdGpuHook::activate() {
   log("Activating AMD GPU support", libsarus::LogLevel::INFO);
 
   try {
-    if (!libsarus::isDeviceFile(fs::path{"/dev/kfd"})) {
+    if (!libsarus::filesystem::isDeviceFile(fs::path{"/dev/kfd"})) {
       return;
     }
   } catch (const libsarus::Error& e) {
@@ -127,7 +127,7 @@ void AmdGpuHook::activate() {
 void AmdGpuHook::parseConfigJSONOfBundle() {
   log("Parsing bundle's config.json", libsarus::LogLevel::INFO);
 
-  auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+  auto json = libsarus::json::read(containerState.bundle() / "config.json");
 
   libsarus::hook::applyLoggingConfigIfAvailable(json);
 
@@ -158,10 +158,10 @@ void AmdGpuHook::performBindMounts() const {
     if (mountPoint.empty())
       continue;
 
-    libsarus::validatedBindMount(mountPoint, mountPoint, userIdentity,
+    libsarus::mount::validatedBindMount(mountPoint, mountPoint, userIdentity,
                                        rootfsDir);
 
-    if (libsarus::isDeviceFile(mountPoint)) {
+    if (libsarus::filesystem::isDeviceFile(mountPoint)) {
       if (devicesCgroupPath.empty()) {
         devicesCgroupPath =
             libsarus::hook::findCgroupPath("devices", "/", containerState.pid());
diff --git a/src/hooks/amdgpu/test/test_AmdGpuHook.cpp b/src/hooks/amdgpu/test/test_AmdGpuHook.cpp
index db41f75f..41ca40d8 100644
--- a/src/hooks/amdgpu/test/test_AmdGpuHook.cpp
+++ b/src/hooks/amdgpu/test/test_AmdGpuHook.cpp
@@ -36,13 +36,13 @@ void createDriSubdir(const fs::path& path, std::vector<int> ids) {
   if (fs::exists(path)) {
     fs::remove_all(path);
   }
-  libsarus::createFoldersIfNecessary(path / "by-path");
+  libsarus::filesystem::createFoldersIfNecessary(path / "by-path");
 
   int busId = 193;
   for (auto id : ids) {
-    libsarus::createFileIfNecessary(path /
+    libsarus::filesystem::createFileIfNecessary(path /
                                          (boost::format("card%1%") % id).str());
-    libsarus::createFileIfNecessary(
+    libsarus::filesystem::createFileIfNecessary(
         path / (boost::format("renderD%1%") % (128 + id)).str());
 
     fs::create_symlink(
@@ -70,7 +70,7 @@ void createOCIBundleConfigJSON(const boost::filesystem::path& bundleDir,
     doc["process"]["env"].PushBack(
         rj::Value{rocrVisibleDevices.c_str(), allocator}, allocator);
   }
-  libsarus::writeJSON(doc, bundleDir / "config.json");
+  libsarus::json::write(doc, bundleDir / "config.json");
 }
 
 TEST_GROUP(AMDGPUHookTestGroup) {
@@ -123,7 +123,7 @@ std::vector<std::string> getExpectedDeviceFiles(
 TEST(AMDGPUHookTestGroup,
      find_all_render_devices_if_ROCR_VISIBLE_DEVICES_is_not_defined) {
   auto mockDriPath = libsarus::PathRAII(
-                         libsarus::makeUniquePathWithRandomSuffix(
+                         libsarus::filesystem::makeUniquePathWithRandomSuffix(
                              boost::filesystem::current_path() / "mockDri"))
                          .getPath();
   createDriSubdir(mockDriPath, {0, 1, 2, 3});
@@ -137,7 +137,7 @@ TEST(AMDGPUHookTestGroup,
 
 TEST(AMDGPUHookTestGroup, find_all_render_devices_in_ROCR_VISIBLE_DEVICES) {
   auto mockDriPath = libsarus::PathRAII(
-                         libsarus::makeUniquePathWithRandomSuffix(
+                         libsarus::filesystem::makeUniquePathWithRandomSuffix(
                              boost::filesystem::current_path() / "mockDri"))
                          .getPath();
   createDriSubdir(mockDriPath, {0, 1, 2, 3});
diff --git a/src/hooks/glibc/GlibcHook.cpp b/src/hooks/glibc/GlibcHook.cpp
index fed11573..8dcc7884 100644
--- a/src/hooks/glibc/GlibcHook.cpp
+++ b/src/hooks/glibc/GlibcHook.cpp
@@ -72,7 +72,7 @@ void GlibcHook::injectGlibcLibrariesIfNecessary() {
 void GlibcHook::parseConfigJSONOfBundle() {
     logMessage("Parsing bundle's config.json", libsarus::LogLevel::INFO);
 
-    auto json = libsarus::readJSON(bundleDir / "config.json");
+    auto json = libsarus::json::read(bundleDir / "config.json");
 
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
@@ -95,13 +95,13 @@ void GlibcHook::parseConfigJSONOfBundle() {
 void GlibcHook::parseEnvironmentVariables() {
     logMessage("Parsing environment variables", libsarus::LogLevel::INFO);
 
-    lddPath = libsarus::getEnvironmentVariable("LDD_PATH");
+    lddPath = libsarus::environment::getVariable("LDD_PATH");
 
-    ldconfigPath = libsarus::getEnvironmentVariable("LDCONFIG_PATH");
+    ldconfigPath = libsarus::environment::getVariable("LDCONFIG_PATH");
 
-    readelfPath = libsarus::getEnvironmentVariable("READELF_PATH");
+    readelfPath = libsarus::environment::getVariable("READELF_PATH");
 
-    auto hostLibrariesColonSeparated = libsarus::getEnvironmentVariable("GLIBC_LIBS");
+    auto hostLibrariesColonSeparated = libsarus::environment::getVariable("GLIBC_LIBS");
     boost::split(hostLibraries, hostLibrariesColonSeparated, boost::is_any_of(":"));
 
     logMessage("Successfully parsed environment variables", libsarus::LogLevel::INFO);
@@ -116,12 +116,12 @@ bool GlibcHook::containerHasGlibc() const {
 
 std::vector<boost::filesystem::path> GlibcHook::get64bitContainerLibraries() const {
     auto isNot64bit = [this](const boost::filesystem::path& lib) {
-        return !libsarus::is64bitSharedLib(rootfsDir / libsarus::realpathWithinRootfs(rootfsDir, lib), readelfPath);
+        return !libsarus::sharedlibs::is64bitSharedLib(rootfsDir / libsarus::filesystem::realpathWithinRootfs(rootfsDir, lib), readelfPath);
     };
     auto doesNotExist = [this](const boost::filesystem::path& lib) {
-        return !boost::filesystem::exists(rootfsDir / libsarus::realpathWithinRootfs(rootfsDir, lib));
+        return !boost::filesystem::exists(rootfsDir / libsarus::filesystem::realpathWithinRootfs(rootfsDir, lib));
     };
-    auto libs = libsarus::getSharedLibsFromDynamicLinker(ldconfigPath, rootfsDir);
+    auto libs = libsarus::sharedlibs::getListFromDynamicLinker(ldconfigPath, rootfsDir);
     auto newEnd = std::remove_if(libs.begin(), libs.end(), doesNotExist);
     newEnd = std::remove_if(libs.begin(), newEnd, isNot64bit);
     libs.erase(newEnd, libs.cend());
@@ -129,7 +129,7 @@ std::vector<boost::filesystem::path> GlibcHook::get64bitContainerLibraries() con
 }
 
 boost::optional<boost::filesystem::path> GlibcHook::findLibc(const std::vector<boost::filesystem::path>& libs) const {
-    auto it = std::find_if(libs.cbegin(), libs.cend(), libsarus::isLibc);
+    auto it = std::find_if(libs.cbegin(), libs.cend(), libsarus::filesystem::isLibc);
     if(it == libs.cend()) {
         return {};
     }
@@ -170,7 +170,7 @@ static std::tuple<unsigned int, unsigned int> detectLibcVersion(
     const std::string& context) {
     auto lddOutput = std::stringstream();
     auto lddCommand = libsarus::CLIArguments{lddPath.string(), "--version"};
-    auto status = libsarus::forkExecWait(lddCommand, preExecActions, {}, &lddOutput);
+    auto status = libsarus::process::forkExecWait(lddCommand, preExecActions, {}, &lddOutput);
     if(status != 0) {
         auto message = boost::format("Failed to detect %s glibc version. Command %s exited with status %d")
             % context % lddCommand % status;
@@ -197,7 +197,7 @@ std::tuple<unsigned int, unsigned int> GlibcHook::detectContainerLibcVersion() c
             SARUS_THROW_ERROR(message.str());
         }
         libsarus::hook::switchToUnprivilegedProcess(userIdentity.uid, userIdentity.gid);
-        libsarus::changeDirectory("/");
+        libsarus::filesystem::changeDirectory("/");
     };
     return detectLibcVersion("/usr/bin/ldd", preExecActions, "container");
 }
@@ -205,8 +205,8 @@ std::tuple<unsigned int, unsigned int> GlibcHook::detectContainerLibcVersion() c
 void GlibcHook::verifyThatHostAndContainerGlibcAreABICompatible(
     const boost::filesystem::path& hostLibc,
     const boost::filesystem::path& containerLibc) const {
-    auto hostSoname = libsarus::getSharedLibSoname(hostLibc, readelfPath);
-    auto containerSoname = libsarus::getSharedLibSoname(rootfsDir / containerLibc, readelfPath);
+    auto hostSoname = libsarus::sharedlibs::getSoname(hostLibc, readelfPath);
+    auto containerSoname = libsarus::sharedlibs::getSoname(rootfsDir / containerLibc, readelfPath);
     if(hostSoname != containerSoname) {
         auto message = boost::format(
             "Failed to inject glibc libraries. Host's glibc is not ABI compatible with container's glibc."
@@ -218,13 +218,13 @@ void GlibcHook::verifyThatHostAndContainerGlibcAreABICompatible(
 void GlibcHook::replaceGlibcLibrariesInContainer() const {
     for (const auto& hostLib : hostLibraries) {
         auto wasLibraryReplaced = false;
-        auto soname = libsarus::getSharedLibSoname(hostLib, readelfPath);
+        auto soname = libsarus::sharedlibs::getSoname(hostLib, readelfPath);
         logMessage(boost::format("Injecting host lib %s with soname %s in the container")
                    % hostLib % soname, libsarus::LogLevel::DEBUG);
 
         for (const auto& containerLib : containerLibraries) {
             if (containerLib.filename().string() == soname) {
-                libsarus::validatedBindMount(hostLib, containerLib, userIdentity, rootfsDir);
+                libsarus::mount::validatedBindMount(hostLib, containerLib, userIdentity, rootfsDir);
                 wasLibraryReplaced = true;
             }
         }
@@ -233,7 +233,7 @@ void GlibcHook::replaceGlibcLibrariesInContainer() const {
             logMessage(boost::format("Could not find ABI-compatible counterpart for host lib (%s) inside container "
                                      "=> adding host lib (%s) into container's /lib64 via bind mount ")
                        % hostLib % hostLib, libsarus::LogLevel::WARN);
-            libsarus::validatedBindMount(hostLib, "/lib64"/hostLib.filename(), userIdentity, rootfsDir);
+            libsarus::mount::validatedBindMount(hostLib, "/lib64"/hostLib.filename(), userIdentity, rootfsDir);
         }
     }
 }
diff --git a/src/hooks/glibc/test/Checker.hpp b/src/hooks/glibc/test/Checker.hpp
index 2bf244be..c95bcf80 100644
--- a/src/hooks/glibc/test/Checker.hpp
+++ b/src/hooks/glibc/test/Checker.hpp
@@ -38,8 +38,8 @@ class Checker {
     Checker& addHostLibcAndSymlink( const boost::filesystem::path& dummyLib,
                                     const boost::filesystem::path& hostLib,
                                     const boost::filesystem::path& hostSymlink) {
-        libsarus::createFoldersIfNecessary((bundleDir / hostLib).parent_path());
-        libsarus::createFoldersIfNecessary((bundleDir / hostSymlink).parent_path());
+        libsarus::filesystem::createFoldersIfNecessary((bundleDir / hostLib).parent_path());
+        libsarus::filesystem::createFoldersIfNecessary((bundleDir / hostSymlink).parent_path());
         boost::filesystem::copy_file(dummyLibsDir / dummyLib, bundleDir / hostLib);
         boost::filesystem::create_symlink(bundleDir / hostLib, bundleDir / hostSymlink);
         hostLibs.push_back(bundleDir / hostSymlink);
@@ -48,7 +48,7 @@ class Checker {
 
     Checker& addHostLib(const boost::filesystem::path& dummyLib,
                         const boost::filesystem::path& hostLib) {
-        libsarus::createFoldersIfNecessary((bundleDir / hostLib).parent_path());
+        libsarus::filesystem::createFoldersIfNecessary((bundleDir / hostLib).parent_path());
         boost::filesystem::copy_file(dummyLibsDir / dummyLib, bundleDir / hostLib);
         hostLibs.push_back(bundleDir / hostLib);
         return *this;
@@ -58,8 +58,8 @@ class Checker {
                                         const boost::filesystem::path& containerLib,
                                         const boost::filesystem::path& containerSymlink,
                                         const boost::filesystem::path& expectedContainerLibAfterInjection) {
-        libsarus::createFoldersIfNecessary((rootfsDir / containerLib).parent_path());
-        libsarus::createFoldersIfNecessary((rootfsDir / containerSymlink).parent_path());
+        libsarus::filesystem::createFoldersIfNecessary((rootfsDir / containerLib).parent_path());
+        libsarus::filesystem::createFoldersIfNecessary((rootfsDir / containerSymlink).parent_path());
         boost::filesystem::copy_file(dummyLibsDir / dummyLib, rootfsDir / containerLib);
         boost::filesystem::create_symlink(rootfsDir / containerLib, rootfsDir / containerSymlink);
         expectContainerLib(containerSymlink, expectedContainerLibAfterInjection);
@@ -69,7 +69,7 @@ class Checker {
     Checker& addContainerLib(   const boost::filesystem::path& dummyLib,
                                 const boost::filesystem::path& containerLib,
                                 const boost::filesystem::path& expectedContainerLibAfterInjection) {
-        libsarus::createFoldersIfNecessary((rootfsDir / containerLib).parent_path());
+        libsarus::filesystem::createFoldersIfNecessary((rootfsDir / containerLib).parent_path());
         boost::filesystem::copy_file(dummyLibsDir / dummyLib, rootfsDir / containerLib);
         expectContainerLib(containerLib, expectedContainerLibAfterInjection);
         return *this;
@@ -83,25 +83,25 @@ class Checker {
     }
 
     Checker& runLdconfigInContainer() {
-        libsarus::createFoldersIfNecessary(rootfsDir / "etc");
-        libsarus::executeCommand("echo '/lib' >> " + (rootfsDir / "etc/ld.so.conf").string());
-        libsarus::executeCommand("echo '/lib64' >> " + (rootfsDir / "etc/ld.so.conf").string());
-        libsarus::executeCommand("ldconfig -r " + rootfsDir.string()); // run ldconfig in rootfs
+        libsarus::filesystem::createFoldersIfNecessary(rootfsDir / "etc");
+        libsarus::process::executeCommand("echo '/lib' >> " + (rootfsDir / "etc/ld.so.conf").string());
+        libsarus::process::executeCommand("echo '/lib64' >> " + (rootfsDir / "etc/ld.so.conf").string());
+        libsarus::process::executeCommand("ldconfig -r " + rootfsDir.string()); // run ldconfig in rootfs
         return *this;
     }
 
     Checker& mockLddWithOlderVersion() {
-        libsarus::copyFile(boost::filesystem::current_path() / "mocks/lddMockOlder", rootfsDir / lddPath);
+        libsarus::filesystem::copyFile(boost::filesystem::current_path() / "mocks/lddMockOlder", rootfsDir / lddPath);
         return *this;
     }
 
     Checker& mockLddWithEqualVersion() {
-        libsarus::copyFile(boost::filesystem::current_path() / "mocks/lddMockEqual", rootfsDir / lddPath);
+        libsarus::filesystem::copyFile(boost::filesystem::current_path() / "mocks/lddMockEqual", rootfsDir / lddPath);
         return *this;
     }
 
     Checker& mockLddWithNewerVersion() {
-        libsarus::copyFile(boost::filesystem::current_path() / "mocks/lddMockNewer", rootfsDir / lddPath);
+        libsarus::filesystem::copyFile(boost::filesystem::current_path() / "mocks/lddMockNewer", rootfsDir / lddPath);
         return *this;
     }
 
@@ -126,15 +126,15 @@ class Checker {
 private:
     void setupTestEnvironment() const {
         auto doc = test_utility::ocihooks::createBaseConfigJSON(rootfsDir, test_utility::misc::getNonRootUserIds());
-        libsarus::writeJSON(doc, bundleDir / "config.json");
+        libsarus::json::write(doc, bundleDir / "config.json");
         test_utility::ocihooks::writeContainerStateToStdin(bundleDir);
 
-        libsarus::setEnvironmentVariable("LDD_PATH", (boost::filesystem::current_path() / "mocks/lddMockEqual").string());
-        libsarus::setEnvironmentVariable("LDCONFIG_PATH", "ldconfig");
-        libsarus::setEnvironmentVariable("READELF_PATH", "readelf");
-        libsarus::setEnvironmentVariable("GLIBC_LIBS", libsarus::makeColonSeparatedListOfPaths(hostLibs));
+        libsarus::environment::setVariable("LDD_PATH", (boost::filesystem::current_path() / "mocks/lddMockEqual").string());
+        libsarus::environment::setVariable("LDCONFIG_PATH", "ldconfig");
+        libsarus::environment::setVariable("READELF_PATH", "readelf");
+        libsarus::environment::setVariable("GLIBC_LIBS", libsarus::filesystem::makeColonSeparatedListOfPaths(hostLibs));
 
-        libsarus::createFoldersIfNecessary(rootfsDir / "tmp",
+        libsarus::filesystem::createFoldersIfNecessary(rootfsDir / "tmp",
                                                 doc["process"]["user"]["uid"].GetInt(),
                                                 doc["process"]["user"]["gid"].GetInt());
     }
diff --git a/src/hooks/mount/MountHook.cpp b/src/hooks/mount/MountHook.cpp
index 7ba43020..04d6637f 100644
--- a/src/hooks/mount/MountHook.cpp
+++ b/src/hooks/mount/MountHook.cpp
@@ -40,7 +40,7 @@ MountHook::MountHook(const libsarus::CLIArguments& args) {
 void MountHook::parseConfigJSONOfBundle() {
     log("Parsing bundle's config.json", libsarus::LogLevel::INFO);
 
-    auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+    auto json = libsarus::json::read(containerState.bundle() / "config.json");
 
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
@@ -69,7 +69,7 @@ void MountHook::parseConfigJSONOfBundle() {
 void MountHook::parseEnvironmentVariables() {
     log("Parsing environment variables", libsarus::LogLevel::INFO);
     try{
-        ldconfigPath = libsarus::getEnvironmentVariable("LDCONFIG_PATH");
+        ldconfigPath = libsarus::environment::getVariable("LDCONFIG_PATH");
     }
     catch (libsarus::Error& e) {}
     log("Successfully parsed environment variables", libsarus::LogLevel::INFO);
@@ -100,7 +100,7 @@ void MountHook::parseCliArguments(const libsarus::CLIArguments& args) {
     auto mountParser = libsarus::MountParser{rootfsDir, userIdentity};
     for (const auto& mountString : inputMounts) {
         auto parseCandidate = replaceStringWildcards(mountString);
-        auto map = libsarus::parseMap(parseCandidate);
+        auto map = libsarus::string::parseMap(parseCandidate);
         bindMounts.push_back(mountParser.parseMountRequest(map));
     }
 
@@ -152,11 +152,11 @@ boost::filesystem::path MountHook::findLibfabricLibdir() const {
         log(message, libsarus::LogLevel::INFO);
         SARUS_THROW_ERROR(message, libsarus::LogLevel::INFO);
     }
-    auto containerLibPaths = libsarus::getSharedLibsFromDynamicLinker(ldconfigPath, rootfsDir);
+    auto containerLibPaths = libsarus::sharedlibs::getListFromDynamicLinker(ldconfigPath, rootfsDir);
     boost::smatch match;
     for (const auto& p : containerLibPaths){
         if (boost::regex_search(p.string(), match, boost::regex("libfabric\\.so(?:\\.\\d+)+$"))
-                && boost::filesystem::exists(rootfsDir / libsarus::realpathWithinRootfs(rootfsDir, p))) {
+                && boost::filesystem::exists(rootfsDir / libsarus::filesystem::realpathWithinRootfs(rootfsDir, p))) {
             auto message = boost::format("Found existing libfabric from the container's dynamic linker cache: %s") % p;
             log(message, libsarus::LogLevel::DEBUG);
             return p.parent_path();
@@ -200,7 +200,7 @@ void MountHook::activate() const {
     performDeviceMounts();
     if (!ldconfigPath.empty()) {
         log("Updating container's dynamic linker cache", libsarus::LogLevel::INFO);
-        libsarus::executeCommand(ldconfigPath.string() + " -r " + rootfsDir.string());
+        libsarus::process::executeCommand(ldconfigPath.string() + " -r " + rootfsDir.string());
     }
 }
 
diff --git a/src/hooks/mount/test/MountHookChecker.hpp b/src/hooks/mount/test/MountHookChecker.hpp
index c2b1f83d..9d072168 100644
--- a/src/hooks/mount/test/MountHookChecker.hpp
+++ b/src/hooks/mount/test/MountHookChecker.hpp
@@ -72,9 +72,9 @@ class MountHookChecker {
 
 private:
     void setupTestEnvironment() const {
-        libsarus::createFoldersIfNecessary(rootfsDir / "etc");
+        libsarus::filesystem::createFoldersIfNecessary(rootfsDir / "etc");
         auto doc = test_utility::ocihooks::createBaseConfigJSON(rootfsDir, test_utility::misc::getNonRootUserIds());
-        libsarus::writeJSON(doc, bundleDir / "config.json");
+        libsarus::json::write(doc, bundleDir / "config.json");
         test_utility::ocihooks::writeContainerStateToStdin(bundleDir);
     }
 
diff --git a/src/hooks/mount/test/test_MountHook.cpp b/src/hooks/mount/test/test_MountHook.cpp
index 8988e117..3706cdc2 100644
--- a/src/hooks/mount/test/test_MountHook.cpp
+++ b/src/hooks/mount/test/test_MountHook.cpp
@@ -51,30 +51,30 @@ void setupMockInDynamicLinkerCache(const boost::filesystem::path& rootfsDir, con
             .parent_path()
             .parent_path() / "CI/dummy_libs/lib_dummy_0.so";
     auto mockRealPath = rootfsDir / mockPathInRootfs;
-    libsarus::copyFile(dummyLib, mockRealPath);
+    libsarus::filesystem::copyFile(dummyLib, mockRealPath);
 
     // populate ld.so.conf with mock directory
-    libsarus::createFileIfNecessary(rootfsDir / "etc/ld.so.conf");
+    libsarus::filesystem::createFileIfNecessary(rootfsDir / "etc/ld.so.conf");
     std::ofstream of{(rootfsDir / "etc/ld.so.conf").c_str()};
     of << mockPathInRootfs.parent_path().string() << "\n";
     of.close(); // write to disk
 
     // create /etc/ld.so.cache
-    libsarus::executeCommand("ldconfig -r " + rootfsDir.string());
+    libsarus::process::executeCommand("ldconfig -r " + rootfsDir.string());
 }
 
 TEST(MountHookTestGroup, fi_provider_path_wildcard_replacement) {
     auto bundleDir = libsarus::PathRAII(
-            libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "mount-hook-test-bundle-dir"));
+            libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "mount-hook-test-bundle-dir"));
     auto rootfsDir = bundleDir.getPath() / "rootfs";
     auto bundleConfig = bundleDir.getPath() / "config.json";
-    libsarus::createFoldersIfNecessary(bundleDir.getPath());
-    libsarus::createFoldersIfNecessary(rootfsDir);
+    libsarus::filesystem::createFoldersIfNecessary(bundleDir.getPath());
+    libsarus::filesystem::createFoldersIfNecessary(rootfsDir);
 
     auto config = test_utility::ocihooks::createBaseConfigJSON(rootfsDir, test_utility::misc::getNonRootUserIds());
     auto& allocator = config.GetAllocator();
 
-    libsarus::setEnvironmentVariable("LDCONFIG_PATH", "ldconfig");
+    libsarus::environment::setVariable("LDCONFIG_PATH", "ldconfig");
     boost::filesystem::path libfabricContainerPath("/libfabricInstall/lib/libfabric.so.1");
     auto args = libsarus::CLIArguments{
                     "mount_hook",
@@ -83,7 +83,7 @@ TEST(MountHookTestGroup, fi_provider_path_wildcard_replacement) {
     // FI_PROVIDER_PATH in environment
     {
         config["process"]["env"].PushBack("FI_PROVIDER_PATH=/fi/provider/path/envVar", allocator);
-        libsarus::writeJSON(config, bundleConfig);
+        libsarus::json::write(config, bundleConfig);
 
         test_utility::ocihooks::writeContainerStateToStdin(bundleDir.getPath());
         MountHook hook{args};
@@ -93,7 +93,7 @@ TEST(MountHookTestGroup, fi_provider_path_wildcard_replacement) {
     {
         config["process"]["env"].SetArray();
         config["process"]["env"].PushBack("FI_PROVIDER_PATH=/fi/provider/path/envVar", allocator);
-        libsarus::writeJSON(config, bundleConfig);
+        libsarus::json::write(config, bundleConfig);
 
         setupMockInDynamicLinkerCache(rootfsDir, libfabricContainerPath);
 
@@ -105,7 +105,7 @@ TEST(MountHookTestGroup, fi_provider_path_wildcard_replacement) {
     {
         config["process"]["env"].SetArray();
         config["process"]["env"].PushBack("FI_PROVIDER_PATH=", allocator);
-        libsarus::writeJSON(config, bundleConfig);
+        libsarus::json::write(config, bundleConfig);
 
         setupMockInDynamicLinkerCache(rootfsDir, libfabricContainerPath);
 
@@ -116,7 +116,7 @@ TEST(MountHookTestGroup, fi_provider_path_wildcard_replacement) {
     // libfabric only in dynamic linker cache
     {
         config["process"]["env"].SetArray();
-        libsarus::writeJSON(config, bundleConfig);
+        libsarus::json::write(config, bundleConfig);
 
         setupMockInDynamicLinkerCache(rootfsDir, libfabricContainerPath);
 
@@ -127,7 +127,7 @@ TEST(MountHookTestGroup, fi_provider_path_wildcard_replacement) {
     // no environment set and no ldconfig
     {
         config["process"]["env"].SetArray();
-        libsarus::writeJSON(config, bundleConfig);
+        libsarus::json::write(config, bundleConfig);
 
         CHECK(unsetenv("LDCONFIG_PATH") == 0);
 
diff --git a/src/hooks/mpi/MpiHook.cpp b/src/hooks/mpi/MpiHook.cpp
index b0eaf4e3..a3c2fd23 100644
--- a/src/hooks/mpi/MpiHook.cpp
+++ b/src/hooks/mpi/MpiHook.cpp
@@ -34,9 +34,9 @@ MpiHook::MpiHook() {
     parseConfigJSONOfBundle();
     parseEnvironmentVariables();
     log("Getting list of shared libs from the container's dynamic linker cache", libsarus::LogLevel::DEBUG);
-    auto containerLibPaths = libsarus::getSharedLibsFromDynamicLinker(ldconfig, rootfsDir);
+    auto containerLibPaths = libsarus::sharedlibs::getListFromDynamicLinker(ldconfig, rootfsDir);
     for (const auto& p : containerLibPaths){
-        if ( !boost::filesystem::exists(rootfsDir / libsarus::realpathWithinRootfs(rootfsDir, p)) ) {
+        if ( !boost::filesystem::exists(rootfsDir / libsarus::filesystem::realpathWithinRootfs(rootfsDir, p)) ) {
             auto message = boost::format("Container library %s has an entry in the dynamic linker cache"
                                          " but does not exist or is a broken symlink in the container's"
                                          " filesystem. Skipping...") % p;
@@ -68,7 +68,7 @@ void MpiHook::activateMpiSupport() {
     injectHostLibraries(hostMpiLibs, hostToContainerMpiLibs, abiCompatibilityCheckerType);
     injectHostLibraries(hostDepLibs, hostToContainerDependencyLibs, "dependencies");
     performBindMounts();
-    libsarus::executeCommand(ldconfig.string() + " -r " + rootfsDir.string()); // update container's dynamic linker
+    libsarus::process::executeCommand(ldconfig.string() + " -r " + rootfsDir.string()); // update container's dynamic linker
 
     log("Successfully activated MPI support", libsarus::LogLevel::INFO);
 }
@@ -76,7 +76,7 @@ void MpiHook::activateMpiSupport() {
 void MpiHook::parseConfigJSONOfBundle() {
     log("Parsing bundle's config.json", libsarus::LogLevel::INFO);
 
-    auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+    auto json = libsarus::json::read(containerState.bundle() / "config.json");
 
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
@@ -98,9 +98,9 @@ void MpiHook::parseConfigJSONOfBundle() {
 void MpiHook::parseEnvironmentVariables() {
     log("Parsing environment variables", libsarus::LogLevel::INFO);
 
-    ldconfig = libsarus::getEnvironmentVariable("LDCONFIG_PATH");
+    ldconfig = libsarus::environment::getVariable("LDCONFIG_PATH");
 
-    auto hostMpiLibsColonSeparated = libsarus::getEnvironmentVariable("MPI_LIBS");
+    auto hostMpiLibsColonSeparated = libsarus::environment::getVariable("MPI_LIBS");
     if(hostMpiLibsColonSeparated.empty()) {
         SARUS_THROW_ERROR("The environment variable MPI_LIBS is expected to be a non-empty colon-separated list of paths");
     }
@@ -252,7 +252,7 @@ void MpiHook::injectHostLibrary(const SharedLibrary& hostLib,
     if (it == hostToContainerLibs.cend()) {
         log(boost::format{"no corresponding libs in container => bind mount (%s) into /lib"} % hostLib.getPath(), libsarus::LogLevel::DEBUG);
         auto containerLib = "/lib" / hostLib.getPath().filename();
-        libsarus::validatedBindMount(hostLib.getPath(), containerLib, userIdentity, rootfsDir);
+        libsarus::mount::validatedBindMount(hostLib.getPath(), containerLib, userIdentity, rootfsDir);
         createSymlinksInDynamicLinkerDefaultSearchDirs(containerLib, hostLib.getPath().filename(), false);
         return;
     }
@@ -265,14 +265,14 @@ void MpiHook::injectHostLibrary(const SharedLibrary& hostLib,
     auto areCompatible{abiCompatibilityChecker->check(hostLib, bestCandidateLib)};
     if(areCompatible.second == boost::none) {
         log(boost::format{"abi-compatible => bind mount host lib (%s) on top of container lib (%s) (i.e. override)"} % hostLib.getPath() % bestCandidateLib.getPath(), libsarus::LogLevel::DEBUG);
-        libsarus::validatedBindMount(hostLib.getPath(), bestCandidateLib.getPath(), userIdentity, rootfsDir);
+        libsarus::mount::validatedBindMount(hostLib.getPath(), bestCandidateLib.getPath(), userIdentity, rootfsDir);
         createSymlinksInDynamicLinkerDefaultSearchDirs(bestCandidateLib.getPath(), hostLib.getPath().filename(), containerHasLibsWithIncompatibleVersion);
         log("Successfully injected host's shared lib", libsarus::LogLevel::DEBUG);
         return;
     }
     log(areCompatible.second.get(), libsarus::LogLevel::INFO);
     auto containerLib = "/lib" / hostLib.getPath().filename();
-    libsarus::validatedBindMount(hostLib.getPath(), containerLib, userIdentity, rootfsDir);
+    libsarus::mount::validatedBindMount(hostLib.getPath(), containerLib, userIdentity, rootfsDir);
     if (areCompatible.first) {
         createSymlinksInDynamicLinkerDefaultSearchDirs(containerLib, hostLib.getPath().filename(), containerHasLibsWithIncompatibleVersion);
     } else {
@@ -296,9 +296,9 @@ void MpiHook::performBindMounts() const {
     auto devicesCgroupPath = boost::filesystem::path{};
 
     for(const auto& mount : bindMounts) {
-        libsarus::validatedBindMount(mount, mount, userIdentity, rootfsDir);
+        libsarus::mount::validatedBindMount(mount, mount, userIdentity, rootfsDir);
 
-        if (libsarus::isDeviceFile(mount)) {
+        if (libsarus::filesystem::isDeviceFile(mount)) {
             if (devicesCgroupPath.empty()) {
                 devicesCgroupPath = libsarus::hook::findCgroupPath("devices", "/", containerState.pid());
             }
@@ -341,9 +341,9 @@ void MpiHook::createSymlinksInDynamicLinkerDefaultSearchDirs(const boost::filesy
     //      you inject libfoo.so.4, you don't want to end up with libfoo.so -> libfoo.so.4 because it may break the container apps.
     //      You should note that the library being injected (configured in Sarus configuration) should've been compiled using sonames,
     //      not the linker names, to avoid breaking the injected library for the same reason stated above.
-    auto libName = libsarus::getSharedLibLinkerName(linkFilename);
+    auto libName = libsarus::sharedlibs::getLinkerName(linkFilename);
     auto linkNames = std::vector<std::string> { libName.string() };
-    for(const auto& versionNumber : libsarus::parseSharedLibAbi(linkFilename)) {
+    for(const auto& versionNumber : libsarus::sharedlibs::parseAbi(linkFilename)) {
         linkNames.push_back(linkNames.back() + "." + versionNumber);
     }
 
@@ -365,17 +365,17 @@ void MpiHook::createSymlinksInDynamicLinkerDefaultSearchDirs(const boost::filesy
     auto linkerDefaultSearchDirs = std::vector<boost::filesystem::path> {"/lib", "/lib64"};
     for (const auto& dir: linkerDefaultSearchDirs) {
         auto searchDir = rootfsDir / dir;
-        libsarus::createFoldersIfNecessary(searchDir);
+        libsarus::filesystem::createFoldersIfNecessary(searchDir);
 
         // prevent writing as root where we are not allowed to
-        if (!libsarus::isPathOnAllowedDevice(searchDir, rootfsDir)) {
+        if (!libsarus::mount::isPathOnAllowedDevice(searchDir, rootfsDir)) {
             log(boost::format("The hook is not allowed to write to %s. Ignoring symlinks creation in this path.") % searchDir, libsarus::LogLevel::WARN);
             continue;
         }
 
         for (const auto& linkName : linkNames) {
-            auto realLink = libsarus::realpathWithinRootfs(rootfsDir, dir / linkName);
-            auto realTarget = libsarus::realpathWithinRootfs(rootfsDir, target);
+            auto realLink = libsarus::filesystem::realpathWithinRootfs(rootfsDir, dir / linkName);
+            auto realTarget = libsarus::filesystem::realpathWithinRootfs(rootfsDir, target);
             bool linkIsTarget = (realLink == realTarget);
             bool preserveLink = (linkName == libName && preserveRootLink && rootLinkExists);
             if (linkIsTarget || preserveLink) {
diff --git a/src/hooks/mpi/SharedLibrary.cpp b/src/hooks/mpi/SharedLibrary.cpp
index 0152104b..106da730 100644
--- a/src/hooks/mpi/SharedLibrary.cpp
+++ b/src/hooks/mpi/SharedLibrary.cpp
@@ -41,8 +41,8 @@ bool areStrictlyAbiCompatible(const SharedLibrary& host, const SharedLibrary& co
 }
 
 SharedLibrary::SharedLibrary(const boost::filesystem::path& path, const boost::filesystem::path& rootDir) : path(path) {
-    linkerName = libsarus::getSharedLibLinkerName(path).string();
-    auto abi = libsarus::resolveSharedLibAbi(path, rootDir);
+    linkerName = libsarus::sharedlibs::getLinkerName(path).string();
+    auto abi = libsarus::sharedlibs::resolveAbi(path, rootDir);
     if (abi.size() > 0)
         major = std::stoi(abi[0]);
     if (abi.size() > 1)
diff --git a/src/hooks/mpi/test/Checker.hpp b/src/hooks/mpi/test/Checker.hpp
index 2956ee4b..3017263b 100644
--- a/src/hooks/mpi/test/Checker.hpp
+++ b/src/hooks/mpi/test/Checker.hpp
@@ -105,36 +105,36 @@ class Checker {
 
 private:
     void setupTestEnvironment() const {
-        libsarus::createFoldersIfNecessary(rootfsDir / "etc");
+        libsarus::filesystem::createFoldersIfNecessary(rootfsDir / "etc");
         auto doc = test_utility::ocihooks::createBaseConfigJSON(rootfsDir, test_utility::misc::getNonRootUserIds());
-        libsarus::writeJSON(doc, bundleDir / "config.json");
+        libsarus::json::write(doc, bundleDir / "config.json");
         createLibraries();
         setupDynamicLinkerInContainer();
         test_utility::ocihooks::writeContainerStateToStdin(bundleDir);
-        libsarus::setEnvironmentVariable("LDCONFIG_PATH", "ldconfig");
-        libsarus::setEnvironmentVariable("MPI_LIBS", libsarus::makeColonSeparatedListOfPaths(hostMpiLibs));
-        libsarus::setEnvironmentVariable("MPI_DEPENDENCY_LIBS", libsarus::makeColonSeparatedListOfPaths(hostDependencyLibs));
-        libsarus::setEnvironmentVariable("BIND_MOUNTS", libsarus::makeColonSeparatedListOfPaths(bindMounts));
+        libsarus::environment::setVariable("LDCONFIG_PATH", "ldconfig");
+        libsarus::environment::setVariable("MPI_LIBS", libsarus::filesystem::makeColonSeparatedListOfPaths(hostMpiLibs));
+        libsarus::environment::setVariable("MPI_DEPENDENCY_LIBS", libsarus::filesystem::makeColonSeparatedListOfPaths(hostDependencyLibs));
+        libsarus::environment::setVariable("BIND_MOUNTS", libsarus::filesystem::makeColonSeparatedListOfPaths(bindMounts));
         for(auto& environmentVariable: environmentVariables) {
-            libsarus::setEnvironmentVariable(environmentVariable.first, environmentVariable.second);
+            libsarus::environment::setVariable(environmentVariable.first, environmentVariable.second);
         }
     }
 
     void createLibraries() const {
         for(const auto& lib : hostDependencyLibs) {
-            libsarus::copyFile(dummyHostLib, lib);
+            libsarus::filesystem::copyFile(dummyHostLib, lib);
         }
         for(const auto& lib : hostMpiLibs) {
-            libsarus::copyFile(dummyHostLib, lib);
+            libsarus::filesystem::copyFile(dummyHostLib, lib);
         }
         for(const auto& lib : preHookContainerLibs) {
-            libsarus::copyFile(dummyContainerLib, rootfsDir / lib);
+            libsarus::filesystem::copyFile(dummyContainerLib, rootfsDir / lib);
         }
     }
 
     void setupDynamicLinkerInContainer() const {
         // write lib directories in /etc/ld.so.conf
-        libsarus::createFileIfNecessary(rootfsDir / "etc/ld.so.conf");
+        libsarus::filesystem::createFileIfNecessary(rootfsDir / "etc/ld.so.conf");
         std::ofstream of{(rootfsDir / "etc/ld.so.conf").c_str()};
         auto writtenSoFar = std::unordered_set<std::string>{};
 
@@ -148,7 +148,7 @@ class Checker {
         of.close(); // write to disk
 
         // create /etc/ld.so.cache
-        libsarus::executeCommand("ldconfig -r " + rootfsDir.string());
+        libsarus::process::executeCommand("ldconfig -r " + rootfsDir.string());
     }
 
     void checkOnlyExpectedLibrariesAreInRootfs() const {
@@ -159,7 +159,7 @@ class Checker {
         auto begin = boost::filesystem::recursive_directory_iterator{rootfsDir};
         auto end = boost::filesystem::recursive_directory_iterator{};
         auto actual_p = std::vector<boost::filesystem::path>{};
-        std::copy_if(begin, end, std::back_inserter(actual_p), libsarus::isSharedLib);
+        std::copy_if(begin, end, std::back_inserter(actual_p), libsarus::filesystem::isSharedLib);
         for(auto& entry: actual_p) {
             actual.push_back(entry.string());
         }
@@ -172,7 +172,7 @@ class Checker {
 
     void checkInjectedAndPreservedLibrariesAsExpected() const {
         for(const auto& lib : *expectedPostHookContainerLibs) {
-            auto libReal = rootfsDir / libsarus::realpathWithinRootfs(rootfsDir, lib);
+            auto libReal = rootfsDir / libsarus::filesystem::realpathWithinRootfs(rootfsDir, lib);
 
             auto preservedLib = std::find(preservedPostHookContainerLibs.cbegin(), preservedPostHookContainerLibs.cend(), lib);
             if (preservedLib != preservedPostHookContainerLibs.cend()){
@@ -191,7 +191,7 @@ class Checker {
         }
 
         auto actuals = std::unordered_set<std::string>{};
-        for(const auto& lib : libsarus::getSharedLibsFromDynamicLinker("ldconfig", rootfsDir)) {
+        for(const auto& lib : libsarus::sharedlibs::getListFromDynamicLinker("ldconfig", rootfsDir)) {
             actuals.insert(lib.filename().string());
         }
 
diff --git a/src/hooks/slurm_global_sync/Hook.cpp b/src/hooks/slurm_global_sync/Hook.cpp
index 6c6b0f3d..f7e27bd9 100644
--- a/src/hooks/slurm_global_sync/Hook.cpp
+++ b/src/hooks/slurm_global_sync/Hook.cpp
@@ -44,8 +44,8 @@ void Hook::loadConfigs() {
     log("Loading configuration (based on environment variables)",
         libsarus::LogLevel::INFO);
 
-    auto baseDir = boost::filesystem::path{ libsarus::getEnvironmentVariable("HOOK_BASE_DIR") };
-    auto passwdFile = libsarus::getEnvironmentVariable("PASSWD_FILE");
+    auto baseDir = boost::filesystem::path{ libsarus::environment::getVariable("HOOK_BASE_DIR") };
+    auto passwdFile = libsarus::environment::getVariable("PASSWD_FILE");
     auto username = libsarus::PasswdDB{passwdFile}.getUsername(uidOfUser);
     syncDir = baseDir / username / ".oci-hooks/slurm-global-sync" / ("jobid-" + slurmJobID + "-stepid-" + slurmStepID);
     syncDirArrival = syncDir / "arrival";
@@ -129,7 +129,7 @@ void Hook::createSyncFile(const boost::filesystem::path& file) const {
             " sync file %s, but it already exists") % file;
         SARUS_THROW_ERROR(message.str());
     }
-    libsarus::createFileIfNecessary(file, uidOfUser, gidOfUser);
+    libsarus::filesystem::createFileIfNecessary(file, uidOfUser, gidOfUser);
 }
 
 size_t Hook::countFilesInDirectory(const boost::filesystem::path& directory) const {
@@ -139,7 +139,7 @@ size_t Hook::countFilesInDirectory(const boost::filesystem::path& directory) con
 }
 
 void Hook::parseConfigJSONOfBundle() {
-    auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+    auto json = libsarus::json::read(containerState.bundle() / "config.json");
 
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
diff --git a/src/hooks/slurm_global_sync/test/test_hook.cpp b/src/hooks/slurm_global_sync/test/test_hook.cpp
index cee8b445..25e757a7 100644
--- a/src/hooks/slurm_global_sync/test/test_hook.cpp
+++ b/src/hooks/slurm_global_sync/test/test_hook.cpp
@@ -56,12 +56,12 @@ void createOCIBundleConfigJSON(const boost::filesystem::path& bundleDir,
         doc["process"]["env"].PushBack(rj::Value{"SLURM_NTASKS=2", allocator}, allocator);
     }
 
-    libsarus::writeJSON(doc, bundleDir / "config.json");
+    libsarus::json::write(doc, bundleDir / "config.json");
 }
 
 TEST(SlurmGlobalSyncTestGroup, test_hook_disabled) {
-    libsarus::setEnvironmentVariable("PASSWD_FILE", passwdFile.string());
-    libsarus::setEnvironmentVariable("HOOK_BASE_DIR", syncBaseDir.string());
+    libsarus::environment::setVariable("PASSWD_FILE", passwdFile.string());
+    libsarus::environment::setVariable("HOOK_BASE_DIR", syncBaseDir.string());
 
     bool generateSlurmEnvironmentVariables = false;
     createOCIBundleConfigJSON(bundleDir.getPath(), rootfsDir, idsOfUser,
@@ -72,14 +72,14 @@ TEST(SlurmGlobalSyncTestGroup, test_hook_disabled) {
 }
 
 TEST(SlurmGlobalSyncTestGroup, test_high_level_synchronization) {
-    libsarus::setEnvironmentVariable("PASSWD_FILE", passwdFile.string());
-    libsarus::setEnvironmentVariable("HOOK_BASE_DIR", syncBaseDir.string());
+    libsarus::environment::setVariable("PASSWD_FILE", passwdFile.string());
+    libsarus::environment::setVariable("HOOK_BASE_DIR", syncBaseDir.string());
     createOCIBundleConfigJSON(bundleDir.getPath(), rootfsDir, idsOfUser);
     test_utility::ocihooks::writeContainerStateToStdin(bundleDir.getPath());
 
     // simulate arrival + departure of other process
-    libsarus::createFileIfNecessary(syncDir / "arrival/slurm-procid-1");
-    libsarus::createFileIfNecessary(syncDir / "departure/slurm-procid-1");
+    libsarus::filesystem::createFileIfNecessary(syncDir / "arrival/slurm-procid-1");
+    libsarus::filesystem::createFileIfNecessary(syncDir / "departure/slurm-procid-1");
 
     // perform synchronization
     auto hook = Hook{};
@@ -89,8 +89,8 @@ TEST(SlurmGlobalSyncTestGroup, test_high_level_synchronization) {
 }
 
 TEST(SlurmGlobalSyncTestGroup, test_internals) {
-    libsarus::setEnvironmentVariable("PASSWD_FILE", passwdFile.string());
-    libsarus::setEnvironmentVariable("HOOK_BASE_DIR", syncBaseDir.string());
+    libsarus::environment::setVariable("PASSWD_FILE", passwdFile.string());
+    libsarus::environment::setVariable("HOOK_BASE_DIR", syncBaseDir.string());
     createOCIBundleConfigJSON(bundleDir.getPath(), rootfsDir, idsOfUser);
     test_utility::ocihooks::writeContainerStateToStdin(bundleDir.getPath());
 
@@ -101,22 +101,22 @@ TEST(SlurmGlobalSyncTestGroup, test_internals) {
     CHECK(!boost::filesystem::exists(syncDir / "arrival/slurm-procid-0"));
     hook.signalArrival();
     CHECK(boost::filesystem::exists(syncDir / "arrival/slurm-procid-0"));
-    CHECK(libsarus::getOwner(syncDir / "arrival/slurm-procid-0") == idsOfUser);
+    CHECK(libsarus::filesystem::getOwner(syncDir / "arrival/slurm-procid-0") == idsOfUser);
 
     // arrival synchronization
     CHECK(hook.allInstancesArrived() == false);
-    libsarus::createFileIfNecessary(syncDir / "arrival/slurm-procid-1");
+    libsarus::filesystem::createFileIfNecessary(syncDir / "arrival/slurm-procid-1");
     CHECK(hook.allInstancesArrived() == true);
 
     // signal departure
     CHECK(!boost::filesystem::exists(syncDir / "departure/slurm-procid-0"));
     hook.signalDeparture();
     CHECK(boost::filesystem::exists(syncDir / "departure/slurm-procid-0"));
-    CHECK(libsarus::getOwner(syncDir / "departure/slurm-procid-0") == idsOfUser);
+    CHECK(libsarus::filesystem::getOwner(syncDir / "departure/slurm-procid-0") == idsOfUser);
 
     // departure synchronization
     CHECK(hook.allInstancesDeparted() == false);
-    libsarus::createFileIfNecessary(syncDir / "departure/slurm-procid-1");
+    libsarus::filesystem::createFileIfNecessary(syncDir / "departure/slurm-procid-1");
     CHECK(hook.allInstancesDeparted() == true);
 
     // cleanup of sync dir
diff --git a/src/hooks/ssh/SshHook.cpp b/src/hooks/ssh/SshHook.cpp
index 023237f1..4b284a92 100644
--- a/src/hooks/ssh/SshHook.cpp
+++ b/src/hooks/ssh/SshHook.cpp
@@ -32,7 +32,7 @@ namespace ssh {
 static bool eventuallyJoinNamespaces(const pid_t pidOfContainer) {
     bool joinNamespaces{true};
     try {
-        auto envJoinNamespaces = libsarus::getEnvironmentVariable("JOIN_NAMESPACES");
+        auto envJoinNamespaces = libsarus::environment::getVariable("JOIN_NAMESPACES");
         joinNamespaces = (boost::algorithm::to_upper_copy(envJoinNamespaces) == std::string("TRUE"));
     } catch (libsarus::Error&) {}
     return joinNamespaces;
@@ -41,10 +41,10 @@ static bool eventuallyJoinNamespaces(const pid_t pidOfContainer) {
 static std::uint16_t getServerPortFromEnv() {
     std::uint16_t serverPort;
     try {
-        serverPort = std::stoi(libsarus::getEnvironmentVariable("SERVER_PORT"));
+        serverPort = std::stoi(libsarus::environment::getVariable("SERVER_PORT"));
     } catch (libsarus::Error&) {}
     try {
-        serverPort = std::stoi(libsarus::getEnvironmentVariable("SERVER_PORT_DEFAULT"));
+        serverPort = std::stoi(libsarus::environment::getVariable("SERVER_PORT_DEFAULT"));
     } catch (libsarus::Error& e) {
         if (serverPort == 0) {
             SARUS_RETHROW_ERROR(e, "At least one of the environment variables SERVER_PORT_DEFAULT (preferred)"
@@ -61,9 +61,9 @@ void SshHook::generateSshKeys(bool overwriteSshKeysIfExist) {
     gidOfUser = getgid();
     username = getUsername(uidOfUser);
     sshKeysDirInHost = getSshKeysDirInHost(username);
-    dropbearDirInHost = libsarus::getEnvironmentVariable("DROPBEAR_DIR");
+    dropbearDirInHost = libsarus::environment::getVariable("DROPBEAR_DIR");
 
-    libsarus::createFoldersIfNecessary(sshKeysDirInHost);
+    libsarus::filesystem::createFoldersIfNecessary(sshKeysDirInHost);
     libsarus::Lockfile lock{ sshKeysDirInHost }; // protect keys from concurrent writes
 
     if(userHasSshKeys() && !overwriteSshKeysIfExist) {
@@ -75,7 +75,7 @@ void SshHook::generateSshKeys(bool overwriteSshKeysIfExist) {
     }
 
     boost::filesystem::remove_all(sshKeysDirInHost);
-    libsarus::createFoldersIfNecessary(sshKeysDirInHost);
+    libsarus::filesystem::createFoldersIfNecessary(sshKeysDirInHost);
     sshKeygen(sshKeysDirInHost / "dropbear_ecdsa_host_key");
     sshKeygen(sshKeysDirInHost / "id_dropbear");
     generateAuthorizedKeys(sshKeysDirInHost / "id_dropbear", sshKeysDirInHost / "authorized_keys");
@@ -104,7 +104,7 @@ void SshHook::startStopSshDaemon() {
     log("Activating SSH in container", libsarus::LogLevel::INFO);
 
     dropbearRelativeDirInContainer = boost::filesystem::path("/opt/oci-hooks/ssh/dropbear");
-    dropbearDirInHost = libsarus::getEnvironmentVariable("DROPBEAR_DIR");
+    dropbearDirInHost = libsarus::environment::getVariable("DROPBEAR_DIR");
     serverPort = getServerPortFromEnv();
     containerState = libsarus::hook::parseStateOfContainerFromStdin();
     parseConfigJSONOfBundle();
@@ -138,7 +138,7 @@ void SshHook::startStopSshDaemon() {
 void SshHook::parseConfigJSONOfBundle() {
     log("Parsing bundle's config.json", libsarus::LogLevel::INFO);
 
-    auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+    auto json = libsarus::json::read(containerState.bundle() / "config.json");
 
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
@@ -174,7 +174,7 @@ void SshHook::parseConfigJSONOfBundle() {
 
     if (pidfileHost.empty()) {
         pidfileHost = containerState.bundle() / 
-        boost::filesystem::path((boost::format("dropbear-%s-%s-%d.pid") % libsarus::getHostname() % containerState.id() % serverPort).str());
+        boost::filesystem::path((boost::format("dropbear-%s-%s-%d.pid") % libsarus::process::getHostname() % containerState.id() % serverPort).str());
     }
 
     log("Successfully parsed bundle's config.json", libsarus::LogLevel::INFO);
@@ -195,12 +195,12 @@ bool SshHook::userHasSshKeys() const {
 }
 
 std::string SshHook::getUsername(uid_t uid) const {
-    auto passwdFile = boost::filesystem::path{ libsarus::getEnvironmentVariable("PASSWD_FILE") };
+    auto passwdFile = boost::filesystem::path{ libsarus::environment::getVariable("PASSWD_FILE") };
     return libsarus::PasswdDB{passwdFile}.getUsername(uidOfUser);
 }
 
 boost::filesystem::path SshHook::getSshKeysDirInHost(const std::string& username) const {
-    auto baseDir = boost::filesystem::path{ libsarus::getEnvironmentVariable("HOOK_BASE_DIR") };
+    auto baseDir = boost::filesystem::path{ libsarus::environment::getVariable("HOOK_BASE_DIR") };
     return baseDir / username / ".oci-hooks/ssh/keys";
 }
 
@@ -227,7 +227,7 @@ void SshHook::sshKeygen(const boost::filesystem::path& outputFile) const {
     auto command = boost::format{"%s/bin/dropbearkey -t ecdsa -f %s"}
         % dropbearDirInHost.string()
         % outputFile.string();
-    libsarus::executeCommand(command.str());
+    libsarus::process::executeCommand(command.str());
 }
 
 static void authorizePublicKey(const boost::filesystem::path& publicKeyFileName,
@@ -246,7 +246,7 @@ void SshHook::generateAuthorizedKeys(const boost::filesystem::path& userKeyFile,
     auto command = boost::format{"%s/bin/dropbearkey -y -f %s"}
         % dropbearDirInHost.string()
         % userKeyFile.string();
-    auto output = libsarus::executeCommand(command.str());
+    auto output = libsarus::process::executeCommand(command.str());
 
     // extract public key
     auto ss = std::stringstream{ output };
@@ -254,7 +254,7 @@ void SshHook::generateAuthorizedKeys(const boost::filesystem::path& userKeyFile,
     auto matches = boost::smatch{};
     auto re = boost::regex{"^(ecdsa-.*)$"};
 
-    libsarus::createFileIfNecessary(authorizedKeysFile, uidOfUser, gidOfUser);
+    libsarus::filesystem::createFileIfNecessary(authorizedKeysFile, uidOfUser, gidOfUser);
 
     // write public key to "authorized_keys" file
     while(std::getline(ss, line)) {
@@ -281,8 +281,8 @@ void SshHook::copyDropbearIntoContainer() const {
     log(boost::format("Copying Dropbear binaries into container under %s") % dropbearDirInContainer,
         libsarus::LogLevel::INFO);
 
-    libsarus::copyFile(dropbearDirInHost / "bin/dbclient", dropbearDirInContainer / "bin/dbclient");
-    libsarus::copyFile(dropbearDirInHost / "bin/dropbear", dropbearDirInContainer / "bin/dropbear");
+    libsarus::filesystem::copyFile(dropbearDirInHost / "bin/dbclient", dropbearDirInContainer / "bin/dbclient");
+    libsarus::filesystem::copyFile(dropbearDirInHost / "bin/dropbear", dropbearDirInContainer / "bin/dropbear");
 
     log("Successfully copied Dropbear binaries into container", libsarus::LogLevel::INFO);
 }
@@ -296,13 +296,13 @@ void SshHook::setupSshKeysDirInContainer() const {
 
     // switch to unprivileged user to make sure that the user has the
     // permission to create a new folder ~/.ssh in the container
-    libsarus::switchIdentity(userIdentity);
-    libsarus::createFoldersIfNecessary(sshKeysDirInContainer);
-    libsarus::switchIdentity(rootIdentity);
+    libsarus::process::switchIdentity(userIdentity);
+    libsarus::filesystem::createFoldersIfNecessary(sshKeysDirInContainer);
+    libsarus::process::switchIdentity(rootIdentity);
 
     bool overlayMountHostDotSsh = true;
     try {
-        auto envOverlayMountHome = libsarus::getEnvironmentVariable("OVERLAY_MOUNT_HOME_SSH");
+        auto envOverlayMountHome = libsarus::environment::getVariable("OVERLAY_MOUNT_HOME_SSH");
         overlayMountHostDotSsh = boost::algorithm::to_upper_copy(envOverlayMountHome) != "FALSE";
     } 
     catch(const libsarus::Error& error) {
@@ -317,10 +317,10 @@ void SshHook::setupSshKeysDirInContainer() const {
         auto lowerDir = containerState.bundle() / "overlay/ssh-lower";
         auto upperDir = containerState.bundle() / "overlay/ssh-upper";
         auto workDir = containerState.bundle() / "overlay/ssh-work";
-        libsarus::createFoldersIfNecessary(lowerDir);
-        libsarus::createFoldersIfNecessary(upperDir, uidOfUser, gidOfUser);
-        libsarus::createFoldersIfNecessary(workDir);
-        libsarus::mountOverlayfs(lowerDir, upperDir, workDir, sshKeysDirInContainer);
+        libsarus::filesystem::createFoldersIfNecessary(lowerDir);
+        libsarus::filesystem::createFoldersIfNecessary(upperDir, uidOfUser, gidOfUser);
+        libsarus::filesystem::createFoldersIfNecessary(workDir);
+        libsarus::mount::mountOverlayfs(lowerDir, upperDir, workDir, sshKeysDirInContainer);
     }
     
     log("Successfully set up directory for SSH keys into container", libsarus::LogLevel::INFO);
@@ -330,27 +330,27 @@ void SshHook::copySshKeysIntoContainer() const {
     log("Copying SSH keys into container", libsarus::LogLevel::INFO);
 
     // server keys
-    libsarus::copyFile(sshKeysDirInHost / "dropbear_ecdsa_host_key",
+    libsarus::filesystem::copyFile(sshKeysDirInHost / "dropbear_ecdsa_host_key",
                             sshKeysDirInContainer / "dropbear_ecdsa_host_key",
                             uidOfUser, gidOfUser);
 
     // client keys
-    libsarus::copyFile(sshKeysDirInHost / "id_dropbear",
+    libsarus::filesystem::copyFile(sshKeysDirInHost / "id_dropbear",
                             sshKeysDirInContainer / "id_dropbear",
                             uidOfUser, gidOfUser);
 
     // update if necessary
     auto containerAuthorizedKeys = sshKeysDirInContainer / "authorized_keys";
-    libsarus::copyFile(sshKeysDirInHost / "authorized_keys",
+    libsarus::filesystem::copyFile(sshKeysDirInHost / "authorized_keys",
                             containerAuthorizedKeys,
                             uidOfUser, gidOfUser);
     if(!userPublicKeyFilename.empty()) {
         log(boost::format("Adding key %s to %s") % userPublicKeyFilename.string() % containerAuthorizedKeys.string(), libsarus::LogLevel::INFO);
         auto rootIdentity = libsarus::UserIdentity{};
         auto userIdentity = libsarus::UserIdentity(uidOfUser, gidOfUser, {});
-        libsarus::switchIdentity(userIdentity);
+        libsarus::process::switchIdentity(userIdentity);
         authorizePublicKey(boost::filesystem::path{userPublicKeyFilename}, containerAuthorizedKeys);
-        libsarus::switchIdentity(rootIdentity);
+        libsarus::process::switchIdentity(rootIdentity);
     }
 
     log("Successfully copied SSH keys into container", libsarus::LogLevel::INFO);
@@ -450,9 +450,9 @@ void SshHook::startSshDaemonInContainer() const {
 
     auto sshKeysPathWithinContainer = "/" / boost::filesystem::relative(sshKeysDirInContainer, rootfsDir);
 
-    auto pidfileContainerReal = libsarus::realpathWithinRootfs(rootfsDir, pidfileContainer);
+    auto pidfileContainerReal = libsarus::filesystem::realpathWithinRootfs(rootfsDir, pidfileContainer);
     auto pidfileContainerFull = rootfsDir / pidfileContainerReal;
-    libsarus::createFoldersIfNecessary(pidfileContainerFull.parent_path(), uidOfUser, gidOfUser);
+    libsarus::filesystem::createFoldersIfNecessary(pidfileContainerFull.parent_path(), uidOfUser, gidOfUser);
 
     auto dropbearCommand = libsarus::CLIArguments{
         dropbearRelativeDirInContainer.string() + "/bin/dropbear",
@@ -461,7 +461,7 @@ void SshHook::startSshDaemonInContainer() const {
         "-p", std::to_string(serverPort),
         "-P", pidfileContainerReal.string()
     };
-    auto status = libsarus::forkExecWait(dropbearCommand, preExecActions);
+    auto status = libsarus::process::forkExecWait(dropbearCommand, preExecActions);
     if(status != 0) {
         auto message = boost::format("%s/bin/dropbear exited with status %d")
             % dropbearRelativeDirInContainer % status;
@@ -472,7 +472,7 @@ void SshHook::startSshDaemonInContainer() const {
     if (!pidfileHost.empty()) {
         std::this_thread::sleep_for(std::chrono::milliseconds(50));
         if (boost::filesystem::is_regular_file(pidfileContainerFull)) {
-            libsarus::copyFile(pidfileContainerFull, pidfileHost, uidOfUser, gidOfUser);
+            libsarus::filesystem::copyFile(pidfileContainerFull, pidfileHost, uidOfUser, gidOfUser);
             auto message = boost::format("Copied Dropbear pidfile to host path (%s)")
                     % pidfileHost;
             log(message, libsarus::LogLevel::INFO);
@@ -489,11 +489,11 @@ void SshHook::startSshDaemonInContainer() const {
 
 void SshHook::stopSshDaemon() {
 
-    auto pid = std::stoi(libsarus::readFile(pidfileHost));
+    auto pid = std::stoi(libsarus::filesystem::readFile(pidfileHost));
 
     log(boost::format("Deactivating SSH daemon with pidfile %s and PID %s")% pidfileHost % pid, libsarus::LogLevel::INFO);
 
-    libsarus::removeFile(pidfileHost);
+    libsarus::filesystem::removeFile(pidfileHost);
 
     if(kill(getpgid(pid), SIGTERM) == 0 ) {
         return;
diff --git a/src/hooks/ssh/test/test_SSHHook.cpp b/src/hooks/ssh/test/test_SSHHook.cpp
index dc89a913..e84ddf40 100644
--- a/src/hooks/ssh/test/test_SSHHook.cpp
+++ b/src/hooks/ssh/test/test_SSHHook.cpp
@@ -71,7 +71,7 @@ class Helper {
     void setupTestEnvironment() {
         // create tmpfs filesystem to allow overlay mounts for rootfs (performed below)
         // to succeed also when testing inside a Docker container
-        libsarus::createFoldersIfNecessary(bundleDir);
+        libsarus::filesystem::createFoldersIfNecessary(bundleDir);
         if(mount(NULL, bundleDir.c_str(), "tmpfs", MS_NOSUID|MS_NODEV, NULL) != 0) {
             auto message = boost::format("Failed to setup tmpfs filesystem on %s: %s")
                 % bundleDir
@@ -79,16 +79,16 @@ class Helper {
             SARUS_THROW_ERROR(message.str());
         }
 
-        libsarus::createFoldersIfNecessary(homeDirInHost,
+        libsarus::filesystem::createFoldersIfNecessary(homeDirInHost,
                                                 std::get<0>(idsOfUser),
                                                 std::get<1>(idsOfUser));
 
-        libsarus::createFoldersIfNecessary(expectedHomeDirInContainer,
+        libsarus::filesystem::createFoldersIfNecessary(expectedHomeDirInContainer,
                                                 std::get<0>(idsOfUser),
                                                 std::get<1>(idsOfUser));
 
         // host's dropbear installation
-        libsarus::createFoldersIfNecessary(dropbearDirInHost.getPath() / "bin");
+        libsarus::filesystem::createFoldersIfNecessary(dropbearDirInHost.getPath() / "bin");
         boost::format setupDropbearCommand = boost::format{
             "cp %1% %2%/bin/dropbearmulti"
             " && ln -s %2%/bin/dropbearmulti %2%/bin/dbclient"
@@ -96,13 +96,13 @@ class Helper {
             " && ln -s %2%/bin/dropbearmulti %2%/bin/dropbearkey"
         } % sarus::common::Config::BuildTime{}.dropbearmultiBuildArtifact.string()
           % dropbearDirInHost.getPath().string();
-        libsarus::executeCommand(setupDropbearCommand.str());
+        libsarus::process::executeCommand(setupDropbearCommand.str());
 
         // hook's environment variables
-        libsarus::setEnvironmentVariable("HOOK_BASE_DIR", sshKeysBaseDir.string());
-        libsarus::setEnvironmentVariable("PASSWD_FILE", passwdFile.string());
-        libsarus::setEnvironmentVariable("DROPBEAR_DIR", dropbearDirInHost.getPath().string());
-        libsarus::setEnvironmentVariable("SERVER_PORT_DEFAULT", std::to_string(serverPortDefault));
+        libsarus::environment::setVariable("HOOK_BASE_DIR", sshKeysBaseDir.string());
+        libsarus::environment::setVariable("PASSWD_FILE", passwdFile.string());
+        libsarus::environment::setVariable("DROPBEAR_DIR", dropbearDirInHost.getPath().string());
+        libsarus::environment::setVariable("SERVER_PORT_DEFAULT", std::to_string(serverPortDefault));
 
         if (!userSshKeyPath.empty()) {
             std::ofstream userSshKeyFile{userSshKeyPath.string()};
@@ -118,11 +118,11 @@ class Helper {
             auto workDir = bundleDir / "work-dirs" / folder;
             auto mergedDir = rootfsDir / folder;
 
-            libsarus::createFoldersIfNecessary(upperDir);
-            libsarus::createFoldersIfNecessary(workDir);
-            libsarus::createFoldersIfNecessary(mergedDir);
+            libsarus::filesystem::createFoldersIfNecessary(upperDir);
+            libsarus::filesystem::createFoldersIfNecessary(workDir);
+            libsarus::filesystem::createFoldersIfNecessary(mergedDir);
 
-            libsarus::mountOverlayfs(lowerDir, upperDir, workDir, mergedDir);
+            libsarus::mount::mountOverlayfs(lowerDir, upperDir, workDir, mergedDir);
         }
 
         // set requested home dir in /etc/passwd
@@ -180,7 +180,7 @@ class Helper {
           doc["annotations"] = extraAnnotations;
         }
 
-        libsarus::writeJSON(doc, bundleDir / "config.json");
+        libsarus::json::write(doc, bundleDir / "config.json");
     }
 
     void writeContainerStateToStdin() const {
@@ -225,7 +225,7 @@ class Helper {
 
     void checkContainerHasServerKeys() const {
         CHECK(boost::filesystem::exists(expectedHomeDirInContainer / ".ssh/dropbear_ecdsa_host_key"));
-        CHECK(libsarus::getOwner(expectedHomeDirInContainer / ".ssh/dropbear_ecdsa_host_key") == idsOfUser);
+        CHECK(libsarus::filesystem::getOwner(expectedHomeDirInContainer / ".ssh/dropbear_ecdsa_host_key") == idsOfUser);
     }
 
     void checkContainerHasClientKeys() const {
@@ -233,9 +233,9 @@ class Helper {
         auto authorizedKeysFile = expectedHomeDirInContainer / ".ssh/authorized_keys";
 
         CHECK(boost::filesystem::exists(userKeyFile));
-        CHECK(libsarus::getOwner(userKeyFile) == idsOfUser);
+        CHECK(libsarus::filesystem::getOwner(userKeyFile) == idsOfUser);
         CHECK(boost::filesystem::exists(authorizedKeysFile));
-        CHECK(libsarus::getOwner(authorizedKeysFile) == idsOfUser);
+        CHECK(libsarus::filesystem::getOwner(authorizedKeysFile) == idsOfUser);
 
         auto expectedAuthKeysPermissions =
             boost::filesystem::owner_read | boost::filesystem::owner_write |
@@ -246,7 +246,7 @@ class Helper {
     }
 
     boost::optional<pid_t> getSshDaemonPid() const {
-        auto out = libsarus::executeCommand("ps ax -o pid,args");
+        auto out = libsarus::process::executeCommand("ps ax -o pid,args");
         std::stringstream ss{out};
         std::string line;
 
@@ -262,7 +262,7 @@ class Helper {
     }
 
     boost::optional<std::uint16_t> getSshDaemonPort() const {
-        auto out = libsarus::executeCommand("ps ax -o args");
+        auto out = libsarus::process::executeCommand("ps ax -o args");
         std::stringstream ss{out};
         std::string line;
 
@@ -289,7 +289,7 @@ class Helper {
             "#!/bin/sh\n"
             "/opt/oci-hooks/ssh/dropbear/bin/dbclient -y -p %s $*\n"
         } % (serverPort > 0 ? serverPort : serverPortDefault);
-        auto actualScript = libsarus::readFile(targetFile);
+        auto actualScript = libsarus::filesystem::readFile(targetFile);
         CHECK_EQUAL(actualScript, expectedScript.str());
 
         auto expectedPermissions =
@@ -307,7 +307,7 @@ class Helper {
         auto expectedMap = std::unordered_map<std::string, std::string>{};
         for (const auto& variable : environmentVariablesInContainer) {
             std::string key, value;
-            std::tie(key, value) = libsarus::parseEnvironmentVariable(variable);
+            std::tie(key, value) = libsarus::environment::parseVariable(variable);
             expectedMap[key] = value;
         }
 
@@ -348,7 +348,7 @@ class Helper {
                 "if [ \"$SSH_CONNECTION\" ]; then\n"
                 "    . /opt/oci-hooks/ssh/dropbear/environment\n"
                 "fi\n");
-        auto actualScript = libsarus::readFile(targetFile);
+        auto actualScript = libsarus::filesystem::readFile(targetFile);
         CHECK_EQUAL(actualScript, expectedScript);
 
         auto expectedPermissions =
@@ -374,7 +374,7 @@ class Helper {
     }
 
     const boost::filesystem::path getDropbearPidFileInContainerAbsolute() const {
-        return rootfsDir / libsarus::realpathWithinRootfs(rootfsDir, dropbearPidFileInContainerRelative);
+        return rootfsDir / libsarus::filesystem::realpathWithinRootfs(rootfsDir, dropbearPidFileInContainerRelative);
     }
 
     const boost::filesystem::path getDropbearPidFileInHost() const {
@@ -422,7 +422,7 @@ class Helper {
     boost::filesystem::path homeDirInContainerPasswd = expectedHomeDirInContainer;
     boost::filesystem::path sshKeysDirInHost = homeDirInHost / ".oci-hooks/ssh/keys";
     libsarus::PathRAII dropbearDirInHost = libsarus::PathRAII{boost::filesystem::absolute(
-                                               libsarus::makeUniquePathWithRandomSuffix("./hook-test-dropbeardir-in-host"))};
+                                               libsarus::filesystem::makeUniquePathWithRandomSuffix("./hook-test-dropbeardir-in-host"))};
     boost::filesystem::path dropbearDirInContainer = rootfsDir / "opt/oci-hooks/ssh/dropbear";
     boost::filesystem::path dropbearPidFileInContainerRelative = "/var/run/dropbear/dropbear.pid";
     libsarus::PathRAII dropbearPidFileInHost = libsarus::PathRAII("");
@@ -572,8 +572,8 @@ TEST(SSHHookTestGroup, testDropbearPidFileInHost) {
     SshHook{}.startStopSshDaemon();
     std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
-    auto pidInContainer = libsarus::readFile(helper.getDropbearPidFileInContainerAbsolute());
-    auto pidInHost = libsarus::readFile(helper.getDropbearPidFileInHost());
+    auto pidInContainer = libsarus::filesystem::readFile(helper.getDropbearPidFileInContainerAbsolute());
+    auto pidInHost = libsarus::filesystem::readFile(helper.getDropbearPidFileInHost());
     CHECK(pidInContainer == pidInHost);
 }
 
@@ -597,13 +597,13 @@ TEST(SSHHookTestGroup, testDropbearPidFilesInCustomPaths) {
     SshHook{}.startStopSshDaemon();
     std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
-    auto pidInContainer = libsarus::readFile(helper.getDropbearPidFileInContainerAbsolute());
-    auto pidInHost = libsarus::readFile(helper.getDropbearPidFileInHost());
+    auto pidInContainer = libsarus::filesystem::readFile(helper.getDropbearPidFileInContainerAbsolute());
+    auto pidInHost = libsarus::filesystem::readFile(helper.getDropbearPidFileInHost());
     CHECK(pidInContainer == pidInHost);
 }
 
 TEST(SSHHookTestGroup, testDefaultMountsDotSshAsOverlayFs) {
-    // libsarus::setEnvironmentVariable("OVERLAY_MOUNT_HOME_SSH", "False");
+    // libsarus::environment::setVariable("OVERLAY_MOUNT_HOME_SSH", "False");
 
     Helper helper{};
 
@@ -624,7 +624,7 @@ TEST(SSHHookTestGroup, testDefaultMountsDotSshAsOverlayFs) {
 }
 
 TEST(SSHHookTestGroup, testEnvVarDisableMountsDotSshAsOverlayFs) {
-    libsarus::setEnvironmentVariable("OVERLAY_MOUNT_HOME_SSH", "False");
+    libsarus::environment::setVariable("OVERLAY_MOUNT_HOME_SSH", "False");
 
     Helper helper{};
 
@@ -642,7 +642,7 @@ TEST(SSHHookTestGroup, testEnvVarDisableMountsDotSshAsOverlayFs) {
     SshHook{}.startStopSshDaemon();
 
     CHECK_FALSE(helper.containerMountsDotSsh());    
-    libsarus::setEnvironmentVariable("OVERLAY_MOUNT_HOME_SSH", "");
+    libsarus::environment::setVariable("OVERLAY_MOUNT_HOME_SSH", "");
 }
 
 TEST(SSHHookTestGroup, testDefaultServerPort) {
@@ -670,7 +670,7 @@ TEST(SSHHookTestGroup, testDefaultServerPortOverridesDeprecatedVar) {
 
     helper.setRootIds();
     helper.setupTestEnvironment(); // "SERVER_PORT_DEFAULT" is set here
-    libsarus::setEnvironmentVariable("SERVER_PORT", std::to_string(expectedPort));
+    libsarus::environment::setVariable("SERVER_PORT", std::to_string(expectedPort));
 
     // generate + check SSH keys in local repository
     helper.setUserIds(); // keygen is executed with user privileges
@@ -690,7 +690,7 @@ TEST(SSHHookTestGroup, testDeprecatedServerPort) {
 
     helper.setRootIds();
     helper.setupTestEnvironment(); // "SERVER_PORT_DEFAULT" is set here
-    libsarus::setEnvironmentVariable("SERVER_PORT", std::to_string(expectedPort));
+    libsarus::environment::setVariable("SERVER_PORT", std::to_string(expectedPort));
     unsetenv("SERVER_PORT_DEFAULT");
 
     // generate + check SSH keys in local repository
diff --git a/src/hooks/stdout_stderr_test/main.cpp b/src/hooks/stdout_stderr_test/main.cpp
index 4c007577..1e43bf3a 100644
--- a/src/hooks/stdout_stderr_test/main.cpp
+++ b/src/hooks/stdout_stderr_test/main.cpp
@@ -16,7 +16,7 @@
 int main(int argc, char* argv[]) {
     boost::filesystem::path bundleDir;
     auto containerState = libsarus::hook::parseStateOfContainerFromStdin();
-    auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+    auto json = libsarus::json::read(containerState.bundle() / "config.json");
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
     std::cout << "hook's stdout" << std::endl;
diff --git a/src/hooks/timestamp/TimestampHook.cpp b/src/hooks/timestamp/TimestampHook.cpp
index 688f82b1..6d68867e 100644
--- a/src/hooks/timestamp/TimestampHook.cpp
+++ b/src/hooks/timestamp/TimestampHook.cpp
@@ -32,7 +32,7 @@ void TimestampHook::activate() {
 }
 
 void TimestampHook::parseConfigJSONOfBundle() {
-    auto json = libsarus::readJSON(containerState.bundle() / "config.json");
+    auto json = libsarus::json::read(containerState.bundle() / "config.json");
 
     libsarus::hook::applyLoggingConfigIfAvailable(json);
 
@@ -52,7 +52,7 @@ void TimestampHook::timestamp() {
     auto& logger = libsarus::Logger::getInstance();
     logger.setLevel(libsarus::LogLevel::INFO);
 
-    libsarus::createFileIfNecessary(logFilePath, uidOfUser, gidOfUser);
+    libsarus::filesystem::createFileIfNecessary(logFilePath, uidOfUser, gidOfUser);
     std::ofstream logFile(logFilePath.string(), std::ios::out | std::ios::app);
 
     auto fullMessage = boost::format("Timestamp hook: %s") % message;
diff --git a/src/hooks/timestamp/test/test_TimestampHook.cpp b/src/hooks/timestamp/test/test_TimestampHook.cpp
index 5bea699c..4405b311 100644
--- a/src/hooks/timestamp/test/test_TimestampHook.cpp
+++ b/src/hooks/timestamp/test/test_TimestampHook.cpp
@@ -42,7 +42,7 @@ void createOCIBundleConfigJSON(const boost::filesystem::path& bundleDir, const s
         doc["process"]["env"].PushBack(rj::Value{logVar.c_str(), allocator}, allocator);
     }
 
-    libsarus::writeJSON(doc, bundleDir / "config.json");
+    libsarus::json::write(doc, bundleDir / "config.json");
 }
 
 TEST(TimestampTestGroup, test_disabled_hook) {
@@ -68,7 +68,7 @@ TEST(TimestampTestGroup, test_existing_file) {
 
     // Set the expected message
     auto expectedMessage = std::string{"unit test"};
-    libsarus::setEnvironmentVariable("TIMESTAMP_HOOK_MESSAGE", expectedMessage);
+    libsarus::environment::setVariable("TIMESTAMP_HOOK_MESSAGE", expectedMessage);
 
     // Create and call hook
     auto hook = TimestampHook{};
@@ -76,7 +76,7 @@ TEST(TimestampTestGroup, test_existing_file) {
 
     // Read logfile and check contents
     {
-        auto logFileContent = libsarus::readFile(logFile);
+        auto logFileContent = libsarus::filesystem::readFile(logFile);
 
         auto initialPattern = "Line 1\nLine 2\n";
         auto timestampPattern = "\\[.*\\..*\\] \\[.*\\] \\[hook\\] \\[INFO\\] Timestamp hook: " + expectedMessage + "\n";
@@ -95,7 +95,7 @@ TEST(TimestampTestGroup, test_non_existing_file) {
 
     // Set the expected message
     auto expectedMessage = std::string{"unit test"};
-    libsarus::setEnvironmentVariable("TIMESTAMP_HOOK_MESSAGE", expectedMessage);
+    libsarus::environment::setVariable("TIMESTAMP_HOOK_MESSAGE", expectedMessage);
 
     // Create and call hook
     auto hook = TimestampHook{};
@@ -103,11 +103,11 @@ TEST(TimestampTestGroup, test_non_existing_file) {
 
     // Basic file checks
     CHECK(boost::filesystem::exists(logFile));
-    CHECK(libsarus::getOwner(logFile) == idsOfUser);
+    CHECK(libsarus::filesystem::getOwner(logFile) == idsOfUser);
 
     // Read logfile and check contents
     {
-        auto logFileContent = libsarus::readFile(logFile);
+        auto logFileContent = libsarus::filesystem::readFile(logFile);
 
         auto timestampPattern = "\\[.*\\..*\\] \\[.*\\] \\[hook\\] \\[INFO\\] Timestamp hook: " + expectedMessage + "\n";
         auto regex = boost::regex(timestampPattern);
diff --git a/src/image_manager/ImageManager.cpp b/src/image_manager/ImageManager.cpp
index 9212f0d8..f83dddcf 100644
--- a/src/image_manager/ImageManager.cpp
+++ b/src/image_manager/ImageManager.cpp
@@ -131,7 +131,7 @@ namespace image_manager {
         auto squashfs = SquashfsImage{*config, unpackedImage.getPath(), squashfsImagePath};
         auto squashfsRAII = libsarus::PathRAII{squashfs.getPathOfImage()};
 
-        auto imageSize = libsarus::getFileSize(squashfsRAII.getPath());
+        auto imageSize = libsarus::filesystem::getFileSize(squashfsRAII.getPath());
         auto imageSizeString = sarus::common::SarusImage::createSizeString(imageSize);
         auto created = sarus::common::SarusImage::createTimeString(std::time(nullptr));
         auto sarusImage = common::SarusImage{
@@ -151,7 +151,7 @@ namespace image_manager {
     std::string ImageManager::retrieveRegistryDigest(const std::string& transport, const common::ImageReference& targetReference) const {
         auto imageDigest = std::string{};
         auto inspectOutput = skopeoDriver.inspectRaw(transport, targetReference.string());
-        auto inspectOutputJson = libsarus::parseJSON(inspectOutput);
+        auto inspectOutputJson = libsarus::json::parse(inspectOutput);
 
         auto mediaType = std::string{};
         auto mediaTypeItr = inspectOutputJson.FindMember("mediaType");
@@ -170,8 +170,8 @@ namespace image_manager {
             || mediaType == "application/vnd.docker.distribution.manifest.v2+json"
             || mediaType == "application/vnd.docker.distribution.manifest.v1+json") {
             printLog("Computing image digest from raw manifest", libsarus::LogLevel::INFO);
-            auto manifestFile = libsarus::PathRAII(libsarus::makeUniquePathWithRandomSuffix(config->directories.temp / "sarusPullManifest"));
-            libsarus::writeTextFile(inspectOutput, manifestFile.getPath());
+            auto manifestFile = libsarus::PathRAII(libsarus::filesystem::makeUniquePathWithRandomSuffix(config->directories.temp / "sarusPullManifest"));
+            libsarus::filesystem::writeTextFile(inspectOutput, manifestFile.getPath());
             imageDigest = skopeoDriver.manifestDigest(manifestFile.getPath());
         }
         // If we have an OCI index or Docker manifest list (aka "fat manifest"), retrieve the digest
diff --git a/src/image_manager/ImageStore.cpp b/src/image_manager/ImageStore.cpp
index 7b41efd8..7c68b4ea 100644
--- a/src/image_manager/ImageStore.cpp
+++ b/src/image_manager/ImageStore.cpp
@@ -66,7 +66,7 @@ namespace image_manager {
 
         try {
             libsarus::Flock lock{metadataFile, libsarus::Flock::Type::writeLock, lockTimeout, lockWarning};
-            auto metadata = libsarus::readJSON(metadataFile);
+            auto metadata = libsarus::json::read(metadataFile);
 
             // remove previous entries with the same image reference (if any)
             auto& images = metadata["images"];
@@ -103,7 +103,7 @@ namespace image_manager {
 
         try {
             libsarus::Flock lock{metadataFile, libsarus::Flock::Type::writeLock, lockTimeout, lockWarning};
-            auto repositoryMetadata = libsarus::readJSON(metadataFile);
+            auto repositoryMetadata = libsarus::json::read(metadataFile);
             auto imageMetadata = findImageMetadata(imageReference, repositoryMetadata);
 
             if (!imageMetadata) {
@@ -135,7 +135,7 @@ namespace image_manager {
 
         try {
             libsarus::Flock lock{metadataFile, libsarus::Flock::Type::writeLock, lockTimeout, lockWarning};
-            auto repositoryMetadata = libsarus::readJSON(metadataFile);
+            auto repositoryMetadata = libsarus::json::read(metadataFile);
             for (const auto& imageMetadata : repositoryMetadata["images"].GetArray()) {
                 // If backing files are present, all image data is available: add the image to list to be visualized.
                 // Else, ensure all image data is cleaned up
@@ -164,7 +164,7 @@ namespace image_manager {
 
         try {
             libsarus::Flock lock{metadataFile, libsarus::Flock::Type::readLock, lockTimeout, lockWarning};
-            auto repositoryMetadata = libsarus::readJSON(metadataFile);
+            auto repositoryMetadata = libsarus::json::read(metadataFile);
             auto imageMetadata = findImageMetadata(reference, repositoryMetadata);
             if (imageMetadata) {
                 // If backing files are present, all image data is available: assign object to return
@@ -177,7 +177,7 @@ namespace image_manager {
                     // Obtain exclusive access to the file by acquiring a write lock
                     lock.convertToType(libsarus::Flock::Type::writeLock);
                     // Check if another process has updated the metadata in the meantime
-                    repositoryMetadata = libsarus::readJSON(metadataFile);
+                    repositoryMetadata = libsarus::json::read(metadataFile);
                     imageMetadata = findImageMetadata(reference, repositoryMetadata);
                     if (imageMetadata) {
                         removeRepositoryMetadataEntry(imageMetadata, repositoryMetadata, &lock);
@@ -360,12 +360,12 @@ namespace image_manager {
      * temporary one.
      */
     void ImageStore::atomicallyUpdateRepositoryMetadataFile(const rapidjson::Value& metadata, libsarus::Flock* const lock) const {
-        auto metadataFileTemp = libsarus::makeUniquePathWithRandomSuffix(metadataFile);
+        auto metadataFileTemp = libsarus::filesystem::makeUniquePathWithRandomSuffix(metadataFile);
 
         printLog( boost::format("Updating repository metadata file: %s") % metadataFile, libsarus::LogLevel::DEBUG);
 
         try {
-            libsarus::writeJSON(metadata, metadataFileTemp);
+            libsarus::json::write(metadata, metadataFileTemp);
             libsarus::Flock newLock{metadataFileTemp, libsarus::Flock::Type::writeLock, milliseconds{1000}, libsarus::Flock::noTimeout};
 
             // Atomically replace old metadata file.
diff --git a/src/image_manager/OCIImage.cpp b/src/image_manager/OCIImage.cpp
index 73596f51..e5ed7b53 100644
--- a/src/image_manager/OCIImage.cpp
+++ b/src/image_manager/OCIImage.cpp
@@ -24,7 +24,7 @@ OCIImage::OCIImage(std::shared_ptr<const common::Config> config, const boost::fi
       imageDir{imagePath}
 {
     log(boost::format("Creating OCIImage object from image at %s") % imageDir.getPath(), libsarus::LogLevel::DEBUG);
-    auto imageIndex = libsarus::readJSON(imageDir.getPath() / "index.json");
+    auto imageIndex = libsarus::json::read(imageDir.getPath() / "index.json");
     auto schemaItr = imageIndex.FindMember("schemaVersion");
     if (schemaItr == imageIndex.MemberEnd() || schemaItr->value.GetUint() != 2) {
         SARUS_THROW_ERROR("Unsupported OCI image index format. The 'schemaVersion' property could not be found or its value is different from '2'");
@@ -33,12 +33,12 @@ OCIImage::OCIImage(std::shared_ptr<const common::Config> config, const boost::fi
     std::string manifestDigest = imageIndex["manifests"][0]["digest"].GetString();
     log(boost::format("Found manifest digest: %s") % manifestDigest, libsarus::LogLevel::DEBUG);
     auto manifestHash = manifestDigest.substr(manifestDigest.find(":")+1);
-    auto imageManifest = libsarus::readJSON(imageDir.getPath() / "blobs/sha256" / manifestHash);
+    auto imageManifest = libsarus::json::read(imageDir.getPath() / "blobs/sha256" / manifestHash);
 
     std::string configDigest = imageManifest["config"]["digest"].GetString();
     log(boost::format("Found config digest: %s") % configDigest, libsarus::LogLevel::DEBUG);
     auto configHash = configDigest.substr(configDigest.find(":")+1);
-    auto imageConfig = libsarus::readJSON(imageDir.getPath() / "blobs/sha256" / configHash);
+    auto imageConfig = libsarus::json::read(imageDir.getPath() / "blobs/sha256" / configHash);
 
     metadata = sarus::common::ImageMetadata(imageConfig["config"]);
     imageID = configHash;
@@ -57,9 +57,9 @@ libsarus::PathRAII OCIImage::unpack() const {
 }
 
 boost::filesystem::path OCIImage::makeTemporaryUnpackDirectory() const {
-    auto tempUnpackDir = libsarus::makeUniquePathWithRandomSuffix(config->directories.temp / "unpack-directory");
+    auto tempUnpackDir = libsarus::filesystem::makeUniquePathWithRandomSuffix(config->directories.temp / "unpack-directory");
     try {
-        libsarus::createFoldersIfNecessary(tempUnpackDir);
+        libsarus::filesystem::createFoldersIfNecessary(tempUnpackDir);
     }
     catch(libsarus::Error& e) {
         auto message = boost::format("Error creating temporary unpacking directory %s") % tempUnpackDir;
diff --git a/src/image_manager/SkopeoDriver.cpp b/src/image_manager/SkopeoDriver.cpp
index 8e392286..b423c23d 100644
--- a/src/image_manager/SkopeoDriver.cpp
+++ b/src/image_manager/SkopeoDriver.cpp
@@ -39,7 +39,7 @@ SkopeoDriver::SkopeoDriver(std::shared_ptr<const common::Config> config)
 
     authFileBasePath = config->directories.repository;
     try {
-        auto xdgRuntimePath = boost::filesystem::path{libsarus::getEnvironmentVariable("XDG_RUNTIME_DIR")};
+        auto xdgRuntimePath = boost::filesystem::path{libsarus::environment::getVariable("XDG_RUNTIME_DIR")};
         if (boost::filesystem::is_directory(xdgRuntimePath)) {
             authFileBasePath = xdgRuntimePath / "sarus";
         }
@@ -48,7 +48,7 @@ SkopeoDriver::SkopeoDriver(std::shared_ptr<const common::Config> config)
                      libsarus::LogLevel::DEBUG);
         }
     }
-    catch (libsarus::Error& e) {}  // libsarus::getEnvironmentVariable() throws if searched variable is not set
+    catch (libsarus::Error& e) {}  // libsarus::environment::getVariable() throws if searched variable is not set
     printLog( boost::format("Set authentication file base path to %s") % authFileBasePath, libsarus::LogLevel::DEBUG);
 
     authFilePath.clear();
@@ -91,10 +91,10 @@ SkopeoDriver::~SkopeoDriver() {
 boost::filesystem::path SkopeoDriver::copyToOCIImage(const std::string& sourceTransport, const std::string& sourceReference) const {
     printLog( boost::format("Copying '%s' to OCI image") % sourceReference, libsarus::LogLevel::INFO);
 
-    auto ociImagePath = libsarus::makeUniquePathWithRandomSuffix(cachePath / "ociImages/image");
+    auto ociImagePath = libsarus::filesystem::makeUniquePathWithRandomSuffix(cachePath / "ociImages/image");
     auto ociImageRAII = libsarus::PathRAII{ociImagePath};
     printLog( boost::format("Creating temporary OCI image in: %s") % ociImagePath, libsarus::LogLevel::DEBUG);
-    libsarus::createFoldersIfNecessary(ociImagePath);
+    libsarus::filesystem::createFoldersIfNecessary(ociImagePath);
 
     if (sourceTransport == "docker") {
         auto imageBlobsPath = ociImagePath / "blobs";
@@ -111,7 +111,7 @@ boost::filesystem::path SkopeoDriver::copyToOCIImage(const std::string& sourceTr
                                  "oci:"+ociImagePath.string()+":sarus-oci-image"};
 
     auto start = std::chrono::system_clock::now();
-    auto status = libsarus::forkExecWait(args);
+    auto status = libsarus::process::forkExecWait(args);
     if(status != 0) {
         auto message = boost::format("Failed to copy '%s' to OCI image") % sourceReference;
         SARUS_THROW_ERROR(message.str());
@@ -136,7 +136,7 @@ std::string SkopeoDriver::inspectRaw(const std::string& sourceTransport, const s
 
     auto start = std::chrono::system_clock::now();
     try {
-        inspectOutput = libsarus::executeCommand(args.string());
+        inspectOutput = libsarus::process::executeCommand(args.string());
     }
     catch(libsarus::Error& e) {
         // Confirm skopeo failed because of image non existent or unauthorized access
@@ -201,10 +201,10 @@ std::string SkopeoDriver::manifestDigest(const boost::filesystem::path& manifest
         SARUS_THROW_ERROR(message.str());
     }
 
-    printLog(boost::format("Manifest to digest: %s") % libsarus::readFile(manifestPath), libsarus::LogLevel::DEBUG);
+    printLog(boost::format("Manifest to digest: %s") % libsarus::filesystem::readFile(manifestPath), libsarus::LogLevel::DEBUG);
 
     auto args = generateBaseArgs() + libsarus::CLIArguments{"manifest-digest", manifestPath.string()};
-    auto digestOutput = libsarus::executeCommand(args.string());
+    auto digestOutput = libsarus::process::executeCommand(args.string());
     boost::algorithm::trim_right_if(digestOutput, boost::is_any_of("\n"));
 
     // The Skopeo debug messages are useful to be embedded in an exception message,
@@ -227,9 +227,9 @@ boost::filesystem::path SkopeoDriver::acquireAuthFile(const common::Config::Auth
     auto authJSON = rapidjson::Document{};
     rapidjson::Pointer(jsonPointer.str().c_str()).Set(authJSON, encodedCredentials.c_str());
 
-    libsarus::createFoldersIfNecessary(authFileBasePath);
-    authFilePath = libsarus::makeUniquePathWithRandomSuffix(authFileBasePath / "sarus-auth").replace_extension(".json");
-    libsarus::writeJSON(authJSON, authFilePath);
+    libsarus::filesystem::createFoldersIfNecessary(authFileBasePath);
+    authFilePath = libsarus::filesystem::makeUniquePathWithRandomSuffix(authFileBasePath / "sarus-auth").replace_extension(".json");
+    libsarus::json::write(authJSON, authFilePath);
     boost::filesystem::permissions(authFilePath, boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_write);
 
     printLog(boost::format("Successfully acquired authentication file %s") % authFilePath, libsarus::LogLevel::INFO);
@@ -277,7 +277,7 @@ std::string SkopeoDriver::getVerbosityOption() const {
 }
 
 libsarus::CLIArguments SkopeoDriver::getPolicyOption() const {
-    auto homePath = boost::filesystem::path{libsarus::getEnvironmentVariable("HOME")};
+    auto homePath = boost::filesystem::path{libsarus::environment::getVariable("HOME")};
     auto userPolicyPath = homePath / ".config/containers/policy.json";
     auto systemPolicyPath = boost::filesystem::path("/etc/containers/policy.json");
 
diff --git a/src/image_manager/SquashfsImage.cpp b/src/image_manager/SquashfsImage.cpp
index 2e56c543..a483dc06 100644
--- a/src/image_manager/SquashfsImage.cpp
+++ b/src/image_manager/SquashfsImage.cpp
@@ -37,8 +37,8 @@ SquashfsImage::SquashfsImage(const common::Config& config,
                              const boost::filesystem::path& pathOfImage)
     : pathOfImage{pathOfImage}
 {
-    auto pathTemp = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix(pathOfImage)};
-    libsarus::createFoldersIfNecessary(pathTemp.getPath().parent_path());
+    auto pathTemp = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix(pathOfImage)};
+    libsarus::filesystem::createFoldersIfNecessary(pathTemp.getPath().parent_path());
 
     log(boost::format("> making squashfs image: %s") % pathOfImage, libsarus::LogLevel::GENERAL);
     log(boost::format("creating squashfs image %s from unpacked image %s") % pathOfImage % unpackedImage,
@@ -47,7 +47,7 @@ SquashfsImage::SquashfsImage(const common::Config& config,
     auto start = std::chrono::system_clock::now();
     
     auto args = generateMksquashfsArgs(config, unpackedImage, pathTemp.getPath());
-    auto mksquashfsOutput = libsarus::executeCommand(args.string());
+    auto mksquashfsOutput = libsarus::process::executeCommand(args.string());
     log(boost::format("mksquashfs output:\n%s") % mksquashfsOutput, libsarus::LogLevel::DEBUG);
 
     boost::filesystem::rename(pathTemp.getPath(), pathOfImage); // atomically create/replace squashfs file
diff --git a/src/image_manager/UmociDriver.cpp b/src/image_manager/UmociDriver.cpp
index d77a66ff..d16a8e0b 100644
--- a/src/image_manager/UmociDriver.cpp
+++ b/src/image_manager/UmociDriver.cpp
@@ -39,7 +39,7 @@ void UmociDriver::unpack(const boost::filesystem::path& imagePath, const boost::
                                  unpackPath.string()};
 
     auto start = std::chrono::system_clock::now();
-    auto status = libsarus::forkExecWait(args);
+    auto status = libsarus::process::forkExecWait(args);
     if(status != 0) {
         auto message = boost::format("Failed to unpack OCI image %s") % imagePath;
         SARUS_THROW_ERROR(message.str());
diff --git a/src/image_manager/Utility.cpp b/src/image_manager/Utility.cpp
index c8d17c42..5e9858a7 100644
--- a/src/image_manager/Utility.cpp
+++ b/src/image_manager/Utility.cpp
@@ -91,7 +91,7 @@ rapidjson::Document getCurrentOCIPlatform() {
     platform.AddMember("architecture", rj::Value{architecture.c_str(), allocator}, allocator);
     platform.AddMember("variant", rj::Value{variant.c_str(), allocator}, allocator);
 
-    auto message = boost::format("Detected current platform: %s") % libsarus::serializeJSON(platform);
+    auto message = boost::format("Detected current platform: %s") % libsarus::json::serialize(platform);
     printLog(message, libsarus::LogLevel::DEBUG);
 
     return platform;
diff --git a/src/image_manager/test/test_ImageStore.cpp b/src/image_manager/test/test_ImageStore.cpp
index d251dd86..06f51f55 100644
--- a/src/image_manager/test/test_ImageStore.cpp
+++ b/src/image_manager/test/test_ImageStore.cpp
@@ -53,13 +53,13 @@ TEST_GROUP(ImageStoreTestGroup) {
 
 static void addImageHarness(const image_manager::ImageStore& imageStore, const common::SarusImage& image) {
     imageStore.addImage(image);
-    libsarus::createFileIfNecessary(image.imageFile);
-    libsarus::createFileIfNecessary(image.metadataFile);
+    libsarus::filesystem::createFileIfNecessary(image.imageFile);
+    libsarus::filesystem::createFileIfNecessary(image.metadataFile);
 }
 
 static bool isFileOwnedBy(const boost::filesystem::path& metadataFile, const libsarus::UserIdentity& userIdentity) {
     uid_t fileUid; gid_t fileGid;
-    std::tie(fileUid, fileGid) = libsarus::getOwner(metadataFile);
+    std::tie(fileUid, fileGid) = libsarus::filesystem::getOwner(metadataFile);
     return fileUid == userIdentity.uid && fileGid == userIdentity.gid;
 }
 
diff --git a/src/image_manager/test/test_SkopeoDriver.cpp b/src/image_manager/test/test_SkopeoDriver.cpp
index 77c8c059..24c83d76 100644
--- a/src/image_manager/test/test_SkopeoDriver.cpp
+++ b/src/image_manager/test/test_SkopeoDriver.cpp
@@ -33,7 +33,7 @@ TEST(SkopeoDriverTestGroup, copyToOCIImage) {
     {
         auto imageReference = std::string{"quay.io/ethcscs/alpine:3.14"};
         auto ociImagePath = driver.copyToOCIImage("docker", imageReference);
-        auto imageIndex = libsarus::readJSON(ociImagePath / "index.json");
+        auto imageIndex = libsarus::json::read(ociImagePath / "index.json");
         std::string imageRef;
         try {
             imageRef = imageIndex["manifests"][0]["annotations"]["org.opencontainers.image.ref.name"].GetString();
@@ -50,7 +50,7 @@ TEST(SkopeoDriverTestGroup, copyToOCIImage) {
     {
         auto archive = boost::filesystem::path{__FILE__}.parent_path() / "saved_image.tar";
         auto ociImagePath = driver.copyToOCIImage("docker-archive", archive.string());
-        auto imageIndex = libsarus::readJSON(ociImagePath / "index.json");
+        auto imageIndex = libsarus::json::read(ociImagePath / "index.json");
         std::string imageRef;
         try {
             imageRef = imageIndex["manifests"][0]["annotations"]["org.opencontainers.image.ref.name"].GetString();
@@ -68,12 +68,12 @@ static void filterInspectOutputTestHelper(const image_manager::SkopeoDriver& dri
                                           const std::string& expectedManifestFilename) {
     auto testSourceDir = boost::filesystem::path{__FILE__}.parent_path();
     auto expectedManifestPath = testSourceDir / expectedManifestFilename;
-    auto expectedManifest = libsarus::readFile(expectedManifestPath);
+    auto expectedManifest = libsarus::filesystem::readFile(expectedManifestPath);
     auto returnedManifest = driver.filterInspectOutput(expectedManifest);
     CHECK(returnedManifest == expectedManifest);
 
     // Check debug output does not alter result
-    auto skopeoDebugLines = libsarus::readFile(testSourceDir / "skopeo_debug_lines.txt");
+    auto skopeoDebugLines = libsarus::filesystem::readFile(testSourceDir / "skopeo_debug_lines.txt");
     returnedManifest = driver.filterInspectOutput(skopeoDebugLines + expectedManifest);
     CHECK(returnedManifest == expectedManifest);
     libsarus::Logger::getInstance().setLevel(libsarus::LogLevel::WARN);
@@ -111,9 +111,9 @@ TEST(SkopeoDriverTestGroup, manifestDigest) {
     CHECK(driver.manifestDigest(testFile) == std::string{"sha256:2c2372178e530e6207e05f0756bb4b3018a92f62616c4af5fd4c42eb361e6079"});
 
     // Test file writing by RapidJSON digests to the same value
-    auto jsonManifest = libsarus::readJSON(rawManifestPath);
-    auto writtenManifest = libsarus::makeUniquePathWithRandomSuffix(config->directories.repository / "testManifest");
-    libsarus::writeJSON(jsonManifest, writtenManifest);
+    auto jsonManifest = libsarus::json::read(rawManifestPath);
+    auto writtenManifest = libsarus::filesystem::makeUniquePathWithRandomSuffix(config->directories.repository / "testManifest");
+    libsarus::json::write(jsonManifest, writtenManifest);
     CHECK(driver.manifestDigest(writtenManifest) == std::string{"sha256:1775bebec23e1f3ce486989bfc9ff3c4e951690df84aa9f926497d82f2ffca9d"});
 
     // Check debug mode does not alter result
@@ -156,12 +156,12 @@ TEST(SkopeoDriverTestGroup, generateBaseArgs_policy) {
     auto& config = configRAII.config;
 
     auto customPolicyPath = config->json["prefixDir"].GetString() + std::string{"/etc/policy.json"};
-    libsarus::createFileIfNecessary(customPolicyPath);
+    libsarus::filesystem::createFileIfNecessary(customPolicyPath);
     rapidjson::Pointer("/containersPolicy/path").Set(config->json, customPolicyPath.c_str());
 
     auto homeMock = boost::filesystem::path{config->json["localRepositoryBaseDir"].GetString() + std::string{"/homeMock"}};
     auto userPolicyMock = homeMock / ".config/containers/policy.json";
-    libsarus::setEnvironmentVariable("HOME", homeMock.string());
+    libsarus::environment::setVariable("HOME", homeMock.string());
 
     /**
      * The unit tests for `copy` and `inspect` commands already implicitly test
@@ -177,7 +177,7 @@ TEST(SkopeoDriverTestGroup, generateBaseArgs_policy) {
 
     // User-specific default policy file
     {
-        libsarus::createFileIfNecessary(userPolicyMock);
+        libsarus::filesystem::createFileIfNecessary(userPolicyMock);
 
         image_manager::SkopeoDriver driver{config};
         auto skopeoArgs = driver.generateBaseArgs();
@@ -205,7 +205,7 @@ TEST(SkopeoDriverTestGroup, generateBaseArgs_registriesd) {
     auto configRAII = test_utility::config::makeConfig();
     auto& config = configRAII.config;
     auto customRegistriesDPath = config->json["prefixDir"].GetString() + std::string{"/etc/registries.d"};
-    libsarus::createFoldersIfNecessary(customRegistriesDPath);
+    libsarus::filesystem::createFoldersIfNecessary(customRegistriesDPath);
     rapidjson::Pointer("/containersRegistries.dPath").Set(config->json, customRegistriesDPath.c_str());
 
     // Expected behavior
@@ -242,8 +242,8 @@ TEST(SkopeoDriverTestGroup, acquireAuthFile) {
 
     // create file in XDG_RUNTIME_DIR if defined and existing
     {
-        libsarus::createFoldersIfNecessary(xdgRuntimeDir);
-        libsarus::setEnvironmentVariable("XDG_RUNTIME_DIR", xdgRuntimeDir.string());
+        libsarus::filesystem::createFoldersIfNecessary(xdgRuntimeDir);
+        libsarus::environment::setVariable("XDG_RUNTIME_DIR", xdgRuntimeDir.string());
 
         // Instantiate the SkopeoDriver object in another scope to check removal
         // of the authFile by the destructor
@@ -254,7 +254,7 @@ TEST(SkopeoDriverTestGroup, acquireAuthFile) {
             CHECK(boost::filesystem::exists(expectedAuthFilePath));
             CHECK(boost::filesystem::status(expectedAuthFilePath).permissions() == expectedPermissions);
             CHECK(expectedAuthFilePath.parent_path() == (xdgRuntimeDir / "sarus"));
-            CHECK(libsarus::readJSON(expectedAuthFilePath) == expectedAuthJSON);
+            CHECK(libsarus::json::read(expectedAuthFilePath) == expectedAuthJSON);
         }
         CHECK_FALSE(boost::filesystem::exists(expectedAuthFilePath));
     }
@@ -268,13 +268,13 @@ TEST(SkopeoDriverTestGroup, acquireAuthFile) {
             CHECK(boost::filesystem::exists(expectedAuthFilePath));
             CHECK(boost::filesystem::status(expectedAuthFilePath).permissions() == expectedPermissions);
             CHECK(expectedAuthFilePath.parent_path() == config->directories.repository);
-            CHECK(libsarus::readJSON(expectedAuthFilePath) == expectedAuthJSON);
+            CHECK(libsarus::json::read(expectedAuthFilePath) == expectedAuthJSON);
         }
         CHECK_FALSE(boost::filesystem::exists(expectedAuthFilePath));
     }
     // create file in Sarus local repo if XDG_RUNTIME_DIR not defined
     {
-        libsarus::createFoldersIfNecessary(xdgRuntimeDir);
+        libsarus::filesystem::createFoldersIfNecessary(xdgRuntimeDir);
         unsetenv("XDG_RUNTIME_DIR");
         {
             auto driver = image_manager::SkopeoDriver{config};
@@ -283,7 +283,7 @@ TEST(SkopeoDriverTestGroup, acquireAuthFile) {
             CHECK(boost::filesystem::exists(expectedAuthFilePath));
             CHECK(boost::filesystem::status(expectedAuthFilePath).permissions() == expectedPermissions);
             CHECK(expectedAuthFilePath.parent_path() == config->directories.repository);
-            CHECK(libsarus::readJSON(expectedAuthFilePath) == expectedAuthJSON);
+            CHECK(libsarus::json::read(expectedAuthFilePath) == expectedAuthJSON);
         }
         CHECK_FALSE(boost::filesystem::exists(expectedAuthFilePath));
     }
diff --git a/src/image_manager/test/test_SquashfsImage.cpp b/src/image_manager/test/test_SquashfsImage.cpp
index 6bf1d6ee..5405bae5 100644
--- a/src/image_manager/test/test_SquashfsImage.cpp
+++ b/src/image_manager/test/test_SquashfsImage.cpp
@@ -29,8 +29,8 @@ TEST(SquashfsImageTestGroup, testSquashfsImage) {
     libsarus::PathRAII repository{config.directories.repository};
     boost::filesystem::remove_all(repository.getPath());
 
-    libsarus::PathRAII unpackedImage{libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-unpackedImage")};
-    libsarus::createFoldersIfNecessary(unpackedImage.getPath());
+    libsarus::PathRAII unpackedImage{libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-unpackedImage")};
+    libsarus::filesystem::createFoldersIfNecessary(unpackedImage.getPath());
 
     SquashfsImage{config, unpackedImage.getPath(), config.getImageFile()};
 
diff --git a/src/image_manager/test/test_Utility.cpp b/src/image_manager/test/test_Utility.cpp
index 62574912..8dabf1fb 100644
--- a/src/image_manager/test/test_Utility.cpp
+++ b/src/image_manager/test/test_Utility.cpp
@@ -51,7 +51,7 @@ TEST(ImageManagerUtilityTestGroup, getPlatformDigestFromOCIIndex) {
     // Alpine manifest list
     {
         auto manifestListPath = boost::filesystem::path{__FILE__}.parent_path() / "docker_manifest_list_alpine.json";
-        auto manifestList = libsarus::readJSON(manifestListPath);
+        auto manifestList = libsarus::json::read(manifestListPath);
 
         platform["architecture"] = "amd64";
         auto returnedDigest = utility::getPlatformDigestFromOCIIndex(manifestList, platform);
@@ -82,7 +82,7 @@ TEST(ImageManagerUtilityTestGroup, getPlatformDigestFromOCIIndex) {
     // Debian manifest list
     {
         auto manifestListPath = boost::filesystem::path{__FILE__}.parent_path() / "docker_manifest_list_debian.json";
-        auto manifestList = libsarus::readJSON(manifestListPath);
+        auto manifestList = libsarus::json::read(manifestListPath);
 
         platform["architecture"] = "amd64";
         auto returnedDigest = utility::getPlatformDigestFromOCIIndex(manifestList, platform);
diff --git a/src/libsarus/DeviceMount.cpp b/src/libsarus/DeviceMount.cpp
index 881184bd..c921c097 100644
--- a/src/libsarus/DeviceMount.cpp
+++ b/src/libsarus/DeviceMount.cpp
@@ -24,13 +24,13 @@ DeviceMount::DeviceMount(Mount&& baseMount, const DeviceAccess& access)
     logMessage(boost::format("Constructing device mount object: source = %s; destination = %s; mount flags = %d; access = %s")
             % getSource().string() % getDestination().string() % getFlags() % access.string(), LogLevel::DEBUG);
 
-    if (!isDeviceFile(getSource())) {
+    if (!libsarus::filesystem::isDeviceFile(getSource())) {
         auto message = boost::format("Source path %s is not a device file") % getSource();
         SARUS_THROW_ERROR(message.str());
     }
 
-    id = getDeviceID(getSource());
-    type = getDeviceType(getSource());
+    id = libsarus::filesystem::getDeviceID(getSource());
+    type = libsarus::filesystem::getDeviceType(getSource());
 }
 
 unsigned int DeviceMount::getMajorID() const {
diff --git a/src/libsarus/Logger.cpp b/src/libsarus/Logger.cpp
index fa3235f4..37a9f4d4 100644
--- a/src/libsarus/Logger.cpp
+++ b/src/libsarus/Logger.cpp
@@ -100,7 +100,7 @@ namespace libsarus {
             return "";
         }
 
-        auto id = boost::format("[%s-%d] ") % libsarus::getHostname() % getpid();
+        auto id = boost::format("[%s-%d] ") % libsarus::process::getHostname() % getpid();
         return id.str();
     }
 
diff --git a/src/libsarus/Mount.cpp b/src/libsarus/Mount.cpp
index 2803c814..bd81bd1c 100644
--- a/src/libsarus/Mount.cpp
+++ b/src/libsarus/Mount.cpp
@@ -39,7 +39,7 @@ void Mount::performMount() const {
         % source.string() % destination.string() % mountFlags, LogLevel::DEBUG);
 
     try {
-        validatedBindMount(source, destination, userIdentity, rootfsDir, mountFlags);
+        mount::validatedBindMount(source, destination, userIdentity, rootfsDir, mountFlags);
     }
     catch (const Error& e) {
         logMessage(e.getErrorTrace().back().errorMessage.c_str(),
diff --git a/src/libsarus/PathRAII.cpp b/src/libsarus/PathRAII.cpp
index a75943fe..01779cec 100644
--- a/src/libsarus/PathRAII.cpp
+++ b/src/libsarus/PathRAII.cpp
@@ -65,7 +65,7 @@ void PathRAII::setFilesAsRemovableByOwner() const {
     }
 
     for (const auto& entry : boost::filesystem::recursive_directory_iterator(*path)) {
-        if (!isSymlink(entry.path())) {
+        if (!libsarus::filesystem::isSymlink(entry.path())) {
             boost::filesystem::permissions(entry.path(), boost::filesystem::perms::add_perms | requiredPermissions);
         }
     }
diff --git a/src/libsarus/test/MountParserChecker.hpp b/src/libsarus/test/MountParserChecker.hpp
index ddd55c62..786013a1 100644
--- a/src/libsarus/test/MountParserChecker.hpp
+++ b/src/libsarus/test/MountParserChecker.hpp
@@ -73,7 +73,7 @@ class MountParserChecker {
           parser = libsarus::MountParser{configRAII.config->getRootfsDirectory(), configRAII.config->userIdentity, configRAII.config->json["userMounts"]};
         }
 
-        auto map = libsarus::parseMap(mountRequest);
+        auto map = libsarus::string::parseMap(mountRequest);
 
         if(isParseErrorExpected) {
             CHECK_THROWS(libsarus::Error, parser.parseMountRequest(map));
diff --git a/src/libsarus/test/test_DeviceMount.cpp b/src/libsarus/test/test_DeviceMount.cpp
index 8314cbc7..27a77aeb 100644
--- a/src/libsarus/test/test_DeviceMount.cpp
+++ b/src/libsarus/test/test_DeviceMount.cpp
@@ -34,8 +34,8 @@ TEST(DeviceMountTestGroup, constructor) {
 IGNORE_TEST(DeviceMountTestGroup, constructor) {
 #endif
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "deviceMount-test-constructor"));
-    libsarus::createFoldersIfNecessary(testDir.getPath());
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "deviceMount-test-constructor"));
+    libsarus::filesystem::createFoldersIfNecessary(testDir.getPath());
 
     auto configRAII = test_utility::config::makeConfig();
     auto& config = configRAII.config;
@@ -56,7 +56,7 @@ IGNORE_TEST(DeviceMountTestGroup, constructor) {
     // source path is not a device file
     {
         auto noDeviceFile = testDir.getPath() / "notADevice";
-        libsarus::createFileIfNecessary(noDeviceFile);
+        libsarus::filesystem::createFileIfNecessary(noDeviceFile);
         auto mountObject = libsarus::Mount{noDeviceFile, noDeviceFile, mount_flags, config->getRootfsDirectory(), config->userIdentity};
 
         CHECK_THROWS(libsarus::Error, DeviceMount(std::move(mountObject), devAccess));
@@ -69,8 +69,8 @@ TEST(DeviceMountTestGroup, getters) {
 IGNORE_TEST(DeviceMountTestGroup, getters) {
 #endif
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "deviceMount-test-getters"));
-    libsarus::createFoldersIfNecessary(testDir.getPath());
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "deviceMount-test-getters"));
+    libsarus::filesystem::createFoldersIfNecessary(testDir.getPath());
 
     auto configRAII = test_utility::config::makeConfig();
     auto& config = configRAII.config;
@@ -120,8 +120,8 @@ TEST(DeviceMountTestGroup, performMount) {
 IGNORE_TEST(DeviceMountTestGroup, performMount) {
 #endif
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "deviceMount-test-performMount"));
-    libsarus::createFoldersIfNecessary(testDir.getPath());
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "deviceMount-test-performMount"));
+    libsarus::filesystem::createFoldersIfNecessary(testDir.getPath());
 
     auto configRAII = test_utility::config::makeConfig();
     auto& config = configRAII.config;
@@ -129,7 +129,7 @@ IGNORE_TEST(DeviceMountTestGroup, performMount) {
     auto bundleDirRAII = libsarus::PathRAII{boost::filesystem::path{config->json["OCIBundleDir"].GetString()}};
     const auto& bundleDir = bundleDirRAII.getPath();
     auto rootfsDir = bundleDir / boost::filesystem::path{config->json["rootfsFolder"].GetString()};
-    libsarus::createFoldersIfNecessary(rootfsDir);
+    libsarus::filesystem::createFoldersIfNecessary(rootfsDir);
 
     auto sourceFile = testDir.getPath() / "sarusTestDevice0";
     auto destinationFile = boost::filesystem::path{"/dev/sarusTestDevice0"};
@@ -145,8 +145,8 @@ IGNORE_TEST(DeviceMountTestGroup, performMount) {
     // perform the mount
     libsarus::DeviceMount{std::move(mountObject), devAccess}.performMount();
     CHECK(test_utility::filesystem::isSameBindMountedFile(sourceFile, rootfsDir / destinationFile));
-    CHECK(libsarus::getDeviceID(rootfsDir / destinationFile) == makedev(majorID, minorID));
-    CHECK(libsarus::getDeviceType(rootfsDir / destinationFile) == 'c');
+    CHECK(libsarus::filesystem::getDeviceID(rootfsDir / destinationFile) == makedev(majorID, minorID));
+    CHECK(libsarus::filesystem::getDeviceType(rootfsDir / destinationFile) == 'c');
 
     // cleanup
     CHECK(umount((rootfsDir / destinationFile).c_str()) == 0);
diff --git a/src/libsarus/test/test_Flock.cpp b/src/libsarus/test/test_Flock.cpp
index 33059a53..a3411c35 100644
--- a/src/libsarus/test/test_Flock.cpp
+++ b/src/libsarus/test/test_Flock.cpp
@@ -34,11 +34,11 @@ static bool lockAcquisitionDoesntThrow(const boost::filesystem::path &fileToLock
 }
 
 TEST_GROUP(FlockTestGroup) {
-    boost::filesystem::path fileToLock = libsarus::makeUniquePathWithRandomSuffix("/tmp/file-to-lock");
+    boost::filesystem::path fileToLock = libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/file-to-lock");
     boost::filesystem::path lockfile = fileToLock.string() + ".lock";
 
     void setup() {
-        libsarus::createFileIfNecessary(fileToLock);
+        libsarus::filesystem::createFileIfNecessary(fileToLock);
     }
 
     void teardown() {
diff --git a/src/libsarus/test/test_HookUtility.cpp b/src/libsarus/test/test_HookUtility.cpp
index 5124134d..067dfa5c 100644
--- a/src/libsarus/test/test_HookUtility.cpp
+++ b/src/libsarus/test/test_HookUtility.cpp
@@ -35,8 +35,8 @@ TEST_GROUP(HooksUtilityTestGroup) {
 TEST(HooksUtilityTestGroup, parseStateOfContainerFromStdin) {
     auto expectedPid = getpid();
     auto expectedBundleDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-bundle-dir"));
-    libsarus::createFoldersIfNecessary(expectedBundleDir.getPath());
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-bundle-dir"));
+    libsarus::filesystem::createFoldersIfNecessary(expectedBundleDir.getPath());
 
     auto returnedBundleDir = boost::filesystem::path();
     pid_t returnedPid;
@@ -50,8 +50,8 @@ TEST(HooksUtilityTestGroup, parseStateOfContainerFromStdin) {
 
 TEST(HooksUtilityTestGroup, getEnvironmentVariableValueFromOCIBundle) {
     auto testBundleDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-bundle-dir"));
-    libsarus::createFoldersIfNecessary(testBundleDir.getPath());
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-bundle-dir"));
+    libsarus::filesystem::createFoldersIfNecessary(testBundleDir.getPath());
     auto bundleConfigFile = testBundleDir.getPath() / "config.json";
 
     auto config = test_utility::ocihooks::createBaseConfigJSON(testBundleDir.getPath() / "rootfs",
@@ -63,7 +63,7 @@ TEST(HooksUtilityTestGroup, getEnvironmentVariableValueFromOCIBundle) {
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY0=value0", allocator);
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY1=value1", allocator);
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY2=value2", allocator);
-        libsarus::writeJSON(config, bundleConfigFile);
+        libsarus::json::write(config, bundleConfigFile);
         auto value = getEnvironmentVariableValueFromOCIBundle("TEST_VAR_SET_NOEMPTY1", testBundleDir.getPath());
         CHECK(bool(value));
         CHECK(*value == std::string("value1"));
@@ -74,7 +74,7 @@ TEST(HooksUtilityTestGroup, getEnvironmentVariableValueFromOCIBundle) {
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY0=value0", allocator);
         config["process"]["env"].PushBack("TEST_VAR_SET_EMPTY=", allocator);
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY2=value2", allocator);
-        libsarus::writeJSON(config, bundleConfigFile);
+        libsarus::json::write(config, bundleConfigFile);
         auto value = getEnvironmentVariableValueFromOCIBundle("TEST_VAR_SET_EMPTY", testBundleDir.getPath());
         CHECK(bool(value));
         CHECK(*value == std::string(""));
@@ -84,7 +84,7 @@ TEST(HooksUtilityTestGroup, getEnvironmentVariableValueFromOCIBundle) {
     {
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY0=value0", allocator);
         config["process"]["env"].PushBack("TEST_VAR_SET_NOEMPTY2=value2", allocator);
-        libsarus::writeJSON(config, bundleConfigFile);
+        libsarus::json::write(config, bundleConfigFile);
         auto value = getEnvironmentVariableValueFromOCIBundle("TEST_VAR_NOT_SET", testBundleDir.getPath());
         CHECK_FALSE(value);
         config["process"]["env"].SetArray();
@@ -93,7 +93,7 @@ TEST(HooksUtilityTestGroup, getEnvironmentVariableValueFromOCIBundle) {
 
 TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-subsys-mount-point"));
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-subsys-mount-point"));
     auto mountinfoPath = testDir.getPath() / "proc" / "1" / "mountinfo";
     auto openmode = std::ios::out | std::ios::trunc;
 
@@ -103,7 +103,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
         auto expectedMountPoint = boost::filesystem::path("/sys/fs/cgroup/devices");
         auto mountinfoContent = boost::format("34 25 0:29 %s %s rw,nosuid,nodev,noexec,relatime shared:15 - cgroup cgroup rw,devices")
                                               % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         boost::filesystem::path returnedMountRoot;
         boost::filesystem::path returnedMountPoint;
         std::tie(returnedMountRoot, returnedMountPoint) = findSubsystemMountPaths("devices", testDir.getPath(), 1);
@@ -119,7 +119,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "34 25 0:29 %s %s rw,nosuid,nodev,noexec,relatime shared:15 - cgroup cgroup rw,devices\n"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         boost::filesystem::path returnedMountRoot;
         boost::filesystem::path returnedMountPoint;
         std::tie(returnedMountRoot, returnedMountPoint) = findSubsystemMountPaths("devices", testDir.getPath(), 1);
@@ -138,7 +138,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         boost::filesystem::path returnedMountRoot;
         boost::filesystem::path returnedMountPoint;
         std::tie(returnedMountRoot, returnedMountPoint) = findSubsystemMountPaths("devices", testDir.getPath(), 1);
@@ -157,7 +157,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         boost::filesystem::path returnedMountRoot;
         boost::filesystem::path returnedMountPoint;
         std::tie(returnedMountRoot, returnedMountPoint) = findSubsystemMountPaths("devices", testDir.getPath(), 1);
@@ -176,7 +176,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         boost::filesystem::path returnedMountRoot;
         boost::filesystem::path returnedMountPoint;
         std::tie(returnedMountRoot, returnedMountPoint) = findSubsystemMountPaths("devices", testDir.getPath(), 1);
@@ -195,7 +195,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         boost::filesystem::path returnedMountRoot;
         boost::filesystem::path returnedMountPoint;
         std::tie(returnedMountRoot, returnedMountPoint) = findSubsystemMountPaths("devices", testDir.getPath(), 1);
@@ -214,7 +214,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         CHECK_THROWS(libsarus::Error, findSubsystemMountPaths("devices", testDir.getPath(), 1));
     }
     // no line corresponding to searched entry
@@ -225,7 +225,7 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "36 25 0:31 / /sys/fs/cgroup/cpu,cpuacct rw,nosuid,nodev,noexec,relatime shared:17 - cgroup cgroup rw,cpuacct,cpu\n"
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             );
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         CHECK_THROWS(libsarus::Error, findSubsystemMountPaths("devices", testDir.getPath(), 1));
     }
     // malformed line corresponding to searched entry (missing superOptions and filesystem type)
@@ -240,14 +240,14 @@ TEST(HooksUtilityTestGroup, findSubsystemMountPaths) {
                 "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
             )
             % expectedMountRoot.string() % expectedMountPoint.string();
-        libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
+        libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath, openmode);
         CHECK_THROWS(libsarus::Error, findSubsystemMountPaths("devices", testDir.getPath(), 1));
     }
 }
 
 TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-cgroup-relative-path"));
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-cgroup-relative-path"));
     auto procFilePath = testDir.getPath() / "proc" / "1" / "cgroup";
     auto openmode = std::ios::out | std::ios::trunc;
 
@@ -256,7 +256,7 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
         auto subsystemMountRoot = boost::filesystem::path("/");
         auto expectedPath = boost::filesystem::path("/user.slice");
         auto procFileContent = boost::format("11:devices:%s") % expectedPath.string();
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         auto returnedPath = findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1);
         CHECK_EQUAL(returnedPath.string(), expectedPath.string());
     }
@@ -271,7 +271,7 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
                 "5:cpuset:/"
             )
             % expectedPath.string();
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         auto returnedPath = findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1);
         CHECK_EQUAL(returnedPath.string(), expectedPath.string());
     }
@@ -286,7 +286,7 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
                 "5:cpuset:/"
             )
             % expectedPath.string();
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         auto returnedPath = findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1);
         CHECK_EQUAL(returnedPath.string(), expectedPath.string());
     }
@@ -302,7 +302,7 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
                 "5:cpuset:/"
             )
             % cgroupInProcFile.string();
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         auto returnedPath = findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1);
         CHECK_EQUAL(returnedPath.string(), expectedPath.string());
     }
@@ -321,7 +321,7 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
                 "5:cpuset:/"
             )
             % expectedPath.string();
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         auto returnedPath = findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1);
         CHECK_EQUAL(returnedPath.string(), expectedPath.string());
     }
@@ -336,7 +336,7 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
                 "5:cpuset:/"
             )
             % expectedPath.string();
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         CHECK_THROWS(libsarus::Error, findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1));
     }
     // no line corresponding to searched entry
@@ -347,14 +347,14 @@ TEST(HooksUtilityTestGroup, findCgroupPathInHierarchy) {
                 "6:cpuacct,cpu:/\n"
                 "5:cpuset:/"
             );
-        libsarus::writeTextFile(procFileContent.str(), procFilePath, openmode);
+        libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath, openmode);
         CHECK_THROWS(libsarus::Error, findCgroupPathInHierarchy("devices", testDir.getPath(), subsystemMountRoot, 1));
     }
 }
 
 TEST(HooksUtilityTestGroup, findCgroupPath) {
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-cgroup-path"));
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-cgroup-path"));
 
     // prepare mock /prod/[pid]/mountinfo file
     auto mountinfoPath = testDir.getPath() / "proc" / "1" / "mountinfo";
@@ -367,7 +367,7 @@ TEST(HooksUtilityTestGroup, findCgroupPath) {
             "49 41 253:2 / /home rw,relatime shared:31 - xfs /dev/mapper/home rw,seclabel,attr2,inode64,noquota"
         )
         % mountPointPath.string();
-    libsarus::writeTextFile(mountinfoContent.str(), mountinfoPath);
+    libsarus::filesystem::writeTextFile(mountinfoContent.str(), mountinfoPath);
 
     // prepare mock /prod/[pid]/cgroup file
     auto procFilePath = testDir.getPath() / "proc" / "1" / "cgroup";
@@ -379,7 +379,7 @@ TEST(HooksUtilityTestGroup, findCgroupPath) {
             "5:cpuset:/"
         )
         % cgroupRelativePath.string();
-    libsarus::writeTextFile(procFileContent.str(), procFilePath);
+    libsarus::filesystem::writeTextFile(procFileContent.str(), procFilePath);
 
     auto expectedPath = mountPointPath / cgroupRelativePath;
 
@@ -387,28 +387,28 @@ TEST(HooksUtilityTestGroup, findCgroupPath) {
     CHECK_THROWS(libsarus::Error, findCgroupPath("devices", testDir.getPath(), 1));
 
     // test with expected path existing
-    libsarus::createFoldersIfNecessary(expectedPath);
+    libsarus::filesystem::createFoldersIfNecessary(expectedPath);
     auto returnedPath = findCgroupPath("devices", testDir.getPath(), 1);
     CHECK(boost::filesystem::equivalent(returnedPath, expectedPath));
 }
 
 TEST(HooksUtilityTestGroup, whitelistDeviceInCgroup) {
     auto testDir = libsarus::PathRAII(
-        libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-whitelist-device"));
+        libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::current_path() / "hooks-test-whitelist-device"));
 
     auto allowFile = testDir.getPath() / "devices.allow";
-    libsarus::createFileIfNecessary(allowFile);
+    libsarus::filesystem::createFileIfNecessary(allowFile);
 
     // regular operation
     whitelistDeviceInCgroup(testDir.getPath(), "/dev/null");
-    auto expectedDeviceID = libsarus::getDeviceID("/dev/null");
+    auto expectedDeviceID = libsarus::filesystem::getDeviceID("/dev/null");
     auto expectedEntry = boost::format("c %u:%u rw") % major(expectedDeviceID) % minor(expectedDeviceID);
-    auto writtenEntry = libsarus::readFile(allowFile);
+    auto writtenEntry = libsarus::filesystem::readFile(allowFile);
     CHECK_EQUAL(writtenEntry, expectedEntry.str());
 
     // deviceFile argument is not a device
     auto dummyFile = testDir.getPath() / "dummy";
-    libsarus::createFileIfNecessary(dummyFile);
+    libsarus::filesystem::createFileIfNecessary(dummyFile);
     CHECK_THROWS(libsarus::Error, whitelistDeviceInCgroup(testDir.getPath(), dummyFile));
 }
 
diff --git a/src/libsarus/test/test_Lockfile.cpp b/src/libsarus/test/test_Lockfile.cpp
index 2cc1e8c9..ed4b94e5 100644
--- a/src/libsarus/test/test_Lockfile.cpp
+++ b/src/libsarus/test/test_Lockfile.cpp
@@ -21,7 +21,7 @@ namespace libsarus {
 namespace test {
 
 TEST_GROUP(LockfileTestGroup) {
-    boost::filesystem::path fileToLock = libsarus::makeUniquePathWithRandomSuffix("/tmp/file-to-lock");
+    boost::filesystem::path fileToLock = libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/file-to-lock");
     boost::filesystem::path lockfile = fileToLock.string() + ".lock";
 };
 
diff --git a/src/libsarus/test/test_Mount.cpp b/src/libsarus/test/test_Mount.cpp
index e083c96d..e883f9e2 100644
--- a/src/libsarus/test/test_Mount.cpp
+++ b/src/libsarus/test/test_Mount.cpp
@@ -42,7 +42,7 @@ IGNORE_TEST(MountTestGroup, mount_test) {
     const auto& bundleDir = bundleDirRAII.getPath();
     auto rootfsDir = bundleDir / boost::filesystem::path{config->json["rootfsFolder"].GetString()};
     auto overlayfsLowerDir = bundleDir / "overlay/rootfs-lower"; // hardcoded so in production code being tested
-    libsarus::createFoldersIfNecessary(overlayfsLowerDir);
+    libsarus::filesystem::createFoldersIfNecessary(overlayfsLowerDir);
 
     auto sourceDirRAII = libsarus::PathRAII{boost::filesystem::path{"./user_mounts_source"}};
     const auto& sourceDir = sourceDirRAII.getPath();
@@ -54,9 +54,9 @@ IGNORE_TEST(MountTestGroup, mount_test) {
     size_t mount_flags = 0;
 
     // Create files and directories
-    libsarus::createFoldersIfNecessary(rootfsDir);
+    libsarus::filesystem::createFoldersIfNecessary(rootfsDir);
     test_utility::filesystem::create_test_directory_tree(sourceDir.string());
-    libsarus::createFileIfNecessary(sourceFile.getPath());
+    libsarus::filesystem::createFileIfNecessary(sourceFile.getPath());
     auto command = "echo \"test data\" >" + sourceFile.getPath().string();
     auto ret = std::system(command.c_str());
     CHECK(WIFEXITED(ret) != 0 && WEXITSTATUS(ret) == 0);
@@ -72,7 +72,7 @@ IGNORE_TEST(MountTestGroup, mount_test) {
     }
     // test mount of existing destination directory
     {
-        libsarus::createFoldersIfNecessary(rootfsDir / destinationDir);
+        libsarus::filesystem::createFoldersIfNecessary(rootfsDir / destinationDir);
         libsarus::Mount{sourceDir, destinationDir.c_str(), mount_flags, config->getRootfsDirectory(), config->userIdentity}.performMount();
         CHECK(test_utility::filesystem::are_directories_equal(sourceDir.string(), (rootfsDir / destinationDir).string(), 1));
 
diff --git a/src/libsarus/test/test_MountParser.cpp b/src/libsarus/test/test_MountParser.cpp
index 45d975c8..e2867dde 100644
--- a/src/libsarus/test/test_MountParser.cpp
+++ b/src/libsarus/test/test_MountParser.cpp
@@ -100,7 +100,7 @@ TEST(MountParserTestGroup, constructors) {
                      / configRAII.config->json["rootfsFolder"].GetString();
 
     auto requestString = std::string("type=bind,src=/src,dst=/dest,readonly");
-    auto requestMap = libsarus::parseMap(requestString);
+    auto requestMap = libsarus::string::parseMap(requestString);
 
     auto mp1 = libsarus::MountParser{configRAII.config->getRootfsDirectory(), configRAII.config->userIdentity};
     if (configRAII.config->json.HasMember("userMounts")) {  
diff --git a/src/libsarus/test/test_MountUtility.cpp b/src/libsarus/test/test_MountUtility.cpp
index c77515cf..df3a56e0 100644
--- a/src/libsarus/test/test_MountUtility.cpp
+++ b/src/libsarus/test/test_MountUtility.cpp
@@ -35,15 +35,15 @@ TEST(MountUtilitiesTestGroup, get_validated_mount_source_test) {
     std::string source_dir_2 = source_dir_2RAII.getPath().string();
 
     // Test invalid input arguments
-    CHECK_THROWS(libsarus::Error, libsarus::getValidatedMountSource(""));
+    CHECK_THROWS(libsarus::Error, libsarus::mount::getValidatedMountSource(""));
 
     // Test non-existing directory
-    CHECK_THROWS(libsarus::Error, libsarus::getValidatedMountSource(source_dir_1));
+    CHECK_THROWS(libsarus::Error, libsarus::mount::getValidatedMountSource(source_dir_1));
 
     // Test existing directory
-    libsarus::createFoldersIfNecessary(source_dir_2);
+    libsarus::filesystem::createFoldersIfNecessary(source_dir_2);
     auto* expected = realpath(source_dir_2.c_str(), NULL);
-    CHECK(libsarus::getValidatedMountSource(source_dir_2) == boost::filesystem::path(expected));
+    CHECK(libsarus::mount::getValidatedMountSource(source_dir_2) == boost::filesystem::path(expected));
 
     // Cleanup
     free(expected);
@@ -56,96 +56,96 @@ TEST(MountUtilitiesTestGroup, get_validated_mount_destination_test) {
     auto bundleDirRAII = libsarus::PathRAII{boost::filesystem::path{config.json["OCIBundleDir"].GetString()}};
     const auto& bundleDir = bundleDirRAII.getPath();
     auto rootfsDir = bundleDir / boost::filesystem::path{config.json["rootfsFolder"].GetString()};
-    libsarus::createFoldersIfNecessary(bundleDir / "overlay/rootfs-lower");
+    libsarus::filesystem::createFoldersIfNecessary(bundleDir / "overlay/rootfs-lower");
 
     // Test invalid input arguments
-    CHECK_THROWS(libsarus::Error, libsarus::getValidatedMountDestination("", rootfsDir));
+    CHECK_THROWS(libsarus::Error, libsarus::mount::getValidatedMountDestination("", rootfsDir));
 
     // Test mount on other device
     auto otherDeviceDir = boost::filesystem::path{"/otherDevice"};
-    libsarus::createFoldersIfNecessary(rootfsDir / otherDeviceDir);
+    libsarus::filesystem::createFoldersIfNecessary(rootfsDir / otherDeviceDir);
     auto imageSquashfs = boost::filesystem::path{__FILE__}.parent_path() / "test_image.squashfs";
-    libsarus::loopMountSquashfs(imageSquashfs, rootfsDir / otherDeviceDir);
-    CHECK_THROWS(libsarus::Error, libsarus::getValidatedMountDestination(otherDeviceDir, rootfsDir));
+    libsarus::mount::loopMountSquashfs(imageSquashfs, rootfsDir / otherDeviceDir);
+    CHECK_THROWS(libsarus::Error, libsarus::mount::getValidatedMountDestination(otherDeviceDir, rootfsDir));
     CHECK(umount((rootfsDir / otherDeviceDir).c_str()) == 0);
 
     // Test non-existing mount point
     auto nonExistingDir = boost::filesystem::path{"/nonExistingMountPoint"};
     auto expected = rootfsDir / nonExistingDir;
-    CHECK(libsarus::getValidatedMountDestination(nonExistingDir, rootfsDir) == expected);
+    CHECK(libsarus::mount::getValidatedMountDestination(nonExistingDir, rootfsDir) == expected);
 
     // Test existing mount point
     auto existingDir = boost::filesystem::path{"/file_in_squashfs_image"};
     expected = rootfsDir / existingDir;
-    libsarus::createFoldersIfNecessary(expected);
-    CHECK(libsarus::getValidatedMountDestination(existingDir, rootfsDir) == expected);
+    libsarus::filesystem::createFoldersIfNecessary(expected);
+    CHECK(libsarus::mount::getValidatedMountDestination(existingDir, rootfsDir) == expected);
 }
 
 TEST(MountUtilitiesTestGroup, bindMount) {
-    auto tempDirRAII = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-bindmount")};
+    auto tempDirRAII = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-bindmount")};
     const auto& tempDir = tempDirRAII.getPath();
     auto fromDir = tempDir / "from";
     auto toDir = tempDir / "to";
 
-    libsarus::createFoldersIfNecessary(fromDir);
-    libsarus::createFoldersIfNecessary(toDir);
-    libsarus::createFileIfNecessary(fromDir / "file");
+    libsarus::filesystem::createFoldersIfNecessary(fromDir);
+    libsarus::filesystem::createFoldersIfNecessary(toDir);
+    libsarus::filesystem::createFileIfNecessary(fromDir / "file");
 
-    libsarus::bindMount(fromDir, toDir);
+    libsarus::mount::bindMount(fromDir, toDir);
 
     // check that "file" is in the mounted directory
     CHECK(boost::filesystem::exists(toDir / "file"));
 
     // check that mounted directory is writable
-    libsarus::createFileIfNecessary(toDir / "file-successfull-write-attempt");
+    libsarus::filesystem::createFileIfNecessary(toDir / "file-successfull-write-attempt");
 
     // cleanup
     CHECK(umount(toDir.c_str()) == 0);
 }
 
 TEST(MountUtilitiesTestGroup, bindMountReadOnly) {
-    auto tempDirRAII = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-bindmount")};
+    auto tempDirRAII = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-bindmount")};
     const auto& tempDir = tempDirRAII.getPath();
     auto fromDir = tempDir / "from";
     auto toDir = tempDir / "to";
 
-    libsarus::createFoldersIfNecessary(fromDir);
-    libsarus::createFoldersIfNecessary(toDir);
-    libsarus::createFileIfNecessary(fromDir / "file");
+    libsarus::filesystem::createFoldersIfNecessary(fromDir);
+    libsarus::filesystem::createFoldersIfNecessary(toDir);
+    libsarus::filesystem::createFileIfNecessary(fromDir / "file");
 
-    libsarus::bindMount(fromDir, toDir, MS_RDONLY);
+    libsarus::mount::bindMount(fromDir, toDir, MS_RDONLY);
 
     // check that "file" is in the mounted directory
     CHECK(boost::filesystem::exists(toDir / "file"));
 
     // check that mounted directory is read-only
-    CHECK_THROWS(libsarus::Error, libsarus::createFileIfNecessary(toDir / "file-failed-write-attempt"));
+    CHECK_THROWS(libsarus::Error, libsarus::filesystem::createFileIfNecessary(toDir / "file-failed-write-attempt"));
 
     // cleanup
     CHECK(umount(toDir.c_str()) == 0);
 }
 
 TEST(MountUtilitiesTestGroup, bindMountRecursive) {
-    auto tempDirRAII = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-bindmount")};
+    auto tempDirRAII = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-bindmount")};
     const auto& tempDir = tempDirRAII.getPath();
 
     auto a = tempDir / "a";
     auto b = tempDir / "b";
     auto c = tempDir / "c";
-    libsarus::createFoldersIfNecessary(a);
-    libsarus::createFoldersIfNecessary(b);
-    libsarus::createFoldersIfNecessary(c);
+    libsarus::filesystem::createFoldersIfNecessary(a);
+    libsarus::filesystem::createFoldersIfNecessary(b);
+    libsarus::filesystem::createFoldersIfNecessary(c);
 
-    libsarus::createFileIfNecessary(c / "d.txt");
+    libsarus::filesystem::createFileIfNecessary(c / "d.txt");
 
     // check that "d.txt" is in the mounted directory
     CHECK(!boost::filesystem::exists(b / "d.txt"));
-    libsarus::bindMount(c, b);
+    libsarus::mount::bindMount(c, b);
     CHECK(boost::filesystem::exists(b / "d.txt"));
 
     // check that mounts are recursive by default
     CHECK(!boost::filesystem::exists(a / "d.txt"));
-    libsarus::bindMount(b, a);
+    libsarus::mount::bindMount(b, a);
     CHECK(boost::filesystem::exists(a / "d.txt"));
 
     // cleanup
@@ -154,12 +154,12 @@ TEST(MountUtilitiesTestGroup, bindMountRecursive) {
 }
 
 TEST(MountUtilitiesTestGroup, loopMountSquashfs) {
-    auto mountPointRAII = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-loopMountSquashfs")};
+    auto mountPointRAII = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-common-loopMountSquashfs")};
     const auto& mountPoint = mountPointRAII.getPath();
-    libsarus::createFoldersIfNecessary(mountPoint);
+    libsarus::filesystem::createFoldersIfNecessary(mountPoint);
 
     auto imageSquashfs = boost::filesystem::path{__FILE__}.parent_path() / "test_image.squashfs";
-    libsarus::loopMountSquashfs(imageSquashfs, mountPoint);
+    libsarus::mount::loopMountSquashfs(imageSquashfs, mountPoint);
     CHECK(boost::filesystem::exists(mountPoint / "file_in_squashfs_image"));
 
     CHECK(umount(mountPoint.string().c_str()) == 0);
diff --git a/src/libsarus/test/test_Utility.cpp b/src/libsarus/test/test_Utility.cpp
index 5dc5bbf5..e760caaa 100644
--- a/src/libsarus/test/test_Utility.cpp
+++ b/src/libsarus/test/test_Utility.cpp
@@ -33,7 +33,7 @@ TEST(UtilityTestGroup, parseEnvironmentVariables) {
     // empty environment
     {
         auto env = std::array<char*, 1>{nullptr};
-        auto map = libsarus::parseEnvironmentVariables(env.data());
+        auto map = libsarus::environment::parseVariables(env.data());
         CHECK(map.empty());
     }
     // non-empty environment
@@ -41,7 +41,7 @@ TEST(UtilityTestGroup, parseEnvironmentVariables) {
         auto var0 = std::string{"key0="};
         auto var1 = std::string{"key1=value1"};
         auto env = std::array<char*, 3>{&var0[0], &var1[0], nullptr};
-        auto actualMap = libsarus::parseEnvironmentVariables(env.data());
+        auto actualMap = libsarus::environment::parseVariables(env.data());
         auto expectedMap = std::unordered_map<std::string, std::string>{
             {"key0", ""},
             {"key1", "value1"}
@@ -55,12 +55,12 @@ TEST(UtilityTestGroup, getEnvironmentVariable) {
     auto testValue = std::string{"dummy"};
 
     // test with variable unset
-    CHECK_THROWS(libsarus::Error, libsarus::getEnvironmentVariable(testKey));
+    CHECK_THROWS(libsarus::Error, libsarus::environment::getVariable(testKey));
 
     // test with variable set
-    libsarus::setEnvironmentVariable(testKey, testValue);
+    libsarus::environment::setVariable(testKey, testValue);
     auto fallbackValue = std::string("fallback");
-    CHECK_EQUAL(libsarus::getEnvironmentVariable(testKey), testValue);
+    CHECK_EQUAL(libsarus::environment::getVariable(testKey), testValue);
 }
 
 TEST(UtilityTestGroup, setEnvironmentVariable) {
@@ -72,7 +72,7 @@ TEST(UtilityTestGroup, setEnvironmentVariable) {
         auto message = boost::format("Error un-setting the variable used by the test: %s") % strerror(errno);
         FAIL(message.str().c_str());
     }
-    libsarus::setEnvironmentVariable(testKey, testValue);
+    libsarus::environment::setVariable(testKey, testValue);
     char *envValue = getenv(testKey.c_str());
     if (envValue == nullptr) {
         auto message = boost::format("Error getting the test variable from the environment");
@@ -82,7 +82,7 @@ TEST(UtilityTestGroup, setEnvironmentVariable) {
 
     // test overwrite with variable set
     testValue = std::string{"overwrite_dummy"};
-    libsarus::setEnvironmentVariable(testKey, testValue);
+    libsarus::environment::setVariable(testKey, testValue);
     envValue = getenv(testKey.c_str());
     if (envValue == nullptr) {
         auto message = boost::format("Error getting the test variable from the environment");
@@ -92,35 +92,35 @@ TEST(UtilityTestGroup, setEnvironmentVariable) {
 }
 
 TEST(UtilityTestGroup, parseKeyValuePair) {
-    auto pair = libsarus::parseKeyValuePair("key=value");
+    auto pair = libsarus::string::parseKeyValuePair("key=value");
     CHECK_EQUAL(pair.first, std::string("key"));
     CHECK_EQUAL(pair.second, std::string("value"));
 
     // key only
-    pair = libsarus::parseKeyValuePair("key_only");
+    pair = libsarus::string::parseKeyValuePair("key_only");
     CHECK_EQUAL(pair.first, std::string("key_only"));
     CHECK_EQUAL(pair.second, std::string(""));
 
     // no value after separator
-    pair = libsarus::parseKeyValuePair("key=");
+    pair = libsarus::string::parseKeyValuePair("key=");
     CHECK_EQUAL(pair.first, std::string("key"));
     CHECK_EQUAL(pair.second, std::string(""));
 
     // non-default separator
-    pair = libsarus::parseKeyValuePair("key:value", ':');
+    pair = libsarus::string::parseKeyValuePair("key:value", ':');
     CHECK_EQUAL(pair.first, std::string("key"));
     CHECK_EQUAL(pair.second, std::string("value"));
 
     // empty input
-    CHECK_THROWS(libsarus::Error, libsarus::parseKeyValuePair(""));
+    CHECK_THROWS(libsarus::Error, libsarus::string::parseKeyValuePair(""));
 
     // missing key
-    CHECK_THROWS(libsarus::Error, libsarus::parseKeyValuePair("=value"));
+    CHECK_THROWS(libsarus::Error, libsarus::string::parseKeyValuePair("=value"));
 }
 
 TEST(UtilityTestGroup, switchIdentity) {
     auto testDirRAII = libsarus::PathRAII{ "./sarus-test-switchIdentity" };
-    libsarus::createFileIfNecessary(testDirRAII.getPath() / "file", 0, 0);
+    libsarus::filesystem::createFileIfNecessary(testDirRAII.getPath() / "file", 0, 0);
     boost::filesystem::permissions(testDirRAII.getPath(), boost::filesystem::owner_all);
 
     uid_t unprivilegedUid;
@@ -128,7 +128,7 @@ TEST(UtilityTestGroup, switchIdentity) {
     std::tie(unprivilegedUid, unprivilegedGid) = test_utility::misc::getNonRootUserIds();
     auto unprivilegedIdentity = libsarus::UserIdentity{unprivilegedUid, unprivilegedGid, {}};
 
-    libsarus::switchIdentity(unprivilegedIdentity);
+    libsarus::process::switchIdentity(unprivilegedIdentity);
 
     // Check identity change
     CHECK_EQUAL(geteuid(), unprivilegedIdentity.uid);
@@ -136,10 +136,10 @@ TEST(UtilityTestGroup, switchIdentity) {
 
     // Check it's not possible to read root-owned files or write in root-owned dirs
     CHECK_THROWS(std::exception, boost::filesystem::exists(testDirRAII.getPath() / "file"));
-    CHECK_THROWS(std::exception, libsarus::createFileIfNecessary(testDirRAII.getPath() / "file_fail"));
+    CHECK_THROWS(std::exception, libsarus::filesystem::createFileIfNecessary(testDirRAII.getPath() / "file_fail"));
 
     auto rootIdentity = libsarus::UserIdentity{};
-    libsarus::switchIdentity(rootIdentity);
+    libsarus::process::switchIdentity(rootIdentity);
 
     CHECK_EQUAL(geteuid(), 0);
     CHECK_EQUAL(getegid(), 0);
@@ -154,7 +154,7 @@ TEST(UtilityTestGroup, setFilesystemUid) {
     auto unprivilegedIdentity = libsarus::UserIdentity{unprivilegedUid, unprivilegedGid, {}};
     auto rootIdentity = libsarus::UserIdentity{};
 
-    libsarus::setFilesystemUid(unprivilegedIdentity);
+    libsarus::process::setFilesystemUid(unprivilegedIdentity);
 
     // check identity change
     CHECK_EQUAL(getuid(), rootIdentity.uid);
@@ -164,7 +164,7 @@ TEST(UtilityTestGroup, setFilesystemUid) {
     CHECK_EQUAL(setfsuid(-1), unprivilegedIdentity.uid);
 
     // switch back to privileged fsuid
-    libsarus::setFilesystemUid(rootIdentity);
+    libsarus::process::setFilesystemUid(rootIdentity);
 
     // check identity change
     CHECK_EQUAL(getuid(), rootIdentity.uid);
@@ -175,15 +175,15 @@ TEST(UtilityTestGroup, setFilesystemUid) {
 }
 
 TEST(UtilityTestGroup, executeCommand) {
-    CHECK_EQUAL(libsarus::executeCommand("printf stdout"), std::string{"stdout"});
-    CHECK_EQUAL(libsarus::executeCommand("bash -c 'printf stderr >&2'"), std::string{"stderr"});
-    CHECK_THROWS(libsarus::Error, libsarus::executeCommand("false"));
-    CHECK_THROWS(libsarus::Error, libsarus::executeCommand("command-that-doesnt-exist-xyz"));
+    CHECK_EQUAL(libsarus::process::executeCommand("printf stdout"), std::string{"stdout"});
+    CHECK_EQUAL(libsarus::process::executeCommand("bash -c 'printf stderr >&2'"), std::string{"stderr"});
+    CHECK_THROWS(libsarus::Error, libsarus::process::executeCommand("false"));
+    CHECK_THROWS(libsarus::Error, libsarus::process::executeCommand("command-that-doesnt-exist-xyz"));
 }
 
 TEST(UtilityTestGroup, makeUniquePathWithRandomSuffix) {
     auto path = boost::filesystem::path{"/tmp/file"};
-    auto uniquePath = libsarus::makeUniquePathWithRandomSuffix(path);
+    auto uniquePath = libsarus::filesystem::makeUniquePathWithRandomSuffix(path);
 
     auto matches = boost::cmatch{};
     auto expectedRegex = boost::regex("^/tmp/file-[A-z]{16}$");
@@ -191,61 +191,61 @@ TEST(UtilityTestGroup, makeUniquePathWithRandomSuffix) {
 }
 
 TEST(UtilityTestGroup, createFoldersIfNecessary) {
-    libsarus::createFoldersIfNecessary("/tmp/grandparent/parent/child");
-    CHECK((libsarus::getOwner("/tmp/grandparent/parent") == std::tuple<uid_t, gid_t>{0, 0}));
-    CHECK((libsarus::getOwner("/tmp/grandparent/parent/child") == std::tuple<uid_t, gid_t>{0, 0}));
+    libsarus::filesystem::createFoldersIfNecessary("/tmp/grandparent/parent/child");
+    CHECK((libsarus::filesystem::getOwner("/tmp/grandparent/parent") == std::tuple<uid_t, gid_t>{0, 0}));
+    CHECK((libsarus::filesystem::getOwner("/tmp/grandparent/parent/child") == std::tuple<uid_t, gid_t>{0, 0}));
     boost::filesystem::remove_all("/tmp/grandparent");
 
-    libsarus::createFoldersIfNecessary("/tmp/grandparent/parent/child", 1000, 1000);
-    CHECK((libsarus::getOwner("/tmp/grandparent/parent") == std::tuple<uid_t, gid_t>{1000, 1000}));
-    CHECK((libsarus::getOwner("/tmp/grandparent/parent/child")  == std::tuple<uid_t, gid_t>{1000, 1000}));
+    libsarus::filesystem::createFoldersIfNecessary("/tmp/grandparent/parent/child", 1000, 1000);
+    CHECK((libsarus::filesystem::getOwner("/tmp/grandparent/parent") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    CHECK((libsarus::filesystem::getOwner("/tmp/grandparent/parent/child")  == std::tuple<uid_t, gid_t>{1000, 1000}));
     boost::filesystem::remove_all("/tmp/grandparent");
 }
 
 TEST(UtilityTestGroup, createFileIfNecessary) {
-    libsarus::createFileIfNecessary("/tmp/testFile");
-    CHECK((libsarus::getOwner("/tmp/testFile") == std::tuple<uid_t, gid_t>{0, 0}));
+    libsarus::filesystem::createFileIfNecessary("/tmp/testFile");
+    CHECK((libsarus::filesystem::getOwner("/tmp/testFile") == std::tuple<uid_t, gid_t>{0, 0}));
     boost::filesystem::remove_all("/tmp/testFile");
 
-    libsarus::createFileIfNecessary("/tmp/testFile", 1000, 1000);
-    CHECK((libsarus::getOwner("/tmp/testFile") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    libsarus::filesystem::createFileIfNecessary("/tmp/testFile", 1000, 1000);
+    CHECK((libsarus::filesystem::getOwner("/tmp/testFile") == std::tuple<uid_t, gid_t>{1000, 1000}));
     boost::filesystem::remove_all("/tmp/testFile");
 }
 
 TEST(UtilityTestGroup, copyFile) {
     auto testDirRAII = libsarus::PathRAII{ "./sarus-test-copyFile" };
     const auto& testDir = testDirRAII.getPath();
-    libsarus::createFileIfNecessary(testDir / "src");
+    libsarus::filesystem::createFileIfNecessary(testDir / "src");
 
     // implicit owner
-    libsarus::copyFile(testDir / "src", testDir / "dst");
-    CHECK((libsarus::getOwner(testDir / "dst") == std::tuple<uid_t, gid_t>{0, 0}));
+    libsarus::filesystem::copyFile(testDir / "src", testDir / "dst");
+    CHECK((libsarus::filesystem::getOwner(testDir / "dst") == std::tuple<uid_t, gid_t>{0, 0}));
 
     // explicit owner + overwrite existing file
-    libsarus::copyFile(testDir / "src", testDir / "dst", 1000, 1000);
-    CHECK((libsarus::getOwner(testDir / "dst") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    libsarus::filesystem::copyFile(testDir / "src", testDir / "dst", 1000, 1000);
+    CHECK((libsarus::filesystem::getOwner(testDir / "dst") == std::tuple<uid_t, gid_t>{1000, 1000}));
 
     // explicit owner + non-existing directory
-    libsarus::copyFile(testDir / "src", testDir / "non-existing-folder/dst", 1000, 1000);
-    CHECK((libsarus::getOwner(testDir / "non-existing-folder") == std::tuple<uid_t, gid_t>{1000, 1000}));
-    CHECK((libsarus::getOwner(testDir / "non-existing-folder/dst") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    libsarus::filesystem::copyFile(testDir / "src", testDir / "non-existing-folder/dst", 1000, 1000);
+    CHECK((libsarus::filesystem::getOwner(testDir / "non-existing-folder") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    CHECK((libsarus::filesystem::getOwner(testDir / "non-existing-folder/dst") == std::tuple<uid_t, gid_t>{1000, 1000}));
 
     boost::filesystem::remove_all(testDir);
 }
 
 TEST(UtilityTestGroup, copyFolder) {
-    libsarus::createFoldersIfNecessary("/tmp/src-folder/subfolder");
-    libsarus::createFileIfNecessary("/tmp/src-folder/file0");
-    libsarus::createFileIfNecessary("/tmp/src-folder/subfolder/file1");
+    libsarus::filesystem::createFoldersIfNecessary("/tmp/src-folder/subfolder");
+    libsarus::filesystem::createFileIfNecessary("/tmp/src-folder/file0");
+    libsarus::filesystem::createFileIfNecessary("/tmp/src-folder/subfolder/file1");
 
-    libsarus::copyFolder("/tmp/src-folder", "/tmp/dst-folder");
-    CHECK((libsarus::getOwner("/tmp/dst-folder/file0") == std::tuple<uid_t, gid_t>{0, 0}));
-    CHECK((libsarus::getOwner("/tmp/dst-folder/subfolder/file1") == std::tuple<uid_t, gid_t>{0, 0}));
+    libsarus::filesystem::copyFolder("/tmp/src-folder", "/tmp/dst-folder");
+    CHECK((libsarus::filesystem::getOwner("/tmp/dst-folder/file0") == std::tuple<uid_t, gid_t>{0, 0}));
+    CHECK((libsarus::filesystem::getOwner("/tmp/dst-folder/subfolder/file1") == std::tuple<uid_t, gid_t>{0, 0}));
     boost::filesystem::remove_all("/tmp/dst-folder");
 
-    libsarus::copyFolder("/tmp/src-folder", "/tmp/dst-folder", 1000, 1000);
-    CHECK((libsarus::getOwner("/tmp/dst-folder/file0") == std::tuple<uid_t, gid_t>{1000, 1000}));
-    CHECK((libsarus::getOwner("/tmp/dst-folder/subfolder/file1") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    libsarus::filesystem::copyFolder("/tmp/src-folder", "/tmp/dst-folder", 1000, 1000);
+    CHECK((libsarus::filesystem::getOwner("/tmp/dst-folder/file0") == std::tuple<uid_t, gid_t>{1000, 1000}));
+    CHECK((libsarus::filesystem::getOwner("/tmp/dst-folder/subfolder/file1") == std::tuple<uid_t, gid_t>{1000, 1000}));
     boost::filesystem::remove_all("/tmp/dst-folder");
     boost::filesystem::remove_all("/tmp/src-folder");
 }
@@ -254,48 +254,48 @@ TEST(UtilityTestGroup, countFilesInDirectory) {
     // nominal usage
     {
         auto testDir = boost::filesystem::path("/tmp/file-count-test");
-        libsarus::createFoldersIfNecessary(testDir);
-        libsarus::createFileIfNecessary(testDir / "file1");
-        libsarus::createFileIfNecessary(testDir / "file2");
-        libsarus::createFileIfNecessary(testDir / "file3");
-        libsarus::createFileIfNecessary(testDir / "file4");
-        CHECK_EQUAL(libsarus::countFilesInDirectory(testDir), 4);
+        libsarus::filesystem::createFoldersIfNecessary(testDir);
+        libsarus::filesystem::createFileIfNecessary(testDir / "file1");
+        libsarus::filesystem::createFileIfNecessary(testDir / "file2");
+        libsarus::filesystem::createFileIfNecessary(testDir / "file3");
+        libsarus::filesystem::createFileIfNecessary(testDir / "file4");
+        CHECK_EQUAL(libsarus::filesystem::countFilesInDirectory(testDir), 4);
 
         boost::filesystem::remove(testDir / "file1");
         boost::filesystem::remove(testDir / "file4");
-        CHECK_EQUAL(libsarus::countFilesInDirectory(testDir), 2);
+        CHECK_EQUAL(libsarus::filesystem::countFilesInDirectory(testDir), 2);
 
         boost::filesystem::remove_all(testDir);
     }
     // non-existing directory
     {
-        CHECK_THROWS(libsarus::Error, libsarus::countFilesInDirectory("/tmp/" + libsarus::generateRandomString(16)));
+        CHECK_THROWS(libsarus::Error, libsarus::filesystem::countFilesInDirectory("/tmp/" + libsarus::string::generateRandom(16)));
     }
     // non-directory argument
     {
         auto testFile = libsarus::PathRAII{"/tmp/file-count-test.txt"};
-        libsarus::createFileIfNecessary(testFile.getPath());
-        CHECK_THROWS(libsarus::Error, libsarus::countFilesInDirectory(testFile.getPath()));
+        libsarus::filesystem::createFileIfNecessary(testFile.getPath());
+        CHECK_THROWS(libsarus::Error, libsarus::filesystem::countFilesInDirectory(testFile.getPath()));
     }
 }
 
 TEST(UtilityTestGroup, parseMap) {
     // empty list
     {
-        auto map = libsarus::parseMap("");
+        auto map = libsarus::string::parseMap("");
         CHECK(map.empty());
     }
     // one key-value pair
     {
         auto list = "key0=value0";
-        auto map = libsarus::parseMap(list);
+        auto map = libsarus::string::parseMap(list);
         CHECK_EQUAL(map.size(), 1);
         CHECK_EQUAL(map["key0"], std::string{"value0"});
     }
     // two key-value pairs
     {
         auto list = "key0=value0,key1=value1";
-        auto map = libsarus::parseMap(list);
+        auto map = libsarus::string::parseMap(list);
         CHECK_EQUAL(map.size(), 2);
         CHECK_EQUAL(map["key0"], std::string{"value0"});
         CHECK_EQUAL(map["key1"], std::string{"value1"});
@@ -303,27 +303,27 @@ TEST(UtilityTestGroup, parseMap) {
     // key only (no value associated)
     {
         auto list = "key_only";
-        auto map = libsarus::parseMap(list);
+        auto map = libsarus::string::parseMap(list);
         CHECK_EQUAL(map.size(), 1);
         CHECK(map["key_only"] == "");
     }
     {
         auto list = "key_only_at_begin,key=value";
-        auto map = libsarus::parseMap(list);
+        auto map = libsarus::string::parseMap(list);
         CHECK_EQUAL(map.size(), 2);
         CHECK(map["key_only_at_begin"] == "");
         CHECK(map["key"] == "value");
     }
     {
         auto list = "key=value,key_only_at_end";
-        auto map = libsarus::parseMap(list);
+        auto map = libsarus::string::parseMap(list);
         CHECK_EQUAL(map.size(), 2);
         CHECK(map["key"] == "value");
         CHECK(map["key_only_at_end"] == "");
     }
     {
         auto list = "key_only0,key_only1";
-        auto map = libsarus::parseMap(list);
+        auto map = libsarus::string::parseMap(list);
         CHECK_EQUAL(map.size(), 2);
         CHECK(map["key_only0"] == "");
         CHECK(map["key_only1"] == "");
@@ -331,166 +331,166 @@ TEST(UtilityTestGroup, parseMap) {
     // missing key error
     {
         auto list = ",key=value";
-        CHECK_THROWS(libsarus::Error, libsarus::parseMap(list));
+        CHECK_THROWS(libsarus::Error, libsarus::string::parseMap(list));
     }
     {
         auto list = "key0=value0,,key1=value1";
-        CHECK_THROWS(libsarus::Error, libsarus::parseMap(list));
+        CHECK_THROWS(libsarus::Error, libsarus::string::parseMap(list));
     }
     {
         auto list = "key0=value0,";
-        CHECK_THROWS(libsarus::Error, libsarus::parseMap(list));
+        CHECK_THROWS(libsarus::Error, libsarus::string::parseMap(list));
     }
     // repeated key error
     {
         auto list = "key0=value0,key0=value1";
-        CHECK_THROWS(libsarus::Error, libsarus::parseMap(list));
+        CHECK_THROWS(libsarus::Error, libsarus::string::parseMap(list));
     }
     // too many values error, a.k.a. repeated kv separator
     {
         auto list = "key0=value0=value1";
-        CHECK_THROWS(libsarus::Error, libsarus::parseMap(list));
+        CHECK_THROWS(libsarus::Error, libsarus::string::parseMap(list));
     }
 }
 
 TEST(UtilityTestGroup, realpathWithinRootfs) {
-    auto path = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-rootfs")};
+    auto path = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-rootfs")};
     const auto& rootfs = path.getPath();
 
-    libsarus::createFoldersIfNecessary(rootfs / "dir0/dir1");
-    libsarus::createFoldersIfNecessary(rootfs / "dirX");
-    libsarus::createFileIfNecessary(rootfs / "dir0/dir1/file");
+    libsarus::filesystem::createFoldersIfNecessary(rootfs / "dir0/dir1");
+    libsarus::filesystem::createFoldersIfNecessary(rootfs / "dirX");
+    libsarus::filesystem::createFileIfNecessary(rootfs / "dir0/dir1/file");
 
     // folder
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1") == "/dir0/dir1");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1") == "/dir0/dir1");
 
     // file
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/file") == "/dir0/dir1/file");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/file") == "/dir0/dir1/file");
 
     // relative symlink
     CHECK_EQUAL(symlink("../../dir0/dir1", (rootfs / "dir0/dir1/link_relative").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative") == "/dir0/dir1");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative") == "/dir0/dir1");
 
     // relative symlink that spills (out of rootfs)
     CHECK_EQUAL(symlink("../../../../dir0/dir1", (rootfs / "dir0/dir1/link_relative_that_spills").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative_that_spills") == "/dir0/dir1");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative_that_spills") == "/dir0/dir1");
 
     // relative symlink recursive
     CHECK_EQUAL(symlink("../../dir0/dir1/link_relative/dir2/dir3", (rootfs / "dir0/dir1/link_relative_recursive").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative_recursive") == "/dir0/dir1/dir2/dir3");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative_recursive") == "/dir0/dir1/dir2/dir3");
 
     // relative symlink recursive that spills (out of rootfs)
     CHECK_EQUAL(symlink("../../../dir0/dir1/link_relative_that_spills/dir2/dir3", (rootfs / "dir0/dir1/link_relative_recursive_that_spills").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative_recursive_that_spills") == "/dir0/dir1/dir2/dir3");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_relative_recursive_that_spills") == "/dir0/dir1/dir2/dir3");
 
     // absolute symlink
     CHECK_EQUAL(symlink("/dir0/dir1", (rootfs / "dir0/dir1/link_absolute").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute") == "/dir0/dir1");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute") == "/dir0/dir1");
 
     // absolute symlink that spills (out of rootfs)
     CHECK_EQUAL(symlink("/dir0/dir1/../../../../dir0/dir1", (rootfs / "dir0/dir1/link_absolute_that_spills").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute_that_spills") == "/dir0/dir1");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute_that_spills") == "/dir0/dir1");
 
     // absolute symlink recursive
     CHECK_EQUAL(symlink("/dir0/dir1/link_absolute/dir2/dir3", (rootfs / "dir0/dir1/link_absolute_recursive").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute_recursive") == "/dir0/dir1/dir2/dir3");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute_recursive") == "/dir0/dir1/dir2/dir3");
 
     // absolute symlink recursive that spills (out of rootfs)
     CHECK_EQUAL(symlink("/dir0/dir1/link_absolute_that_spills/dir2/dir3", (rootfs / "dir0/dir1/link_absolute_recursive_that_spills").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute_recursive_that_spills") == "/dir0/dir1/dir2/dir3");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dir0/dir1/link_absolute_recursive_that_spills") == "/dir0/dir1/dir2/dir3");
 
     // absolute symlink sharing no part of the path with the target
     CHECK_EQUAL(symlink("/dir0/dir1", (rootfs / "dirX/link_absolute_with_no_common_path").string().c_str()), 0);
-    CHECK(libsarus::realpathWithinRootfs(rootfs, "/dirX/link_absolute_with_no_common_path") == "/dir0/dir1");
+    CHECK(libsarus::filesystem::realpathWithinRootfs(rootfs, "/dirX/link_absolute_with_no_common_path") == "/dir0/dir1");
 }
 
 TEST(UtilityTestGroup, getSharedLibLinkerName) {
-    CHECK(libsarus::getSharedLibLinkerName("file.so") == "file.so");
-    CHECK(libsarus::getSharedLibLinkerName("file.so.1") == "file.so");
-    CHECK(libsarus::getSharedLibLinkerName("file.so.1.0") == "file.so");
-    CHECK(libsarus::getSharedLibLinkerName("file.so.1.0.0") == "file.so");
+    CHECK(libsarus::sharedlibs::getLinkerName("file.so") == "file.so");
+    CHECK(libsarus::sharedlibs::getLinkerName("file.so.1") == "file.so");
+    CHECK(libsarus::sharedlibs::getLinkerName("file.so.1.0") == "file.so");
+    CHECK(libsarus::sharedlibs::getLinkerName("file.so.1.0.0") == "file.so");
 
-    CHECK_THROWS(libsarus::Error, libsarus::getSharedLibLinkerName("not-a-shared-lib"));
-    CHECK_THROWS(libsarus::Error, libsarus::getSharedLibLinkerName("not-a-shared-lib.soa"));
+    CHECK_THROWS(libsarus::Error, libsarus::sharedlibs::getLinkerName("not-a-shared-lib"));
+    CHECK_THROWS(libsarus::Error, libsarus::sharedlibs::getLinkerName("not-a-shared-lib.soa"));
 }
 
 TEST(UtilityTestGroup, isSharedLib) {
-    CHECK(libsarus::isSharedLib("/dir/libc.so") == true);
-    CHECK(libsarus::isSharedLib("libc.so") == true);
-    CHECK(libsarus::isSharedLib("libc.so.1") == true);
-    CHECK(libsarus::isSharedLib("libc.so.1.2") == true);
-
-    CHECK(libsarus::isSharedLib("libc") == false);
-    CHECK(libsarus::isSharedLib("libc.s") == false);
-    CHECK(libsarus::isSharedLib("ld.so.conf") == false);
-    CHECK(libsarus::isSharedLib("ld.so.cache") == false);
+    CHECK(libsarus::filesystem::isSharedLib("/dir/libc.so") == true);
+    CHECK(libsarus::filesystem::isSharedLib("libc.so") == true);
+    CHECK(libsarus::filesystem::isSharedLib("libc.so.1") == true);
+    CHECK(libsarus::filesystem::isSharedLib("libc.so.1.2") == true);
+
+    CHECK(libsarus::filesystem::isSharedLib("libc") == false);
+    CHECK(libsarus::filesystem::isSharedLib("libc.s") == false);
+    CHECK(libsarus::filesystem::isSharedLib("ld.so.conf") == false);
+    CHECK(libsarus::filesystem::isSharedLib("ld.so.cache") == false);
 }
 
 TEST(UtilityTestGroup, parseSharedLibAbi) {
-    CHECK_THROWS(libsarus::Error, libsarus::parseSharedLibAbi("invalid"));
-    CHECK(libsarus::parseSharedLibAbi("libc.so") == (std::vector<std::string>{}));
-    CHECK(libsarus::parseSharedLibAbi("libc.so.1") == (std::vector<std::string>{"1"}));
-    CHECK(libsarus::parseSharedLibAbi("libc.so.1.2") == (std::vector<std::string>{"1", "2"}));
-    CHECK(libsarus::parseSharedLibAbi("libc.so.1.2.3") == (std::vector<std::string>{"1", "2", "3"}));
-    CHECK(libsarus::parseSharedLibAbi("libc.so.1.2.3rc1") == (std::vector<std::string>{"1", "2", "3rc1"}));
-
-    CHECK(libsarus::parseSharedLibAbi("libfoo.so.0") == (std::vector<std::string>{"0"}));
+    CHECK_THROWS(libsarus::Error, libsarus::sharedlibs::parseAbi("invalid"));
+    CHECK(libsarus::sharedlibs::parseAbi("libc.so") == (std::vector<std::string>{}));
+    CHECK(libsarus::sharedlibs::parseAbi("libc.so.1") == (std::vector<std::string>{"1"}));
+    CHECK(libsarus::sharedlibs::parseAbi("libc.so.1.2") == (std::vector<std::string>{"1", "2"}));
+    CHECK(libsarus::sharedlibs::parseAbi("libc.so.1.2.3") == (std::vector<std::string>{"1", "2", "3"}));
+    CHECK(libsarus::sharedlibs::parseAbi("libc.so.1.2.3rc1") == (std::vector<std::string>{"1", "2", "3rc1"}));
+
+    CHECK(libsarus::sharedlibs::parseAbi("libfoo.so.0") == (std::vector<std::string>{"0"}));
 }
 
 TEST(UtilityTestGroup, resolveSharedLibAbi) {
     auto testDirRaii = libsarus::PathRAII{
-        libsarus::makeUniquePathWithRandomSuffix("/tmp/sarus-test-utility-resolveSharedLibAbi")
+        libsarus::filesystem::makeUniquePathWithRandomSuffix("/tmp/sarus-test-utility-resolveSharedLibAbi")
     };
     const auto& testDir = testDirRaii.getPath();
 
     // invalid library filename
-    libsarus::createFileIfNecessary(testDir / "invalid");
-    CHECK_THROWS(libsarus::Error, libsarus::resolveSharedLibAbi(testDir / "invalid"));
+    libsarus::filesystem::createFileIfNecessary(testDir / "invalid");
+    CHECK_THROWS(libsarus::Error, libsarus::sharedlibs::resolveAbi(testDir / "invalid"));
 
     // libtest.so
-    libsarus::createFileIfNecessary(testDir / "libtest.so");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "libtest.so") == std::vector<std::string>{});
+    libsarus::filesystem::createFileIfNecessary(testDir / "libtest.so");
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "libtest.so") == std::vector<std::string>{});
 
     // libtest.so.1
-    libsarus::createFileIfNecessary(testDir / "libtest.so.1");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "libtest.so.1") == std::vector<std::string>{"1"});
+    libsarus::filesystem::createFileIfNecessary(testDir / "libtest.so.1");
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "libtest.so.1") == std::vector<std::string>{"1"});
 
     // libtest_symlink.so.1 -> libtest_symlink.so.1.2
-    libsarus::createFileIfNecessary(testDir / "libtest_symlink.so.1.2");
+    libsarus::filesystem::createFileIfNecessary(testDir / "libtest_symlink.so.1.2");
     boost::filesystem::create_symlink(testDir / "libtest_symlink.so.1.2", testDir / "libtest_symlink.so.1");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "libtest_symlink.so.1") == (std::vector<std::string>{"1", "2"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "libtest_symlink.so.1") == (std::vector<std::string>{"1", "2"}));
 
     // libtest_symlink.so.1.2.3 -> libtest_symlink.so.1.2
     boost::filesystem::create_symlink(testDir / "libtest_symlink.so.1.2", testDir / "libtest_symlink.so.1.2.3");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "libtest_symlink.so.1.2.3") == (std::vector<std::string>{"1", "2", "3"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "libtest_symlink.so.1.2.3") == (std::vector<std::string>{"1", "2", "3"}));
 
     // libtest_symlink.so -> libtest_symlink.so.1.2.3 -> libtest_symlink.so.1.2
     boost::filesystem::create_symlink(testDir / "libtest_symlink.so.1.2.3", testDir / "libtest_symlink.so");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "libtest_symlink.so") == (std::vector<std::string>{"1", "2", "3"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "libtest_symlink.so") == (std::vector<std::string>{"1", "2", "3"}));
 
     // subdir/libtest_symlink.so -> ../libtest_symlink.so.1.2.3 -> libtest_symlink.so.1.2
-    libsarus::createFoldersIfNecessary(testDir / "subdir");
+    libsarus::filesystem::createFoldersIfNecessary(testDir / "subdir");
     boost::filesystem::create_symlink("../libtest_symlink.so.1.2.3", testDir / "subdir/libtest_symlink.so");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "subdir/libtest_symlink.so") == (std::vector<std::string>{"1", "2", "3"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "subdir/libtest_symlink.so") == (std::vector<std::string>{"1", "2", "3"}));
 
     // /libtest_symlink_within_rootdir.so -> /subdir/libtest_symlink_within_rootdir.so.1 -> ../libtest_symlink_within_rootdir.so.1.2
     boost::filesystem::create_symlink("/subdir/libtest_symlink_within_rootdir.so.1", testDir / "libtest_symlink_within_rootdir.so");
     boost::filesystem::create_symlink("../libtest_symlink_within_rootdir.so.1.2", testDir / "/subdir/libtest_symlink_within_rootdir.so.1");
-    libsarus::createFileIfNecessary(testDir / "libtest_symlink_within_rootdir.so.1.2");
-    CHECK(libsarus::resolveSharedLibAbi("/libtest_symlink_within_rootdir.so", testDir) == (std::vector<std::string>{"1", "2"}));
+    libsarus::filesystem::createFileIfNecessary(testDir / "libtest_symlink_within_rootdir.so.1.2");
+    CHECK(libsarus::sharedlibs::resolveAbi("/libtest_symlink_within_rootdir.so", testDir) == (std::vector<std::string>{"1", "2"}));
 
     // Some vendors have symlinks with incompatible major versions,
     // like libvdpau_nvidia.so.1 -> libvdpau_nvidia.so.440.33.01.
     // For these cases, we trust the vendor and resolve the Lib Abi to that of the symlink.
     // Note here we use libtest.so.1 as the "original lib file" and create a symlink to it.
     boost::filesystem::create_symlink(testDir / "libtest.so.1", testDir / "libtest.so.234.56");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "libtest.so.234.56") == (std::vector<std::string>{"234", "56"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "libtest.so.234.56") == (std::vector<std::string>{"234", "56"}));
 
     boost::filesystem::create_symlink("../libtest.so.1.2", testDir / "subdir" / "libtest.so.234.56");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "subdir" / "libtest.so.234.56") == (std::vector<std::string>{"234", "56"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "subdir" / "libtest.so.234.56") == (std::vector<std::string>{"234", "56"}));
 
     boost::filesystem::create_symlink("../libtest.so.1.2", testDir / "subdir" / "libtest.so.234");
-    CHECK(libsarus::resolveSharedLibAbi(testDir / "subdir" / "libtest.so.234") == (std::vector<std::string>{"234"}));
+    CHECK(libsarus::sharedlibs::resolveAbi(testDir / "subdir" / "libtest.so.234") == (std::vector<std::string>{"234"}));
 }
 
 TEST(UtilityTestGroup, getSharedLibSoname) {
@@ -500,26 +500,26 @@ TEST(UtilityTestGroup, getSharedLibSoname) {
         .parent_path()
         .parent_path()
         .parent_path() / "CI/dummy_libs";
-    CHECK_EQUAL(libsarus::getSharedLibSoname(dummyLibsDir / "libc.so.6-host", "readelf"), std::string("libc.so.6"));
-    CHECK_EQUAL(libsarus::getSharedLibSoname(dummyLibsDir / "ld-linux-x86-64.so.2-host", "readelf"), std::string("ld-linux-x86-64.so.2"));
-    CHECK_THROWS(libsarus::Error, libsarus::getSharedLibSoname(dummyLibsDir / "lib_dummy_0.so", "readelf"));
+    CHECK_EQUAL(libsarus::sharedlibs::getSoname(dummyLibsDir / "libc.so.6-host", "readelf"), std::string("libc.so.6"));
+    CHECK_EQUAL(libsarus::sharedlibs::getSoname(dummyLibsDir / "ld-linux-x86-64.so.2-host", "readelf"), std::string("ld-linux-x86-64.so.2"));
+    CHECK_THROWS(libsarus::Error, libsarus::sharedlibs::getSoname(dummyLibsDir / "lib_dummy_0.so", "readelf"));
 }
 
 TEST(UtilityTestGroup, isLibc) {
     // libc
-    CHECK(libsarus::isLibc("libc.so"));
-    CHECK(libsarus::isLibc("libc.so.6"));
-    CHECK(libsarus::isLibc("libc-2.29.so"));
-    CHECK(libsarus::isLibc("/libc.so"));
-    CHECK(libsarus::isLibc("../libc.so"));
-    CHECK(libsarus::isLibc("dir/libc.so"));
-    CHECK(libsarus::isLibc("dir/dir/libc.so"));
-    CHECK(libsarus::isLibc("/root/libc.so"));
-    CHECK(libsarus::isLibc("/root/dir/libc.so"));
+    CHECK(libsarus::filesystem::isLibc("libc.so"));
+    CHECK(libsarus::filesystem::isLibc("libc.so.6"));
+    CHECK(libsarus::filesystem::isLibc("libc-2.29.so"));
+    CHECK(libsarus::filesystem::isLibc("/libc.so"));
+    CHECK(libsarus::filesystem::isLibc("../libc.so"));
+    CHECK(libsarus::filesystem::isLibc("dir/libc.so"));
+    CHECK(libsarus::filesystem::isLibc("dir/dir/libc.so"));
+    CHECK(libsarus::filesystem::isLibc("/root/libc.so"));
+    CHECK(libsarus::filesystem::isLibc("/root/dir/libc.so"));
 
     // not libc
-    CHECK(!libsarus::isLibc("libcl.so"));
-    CHECK(!libsarus::isLibc("libc_bogus.so"));
+    CHECK(!libsarus::filesystem::isLibc("libcl.so"));
+    CHECK(!libsarus::filesystem::isLibc("libc_bogus.so"));
 }
 
 TEST(UtilityTestGroup, is64bitSharedLib) {
@@ -529,9 +529,9 @@ TEST(UtilityTestGroup, is64bitSharedLib) {
         .parent_path()
         .parent_path()
         .parent_path() / "CI/dummy_libs";
-    CHECK(libsarus::is64bitSharedLib(dummyLibsDir / "libc.so.6-host", "readelf"));
-    CHECK(libsarus::is64bitSharedLib(dummyLibsDir / "ld-linux-x86-64.so.2-host", "readelf"));
-    CHECK(!libsarus::is64bitSharedLib(dummyLibsDir / "libc.so.6-32bit-container", "readelf"));
+    CHECK(libsarus::sharedlibs::is64bitSharedLib(dummyLibsDir / "libc.so.6-host", "readelf"));
+    CHECK(libsarus::sharedlibs::is64bitSharedLib(dummyLibsDir / "ld-linux-x86-64.so.2-host", "readelf"));
+    CHECK(!libsarus::sharedlibs::is64bitSharedLib(dummyLibsDir / "libc.so.6-32bit-container", "readelf"));
 }
 
 TEST(UtilityTestGroup, serializeJSON) {
@@ -546,18 +546,18 @@ TEST(UtilityTestGroup, serializeJSON) {
     json["array"].PushBack(rj::Value{1}, allocator);
     json["array"].PushBack(rj::Value{2}, allocator);
 
-    auto actual = libsarus::serializeJSON(json);
+    auto actual = libsarus::json::serialize(json);
     auto expected = std::string{"{\"string\":\"stringValue\",\"int\":11,\"array\":[0,1,2]}"};
 
-    CHECK_EQUAL(libsarus::removeWhitespaces(actual), expected);
+    CHECK_EQUAL(libsarus::string::removeWhitespaces(actual), expected);
 }
 
 TEST(UtilityTestGroup, setCpuAffinity_invalid_argument) {
-    CHECK_THROWS(libsarus::Error, libsarus::setCpuAffinity({})); // no CPUs
+    CHECK_THROWS(libsarus::Error, libsarus::process::setCpuAffinity({})); // no CPUs
 }
 
 TEST(UtilityTestGroup, getCpuAffinity_setCpuAffinity) {
-    auto initialCpus = libsarus::getCpuAffinity();
+    auto initialCpus = libsarus::process::getCpuAffinity();
 
     if(initialCpus.size() <= 1) {
         std::cerr << "Skipping CPU affinity unit test. Not enough CPUs available" << std::endl;
@@ -567,13 +567,13 @@ TEST(UtilityTestGroup, getCpuAffinity_setCpuAffinity) {
     // set new affinity (removing one CPU)
     auto newCpus = initialCpus;
     newCpus.pop_back();
-    libsarus::setCpuAffinity(newCpus);
+    libsarus::process::setCpuAffinity(newCpus);
 
     // check
-    CHECK(libsarus::getCpuAffinity() == newCpus);
+    CHECK(libsarus::process::getCpuAffinity() == newCpus);
 
     // restore initial affinity
-    libsarus::setCpuAffinity(initialCpus);
+    libsarus::process::setCpuAffinity(initialCpus);
 }
 
 }}
diff --git a/src/libsarus/utility/environment.cpp b/src/libsarus/utility/environment.cpp
index 5e869906..1dbfc7a9 100644
--- a/src/libsarus/utility/environment.cpp
+++ b/src/libsarus/utility/environment.cpp
@@ -19,21 +19,22 @@
  */
 
 namespace libsarus {
+namespace environment {
 
-std::unordered_map<std::string, std::string> parseEnvironmentVariables(char** env) {
+std::unordered_map<std::string, std::string> parseVariables(char** env) {
     auto map = std::unordered_map<std::string, std::string>{};
     for(size_t i=0; env[i] != nullptr; ++i) {
         std::string key, value;
-        std::tie(key, value) = parseEnvironmentVariable(env[i]);
+        std::tie(key, value) = parseVariable(env[i]);
         map[key] = value;
     }
     return map;
 }
 
-std::pair<std::string, std::string> parseEnvironmentVariable(const std::string& variable) {
+std::pair<std::string, std::string> parseVariable(const std::string& variable) {
     std::pair<std::string, std::string> kvPair;
     try {
-        kvPair = libsarus::parseKeyValuePair(variable);
+        kvPair = string::parseKeyValuePair(variable);
     }
     catch(const libsarus::Error& e) {
         auto message = boost::format("Failed to parse environment variable: %s") % e.what();
@@ -42,7 +43,7 @@ std::pair<std::string, std::string> parseEnvironmentVariable(const std::string&
     return kvPair;
 }
 
-std::string getEnvironmentVariable(const std::string& key) {
+std::string getVariable(const std::string& key) {
     char* p;
     if((p = getenv(key.c_str())) == nullptr) {
         auto message = boost::format("Environment doesn't contain variable with key %s") % key;
@@ -52,7 +53,7 @@ std::string getEnvironmentVariable(const std::string& key) {
     return p;
 }
 
-void setEnvironmentVariable(const std::string& key, const std::string& value) {
+void setVariable(const std::string& key, const std::string& value) {
     int overwrite = 1;
     if(setenv(key.c_str(), value.c_str(), overwrite) != 0) {
         auto message = boost::format("Failed to setenv(%s, %s, %d): %s")
@@ -62,7 +63,7 @@ void setEnvironmentVariable(const std::string& key, const std::string& value) {
     logMessage(boost::format("Set environment variable %s=%s") % key % value, libsarus::LogLevel::DEBUG);
 }
 
-void clearEnvironmentVariables() {
+void clearVariables() {
     if(clearenv() != 0) {
         SARUS_THROW_ERROR("Failed to clear host environment variables");
     }
@@ -76,4 +77,4 @@ void clearEnvironmentVariables() {
     }
 }
 
-}
+}}
diff --git a/src/libsarus/utility/environment.hpp b/src/libsarus/utility/environment.hpp
index c5c6902b..17711301 100644
--- a/src/libsarus/utility/environment.hpp
+++ b/src/libsarus/utility/environment.hpp
@@ -20,13 +20,14 @@
  */
 
 namespace libsarus {
+namespace environment {
 
-std::unordered_map<std::string, std::string> parseEnvironmentVariables(char** env);
-std::pair<std::string, std::string> parseEnvironmentVariable(const std::string& variable);
-std::string getEnvironmentVariable(const std::string& key);
-void setEnvironmentVariable(const std::string& key, const std::string& value);
-void clearEnvironmentVariables();
+std::unordered_map<std::string, std::string> parseVariables(char** env);
+std::pair<std::string, std::string> parseVariable(const std::string& variable);
+std::string getVariable(const std::string& key);
+void setVariable(const std::string& key, const std::string& value);
+void clearVariables();
 
-}
+}}
 
 #endif
diff --git a/src/libsarus/utility/filesystem.cpp b/src/libsarus/utility/filesystem.cpp
index 3dc67196..04d1696d 100644
--- a/src/libsarus/utility/filesystem.cpp
+++ b/src/libsarus/utility/filesystem.cpp
@@ -26,6 +26,7 @@
  */
 
 namespace libsarus {
+namespace filesystem {
 
 size_t getFileSize(const boost::filesystem::path& filename) {
     struct stat st;
@@ -139,7 +140,7 @@ void copyFolder(const boost::filesystem::path& src, const boost::filesystem::pat
         SARUS_THROW_ERROR(message.str());
     }
 
-    libsarus::createFoldersIfNecessary(dst, uid, gid);
+    filesystem::createFoldersIfNecessary(dst, uid, gid);
 
     // for each file/folder in the directory
     for(boost::filesystem::directory_iterator entry{src};
@@ -216,7 +217,7 @@ boost::filesystem::path makeUniquePathWithRandomSuffix(const boost::filesystem::
 
     do {
         const size_t sizeOfRandomSuffix = 16;
-        uniquePath = path.string() + "-" + generateRandomString(sizeOfRandomSuffix);
+        uniquePath = path.string() + "-" + string::generateRandom(sizeOfRandomSuffix);
     } while(boost::filesystem::exists(uniquePath));
 
     return uniquePath;
@@ -328,10 +329,10 @@ dev_t getDeviceID(const boost::filesystem::path& path) {
 
 char getDeviceType(const boost::filesystem::path& path) {
     char deviceType;
-    if (libsarus::isCharacterDevice(path)) {
+    if (filesystem::isCharacterDevice(path)) {
         deviceType = 'c';
     }
-    else if (libsarus::isBlockDevice(path)) {
+    else if (filesystem::isBlockDevice(path)) {
         deviceType = 'b';
     }
     else {
@@ -419,4 +420,4 @@ bool isSharedLib(const boost::filesystem::path& file) {
     return pos+3 == filename.cend() || *(pos+3) == '.';
 }
 
-}
+}}
diff --git a/src/libsarus/utility/filesystem.hpp b/src/libsarus/utility/filesystem.hpp
index 81e5333c..b4806b5f 100644
--- a/src/libsarus/utility/filesystem.hpp
+++ b/src/libsarus/utility/filesystem.hpp
@@ -23,6 +23,7 @@
  */
 
 namespace libsarus {
+namespace filesystem {
 
 std::tuple<uid_t, gid_t> getOwner(const boost::filesystem::path&);
 void setOwner(const boost::filesystem::path&, uid_t, gid_t);
@@ -55,6 +56,6 @@ bool isSymlink(const boost::filesystem::path& path);
 bool isLibc(const boost::filesystem::path&);
 bool isSharedLib(const boost::filesystem::path& file);
 
-}
+}}
 
 #endif
diff --git a/src/libsarus/utility/hook.cpp b/src/libsarus/utility/hook.cpp
index 2554dab1..5c02a8ce 100644
--- a/src/libsarus/utility/hook.cpp
+++ b/src/libsarus/utility/hook.cpp
@@ -104,10 +104,10 @@ ContainerState parseStateOfContainerFromStdin() {
 
 std::unordered_map<std::string, std::string> parseEnvironmentVariablesFromOCIBundle(const boost::filesystem::path& bundleDir) {
     auto env = std::unordered_map<std::string, std::string>{};
-    auto json = libsarus::readJSON(bundleDir / "config.json");
+    auto json = json::read(bundleDir / "config.json");
     for(const auto& variable : json["process"]["env"].GetArray()) {
         std::string k, v;
-        std::tie(k, v) = libsarus::parseEnvironmentVariable(variable.GetString());
+        std::tie(k, v) = environment::parseVariable(variable.GetString());
         env[k] = v;
     }
     return env;
@@ -115,10 +115,10 @@ std::unordered_map<std::string, std::string> parseEnvironmentVariablesFromOCIBun
 
 boost::optional<std::string> getEnvironmentVariableValueFromOCIBundle(const std::string& key, const boost::filesystem::path& bundleDir) {
     boost::optional<std::string> value;
-    auto json = libsarus::readJSON(bundleDir / "config.json");
+    auto json = json::read(bundleDir / "config.json");
     for(const auto& variable : json["process"]["env"].GetArray()) {
         std::string k, v;
-        std::tie(k, v) = libsarus::parseEnvironmentVariable(variable.GetString());
+        std::tie(k, v) = environment::parseVariable(variable.GetString());
         if (k == key) {
             value = v;
             break;
@@ -167,7 +167,7 @@ std::tuple<boost::filesystem::path, boost::filesystem::path> findSubsystemMountP
     hook::logMessage(boost::format("Parsing %s for \"%s\" cgroup subsystem mount paths") % mountinfoPath % subsystemName,
                         libsarus::LogLevel::DEBUG);
 
-    auto mountinfoText = libsarus::readFile(mountinfoPath);
+    auto mountinfoText = filesystem::readFile(mountinfoPath);
     auto mountinfoLines = std::vector<std::string>{};
     boost::split(mountinfoLines, mountinfoText, boost::is_any_of("\n"));
 
@@ -223,7 +223,7 @@ boost::filesystem::path findCgroupPathInHierarchy(const std::string& subsystemNa
                         libsarus::LogLevel::DEBUG);
 
     auto cgroupPath = boost::filesystem::path("/");
-    auto procFileText = libsarus::readFile(procFilePath);
+    auto procFileText = filesystem::readFile(procFilePath);
     auto procFileLines = std::vector<std::string>{};
     boost::split(procFileLines, procFileText, boost::is_any_of("\n"));
 
@@ -297,19 +297,19 @@ void whitelistDeviceInCgroup(const boost::filesystem::path& cgroupPath, const bo
 
     char deviceType;
     try {
-        deviceType = libsarus::getDeviceType(deviceFile);
+        deviceType = filesystem::getDeviceType(deviceFile);
     }
     catch(const libsarus::Error& e) {
         auto message = boost::format("Failed to whitelist %s: not a valid device file") % deviceFile;
         SARUS_RETHROW_ERROR(e, message.str());
     }
 
-    auto deviceID = libsarus::getDeviceID(deviceFile);
+    auto deviceID = filesystem::getDeviceID(deviceFile);
     auto entry = boost::format("%c %u:%u rw") % deviceType % major(deviceID) % minor(deviceID);
     hook::logMessage(boost::format("Whitelist entry: %s") % entry.str(), libsarus::LogLevel::DEBUG);
 
     auto allowFile = cgroupPath / "devices.allow";
-    libsarus::writeTextFile(entry.str(), allowFile, std::ios_base::app);
+    filesystem::writeTextFile(entry.str(), allowFile, std::ios_base::app);
 
     hook::logMessage(boost::format("Successfully whitelisted device %s for rw access") % deviceFile,
             libsarus::LogLevel::DEBUG);
diff --git a/src/libsarus/utility/json.cpp b/src/libsarus/utility/json.cpp
index 88cee3f5..207b7ec8 100644
--- a/src/libsarus/utility/json.cpp
+++ b/src/libsarus/utility/json.cpp
@@ -30,8 +30,9 @@
  */
 
 namespace libsarus {
+namespace json {
 
-rapidjson::Document parseJSONStream(std::istream& is) {
+rapidjson::Document parseStream(std::istream& is) {
     auto json = rapidjson::Document{};
 
     try {
@@ -45,9 +46,9 @@ rapidjson::Document parseJSONStream(std::istream& is) {
     return json;
 }
 
-rapidjson::Document parseJSON(const std::string& string) {
+rapidjson::Document parse(const std::string& string) {
     std::istringstream iss(string);
-    auto json = parseJSONStream(iss);
+    auto json = parseStream(iss);
     if (json.HasParseError()) {
         auto message = boost::format(
             "Error parsing JSON string:\n'%s'\nInput data is not valid JSON\n"
@@ -60,9 +61,9 @@ rapidjson::Document parseJSON(const std::string& string) {
     return json;
 }
 
-rapidjson::Document readJSON(const boost::filesystem::path& filename) {
+rapidjson::Document read(const boost::filesystem::path& filename) {
     std::ifstream ifs(filename.string());
-    auto json = parseJSONStream(ifs);
+    auto json = parseStream(ifs);
     if (json.HasParseError()) {
         auto message = boost::format(
             "Error parsing JSON file %s. Input data is not valid JSON\n"
@@ -75,7 +76,7 @@ rapidjson::Document readJSON(const boost::filesystem::path& filename) {
     return json;
 }
 
-rapidjson::SchemaDocument readJSONSchema(const boost::filesystem::path& schemaFile) {
+rapidjson::SchemaDocument readSchema(const boost::filesystem::path& schemaFile) {
     class RemoteSchemaDocumentProvider : public rapidjson::IRemoteSchemaDocumentProvider {
     public:
         RemoteSchemaDocumentProvider(const boost::filesystem::path& schemasDir)
@@ -83,20 +84,20 @@ rapidjson::SchemaDocument readJSONSchema(const boost::filesystem::path& schemaFi
         {}
         const rapidjson::SchemaDocument* GetRemoteDocument(const char* uri, rapidjson::SizeType length) override {
             auto filename = std::string(uri, length);
-            auto schema = libsarus::readJSON(schemasDir / filename);
+            auto schema = json::read(schemasDir / filename);
             return new rapidjson::SchemaDocument(schema);
         }
     private:
         boost::filesystem::path schemasDir;
     };
 
-    auto schemaJSON = libsarus::readJSON(schemaFile);
+    auto schemaJSON = json::read(schemaFile);
     auto provider = RemoteSchemaDocumentProvider{ schemaFile.parent_path() };
     return rapidjson::SchemaDocument{ schemaJSON, nullptr, rapidjson::SizeType(0), &provider };
 }
 
-rapidjson::Document readAndValidateJSON(const boost::filesystem::path& jsonFile, const boost::filesystem::path& schemaFile) {
-    auto schema = readJSONSchema(schemaFile);
+rapidjson::Document readAndValidate(const boost::filesystem::path& jsonFile, const boost::filesystem::path& schemaFile) {
+    auto schema = readSchema(schemaFile);
 
     rapidjson::Document json;
 
@@ -150,9 +151,9 @@ rapidjson::Document readAndValidateJSON(const boost::filesystem::path& jsonFile,
     return json;
 }
 
-void writeJSON(const rapidjson::Value& json, const boost::filesystem::path& filename) {
+void write(const rapidjson::Value& json, const boost::filesystem::path& filename) {
     try {
-        createFoldersIfNecessary(filename.parent_path());
+        filesystem::createFoldersIfNecessary(filename.parent_path());
         std::ofstream ofs(filename.string());
         if(!ofs) {
             auto message = boost::format("Failed to open std::ofstream for %s") % filename;
@@ -169,7 +170,7 @@ void writeJSON(const rapidjson::Value& json, const boost::filesystem::path& file
     }
 }
 
-std::string serializeJSON(const rapidjson::Value& json) {
+std::string serialize(const rapidjson::Value& json) {
     namespace rj = rapidjson;
     rj::StringBuffer buffer;
     rj::Writer<rj::StringBuffer> writer(buffer);
@@ -177,4 +178,4 @@ std::string serializeJSON(const rapidjson::Value& json) {
     return buffer.GetString();
 }
 
-}
+}}
diff --git a/src/libsarus/utility/json.hpp b/src/libsarus/utility/json.hpp
index 38a21352..0932865a 100644
--- a/src/libsarus/utility/json.hpp
+++ b/src/libsarus/utility/json.hpp
@@ -22,16 +22,17 @@
  */
 
 namespace libsarus {
+namespace json {
 
-rapidjson::SchemaDocument readJSONSchema(const boost::filesystem::path& schemaFile);
-rapidjson::Document parseJSONStream(std::istream& is);
-rapidjson::Document parseJSON(const std::string& string);
-rapidjson::Document readJSON(const boost::filesystem::path& filename);
-rapidjson::Document readAndValidateJSON(const boost::filesystem::path& jsonFile,
+rapidjson::SchemaDocument readSchema(const boost::filesystem::path& schemaFile);
+rapidjson::Document parseStream(std::istream& is);
+rapidjson::Document parse(const std::string& string);
+rapidjson::Document read(const boost::filesystem::path& filename);
+rapidjson::Document readAndValidate(const boost::filesystem::path& jsonFile,
                                         const boost::filesystem::path& schemaFile);
-void writeJSON(const rapidjson::Value& json, const boost::filesystem::path& filename);
-std::string serializeJSON(const rapidjson::Value& json);
+void write(const rapidjson::Value& json, const boost::filesystem::path& filename);
+std::string serialize(const rapidjson::Value& json);
 
-}
+}}
 
 #endif
diff --git a/src/libsarus/utility/mount.cpp b/src/libsarus/utility/mount.cpp
index b3d5e343..521ff2bb 100644
--- a/src/libsarus/utility/mount.cpp
+++ b/src/libsarus/utility/mount.cpp
@@ -28,6 +28,7 @@
  */
 
 namespace libsarus {
+namespace mount {
 
 boost::filesystem::path getValidatedMountSource(const boost::filesystem::path& source) {
     logMessage(boost::format("Validating mount source: %s") % source, LogLevel::DEBUG);
@@ -60,7 +61,7 @@ boost::filesystem::path getValidatedMountDestination(const boost::filesystem::pa
     if (rootfsDir.is_relative()) {
         SARUS_THROW_ERROR("Internal error: rootfsDir is not an absolute path");
     }
-    auto destinationReal = rootfsDir / realpathWithinRootfs(rootfsDir, destination);
+    auto destinationReal = rootfsDir / filesystem::realpathWithinRootfs(rootfsDir, destination);
 
     /* If the destination does not exist, check its parents */
     if (!boost::filesystem::exists(destinationReal)) {
@@ -175,7 +176,7 @@ void validatedBindMount(const boost::filesystem::path& source,
 
     try {
         // switch to user identity to make sure user has access to the mount source
-        switchIdentity(userIdentity);
+        process::switchIdentity(userIdentity);
         auto sourceReal = getValidatedMountSource(source);
         auto destinationReal = getValidatedMountDestination(destination, rootfsDir);
 
@@ -185,28 +186,28 @@ void validatedBindMount(const boost::filesystem::path& source,
         // Using the Boost filesystem predicate function as root will be denied if the mount source is in a
         // root_squashed filesystem.
         auto mountSourceIsDirectory = boost::filesystem::is_directory(sourceReal);
-        switchIdentity(rootIdentity);
+        process::switchIdentity(rootIdentity);
 
         // Create file or folder if necessary, after validation.
         // Always assign ownership of the newly-created mount point to the container user:
         // while it has no effect on the ownership and permissions of the mounted resource in the container
         // (they are the same as the mount source), a non-root-owned file reduces cleanup problems (in case there are any).
         if (mountSourceIsDirectory){
-            createFoldersIfNecessary(destinationReal, userIdentity.uid, userIdentity.gid);
+            filesystem::createFoldersIfNecessary(destinationReal, userIdentity.uid, userIdentity.gid);
         }
         else {
-            createFileIfNecessary(destinationReal, userIdentity.uid, userIdentity.gid);
+            filesystem::createFileIfNecessary(destinationReal, userIdentity.uid, userIdentity.gid);
         }
 
         // switch to user filesystem identity to make sure we can access paths as root even on root_squashed filesystems
-        setFilesystemUid(userIdentity);
+        process::setFilesystemUid(userIdentity);
         bindMount(sourceReal, destinationReal, flags);
-        setFilesystemUid(rootIdentity);
+        process::setFilesystemUid(rootIdentity);
     }
     catch(Error& e) {
         // Restore root identity in case the exception happened while having a non-privileged id.
         // By setting the euid, the fsuid will also be set accordingly.
-        switchIdentity(rootIdentity);
+        process::switchIdentity(rootIdentity);
         auto message = boost::format("Failed to bind mount %s on container's %s: %s")
                        % source.string() % destination.string() % e.what();
         SARUS_RETHROW_ERROR(e, message.str());
@@ -226,19 +227,19 @@ void bindMount(const boost::filesystem::path& from, const boost::filesystem::pat
     }
 
     // bind mount
-    if(mount(from.c_str(), to.c_str(), "bind", flagsForBindMount, NULL) != 0) {
+    if(::mount(from.c_str(), to.c_str(), "bind", flagsForBindMount, NULL) != 0) {
         auto message = boost::format("Failed to bind mount %s -> %s (error: %s)") % from % to % strerror(errno);
         SARUS_THROW_ERROR(message.str());
     }
 
     // remount to apply flags
-    if(mount(from.c_str(), to.c_str(), "bind", flagsForRemount, NULL) != 0) {
+    if(::mount(from.c_str(), to.c_str(), "bind", flagsForRemount, NULL) != 0) {
         auto message = boost::format("Failed to re-bind mount %s -> %s (error: %s)") % from % to % strerror(errno);
         SARUS_THROW_ERROR(message.str());
     }
 
     // remount to apply propagation type
-    if(mount(NULL, to.c_str(), NULL, flagsForPropagationRemount, NULL) != 0) {
+    if(::mount(NULL, to.c_str(), NULL, flagsForPropagationRemount, NULL) != 0) {
         auto message = boost::format("Failed to remount %s as non-shared (error: %s)") % to % strerror(errno);
         SARUS_THROW_ERROR(message.str());
     }
@@ -257,7 +258,7 @@ void loopMountSquashfs(const boost::filesystem::path& image, const boost::filesy
     logMessage(boost::format{"Performing loop mount: %s "} % command, LogLevel::DEBUG);
 
     try {
-        executeCommand(command);
+        process::executeCommand(command);
     }
     catch(Error& e) {
         auto message = boost::format("Failed to loop mount %s on %s") % image % mountPoint;
@@ -276,11 +277,11 @@ void mountOverlayfs(const boost::filesystem::path& lowerDir,
         % workDir.string();
     logMessage(boost::format{"Performing overlay mount to %s "} % mountPoint, LogLevel::DEBUG);
     logMessage(boost::format{"Overlay options: %s "} % options.str(), LogLevel::DEBUG);
-    if(mount("overlay", mountPoint.c_str(), "overlay", MS_MGC_VAL, options.str().c_str()) != 0) {
+    if(::mount("overlay", mountPoint.c_str(), "overlay", MS_MGC_VAL, options.str().c_str()) != 0) {
         auto message = boost::format("Failed to mount OverlayFS on %s (options: %s): %s")
             % mountPoint % options % strerror(errno);
         SARUS_THROW_ERROR(message.str());
     }
 }
 
-}
+}}
diff --git a/src/libsarus/utility/mount.hpp b/src/libsarus/utility/mount.hpp
index 86e23f9b..0e241385 100644
--- a/src/libsarus/utility/mount.hpp
+++ b/src/libsarus/utility/mount.hpp
@@ -26,6 +26,7 @@
  */
 
 namespace libsarus {
+namespace mount {
 
 boost::filesystem::path getValidatedMountSource(const boost::filesystem::path&);
 boost::filesystem::path getValidatedMountDestination(const boost::filesystem::path& destination,
@@ -44,6 +45,6 @@ void mountOverlayfs(const boost::filesystem::path& lowerDir,
                     const boost::filesystem::path& workDir,
                     const boost::filesystem::path& mountPoint);
 
-}
+}}
 
 #endif
diff --git a/src/libsarus/utility/process.cpp b/src/libsarus/utility/process.cpp
index 68bdace2..4db61f27 100644
--- a/src/libsarus/utility/process.cpp
+++ b/src/libsarus/utility/process.cpp
@@ -30,6 +30,7 @@
  */
 
 namespace libsarus {
+namespace process {
 
 static void logProcessUserAndGroupIdentifiers() {
     uid_t ruid, euid, suid;
@@ -305,4 +306,4 @@ void setStdinEcho(bool flag)
     (void) tcsetattr(STDIN_FILENO, TCSANOW, &tty);
 }
 
-}
+}}
diff --git a/src/libsarus/utility/process.hpp b/src/libsarus/utility/process.hpp
index 1a96b3fb..dc226fe7 100644
--- a/src/libsarus/utility/process.hpp
+++ b/src/libsarus/utility/process.hpp
@@ -25,6 +25,7 @@
  */
 
 namespace libsarus {
+namespace process {
 
 void switchIdentity(const libsarus::UserIdentity&);
 void setFilesystemUid(const libsarus::UserIdentity&);
@@ -38,6 +39,6 @@ std::vector<int> getCpuAffinity();
 void setCpuAffinity(const std::vector<int>&);
 void setStdinEcho(bool);
 
-}
+}}
 
 #endif
diff --git a/src/libsarus/utility/sharedLibs.cpp b/src/libsarus/utility/sharedLibs.cpp
index 18142397..3813cf2a 100644
--- a/src/libsarus/utility/sharedLibs.cpp
+++ b/src/libsarus/utility/sharedLibs.cpp
@@ -25,8 +25,9 @@
  */
 
 namespace libsarus {
+namespace sharedlibs {
 
-boost::filesystem::path getSharedLibLinkerName(const boost::filesystem::path& path) {
+boost::filesystem::path getLinkerName(const boost::filesystem::path& path) {
     auto extension = std::string{".so"};
     auto filename = path.filename().string();
     auto dot = std::find_end(filename.begin(), filename.end(), extension.cbegin(), extension.cend());
@@ -40,13 +41,13 @@ boost::filesystem::path getSharedLibLinkerName(const boost::filesystem::path& pa
     return filename;
 }
 
-std::vector<boost::filesystem::path> getSharedLibsFromDynamicLinker(
+std::vector<boost::filesystem::path> getListFromDynamicLinker(
     const boost::filesystem::path& ldconfigPath,
     const boost::filesystem::path& rootDir) {
 
     auto libraries = std::vector<boost::filesystem::path>{};
     auto command = boost::format("%s -r %s -p") % ldconfigPath.string() % rootDir.string();
-    auto output = libsarus::executeCommand(command.str());
+    auto output = process::executeCommand(command.str());
     std::stringstream stream{output};
     std::string line;
     while(std::getline(stream, line)) {
@@ -62,8 +63,8 @@ std::vector<boost::filesystem::path> getSharedLibsFromDynamicLinker(
     return libraries;
 }
 
-std::vector<std::string> parseSharedLibAbi(const boost::filesystem::path& lib) {
-    if(!isSharedLib(lib)) {
+std::vector<std::string> parseAbi(const boost::filesystem::path& lib) {
+    if(!filesystem::isSharedLib(lib)) {
         auto message = boost::format{"Cannot parse ABI version of '%s': not a shared library"} % lib;
         SARUS_THROW_ERROR(message.str());
     }
@@ -90,9 +91,9 @@ std::vector<std::string> parseSharedLibAbi(const boost::filesystem::path& lib) {
     return tokens;
 }
 
-std::vector<std::string> resolveSharedLibAbi(const boost::filesystem::path& lib,
+std::vector<std::string> resolveAbi(const boost::filesystem::path& lib,
                                              const boost::filesystem::path& rootDir) {
-    if(!isSharedLib(lib)) {
+    if(!filesystem::isSharedLib(lib)) {
         auto message = boost::format{"Cannot resolve ABI version of '%s': not a shared library"} % lib;
         SARUS_THROW_ERROR(message.str());
     }
@@ -100,17 +101,17 @@ std::vector<std::string> resolveSharedLibAbi(const boost::filesystem::path& lib,
     auto longestAbiSoFar = std::vector<std::string>{};
 
     auto traversedSymlinks = std::vector<boost::filesystem::path>{};
-    auto libReal = appendPathsWithinRootfs(rootDir, "/", lib, &traversedSymlinks);
+    auto libReal = filesystem::appendPathsWithinRootfs(rootDir, "/", lib, &traversedSymlinks);
     auto pathsToProcess = std::move(traversedSymlinks);
     pathsToProcess.push_back(std::move(libReal));
 
     for(const auto& path : pathsToProcess) {
-        if(!isSharedLib(path)) {
+        if(!filesystem::isSharedLib(path)) {
             // some traversed symlinks may not be library filenames,
             // e.g. with /lib -> /lib64
             continue;
         }
-        if(getSharedLibLinkerName(path) != getSharedLibLinkerName(lib)) {
+        if(sharedlibs::getLinkerName(path) != sharedlibs::getLinkerName(lib)) {
             // E.g. on Cray we could have:
             // mpich-gnu-abi/7.1/lib/libmpi.so.12 -> ../../../mpich-gnu/7.1/lib/libmpich_gnu_71.so.3.0.1
             // Let's ignore the symlink's target in this case
@@ -121,7 +122,7 @@ std::vector<std::string> resolveSharedLibAbi(const boost::filesystem::path& lib,
             continue;
         }
 
-        auto abi = parseSharedLibAbi(path);
+        auto abi = sharedlibs::parseAbi(path);
 
         const auto& shorter = abi.size() < longestAbiSoFar.size() ? abi : longestAbiSoFar;
         const auto& longer = abi.size() > longestAbiSoFar.size() ? abi : longestAbiSoFar;
@@ -143,9 +144,9 @@ std::vector<std::string> resolveSharedLibAbi(const boost::filesystem::path& lib,
     return longestAbiSoFar;
 }
 
-std::string getSharedLibSoname(const boost::filesystem::path& path, const boost::filesystem::path& readelfPath) {
+std::string getSoname(const boost::filesystem::path& path, const boost::filesystem::path& readelfPath) {
     auto command = boost::format("%s -d %d") % readelfPath % path;
-    auto output = libsarus::executeCommand(command.str());
+    auto output = process::executeCommand(command.str());
 
     std::stringstream stream{output};
     std::string line;
@@ -166,7 +167,7 @@ bool is64bitSharedLib(const boost::filesystem::path& path, const boost::filesyst
     boost::regex re("^ *Machine: +Advanced Micro Devices X86-64 *$");
 
     auto command = boost::format("%s -h %s") % readelfPath.string() % path.string();
-    auto output = libsarus::executeCommand(command.str());
+    auto output = process::executeCommand(command.str());
 
     std::stringstream stream{output};
     std::string line;
@@ -179,4 +180,4 @@ bool is64bitSharedLib(const boost::filesystem::path& path, const boost::filesyst
     return false;
 }
 
-}
+}}
diff --git a/src/libsarus/utility/sharedLibs.hpp b/src/libsarus/utility/sharedLibs.hpp
index daec5d1d..74a6d387 100644
--- a/src/libsarus/utility/sharedLibs.hpp
+++ b/src/libsarus/utility/sharedLibs.hpp
@@ -21,17 +21,18 @@
  */
 
 namespace libsarus {
+namespace sharedlibs {
 
-boost::filesystem::path getSharedLibLinkerName(const boost::filesystem::path& path);
-std::vector<boost::filesystem::path> getSharedLibsFromDynamicLinker(
+boost::filesystem::path getLinkerName(const boost::filesystem::path& path);
+std::vector<boost::filesystem::path> getListFromDynamicLinker(
     const boost::filesystem::path& ldconfigPath,
     const boost::filesystem::path& rootDir);
-std::vector<std::string> parseSharedLibAbi(const boost::filesystem::path& lib);
-std::vector<std::string> resolveSharedLibAbi(const boost::filesystem::path& lib,
-                                           const boost::filesystem::path& rootDir = "/");
-std::string getSharedLibSoname(const boost::filesystem::path& path, const boost::filesystem::path& readelfPath);
+std::vector<std::string> parseAbi(const boost::filesystem::path& lib);
+std::vector<std::string> resolveAbi(const boost::filesystem::path& lib,
+                                    const boost::filesystem::path& rootDir = "/");
+std::string getSoname(const boost::filesystem::path& path, const boost::filesystem::path& readelfPath);
 bool is64bitSharedLib(const boost::filesystem::path& path, const boost::filesystem::path& readelfPath);
 
-}
+}}
 
 #endif
diff --git a/src/libsarus/utility/string.cpp b/src/libsarus/utility/string.cpp
index 1215abf5..4d7e5277 100644
--- a/src/libsarus/utility/string.cpp
+++ b/src/libsarus/utility/string.cpp
@@ -26,6 +26,7 @@
  */
 
 namespace libsarus {
+namespace string {
 
 std::string removeWhitespaces(const std::string& s) {
     auto result = s;
@@ -34,7 +35,7 @@ std::string removeWhitespaces(const std::string& s) {
     return result;
 }
 
-std::string replaceString(std::string &buf, const std::string& from, const std::string& to) {
+std::string replace(std::string &buf, const std::string& from, const std::string& to) {
     std::string::size_type pos = buf.find(from);
     while(pos != std::string::npos){
         buf.replace(pos, from.size(), to);
@@ -65,7 +66,7 @@ std::pair<std::string, std::string> parseKeyValuePair(const std::string& pairStr
     return std::pair<std::string, std::string>{key, value};
 }
 
-std::string generateRandomString(size_t size) {
+std::string generateRandom(size_t size) {
     auto dist = std::uniform_int_distribution<std::mt19937::result_type>(0, 'z'-'a');
     std::mt19937 generator;
     generator.seed(std::random_device()());
@@ -104,7 +105,7 @@ std::unordered_map<std::string, std::string> parseMap(const std::string& input,
     for(const auto& pair : pairs) {
         std::string key, value;
         try {
-            std::tie(key, value) = libsarus::parseKeyValuePair(pair, keyValueSeparators);
+            std::tie(key, value) = string::parseKeyValuePair(pair, keyValueSeparators);
         }
         catch(std::exception& e) {
             auto message = boost::format("Error parsing '%s'. %s") % input % e.what();
@@ -135,4 +136,4 @@ std::unordered_map<std::string, std::string> parseMap(const std::string& input,
     return map;
 }
 
-}
+}}
diff --git a/src/libsarus/utility/string.hpp b/src/libsarus/utility/string.hpp
index 39932ec2..3b787195 100644
--- a/src/libsarus/utility/string.hpp
+++ b/src/libsarus/utility/string.hpp
@@ -21,16 +21,17 @@
  */
 
 namespace libsarus {
+namespace string {
 
 std::string removeWhitespaces(const std::string&);
-std::string replaceString(std::string &buf, const std::string& from, const std::string& to);
+std::string replace(std::string &buf, const std::string& from, const std::string& to);
 std::string eraseFirstAndLastDoubleQuote(const std::string& buf);
 std::pair<std::string, std::string> parseKeyValuePair(const std::string& pairString, const char separator = '=');
-std::string generateRandomString(size_t size);
+std::string generateRandom(size_t size);
 std::unordered_map<std::string, std::string> parseMap(const std::string& input,
                                                       const char pairSeparators = ',',
                                                       const char keyValueSeparators = '=');
 
-}
+}}
 
 #endif
diff --git a/src/main.cpp b/src/main.cpp
index d67d2955..55f1d77f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -51,7 +51,7 @@ int main(int argc, char* argv[]) {
         auto config = std::make_shared<sarus::common::Config>(sarusInstallationPrefixDir);
         config->program_start = program_start;
         runtime::SecurityChecks{config}.runSecurityChecks(sarusInstallationPrefixDir);
-        config->commandRun.hostEnvironment = libsarus::parseEnvironmentVariables(environ);
+        config->commandRun.hostEnvironment = libsarus::environment::parseVariables(environ);
 
 
         // Process command
diff --git a/src/runtime/OCIBundleConfig.cpp b/src/runtime/OCIBundleConfig.cpp
index 55c16d9e..c46f03a7 100644
--- a/src/runtime/OCIBundleConfig.cpp
+++ b/src/runtime/OCIBundleConfig.cpp
@@ -41,10 +41,10 @@ OCIBundleConfig::OCIBundleConfig(std::shared_ptr<const common::Config> config)
 void OCIBundleConfig::generateConfigFile() const {
     utility::logMessage("Generating bundle's config file", libsarus::LogLevel::INFO);
     makeJsonDocument();
-    libsarus::createFileIfNecessary(configFile);
+    libsarus::filesystem::createFileIfNecessary(configFile);
     boost::filesystem::permissions(configFile, boost::filesystem::perms::owner_read |
                                                boost::filesystem::perms::owner_write);
-    libsarus::writeJSON(*document, configFile);
+    libsarus::json::write(*document, configFile);
     utility::logMessage("Successfully generated bundle's config file", libsarus::LogLevel::INFO);
 }
 
@@ -376,7 +376,7 @@ rj::Value OCIBundleConfig::makeMemberLinux() const {
 
             auto seccompProfile = rj::Document{};
             try {
-                seccompProfile.CopyFrom(libsarus::readJSON(seccompProfilePath), *allocator);
+                seccompProfile.CopyFrom(libsarus::json::read(seccompProfilePath), *allocator);
             }
             catch(libsarus::Error& e) {
                 auto message = boost::format("Error reading seccomp profile: %s\n"
diff --git a/src/runtime/OCIHooksFactory.cpp b/src/runtime/OCIHooksFactory.cpp
index bce57541..59290827 100644
--- a/src/runtime/OCIHooksFactory.cpp
+++ b/src/runtime/OCIHooksFactory.cpp
@@ -57,7 +57,7 @@ OCIHook OCIHooksFactory::createHook(const boost::filesystem::path& jsonFile,
                                     const boost::filesystem::path& schemaFile) const {
     utility::logMessage(boost::format{"Creating OCI hook object from %s"} % jsonFile,
                         libsarus::LogLevel::INFO);
-    auto json = libsarus::readAndValidateJSON(jsonFile, schemaFile);
+    auto json = libsarus::json::readAndValidate(jsonFile, schemaFile);
     auto hook = OCIHook{};
 
     hook.jsonFile = jsonFile;
diff --git a/src/runtime/Runtime.cpp b/src/runtime/Runtime.cpp
index 4e2f3cd0..fcfcbff8 100644
--- a/src/runtime/Runtime.cpp
+++ b/src/runtime/Runtime.cpp
@@ -41,10 +41,10 @@ Runtime::Runtime(std::shared_ptr<common::Config> config)
     , bundleConfig{config}
     , fdHandler{config}
 {
-    libsarus::clearEnvironmentVariables();
+    libsarus::environment::clearVariables();
 
-    auto status = libsarus::readFile("/proc/self/status");
-    config->commandRun.cpuAffinity = libsarus::getCpuAffinity();
+    auto status = libsarus::filesystem::readFile("/proc/self/status");
+    config->commandRun.cpuAffinity = libsarus::process::getCpuAffinity();
 }
 
 void Runtime::setupOCIBundle() {
@@ -71,7 +71,7 @@ static std::string getContainerName(const common::Config::CommandRun& commandRun
     if(commandRun.containerName) {
         return commandRun.containerName.get();
     }
-    return "sarus-container-" + libsarus::generateRandomString(16);
+    return "sarus-container-" + libsarus::string::generateRandom(16);
 }
 
 void Runtime::executeContainer() const {
@@ -79,7 +79,7 @@ void Runtime::executeContainer() const {
     utility::logMessage("Executing " + containerID, libsarus::LogLevel::INFO);
 
     // chdir to bundle
-    libsarus::changeDirectory(bundleDir);
+    libsarus::filesystem::changeDirectory(bundleDir);
 
     // assemble runc args
     auto runcPath = config->json["runcPath"].GetString();
@@ -106,7 +106,7 @@ void Runtime::executeContainer() const {
     };
 
     // execute runc
-    auto status = libsarus::forkExecWait(args,
+    auto status = libsarus::process::forkExecWait(args,
                                        std::function<void()>{std::bind(setParentDeathSignal, getpid())},
                                        std::function<void(pid_t)>{utility::setupSignalProxying});
     if(status != 0) {
@@ -167,13 +167,13 @@ void Runtime::mountImageIntoRootfs() const {
     auto lowerDir = bundleDir / "overlay/rootfs-lower";
     auto upperDir = bundleDir / "overlay/rootfs-upper";
     auto workDir = bundleDir / "overlay/rootfs-work";
-    libsarus::createFoldersIfNecessary(rootfsDir);
-    libsarus::createFoldersIfNecessary(lowerDir);
-    libsarus::createFoldersIfNecessary(upperDir, config->userIdentity.uid, config->userIdentity.gid);
-    libsarus::createFoldersIfNecessary(workDir);
+    libsarus::filesystem::createFoldersIfNecessary(rootfsDir);
+    libsarus::filesystem::createFoldersIfNecessary(lowerDir);
+    libsarus::filesystem::createFoldersIfNecessary(upperDir, config->userIdentity.uid, config->userIdentity.gid);
+    libsarus::filesystem::createFoldersIfNecessary(workDir);
 
-    libsarus::loopMountSquashfs(config->getImageFile(), lowerDir);
-    libsarus::mountOverlayfs(lowerDir, upperDir, workDir, rootfsDir);
+    libsarus::mount::loopMountSquashfs(config->getImageFile(), lowerDir);
+    libsarus::mount::mountOverlayfs(lowerDir, upperDir, workDir, rootfsDir);
 
     utility::logMessage("Successfully mounted image into bundle's rootfs", libsarus::LogLevel::INFO);
 }
@@ -182,7 +182,7 @@ void Runtime::setupDevFilesystem() const {
     utility::logMessage("Setting up /dev filesystem", libsarus::LogLevel::INFO);
 
     const char* ramFilesystemType = config->json["ramFilesystemType"].GetString();
-    libsarus::createFoldersIfNecessary(rootfsDir / "dev");
+    libsarus::filesystem::createFoldersIfNecessary(rootfsDir / "dev");
     auto flags = MS_NOSUID | MS_STRICTATIME;
     auto* options = "mode=755,size=65536k";
     if(mount(NULL, (rootfsDir / "dev").c_str(), ramFilesystemType, flags, options) != 0) {
@@ -200,23 +200,23 @@ void Runtime::copyEtcFilesIntoRootfs() const {
     utility::logMessage("Copying /etc files into rootfs", libsarus::LogLevel::INFO);
     auto prefixDir = boost::filesystem::path{config->json["prefixDir"].GetString()};
 
-    libsarus::copyFile(   "/etc/hosts",
+    libsarus::filesystem::copyFile(   "/etc/hosts",
                         rootfsDir / "etc/hosts",
                         config->userIdentity.uid, config->userIdentity.gid);
 
-    libsarus::copyFile(   "/etc/resolv.conf",
+    libsarus::filesystem::copyFile(   "/etc/resolv.conf",
                         rootfsDir / "etc/resolv.conf",
                         config->userIdentity.uid, config->userIdentity.gid);
 
-    libsarus::copyFile(   prefixDir / "etc/container/nsswitch.conf",
+    libsarus::filesystem::copyFile(   prefixDir / "etc/container/nsswitch.conf",
                         rootfsDir / "etc/nsswitch.conf",
                         config->userIdentity.uid, config->userIdentity.gid);
 
-    libsarus::copyFile(   prefixDir / "etc/passwd",
+    libsarus::filesystem::copyFile(   prefixDir / "etc/passwd",
                         rootfsDir / "etc/passwd",
                         config->userIdentity.uid, config->userIdentity.gid);
 
-    libsarus::copyFile(   prefixDir / "etc/group",
+    libsarus::filesystem::copyFile(   prefixDir / "etc/group",
                         rootfsDir / "etc/group",
                         config->userIdentity.uid, config->userIdentity.gid);
 
@@ -228,8 +228,8 @@ void Runtime::mountInitProgramIntoRootfsIfNecessary() const {
         utility::logMessage("Mounting init program into rootfs", libsarus::LogLevel::INFO);
         auto src = boost::filesystem::path{ config->json["initPath"].GetString() };
         auto dst = rootfsDir / "dev/init";
-        libsarus::createFileIfNecessary(dst);
-        libsarus::bindMount(src, dst);
+        libsarus::filesystem::createFileIfNecessary(dst);
+        libsarus::mount::bindMount(src, dst);
         utility::logMessage("Successfully mounted init program into rootfs", libsarus::LogLevel::INFO);
     }
 }
diff --git a/src/runtime/SecurityChecks.cpp b/src/runtime/SecurityChecks.cpp
index 13a6016b..21f8e1b5 100644
--- a/src/runtime/SecurityChecks.cpp
+++ b/src/runtime/SecurityChecks.cpp
@@ -63,7 +63,7 @@ void SecurityChecks::checkThatBinariesInSarusJsonAreUntamperable() const {
 void SecurityChecks::checkThatPathIsRootOwned(const boost::filesystem::path& path) const {
     uid_t uid; gid_t gid;
     try {
-        std::tie(uid, gid) = libsarus::getOwner(path);
+        std::tie(uid, gid) = libsarus::filesystem::getOwner(path);
     }
     catch(libsarus::Error& e) {
         auto message = boost::format("Failed to check that path %s is untamperable") % path;
diff --git a/src/runtime/Utility.cpp b/src/runtime/Utility.cpp
index cd2bf9e0..397d67b6 100644
--- a/src/runtime/Utility.cpp
+++ b/src/runtime/Utility.cpp
@@ -137,7 +137,7 @@ std::vector<std::unique_ptr<libsarus::Mount>> generatePMIxMounts(std::shared_ptr
         boost::smatch matches;
         if (boost::regex_match(slurmMpiType->second, matches, boost::regex{"^pmix*"})) {
             try {
-                auto slurmConfig = libsarus::executeCommand("scontrol show config");
+                auto slurmConfig = libsarus::process::executeCommand("scontrol show config");
                 auto slurmJobId  = hostEnvironment.at("SLURM_JOB_ID");
                 auto slurmJobUid = hostEnvironment.at("SLURM_JOB_UID");
                 auto slurmStepId = hostEnvironment.at("SLURM_STEP_ID");
diff --git a/src/runtime/test/test_FileDescriptorHandler.cpp b/src/runtime/test/test_FileDescriptorHandler.cpp
index df598f98..e25aaadb 100644
--- a/src/runtime/test/test_FileDescriptorHandler.cpp
+++ b/src/runtime/test/test_FileDescriptorHandler.cpp
@@ -26,7 +26,7 @@ TEST_GROUP(RuntimeTestGroup) {
 std::vector<int> openFiles(const std::vector<boost::filesystem::path>& testFiles) {
     auto testFDs = std::vector<int>{};
     for (const auto& file : testFiles) {
-        libsarus::createFileIfNecessary(file);
+        libsarus::filesystem::createFileIfNecessary(file);
         // open files with Linux functions, in order to get file descriptors
         testFDs.push_back(open(file.c_str(), O_RDONLY));
     }
diff --git a/src/runtime/test/test_OCIBundleConfig.cpp b/src/runtime/test/test_OCIBundleConfig.cpp
index 2b0aa09f..210dbbbd 100644
--- a/src/runtime/test/test_OCIBundleConfig.cpp
+++ b/src/runtime/test/test_OCIBundleConfig.cpp
@@ -107,7 +107,7 @@ static void setupTestConfig(std::shared_ptr<common::Config>& config) {
 
 static libsarus::PathRAII createTestBundle(const std::shared_ptr<common::Config>& config) {
     auto bundleDir = libsarus::PathRAII{boost::filesystem::path{config->json["OCIBundleDir"].GetString()}};
-    libsarus::createFoldersIfNecessary(bundleDir.getPath());
+    libsarus::filesystem::createFoldersIfNecessary(bundleDir.getPath());
     return bundleDir;
 }
 
@@ -134,7 +134,7 @@ static void sortJsonEnvironmentArray(rj::Document& json) {
 
 static rj::Document getExpectedJson() {
     auto expectedConfigFile = boost::filesystem::path{__FILE__}.parent_path() / "expected_config.json";
-    auto expectedJson = libsarus::readJSON(expectedConfigFile);
+    auto expectedJson = libsarus::json::read(expectedConfigFile);
     expectedJson["process"]["user"]["uid"] = int(getuid());
     expectedJson["process"]["user"]["gid"] = int(getgid());
     sortJsonEnvironmentArray(expectedJson);
@@ -224,7 +224,7 @@ TEST(OCIBundleConfigTestGroup, OCIBundleConfig) {
     // check existence and permissions of bundle's config.json
     auto actualConfigFile = bundleDir.getPath() / "config.json";
     checkExistenceAndPermissions(actualConfigFile);
-    auto actualJson = libsarus::readJSON(actualConfigFile);
+    auto actualJson = libsarus::json::read(actualConfigFile);
     sortJsonEnvironmentArray(actualJson);
 
     auto expectedJson = getExpectedJson();
@@ -252,7 +252,7 @@ IGNORE_TEST(OCIBundleConfigTestGroup, allowed_devices) {
     // check existence and permissions of bundle's config.json
     auto actualConfigFile = bundleDir.getPath() / "config.json";
     checkExistenceAndPermissions(actualConfigFile);
-    auto actualJson = libsarus::readJSON(actualConfigFile);
+    auto actualJson = libsarus::json::read(actualConfigFile);
     sortJsonEnvironmentArray(actualJson);
 
     auto expectedJson = getExpectedJson();
diff --git a/src/runtime/test/test_OCIHooks.cpp b/src/runtime/test/test_OCIHooks.cpp
index 6ff901dd..fd9eefb5 100644
--- a/src/runtime/test/test_OCIHooks.cpp
+++ b/src/runtime/test/test_OCIHooks.cpp
@@ -24,7 +24,7 @@ namespace test {
 namespace rj = rapidjson;
 
 TEST_GROUP(OCIHooksTestGroup) {
-    libsarus::PathRAII testDirRAII = libsarus::PathRAII{ libsarus::makeUniquePathWithRandomSuffix("test_oci_hook") };
+    libsarus::PathRAII testDirRAII = libsarus::PathRAII{ libsarus::filesystem::makeUniquePathWithRandomSuffix("test_oci_hook") };
     boost::filesystem::path jsonFile = testDirRAII.getPath() / "hook.json";
     boost::filesystem::path schemaFile = boost::filesystem::path{__FILE__}
         .parent_path()
@@ -34,7 +34,7 @@ TEST_GROUP(OCIHooksTestGroup) {
 };
 
 TEST(OCIHooksTestGroup, create_hook_with_schema_incompatibility) {
-    libsarus::createFoldersIfNecessary(jsonFile.parent_path());
+    libsarus::filesystem::createFoldersIfNecessary(jsonFile.parent_path());
 
     // missing "stages" property
     {
@@ -73,7 +73,7 @@ TEST(OCIHooksTestGroup, create_hook_with_schema_incompatibility) {
 }
 
 TEST(OCIHooksTestGroup, create_hook_with_bad_version) {
-    libsarus::createFoldersIfNecessary(jsonFile.parent_path());
+    libsarus::filesystem::createFoldersIfNecessary(jsonFile.parent_path());
     auto os = std::ofstream(jsonFile.c_str());
     os << R"(
     {
@@ -95,7 +95,7 @@ TEST(OCIHooksTestGroup, create_hook_with_bad_version) {
 // Hopefully this will get fixed in some future release of RapidJson,
 // then this test will fail and we will know that the fix occurred :)
 TEST(OCIHooksTestGroup, create_hook_with_unsupported_regex) {
-    libsarus::createFoldersIfNecessary(jsonFile.parent_path());
+    libsarus::filesystem::createFoldersIfNecessary(jsonFile.parent_path());
     auto os = std::ofstream(jsonFile.c_str());
     os << R"(
     {
@@ -115,7 +115,7 @@ TEST(OCIHooksTestGroup, create_hook_with_unsupported_regex) {
 }
 
 TEST(OCIHooksTestGroup, create_hook_and_check_members) {
-    libsarus::createFoldersIfNecessary(jsonFile.parent_path());
+    libsarus::filesystem::createFoldersIfNecessary(jsonFile.parent_path());
     auto os = std::ofstream(jsonFile.c_str());
     os << R"(
     {
@@ -166,7 +166,7 @@ TEST(OCIHooksTestGroup, create_hook_and_check_members) {
 }
 
 TEST(OCIHooksTestGroup, create_hook_and_check_activation) {
-    libsarus::createFoldersIfNecessary(jsonFile.parent_path());
+    libsarus::filesystem::createFoldersIfNecessary(jsonFile.parent_path());
     auto os = std::ofstream(jsonFile.c_str());
     os << R"(
     {
diff --git a/src/runtime/test/test_Runtime.cpp b/src/runtime/test/test_Runtime.cpp
index 1de630b1..391e34af 100644
--- a/src/runtime/test/test_Runtime.cpp
+++ b/src/runtime/test/test_Runtime.cpp
@@ -68,14 +68,14 @@ IGNORE_TEST(RuntimeTestGroup, setupOCIBundle) {
     auto prefixDir = boost::filesystem::path{config->json["prefixDir"].GetString()};
 
     // create test folders / files
-    libsarus::createFoldersIfNecessary(bundleDir);
-    libsarus::createFileIfNecessary(prefixDir / "etc/container/nsswitch.conf");
-    libsarus::createFileIfNecessary(prefixDir / "etc/passwd");
-    libsarus::createFileIfNecessary(prefixDir / "etc/group");
+    libsarus::filesystem::createFoldersIfNecessary(bundleDir);
+    libsarus::filesystem::createFileIfNecessary(prefixDir / "etc/container/nsswitch.conf");
+    libsarus::filesystem::createFileIfNecessary(prefixDir / "etc/passwd");
+    libsarus::filesystem::createFileIfNecessary(prefixDir / "etc/group");
 
     // create dummy metadata file in image repo
     auto metadataFileRAII = libsarus::PathRAII{boost::filesystem::path(config->directories.images / (config->imageReference.getUniqueKey() + ".meta"))};
-    libsarus::createFileIfNecessary(metadataFileRAII.getPath());
+    libsarus::filesystem::createFileIfNecessary(metadataFileRAII.getPath());
     std::ofstream metadataStream(metadataFileRAII.getPath().c_str());
     metadataStream << "{}";
     metadataStream.close();
@@ -101,7 +101,7 @@ IGNORE_TEST(RuntimeTestGroup, setupOCIBundle) {
 
     // check that rootfs is writable
     auto fileToCreate = rootfsDir / "file_to_create";
-    libsarus::executeCommand("touch " + fileToCreate.string());
+    libsarus::process::executeCommand("touch " + fileToCreate.string());
 
     // check that bundle's config file exists
     CHECK(boost::filesystem::exists(bundleDir / "config.json"));
diff --git a/src/runtime/test/test_SecurityChecks.cpp b/src/runtime/test/test_SecurityChecks.cpp
index 94267782..a600bc24 100644
--- a/src/runtime/test/test_SecurityChecks.cpp
+++ b/src/runtime/test/test_SecurityChecks.cpp
@@ -30,9 +30,9 @@ TEST(SecurityChecksTestGroup, checkThatPathIsUntamperable) {
     std::tuple<uid_t, gid_t> rootIds{0, 0};
     std::tuple<uid_t, gid_t> nonRootIds{1000, 1000};
 
-    auto testPathRAII = libsarus::PathRAII{libsarus::makeUniquePathWithRandomSuffix("/sarus-securitychecks-test")};
+    auto testPathRAII = libsarus::PathRAII{libsarus::filesystem::makeUniquePathWithRandomSuffix("/sarus-securitychecks-test")};
     const auto& testDirectory = testPathRAII.getPath();
-    libsarus::createFoldersIfNecessary(testDirectory, std::get<0>(rootIds), std::get<1>(rootIds));
+    libsarus::filesystem::createFoldersIfNecessary(testDirectory, std::get<0>(rootIds), std::get<1>(rootIds));
 
     // non-existent file
     {
@@ -42,24 +42,24 @@ TEST(SecurityChecksTestGroup, checkThatPathIsUntamperable) {
     // untamperable file
     {
         auto path = testDirectory / "untamperable-file";
-        libsarus::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
         securityChecks.checkThatPathIsUntamperable(path);
     }
     {
         auto path = testDirectory / "untamperable-file-gidx";
-        libsarus::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(nonRootIds));
         securityChecks.checkThatPathIsUntamperable(path);
     }
 
     // untamperable folder
     {
         auto path = testDirectory / "untamperable-subfolder";
-        libsarus::createFoldersIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
         securityChecks.checkThatPathIsUntamperable(path);
     }
     {
         auto path = testDirectory / "untamperable-subfolder-gidx";
-        libsarus::createFoldersIfNecessary(path, std::get<0>(rootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFoldersIfNecessary(path, std::get<0>(rootIds), std::get<1>(nonRootIds));
         securityChecks.checkThatPathIsUntamperable(path);
     }
 
@@ -67,15 +67,15 @@ TEST(SecurityChecksTestGroup, checkThatPathIsUntamperable) {
     {
         auto parent = testDirectory / "tamperable-parent-folder";
         auto path = parent / "file";
-        libsarus::createFoldersIfNecessary(parent, std::get<0>(nonRootIds), std::get<1>(nonRootIds));
-        libsarus::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(parent, std::get<0>(nonRootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(path));
     }
 
     // writability
     {
         auto path = testDirectory / "group-writable-file";
-        libsarus::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFileIfNecessary(path, std::get<0>(rootIds), std::get<1>(rootIds));
 
         // ok permissions
         boost::filesystem::permissions(path, boost::filesystem::owner_all
@@ -100,18 +100,18 @@ TEST(SecurityChecksTestGroup, checkThatPathIsUntamperable) {
     {
         auto subdir0 = libsarus::PathRAII{testDirectory / "dir0"};
         const auto& subdir1 = subdir0.getPath() / "dir1";
-        libsarus::createFoldersIfNecessary(subdir1, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(subdir1, std::get<0>(rootIds), std::get<1>(rootIds));
         securityChecks.checkThatPathIsUntamperable(subdir0.getPath());
         securityChecks.checkThatPathIsUntamperable(subdir1);
 
         // tamperable subdirectory
         auto tamperableSubdir = libsarus::PathRAII{subdir1 / "tamperable-dir"};
-        libsarus::createFoldersIfNecessary(tamperableSubdir.getPath(), std::get<0>(nonRootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFoldersIfNecessary(tamperableSubdir.getPath(), std::get<0>(nonRootIds), std::get<1>(nonRootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(subdir0.getPath()));
 
         // tamperable file
         auto file = subdir1 / "tamperable-file";
-        libsarus::createFileIfNecessary(file, std::get<0>(nonRootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFileIfNecessary(file, std::get<0>(nonRootIds), std::get<1>(nonRootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(subdir0.getPath()));
     }
 
@@ -119,27 +119,27 @@ TEST(SecurityChecksTestGroup, checkThatPathIsUntamperable) {
     {
         auto path = libsarus::PathRAII{testDirectory / "no" / "problem"};
         const auto& untamperable = path.getPath();
-        libsarus::createFoldersIfNecessary(untamperable, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(untamperable, std::get<0>(rootIds), std::get<1>(rootIds));
         securityChecks.checkThatPathIsUntamperable(untamperable);
 
         auto untamperable2 = untamperable / "still" / "ok";
-        libsarus::createFoldersIfNecessary(untamperable2, std::get<0>(rootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFoldersIfNecessary(untamperable2, std::get<0>(rootIds), std::get<1>(nonRootIds));
         securityChecks.checkThatPathIsUntamperable(untamperable2);
 
         auto tamperable = untamperable / "ouch";
-        libsarus::createFoldersIfNecessary(tamperable, std::get<0>(nonRootIds), std::get<1>(nonRootIds));
+        libsarus::filesystem::createFoldersIfNecessary(tamperable, std::get<0>(nonRootIds), std::get<1>(nonRootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(tamperable));
 
         auto tamperable2 = untamperable / "duh";
-        libsarus::createFoldersIfNecessary(tamperable2, std::get<0>(nonRootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(tamperable2, std::get<0>(nonRootIds), std::get<1>(rootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(tamperable2));
 
         auto broken = tamperable / "tamperable" / "in" / "path";
-        libsarus::createFoldersIfNecessary(broken, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(broken, std::get<0>(rootIds), std::get<1>(rootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(broken));
 
         auto broken2 = tamperable2 / "tamperable" / "in" / "path";
-        libsarus::createFoldersIfNecessary(broken2, std::get<0>(rootIds), std::get<1>(rootIds));
+        libsarus::filesystem::createFoldersIfNecessary(broken2, std::get<0>(rootIds), std::get<1>(rootIds));
         CHECK_THROWS(libsarus::Error, securityChecks.checkThatPathIsUntamperable(broken2));
     }
 }
diff --git a/src/test_utility/Misc.hpp b/src/test_utility/Misc.hpp
index d1a92387..28d61176 100644
--- a/src/test_utility/Misc.hpp
+++ b/src/test_utility/Misc.hpp
@@ -24,7 +24,7 @@ namespace test_utility {
 namespace misc {
 
 std::tuple<uid_t, gid_t> getNonRootUserIds() {
-    auto out = libsarus::executeCommand("getent passwd");
+    auto out = libsarus::process::executeCommand("getent passwd");
     std::stringstream ss{out};
     auto passwd = libsarus::PasswdDB{ss};
 
diff --git a/src/test_utility/config.cpp b/src/test_utility/config.cpp
index f3e4154a..41e53d1b 100644
--- a/src/test_utility/config.cpp
+++ b/src/test_utility/config.cpp
@@ -45,11 +45,11 @@ ConfigRAII::~ConfigRAII() {
 static void populateJSON(rj::Document& document) {
     auto& allocator = document.GetAllocator();
 
-    auto prefixDir = libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::absolute("sarus-test-prefix-dir"));
+    auto prefixDir = libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::absolute("sarus-test-prefix-dir"));
     auto hooksDir = prefixDir / "etc/hooks.d";
     auto bundleDir = prefixDir / "var/OCIBundle";
-    auto localRepositoryBaseDir = libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::absolute("sarus-test-localRepositoryBaseDir"));
-    auto centralizedRepositoryDir = libsarus::makeUniquePathWithRandomSuffix(boost::filesystem::absolute("sarus-test-centralizedRepositoryDir"));
+    auto localRepositoryBaseDir = libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::absolute("sarus-test-localRepositoryBaseDir"));
+    auto centralizedRepositoryDir = libsarus::filesystem::makeUniquePathWithRandomSuffix(boost::filesystem::absolute("sarus-test-centralizedRepositoryDir"));
 
     document.AddMember( "securityChecks",
                         false,
@@ -153,7 +153,7 @@ static void populateJSON(rj::Document& document) {
 }
 
 void createOCIHook(const boost::filesystem::path& hooksDir) {
-    libsarus::createFoldersIfNecessary(hooksDir);
+    libsarus::filesystem::createFoldersIfNecessary(hooksDir);
 
     auto hook = hooksDir / "test-hook.json";
     auto os = std::ofstream{ hook.c_str() };
@@ -186,15 +186,15 @@ ConfigRAII makeConfig() {
     auto prefixDir = boost::filesystem::path{ raii.config->json["prefixDir"].GetString() };
 
     // passwd + group
-    libsarus::createFoldersIfNecessary(prefixDir / "etc");
-    libsarus::executeCommand("getent passwd >" + prefixDir.string() + "/etc/passwd");
-    libsarus::executeCommand("getent group >" + prefixDir.string() + "/etc/group");
+    libsarus::filesystem::createFoldersIfNecessary(prefixDir / "etc");
+    libsarus::process::executeCommand("getent passwd >" + prefixDir.string() + "/etc/passwd");
+    libsarus::process::executeCommand("getent group >" + prefixDir.string() + "/etc/group");
 
      // JSON schemas
     auto repoRootDir = boost::filesystem::path{__FILE__}.parent_path().parent_path().parent_path();
-    libsarus::copyFile(repoRootDir / "etc/definitions.schema.json", prefixDir / "etc/definitions.schema.json");
-    libsarus::copyFile(repoRootDir / "etc/sarus.schema.json", prefixDir / "etc/sarus.schema.json");
-    libsarus::copyFile(repoRootDir / "etc/hook.schema.json", prefixDir / "etc/hook.schema.json");
+    libsarus::filesystem::copyFile(repoRootDir / "etc/definitions.schema.json", prefixDir / "etc/definitions.schema.json");
+    libsarus::filesystem::copyFile(repoRootDir / "etc/sarus.schema.json", prefixDir / "etc/sarus.schema.json");
+    libsarus::filesystem::copyFile(repoRootDir / "etc/hook.schema.json", prefixDir / "etc/hook.schema.json");
 
     // hooks
     createOCIHook(raii.config->json["hooksDir"].GetString());
@@ -204,7 +204,7 @@ ConfigRAII makeConfig() {
 
     // image + metadata
     raii.config->imageReference = common::ImageReference{"test", "test", "test", "test_image"};
-    libsarus::createFileIfNecessary(raii.config->getMetadataFileOfImage());
+    libsarus::filesystem::createFileIfNecessary(raii.config->getMetadataFileOfImage());
     std::ofstream metadataStream(raii.config->getMetadataFileOfImage().c_str());
     metadataStream << R"(
     {
diff --git a/src/test_utility/filesystem.cpp b/src/test_utility/filesystem.cpp
index e4213b2f..4d4aa85c 100644
--- a/src/test_utility/filesystem.cpp
+++ b/src/test_utility/filesystem.cpp
@@ -163,29 +163,29 @@ void createBlockDeviceFile(const boost::filesystem::path& path, const int majorI
 }
 
 void create_test_directory_tree(const std::string& dir) {
-    libsarus::executeCommand("mkdir -p " + dir);
-    libsarus::executeCommand("touch " + dir + "/a.txt");
-    libsarus::executeCommand("touch " + dir + "/b.md");
-    libsarus::executeCommand("touch " + dir + "/c.h");
-    libsarus::executeCommand("chmod 755 " + dir + "/a.txt");
-    libsarus::executeCommand("chmod 644 " + dir + "/b.md");
-    libsarus::executeCommand("chmod 700 " + dir + "/c.h");
-
-    libsarus::executeCommand("mkdir -p " + dir + "/sub1");
-    libsarus::executeCommand("touch " + dir + "/sub1/d.cpp");
-    libsarus::executeCommand("touch " + dir + "/sub1/e.so");
-    libsarus::executeCommand("chmod 600 " + dir + "/sub1/d.cpp");
-    libsarus::executeCommand("chmod 775 " + dir + "/sub1/e.so");
-
-    libsarus::executeCommand("mkdir -p " + dir + "/sub1/ssub11");
-    libsarus::executeCommand("touch " + dir + "/sub1/ssub11/g.pdf");
-    libsarus::executeCommand("touch " + dir + "/sub1/ssub11/h.py");
-    libsarus::executeCommand("chmod 665 " + dir + "/sub1/ssub11/g.pdf");
-    libsarus::executeCommand("chmod 777 " + dir + "/sub1/ssub11/h.py");
-
-    libsarus::executeCommand("mkdir -p " + dir + "/sub2");
-    libsarus::executeCommand("touch " + dir + "/sub2/f.a");
-    libsarus::executeCommand("chmod 666 " + dir + "/sub2/f.a");
+    libsarus::process::executeCommand("mkdir -p " + dir);
+    libsarus::process::executeCommand("touch " + dir + "/a.txt");
+    libsarus::process::executeCommand("touch " + dir + "/b.md");
+    libsarus::process::executeCommand("touch " + dir + "/c.h");
+    libsarus::process::executeCommand("chmod 755 " + dir + "/a.txt");
+    libsarus::process::executeCommand("chmod 644 " + dir + "/b.md");
+    libsarus::process::executeCommand("chmod 700 " + dir + "/c.h");
+
+    libsarus::process::executeCommand("mkdir -p " + dir + "/sub1");
+    libsarus::process::executeCommand("touch " + dir + "/sub1/d.cpp");
+    libsarus::process::executeCommand("touch " + dir + "/sub1/e.so");
+    libsarus::process::executeCommand("chmod 600 " + dir + "/sub1/d.cpp");
+    libsarus::process::executeCommand("chmod 775 " + dir + "/sub1/e.so");
+
+    libsarus::process::executeCommand("mkdir -p " + dir + "/sub1/ssub11");
+    libsarus::process::executeCommand("touch " + dir + "/sub1/ssub11/g.pdf");
+    libsarus::process::executeCommand("touch " + dir + "/sub1/ssub11/h.py");
+    libsarus::process::executeCommand("chmod 665 " + dir + "/sub1/ssub11/g.pdf");
+    libsarus::process::executeCommand("chmod 777 " + dir + "/sub1/ssub11/h.py");
+
+    libsarus::process::executeCommand("mkdir -p " + dir + "/sub2");
+    libsarus::process::executeCommand("touch " + dir + "/sub2/f.a");
+    libsarus::process::executeCommand("chmod 666 " + dir + "/sub2/f.a");
 }
 
 } // filesystem