diff --git a/application/CMakeLists.txt b/application/CMakeLists.txt
index 0f6792d3d2..4dec6867b0 100644
--- a/application/CMakeLists.txt
+++ b/application/CMakeLists.txt
@@ -10,10 +10,11 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/F3DConfig.h.in"
     "${CMAKE_CURRENT_BINARY_DIR}/F3DConfig.h")
 
 set(F3D_SOURCE_FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/F3DIcon.cxx
   ${CMAKE_CURRENT_SOURCE_DIR}/F3DColorMapTools.cxx
   ${CMAKE_CURRENT_SOURCE_DIR}/F3DConfigFileTools.cxx
-  ${CMAKE_CURRENT_BINARY_DIR}/F3DIcon.cxx
-  ${CMAKE_CURRENT_SOURCE_DIR}/F3DOptionsParser.cxx
+  ${CMAKE_CURRENT_SOURCE_DIR}/F3DOptionsTools.cxx
+  ${CMAKE_CURRENT_SOURCE_DIR}/F3DPluginsTools.cxx
   ${CMAKE_CURRENT_SOURCE_DIR}/F3DStarter.cxx
   ${CMAKE_CURRENT_SOURCE_DIR}/F3DSystemTools.cxx
   ${CMAKE_CURRENT_SOURCE_DIR}/main.cxx
@@ -86,6 +87,10 @@ set(f3d_compile_options_private "")
 set(f3d_compile_options_public "")
 set(f3d_link_options_public "")
 
+# This is required to avoid cxxopts
+# splitting input positional option by commas
+target_compile_definitions(f3d PRIVATE "CXXOPTS_VECTOR_DELIMITER='\\0'")
+
 # Headless EGL build
 if (VTK_OPENGL_HAS_EGL)
   target_compile_definitions(f3d PRIVATE F3D_HEADLESS_BUILD)
diff --git a/application/F3DColorMapTools.cxx b/application/F3DColorMapTools.cxx
index 0533f3246b..57961f65b2 100644
--- a/application/F3DColorMapTools.cxx
+++ b/application/F3DColorMapTools.cxx
@@ -1,6 +1,6 @@
 #include "F3DColorMapTools.h"
 
-#include "F3DConfigFileTools.h"
+#include "F3DSystemTools.h"
 
 #include "image.h"
 #include "log.h"
@@ -23,16 +23,14 @@ std::string Find(const std::string& str)
     }
   }
 
-  std::vector<fs::path> dirsToCheck;
-  dirsToCheck.emplace_back(F3DConfigFileTools::GetUserConfigFileDirectory() / "colormaps");
+  std::vector<fs::path> dirsToCheck{ F3DSystemTools::GetUserConfigFileDirectory() / "colormaps",
 #ifdef __APPLE__
-  dirsToCheck.emplace_back("/usr/local/etc/f3d/colormaps");
+    "/usr/local/etc/f3d/colormaps",
 #endif
 #ifdef __linux__
-  dirsToCheck.emplace_back("/etc/f3d/colormaps");
-  dirsToCheck.emplace_back("/usr/share/f3d/colormaps");
+    "/etc/f3d/colormaps", "/usr/share/f3d/colormaps",
 #endif
-  dirsToCheck.emplace_back(F3DConfigFileTools::GetBinaryResourceDirectory() / "colormaps");
+    F3DSystemTools::GetBinaryResourceDirectory() / "colormaps" };
 
   for (const fs::path& dir : dirsToCheck)
   {
diff --git a/application/F3DConfigFileTools.cxx b/application/F3DConfigFileTools.cxx
index 875ae7a0fc..12cf787b50 100644
--- a/application/F3DConfigFileTools.cxx
+++ b/application/F3DConfigFileTools.cxx
@@ -3,78 +3,24 @@
 #include "F3DConfig.h"
 #include "F3DSystemTools.h"
 
+#include "nlohmann/json.hpp"
+
 #include "log.h"
 
-#include <cstring>
 #include <filesystem>
+#include <fstream>
+#include <set>
 #include <vector>
 
 namespace fs = std::filesystem;
 
-//----------------------------------------------------------------------------
-fs::path F3DConfigFileTools::GetUserConfigFileDirectory()
-{
-  std::string applicationName = "f3d";
-  fs::path dirPath;
-#if defined(_WIN32)
-  const char* appData = std::getenv("APPDATA");
-  if (!appData)
-  {
-    return {};
-  }
-  dirPath = fs::path(appData);
-#else
-  // Implementing XDG specifications
-  const char* xdgConfigHome = std::getenv("XDG_CONFIG_HOME");
-  if (xdgConfigHome && strlen(xdgConfigHome) > 0)
-  {
-    dirPath = fs::path(xdgConfigHome);
-  }
-  else
-  {
-    const char* home = std::getenv("HOME");
-    if (!home || strlen(home) == 0)
-    {
-      return {};
-    }
-    dirPath = fs::path(home);
-    dirPath /= ".config";
-  }
-#endif
-  dirPath /= applicationName;
-  return dirPath;
-}
-
-//----------------------------------------------------------------------------
-fs::path F3DConfigFileTools::GetBinaryResourceDirectory()
+namespace
 {
-  fs::path dirPath;
-  try
-  {
-    dirPath = F3DSystemTools::GetApplicationPath();
-
-    // transform path to exe to path to install
-    // /install/bin/f3d -> /install
-    dirPath = fs::canonical(dirPath).parent_path().parent_path();
-
-    // Add binary specific paths
-#if F3D_MACOS_BUNDLE
-    dirPath /= "Resources";
-#else
-    dirPath /= "share/f3d";
-#endif
-  }
-  catch (const fs::filesystem_error&)
-  {
-    f3d::log::debug("Cannot recover binary configuration file directory: ", dirPath.string());
-    return {};
-  }
-
-  return dirPath;
-}
-
 //----------------------------------------------------------------------------
-std::vector<fs::path> F3DConfigFileTools::GetConfigPaths(const std::string& configSearch)
+/**
+ * Recover a OS-specific vector of potential config file directories
+ */
+std::vector<fs::path> GetConfigPaths(const std::string& configSearch)
 {
   std::vector<std::filesystem::path> paths;
 
@@ -88,8 +34,8 @@ std::vector<fs::path> F3DConfigFileTools::GetConfigPaths(const std::string& conf
     "/etc/f3d",
     "/usr/share/f3d/configs",
 #endif
-    F3DConfigFileTools::GetBinaryResourceDirectory() / "configs",
-    F3DConfigFileTools::GetUserConfigFileDirectory(),
+    F3DSystemTools::GetBinaryResourceDirectory() / "configs",
+    F3DSystemTools::GetUserConfigFileDirectory(),
   };
 
   for (const fs::path& dir : dirsToCheck)
@@ -131,3 +77,133 @@ std::vector<fs::path> F3DConfigFileTools::GetConfigPaths(const std::string& conf
 
   return paths;
 }
+}
+
+//----------------------------------------------------------------------------
+F3DOptionsTools::OptionsEntries F3DConfigFileTools::ReadConfigFiles(const std::string& userConfig)
+{
+  // Default config directory name
+  std::string configSearch = "config";
+  if (!userConfig.empty())
+  {
+    // Check if provided userConfig is a full path
+    auto path = fs::path(userConfig);
+    if (path.stem() == userConfig || path.filename() == userConfig)
+    {
+      // Only a stem or a filename, use provided userConfig as configSearch
+      configSearch = userConfig;
+    }
+    else
+    {
+      // Assume its a full path and use as is, not searching for config files
+      configSearch = "";
+    }
+  }
+
+  // Recover config paths to search for config files
+  std::vector<fs::path> configPaths;
+  if (!configSearch.empty())
+  {
+    for (const auto& path : ::GetConfigPaths(configSearch))
+    {
+      configPaths.emplace_back(path);
+    }
+  }
+  else
+  {
+    configPaths.emplace_back(userConfig);
+  }
+
+  // Recover actual individual config file paths
+  std::set<fs::path> actualConfigFilePaths;
+  for (auto configPath : configPaths)
+  {
+    // Recover an absolute canonical path to config file
+    try
+    {
+      configPath = fs::canonical(fs::path(configPath)).string();
+    }
+    catch (const fs::filesystem_error&)
+    {
+      f3d::log::error("Configuration file does not exist: ", configPath.string(), " , ignoring it");
+      continue;
+    }
+
+    // Recover all config files if needed in directories
+    if (fs::is_directory(configPath))
+    {
+      f3d::log::debug("Using config directory ", configPath.string());
+      for (auto& entry : std::filesystem::directory_iterator(configPath))
+      {
+        actualConfigFilePaths.emplace(entry);
+      }
+    }
+    else
+    {
+      f3d::log::debug("Using config file ", configPath.string());
+      actualConfigFilePaths.emplace(configPath);
+    }
+  }
+
+  // If we used a configSearch but did not find any, warn the user
+  if (!configSearch.empty() && actualConfigFilePaths.empty())
+  {
+    f3d::log::warn("Configuration file for \"", configSearch, "\" could not be found");
+  }
+
+  // Read config files
+  F3DOptionsTools::OptionsEntries confEntries;
+  for (const auto& configFilePath : actualConfigFilePaths)
+  {
+    std::ifstream file(configFilePath);
+    if (!file.is_open())
+    {
+      // Cannot be tested
+      f3d::log::warn(
+        "Unable to open the configuration file: ", configFilePath.string(), " , ignoring it");
+      continue;
+    }
+
+    // Read the file into a json
+    nlohmann::ordered_json json;
+    try
+    {
+      file >> json;
+    }
+    catch (const std::exception& ex)
+    {
+      f3d::log::error(
+        "Unable to parse the configuration file ", configFilePath.string(), " , ignoring it");
+      f3d::log::error(ex.what());
+      continue;
+    }
+
+    // For each config "pattern"
+    for (const auto& configBlock : json.items())
+    {
+      // Add each config entry into an option dict
+      F3DOptionsTools::OptionsDict entry;
+      for (const auto& item : configBlock.value().items())
+      {
+        if (item.value().is_number() || item.value().is_boolean())
+        {
+          entry[item.key()] = nlohmann::to_string(item.value());
+        }
+        else if (item.value().is_string())
+        {
+          entry[item.key()] = item.value().get<std::string>();
+        }
+        else
+        {
+          f3d::log::error(item.key(), " from ", configFilePath.string(),
+            " must be a string, a boolean or a number, ignoring entry");
+          continue;
+        }
+      }
+
+      // Emplace the option dict for that pattern into the config entries vector
+      confEntries.emplace_back(entry, configFilePath, configBlock.key());
+    }
+  }
+  return confEntries;
+}
diff --git a/application/F3DConfigFileTools.h b/application/F3DConfigFileTools.h
index 2991712a76..d166032a8b 100644
--- a/application/F3DConfigFileTools.h
+++ b/application/F3DConfigFileTools.h
@@ -1,21 +1,20 @@
+#ifndef F3DConfigFileTools_h
+#define F3DConfigFileTools_h
 /**
  * @class   F3DConfigFileTools
- * @brief   A namespace to recover path to config file and related directories, cross platform
- *
+ * @brief   A namespace to parse config files
  */
+#include "F3DOptionsTools.h"
 
-#ifndef F3DConfigFileTools_h
-#define F3DConfigFileTools_h
-
-#include <filesystem>
 #include <string>
-#include <vector>
 
 namespace F3DConfigFileTools
 {
-std::filesystem::path GetUserConfigFileDirectory();
-std::filesystem::path GetBinaryResourceDirectory();
-std::vector<std::filesystem::path> GetConfigPaths(const std::string& configSearch);
+/**
+ * Read config files using userConfig if any, return an optionEntries
+ * containing ordered optionDict.
+ */
+F3DOptionsTools::OptionsEntries ReadConfigFiles(const std::string& userConfig);
 }
 
 #endif
diff --git a/application/F3DOptionsParser.cxx b/application/F3DOptionsParser.cxx
deleted file mode 100644
index 7fe5986d86..0000000000
--- a/application/F3DOptionsParser.cxx
+++ /dev/null
@@ -1,841 +0,0 @@
-#include "F3DOptionsParser.h"
-
-#include "F3DConfig.h"
-#include "F3DConfigFileTools.h"
-#include "F3DException.h"
-#include "F3DSystemTools.h"
-
-#include "cxxopts.hpp"
-#include "nlohmann/json.hpp"
-
-#include "engine.h"
-#include "export.h"
-#include "interactor.h"
-#include "log.h"
-#include "options.h"
-#include "utils.h"
-
-#include <filesystem>
-#include <fstream>
-#include <iomanip>
-#include <regex>
-#include <set>
-#include <sstream>
-#include <utility>
-#include <vector>
-
-namespace fs = std::filesystem;
-
-//----------------------------------------------------------------------------
-class ConfigurationOptions
-{
-public:
-  ConfigurationOptions(int argc, char** argv)
-    : Argc(argc)
-    , Argv(argv)
-  {
-    this->ExecutableName = argc > 0 && argv[0][0] ? fs::path(argv[0]).filename().string() : "f3d";
-  }
-
-  void GetOptions(F3DAppOptions& appOptions, f3d::options& options,
-    std::vector<std::string>& inputs, const std::string& filePathForConfigBlock = "",
-    bool allOptionsInitialized = false, bool parseCommandLine = true);
-  bool InitializeDictionaryFromConfigFile(const std::string& userConfigFile);
-  void LoadPlugins(const F3DAppOptions& appOptions) const;
-  std::vector<std::string> GetPluginSearchPaths() const;
-
-  enum class HasDefault : bool
-  {
-    YES = true,
-    NO = false
-  };
-
-  enum class MayHaveConfig : bool
-  {
-    YES = true,
-    NO = false
-  };
-
-  enum class HasImplicitValue : bool
-  {
-    YES = true,
-    NO = false
-  };
-
-protected:
-  bool GetOptionConfig(const std::string& option, std::string& configValue) const
-  {
-    auto localIt = this->CurrentFileConfig.find(option);
-    if (localIt != this->CurrentFileConfig.end())
-    {
-      configValue = localIt->second;
-      return true;
-    }
-    return false;
-  }
-
-  template<class T>
-  static std::string ToString(T currValue)
-  {
-    std::stringstream ss;
-    ss << currValue;
-    return ss.str();
-  }
-
-  static std::string ToString(bool currValue)
-  {
-    return currValue ? "true" : "false";
-  }
-
-  template<class T>
-  static std::string ToString(const std::vector<T>& currValue)
-  {
-    std::stringstream ss;
-    for (size_t i = 0; i < currValue.size(); i++)
-    {
-      ss << currValue[i];
-      if (i != currValue.size() - 1)
-      {
-        ss << ",";
-      }
-    }
-    return ss.str();
-  }
-
-  std::string CollapseName(const std::string& longName, const std::string& shortName) const
-  {
-    std::stringstream ss;
-    if (shortName != "")
-    {
-      ss << shortName << ",";
-    }
-    ss << longName;
-    return ss.str();
-  }
-
-  void DeclareOption(cxxopts::OptionAdder& group, const std::string& longName,
-    const std::string& shortName, const std::string& doc)
-  {
-    this->AllLongOptions.push_back(longName);
-    group(this->CollapseName(longName, shortName), doc);
-  }
-
-  template<class T>
-  void DeclareOption(cxxopts::OptionAdder& group, const std::string& longName,
-    const std::string& shortName, const std::string& doc, T& var, HasDefault hasDefault,
-    MayHaveConfig mayHaveConfig, const std::string& argHelp = "",
-    HasImplicitValue hasImplicitValue = HasImplicitValue::NO, const std::string& implicitValue = "")
-  {
-    bool hasDefaultBool = hasDefault == HasDefault::YES;
-    auto val = cxxopts::value<T>(var);
-
-    if (hasImplicitValue == HasImplicitValue::YES)
-    {
-      val->implicit_value(implicitValue);
-    }
-
-    std::string defaultVal;
-    if (hasDefaultBool)
-    {
-      defaultVal = ConfigurationOptions::ToString(var);
-    }
-
-    if (mayHaveConfig == MayHaveConfig::YES)
-    {
-      hasDefaultBool |= this->GetOptionConfig(longName, defaultVal);
-    }
-
-    if (hasDefaultBool)
-    {
-      val = val->default_value(defaultVal);
-    }
-    var = {};
-    this->AllLongOptions.push_back(longName);
-    group(this->CollapseName(longName, shortName), doc, val, argHelp);
-  }
-
-  void PrintHelpPair(
-    const std::string& key, const std::string& help, int keyWidth = 10, int helpWidth = 70);
-  void PrintHelp(const cxxopts::Options& cxxOptions);
-  void PrintVersion();
-  void PrintReadersList();
-  void PrintPluginsScan();
-
-  std::pair<std::string, int> GetClosestOption(const std::string& option)
-  {
-    std::pair<std::string, int> ret = { "", std::numeric_limits<int>::max() };
-
-    for (const std::string& name : this->AllLongOptions)
-    {
-      int distance = f3d::utils::textDistance(name, option);
-      if (distance < ret.second)
-      {
-        ret = { name, distance };
-      }
-    }
-
-    return ret;
-  }
-
-private:
-  int Argc;
-  char** Argv;
-
-  using ConfigDict = std::map<std::string, std::string>;
-  using ConfigEntry = std::tuple<ConfigDict, fs::path, std::string>;
-  using ConfigEntries = std::vector<ConfigEntry>;
-  ConfigEntries GlobalConfigEntries;
-  ConfigEntries RegexConfigEntries;
-  std::string ExecutableName;
-  std::vector<std::string> AllLongOptions;
-
-  ConfigDict CurrentFileConfig;
-};
-
-//----------------------------------------------------------------------------
-std::vector<std::string> ConfigurationOptions::GetPluginSearchPaths() const
-{
-  // Recover F3D_PLUGINS_PATH first
-  auto searchPaths = F3DSystemTools::GetVectorEnvironnementVariable("F3D_PLUGINS_PATH");
-#if F3D_MACOS_BUNDLE
-  return searchPaths;
-#else
-  // Add a executable related path
-  auto tmpPath = F3DSystemTools::GetApplicationPath();
-  tmpPath = tmpPath.parent_path().parent_path();
-  tmpPath /= F3D::PluginsInstallDir;
-  searchPaths.push_back(tmpPath.string());
-  return searchPaths;
-#endif
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::LoadPlugins(const F3DAppOptions& appOptions) const
-{
-  try
-  {
-    f3d::engine::autoloadPlugins();
-
-    for (const std::string& plugin : appOptions.Plugins)
-    {
-      if (!plugin.empty())
-      {
-        f3d::engine::loadPlugin(plugin, this->GetPluginSearchPaths());
-      }
-    }
-  }
-  catch (const f3d::engine::plugin_exception& e)
-  {
-    f3d::log::warn("Plugin failed to load: ", e.what());
-  }
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::PrintPluginsScan()
-{
-#if F3D_MACOS_BUNDLE
-  f3d::log::error("option not supported with the macOS bundle");
-#else
-  auto appPath = F3DSystemTools::GetApplicationPath();
-  appPath = appPath.parent_path().parent_path();
-
-  appPath /= "share/f3d/plugins";
-
-  auto plugins = f3d::engine::getPluginsList(appPath.string());
-
-  f3d::log::info("Found ", plugins.size(), " plugins:");
-
-  for (const std::string& p : plugins)
-  {
-    f3d::log::info(" - ", p);
-  }
-#endif
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::GetOptions(F3DAppOptions& appOptions, f3d::options& options,
-  std::vector<std::string>& inputs, const std::string& filePathForConfigBlock,
-  bool allOptionsInitialized, bool parseCommandLine)
-{
-  inputs.clear(); /* needed because this function is called multiple times */
-
-  /* start with an empty config ... */
-  ConfigDict tmpConfig;
-
-  const auto update = [&](const ConfigDict& config)
-  {
-    /* insert or update the values from the argument into `tmpConfig`.
-     * also log the insertions/updates details in verbose mode */
-    for (const auto& [key, value] : config)
-    {
-      const std::string del = tmpConfig.count(key) ? key + ": " + tmpConfig[key] : "";
-      const std::string add = std::string(key).append(": ").append(value);
-      if (add == del)
-      {
-        f3d::log::debug("= ", add);
-      }
-      else
-      {
-        if (!del.empty())
-        {
-          f3d::log::debug("- ", del);
-        }
-        f3d::log::debug("+ ", add);
-      }
-
-      tmpConfig[key] = value;
-    }
-  };
-
-  /* apply global entries, `pattern` will always be `"global"` here */
-  for (const auto& [conf, source, pattern] : this->GlobalConfigEntries)
-  {
-    f3d::log::debug("using `", pattern, "` config from ", source.string());
-    update(conf);
-  }
-
-  /* ... then go through matching regex configs and override */
-  if (!filePathForConfigBlock.empty())
-  {
-    for (auto const& [conf, source, pattern] : this->RegexConfigEntries)
-    {
-      std::regex re(pattern, std::regex_constants::icase);
-      std::smatch matches;
-      if (std::regex_match(filePathForConfigBlock, matches, re))
-      {
-        f3d::log::debug("using `", pattern, "` config from ", source.string());
-        update(conf);
-      }
-    }
-  }
-
-  this->CurrentFileConfig = tmpConfig;
-
-  // When parsing multiple times, hasDefault should be forced to yes after the first pass as all
-  // options are expected to be already initialized, which means they have a "default" in the
-  // cxxopts sense.
-  HasDefault LocalHasDefaultNo = allOptionsInitialized ? HasDefault::YES : HasDefault::NO;
-
-  std::unordered_map<std::string, std::string> libf3dOptions;
-  std::vector<std::string> keys = options.getNames();
-  for (const std::string& key : keys)
-  {
-    libf3dOptions.emplace(key, options.getAsString(key));
-  }
-
-  try
-  {
-    cxxopts::Options cxxOptions(this->ExecutableName, F3D::AppTitle);
-    cxxOptions.custom_help("[OPTIONS...] file1 file2 ...");
-    // clang-format off
-    auto grp0 = cxxOptions.add_options("Applicative");
-    this->DeclareOption(grp0, "output", "", "Render to file", appOptions.Output, LocalHasDefaultNo, MayHaveConfig::YES, "<png file>");
-    this->DeclareOption(grp0, "no-background", "", "No background when render to file", appOptions.NoBackground, HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp0, "help", "h", "Print help");
-    this->DeclareOption(grp0, "version", "", "Print version details");
-    this->DeclareOption(grp0, "readers-list", "", "Print the list of readers");
-    this->DeclareOption(grp0, "config", "", "Specify the configuration file to use. absolute/relative path or filename/filestem to search in configuration file locations.", appOptions.UserConfigFile, LocalHasDefaultNo, MayHaveConfig::NO, "<filePath/filename/fileStem>");
-    this->DeclareOption(grp0, "dry-run", "", "Do not read the configuration file", appOptions.DryRun,  HasDefault::YES, MayHaveConfig::NO );
-    this->DeclareOption(grp0, "no-render", "", "Do not render anything and quit right after loading the first file, use with --verbose to recover information about a file.", appOptions.NoRender, HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp0, "max-size", "", "Maximum size in Mib of a file to load, negative value means unlimited", appOptions.MaxSize,  HasDefault::YES, MayHaveConfig::YES, "<size in Mib>");
-    this->DeclareOption(grp0, "watch", "", "Watch current file and automatically reload it whenever it is modified on disk", appOptions.Watch,  HasDefault::YES, MayHaveConfig::YES );
-    this->DeclareOption(grp0, "load-plugins", "", "List of plugins to load separated with a comma", appOptions.Plugins, LocalHasDefaultNo, MayHaveConfig::YES, "<paths or names>");
-    this->DeclareOption(grp0, "scan-plugins", "", "Scan standard directories for plugins and display available plugins (result can be incomplete)");
-    this->DeclareOption(grp0, "screenshot-filename", "", "Screenshot filename", appOptions.ScreenshotFilename, HasDefault::YES, MayHaveConfig::YES, "<filename>");
-
-    auto grp1 = cxxOptions.add_options("General");
-    this->DeclareOption(grp1, "verbose", "", "Set verbose level, providing more information about the loaded data in the console output", appOptions.VerboseLevel, HasDefault::YES, MayHaveConfig::YES, "{debug, info, warning, error, quiet}", HasImplicitValue::YES, "debug");
-    this->DeclareOption(grp1, "progress", "", "Show loading progress bar", libf3dOptions["ui.loader_progress"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "animation-progress", "", "Show animation progress bar", libf3dOptions["ui.animation_progress"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "geometry-only", "", "Do not read materials, cameras and lights from file", appOptions.GeometryOnly, HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "group-geometries", "", "When opening multiple files, show them all in the same scene. Force geometry-only. The configuration file for the first file will be loaded.", appOptions.GroupGeometries, HasDefault::YES, MayHaveConfig::NO);
-    this->DeclareOption(grp1, "up", "", "Up direction", libf3dOptions["scene.up_direction"], HasDefault::YES, MayHaveConfig::YES, "{-X, +X, -Y, +Y, -Z, +Z}");
-    this->DeclareOption(grp1, "axis", "x", "Show axes", libf3dOptions["interactor.axis"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "grid", "g", "Show grid", libf3dOptions["render.grid.enable"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "grid-absolute", "", "Position grid at the absolute origin instead of below the model", libf3dOptions["render.grid.absolute"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "grid-unit", "", "Size of grid unit square, set to a non-positive value for automatic computation", libf3dOptions["render.grid.unit"], HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid-subdivisions", "", "Number of grid subdivisions", libf3dOptions["render.grid.subdivisions"], HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid-color", "", "Color of main grid lines", libf3dOptions["render.grid.color"], HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "edges", "e", "Show cell edges", libf3dOptions["render.show_edges"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "camera-index", "", "Select the camera to use", libf3dOptions["scene.camera.index"], HasDefault::YES, MayHaveConfig::YES, "<index>");
-    this->DeclareOption(grp1, "trackball", "k", "Enable trackball interaction", libf3dOptions["interactor.trackball"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "invert-zoom", "", "Invert zoom direction with right mouse click", libf3dOptions["interactor.invert_zoom"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "animation-autoplay", "", "Automatically start animation", libf3dOptions["scene.animation.autoplay"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp1, "animation-index", "", "Select animation to show", libf3dOptions["scene.animation.index"], HasDefault::YES, MayHaveConfig::YES, "<index>");
-    this->DeclareOption(grp1, "animation-speed-factor", "", "Set animation speed factor", libf3dOptions["scene.animation.speed_factor"], HasDefault::YES, MayHaveConfig::YES, "<factor>");
-    this->DeclareOption(grp1, "animation-time", "", "Set animation time to load", libf3dOptions["scene.animation.time"], HasDefault::YES, MayHaveConfig::YES, "<time>");
-    this->DeclareOption(grp1, "animation-frame-rate", "", "Set animation frame rate when playing animation interactively", libf3dOptions["scene.animation.frame_rate"], HasDefault::YES, MayHaveConfig::YES, "<frame rate>");
-    this->DeclareOption(grp1, "font-file", "", "Path to a FreeType compatible font file", libf3dOptions["ui.font_file"], LocalHasDefaultNo, MayHaveConfig::NO, "<file_path>");
-
-    auto grp2 = cxxOptions.add_options("Material");
-    this->DeclareOption(grp2, "point-sprites", "o", "Show sphere sprites instead of geometry", libf3dOptions["model.point_sprites.enable"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp2, "point-type", "", "Point sprites type when showing point sprites", libf3dOptions["model.point_sprites.type"], HasDefault::YES, MayHaveConfig::YES, "<sphere|gaussian>");
-    this->DeclareOption(grp2, "point-size", "", "Point size when showing vertices or point sprites", libf3dOptions["render.point_size"], HasDefault::YES, MayHaveConfig::YES, "<size>");
-    this->DeclareOption(grp2, "line-width", "", "Line width when showing edges", libf3dOptions["render.line_width"], HasDefault::YES, MayHaveConfig::YES, "<width>");
-    this->DeclareOption(grp2, "backface-type", "", "Backface type, can be default (usually visible), visible or hidden", libf3dOptions["render.backface_type"], HasDefault::YES, MayHaveConfig::YES, "<default|visible|hidden>");
-    this->DeclareOption(grp2, "color", "", "Solid color", libf3dOptions["model.color.rgb"], HasDefault::YES, MayHaveConfig::YES, "<R,G,B>");
-    this->DeclareOption(grp2, "opacity", "", "Opacity", libf3dOptions["model.color.opacity"], HasDefault::YES, MayHaveConfig::YES, "<opacity>");
-    this->DeclareOption(grp2, "roughness", "", "Roughness coefficient (0.0-1.0)", libf3dOptions["model.material.roughness"], HasDefault::YES, MayHaveConfig::YES, "<roughness>");
-    this->DeclareOption(grp2, "metallic", "", "Metallic coefficient (0.0-1.0)", libf3dOptions["model.material.metallic"], HasDefault::YES, MayHaveConfig::YES, "<metallic>");
-    this->DeclareOption(grp2, "hdri-file", "", "Path to an image file that can be used as a light source and skybox", libf3dOptions["render.hdri.file"], LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "hdri-ambient", "f", "Enable HDRI ambient lighting", libf3dOptions["render.hdri.ambient"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp2, "hdri-skybox", "j", "Enable HDRI skybox background", libf3dOptions["render.background.skybox"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp2, "texture-matcap", "", "Path to a texture file containing a material capture", libf3dOptions["model.matcap.texture"], LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "texture-base-color", "", "Path to a texture file that sets the color of the object", libf3dOptions["model.color.texture"], LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "texture-material", "", "Path to a texture file that sets the Occlusion, Roughness and Metallic values of the object", libf3dOptions["model.material.texture"], LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "texture-emissive", "", "Path to a texture file that sets the emitted light of the object", libf3dOptions["model.emissive.texture"], LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "emissive-factor", "", "Emissive factor. This value is multiplied with the emissive color when an emissive texture is present", libf3dOptions["model.emissive.factor"], HasDefault::YES, MayHaveConfig::YES, "<R,G,B>");
-    this->DeclareOption(grp2, "texture-normal", "", "Path to a texture file that sets the normal map of the object", libf3dOptions["model.normal.texture"], LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "normal-scale", "", "Normal scale affects the strength of the normal deviation from the normal texture", libf3dOptions["model.normal.scale"], HasDefault::YES, MayHaveConfig::YES, "<normalScale>");
-
-    auto grp3 = cxxOptions.add_options("Window");
-    this->DeclareOption(grp3, "bg-color", "", "Background color", libf3dOptions["render.background.color"], HasDefault::YES, MayHaveConfig::YES, "<R,G,B>");
-    this->DeclareOption(grp3, "resolution", "", "Window resolution", appOptions.Resolution, HasDefault::YES, MayHaveConfig::YES, "<width,height>");
-    this->DeclareOption(grp3, "position", "", "Window position", appOptions.Position, HasDefault::YES, MayHaveConfig::YES, "<x,y>");
-    this->DeclareOption(grp3, "fps", "z", "Display frame per second", libf3dOptions["ui.fps"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp3, "filename", "n", "Display filename", libf3dOptions["ui.filename"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp3, "metadata", "m", "Display file metadata", libf3dOptions["ui.metadata"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp3, "blur-background", "u", "Blur background", libf3dOptions["render.background.blur"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp3, "blur-coc", "", "Blur circle of confusion radius", libf3dOptions["render.background.blur_coc"], HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp3, "light-intensity", "", "Light intensity", libf3dOptions["render.light.intensity"], HasDefault::YES, MayHaveConfig::YES, "<intensity>");
-
-    auto grp4 = cxxOptions.add_options("Scientific visualization");
-    this->DeclareOption(grp4, "scalars", "s", "Color by scalars", libf3dOptions["model.scivis.array_name"], HasDefault::YES, MayHaveConfig::YES, "<array_name>", HasImplicitValue::YES, "");
-    this->DeclareOption(grp4, "comp", "y", "Component from the scalar array to color with. -1 means magnitude, -2 or the short option, -y, means direct scalars", libf3dOptions["model.scivis.component"], HasDefault::YES, MayHaveConfig::YES, "<comp_index>", HasImplicitValue::YES, "-2");
-    this->DeclareOption(grp4, "cells", "c", "Use a scalar array from the cells", libf3dOptions["model.scivis.cells"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp4, "range", "", "Custom range for the coloring by array", libf3dOptions["model.scivis.range"], HasDefault::YES, MayHaveConfig::YES, "<min,max>");
-    this->DeclareOption(grp4, "bar", "b", "Show scalar bar", libf3dOptions["ui.scalar_bar"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp4, "colormap-file", "", "Specify a colormap image", appOptions.ColorMapFile, LocalHasDefaultNo, MayHaveConfig::YES, "<filePath/filename/fileStem>");
-    this->DeclareOption(grp4, "colormap", "", "Specify a custom colormap (ignored if \"colormap-file\" is specified)", libf3dOptions["model.scivis.colormap"], HasDefault::YES, MayHaveConfig::YES, "<color_list>");
-    this->DeclareOption(grp4, "volume", "v", "Show volume if the file is compatible", libf3dOptions["model.volume.enable"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp4, "inverse", "i", "Inverse opacity function for volume rendering", libf3dOptions["model.volume.inverse"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-
-    auto grpCamera = cxxOptions.add_options("Camera");
-    this->DeclareOption(grpCamera, "camera-position", "", "Camera position (overrides camera direction and camera zoom factor if any)", appOptions.CameraPosition, HasDefault::YES, MayHaveConfig::YES, "<X,Y,Z>");
-    this->DeclareOption(grpCamera, "camera-focal-point", "", "Camera focal point", appOptions.CameraFocalPoint, HasDefault::YES, MayHaveConfig::YES, "<X,Y,Z>");
-    this->DeclareOption(grpCamera, "camera-view-up", "", "Camera view up", appOptions.CameraViewUp, HasDefault::YES, MayHaveConfig::YES, "<X,Y,Z>");
-    this->DeclareOption(grpCamera, "camera-view-angle", "", "Camera view angle (non-zero, in degrees)", appOptions.CameraViewAngle, LocalHasDefaultNo, MayHaveConfig::YES, "<angle>");
-    this->DeclareOption(grpCamera, "camera-direction", "", "Camera direction", appOptions.CameraDirection, HasDefault::YES, MayHaveConfig::YES, "<X,Y,Z>");
-    this->DeclareOption(grpCamera, "camera-zoom-factor", "", "Camera zoom factor (non-zero)", appOptions.CameraZoomFactor, HasDefault::YES, MayHaveConfig::YES, "<factor>");
-    this->DeclareOption(grpCamera, "camera-azimuth-angle", "", "Camera azimuth angle (in degrees), performed after other camera options", appOptions.CameraAzimuthAngle, HasDefault::YES, MayHaveConfig::YES, "<angle>");
-    this->DeclareOption(grpCamera, "camera-elevation-angle", "", "Camera elevation angle (in degrees), performed after other camera options", appOptions.CameraElevationAngle, HasDefault::YES, MayHaveConfig::YES, "<angle>");
-    this->DeclareOption(grpCamera, "camera-orthographic", "", "Use an orthographic camera", libf3dOptions["scene.camera.orthographic"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-
-#if F3D_MODULE_RAYTRACING
-    auto grp5 = cxxOptions.add_options("Raytracing");
-    this->DeclareOption(grp5, "raytracing", "r", "Enable raytracing", libf3dOptions["render.raytracing.enable"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp5, "samples", "", "Number of samples per pixel", libf3dOptions["render.raytracing.samples"], HasDefault::YES, MayHaveConfig::YES, "<samples>");
-    this->DeclareOption(grp5, "denoise", "d", "Denoise the image", libf3dOptions["render.raytracing.denoise"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-#endif
-
-    auto grp6 = cxxOptions.add_options("PostFX (OpenGL)");
-    this->DeclareOption(grp6, "translucency-support", "p", "Enable translucency support, implemented using depth peeling", libf3dOptions["render.effect.translucency_support"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp6, "ambient-occlusion", "q", "Enable ambient occlusion providing approximate shadows for better depth perception, implemented using SSAO", libf3dOptions["render.effect.ambient_occlusion"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp6, "anti-aliasing", "a", "Enable anti-aliasing, implemented using FXAA", libf3dOptions["render.effect.anti_aliasing"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp6, "tone-mapping", "t", "Enable Tone Mapping, providing balanced coloring", libf3dOptions["render.effect.tone_mapping"], HasDefault::YES, MayHaveConfig::YES, "<bool>", HasImplicitValue::YES, "1");
-    this->DeclareOption(grp6, "final-shader", "", "Execute the final shader at the end of the rendering pipeline", libf3dOptions["render.effect.final_shader"], LocalHasDefaultNo, MayHaveConfig::YES, "<GLSL code>");
-
-    auto grp7 = cxxOptions.add_options("Testing");
-    this->DeclareOption(grp7, "ref", "", "Reference", appOptions.Reference, LocalHasDefaultNo, MayHaveConfig::YES, "<png file>");
-    this->DeclareOption(grp7, "ref-threshold", "", "Testing threshold", appOptions.RefThreshold, HasDefault::YES, MayHaveConfig::YES, "<threshold>");
-    this->DeclareOption(grp7, "interaction-test-record", "", "Path to an interaction log file to record interactions events to", appOptions.InteractionTestRecordFile, LocalHasDefaultNo, MayHaveConfig::YES, "<file_path>");
-    this->DeclareOption(grp7, "interaction-test-play", "", "Path to an interaction log file to play interaction events from when loading a file", appOptions.InteractionTestPlayFile, LocalHasDefaultNo, MayHaveConfig::YES,"<file_path>");
-    // clang-format on
-
-    cxxOptions.allow_unrecognised_options();
-
-    if (parseCommandLine)
-    {
-      auto result = cxxOptions.parse(this->Argc, this->Argv);
-      for (const auto& [key, val] : libf3dOptions)
-      {
-        options.setAsString(key, val);
-      }
-      auto unmatched = result.unmatched();
-      bool found_unknown_option = false;
-      for (std::string unknownOption : unmatched)
-      {
-        if (!unknownOption.empty() && unknownOption[0] != '-')
-        {
-          inputs.push_back(unknownOption);
-        }
-        else
-        {
-          f3d::log::error("Unknown option '", unknownOption, "'");
-          found_unknown_option = true;
-
-          // check if it's a long option
-          if (unknownOption.substr(0, 2) == "--")
-          {
-            const size_t i = unknownOption.find('=');
-
-            // remove "--" and everything after the first "=" (if any)
-            const std::string unknownName =
-              unknownOption.substr(2, i != std::string::npos ? i - 2 : i);
-
-            auto [closestName, dist] = this->GetClosestOption(unknownName);
-            const std::string closestOption =
-              i == std::string::npos ? closestName : closestName + unknownOption.substr(i);
-
-            f3d::log::error("Did you mean '--", closestOption, "'?");
-          }
-        }
-      }
-      if (found_unknown_option)
-      {
-        f3d::log::waitForUser();
-        throw F3DExFailure("unknown options");
-      }
-
-      if (result.count("help") > 0)
-      {
-        this->PrintHelp(cxxOptions);
-        throw F3DExNoProcess("help requested");
-      }
-
-      if (result.count("version") > 0)
-      {
-        this->PrintVersion();
-        throw F3DExNoProcess("version requested");
-      }
-
-      if (result.count("scan-plugins") > 0)
-      {
-        this->PrintPluginsScan();
-        throw F3DExNoProcess("scan plugins requested");
-      }
-
-      if (result.count("readers-list") > 0)
-      {
-        this->LoadPlugins(appOptions);
-        this->PrintReadersList();
-        throw F3DExNoProcess("reader list requested");
-      }
-    }
-    else
-    {
-      // this will update the options using the config file without parsing actual argc/argv
-      cxxOptions.parse(1, nullptr);
-      for (const auto& [key, val] : libf3dOptions)
-      {
-        options.setAsString(key, val);
-      }
-    }
-  }
-  catch (const cxxopts::exceptions::exception& ex)
-  {
-    f3d::log::error("Error parsing command line arguments: ", ex.what());
-    throw F3DExFailure("Could not parse command line arguments");
-  }
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::PrintHelpPair(
-  const std::string& key, const std::string& help, int keyWidth, int helpWidth)
-{
-  std::stringstream ss;
-  ss << "  " << std::left << std::setw(keyWidth) << key << " " << std::setw(helpWidth) << help;
-  f3d::log::info(ss.str());
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::PrintHelp(const cxxopts::Options& cxxOptions)
-{
-  const std::vector<std::pair<std::string, std::string>> examples = {
-    { this->ExecutableName + " file.vtu -xtgans",
-      "View a unstructured mesh in a typical nice looking sciviz style" },
-    { this->ExecutableName + " file.glb -tuqap --hdri-file=file.hdr --hdri-ambient --hdri-skybox",
-      "View a gltf file in a realistic environment" },
-    { this->ExecutableName + " file.ply -so --point-size=0 --comp=-2",
-      "View a point cloud file with direct scalars rendering" },
-    { this->ExecutableName + " folder", "View all files in folder" },
-  };
-
-  f3d::log::setUseColoring(false);
-  f3d::log::info(cxxOptions.help());
-  f3d::log::info("Keys:");
-  for (const auto& key : f3d::interactor::getDefaultInteractionsInfo())
-  {
-    this->PrintHelpPair(key.first, key.second);
-  }
-
-  f3d::log::info("\nExamples:");
-  for (const auto& example : examples)
-  {
-    this->PrintHelpPair(example.first, example.second, 50);
-  }
-  f3d::log::info("\nReport bugs to https://github.com/f3d-app/f3d/issues");
-  f3d::log::setUseColoring(true);
-  f3d::log::waitForUser();
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::PrintVersion()
-{
-  f3d::log::setUseColoring(false);
-  f3d::log::info(F3D::AppName + " " + F3D::AppVersion + "\n");
-  f3d::log::info(F3D::AppTitle);
-  auto libInfo = f3d::engine::getLibInfo();
-  f3d::log::info("Version: " + libInfo.VersionFull + ".");
-  f3d::log::info("Build date: " + libInfo.BuildDate + ".");
-  f3d::log::info("Build system: " + libInfo.BuildSystem + ".");
-  f3d::log::info("Compiler: " + libInfo.Compiler + ".");
-  for (const auto& [name, enabled] : libInfo.Modules)
-  {
-    f3d::log::info("Module " + name + ": " + (enabled ? "ON." : "OFF."));
-  }
-  f3d::log::info("VTK version: " + libInfo.VTKVersion + ".");
-  for (const auto& cr : libInfo.Copyrights)
-  {
-    f3d::log::info("Copyright (C) " + cr + ".");
-  }
-  f3d::log::info("License " + libInfo.License + ".");
-  f3d::log::setUseColoring(true);
-  f3d::log::waitForUser();
-}
-
-//----------------------------------------------------------------------------
-void ConfigurationOptions::PrintReadersList()
-{
-  size_t nameColSize = 0;
-  size_t extsColSize = 0;
-  size_t mimeColSize = 0;
-  size_t descColSize = 0;
-  size_t plugColSize = 0;
-
-  std::vector<f3d::engine::readerInformation> readersInfo = f3d::engine::getReadersInfo();
-  if (readersInfo.empty())
-  {
-    f3d::log::warn("No registered reader found!");
-    return;
-  }
-  // Compute the size of the 5 columns
-  for (const auto& reader : readersInfo)
-  {
-    // There is at least one MIME type for each extension
-    assert(reader.Extensions.size() >= reader.MimeTypes.size());
-
-    nameColSize = std::max(nameColSize, reader.Name.length());
-    descColSize = std::max(descColSize, reader.Description.length());
-    plugColSize = std::max(plugColSize, reader.PluginName.length());
-
-    for (const auto& ext : reader.Extensions)
-    {
-      extsColSize = std::max(extsColSize, ext.length());
-    }
-    for (const auto& mime : reader.MimeTypes)
-    {
-      mimeColSize = std::max(mimeColSize, mime.length());
-    }
-  }
-  const size_t colGap = 4;
-  nameColSize += colGap;
-  extsColSize += colGap;
-  mimeColSize += colGap;
-  descColSize += colGap;
-  plugColSize += colGap;
-
-  std::string separator =
-    std::string(nameColSize + extsColSize + descColSize + mimeColSize + plugColSize - colGap, '-');
-
-  // Print the rows split in 3 columns
-  std::stringstream headerLine;
-  headerLine << std::left << std::setw(nameColSize) << "Name" << std::setw(plugColSize) << "Plugin"
-             << std::setw(descColSize) << "Description" << std::setw(extsColSize) << "Exts"
-             << std::setw(mimeColSize - colGap) << "Mime-types";
-  f3d::log::info(headerLine.str());
-  f3d::log::info(separator);
-
-  for (const auto& reader : readersInfo)
-  {
-    for (size_t i = 0; i < reader.Extensions.size(); i++)
-    {
-      std::stringstream readerLine;
-      readerLine << std::left;
-      readerLine << std::setw(nameColSize) << (i == 0 ? reader.Name : "");
-      readerLine << std::setw(plugColSize) << (i == 0 ? reader.PluginName : "");
-      readerLine << std::setw(descColSize) << (i == 0 ? reader.Description : "");
-      readerLine << std::setw(extsColSize)
-                 << (i < reader.Extensions.size() ? reader.Extensions[i] : "");
-      readerLine << std::setw(mimeColSize - colGap)
-                 << (i < reader.MimeTypes.size() ? reader.MimeTypes[i] : "");
-
-      f3d::log::info(readerLine.str());
-    }
-  }
-  f3d::log::waitForUser();
-}
-
-//----------------------------------------------------------------------------
-bool ConfigurationOptions::InitializeDictionaryFromConfigFile(const std::string& config)
-{
-  // we expect this function to only get called once but clear anyway just in case
-  this->GlobalConfigEntries.clear();
-  this->RegexConfigEntries.clear();
-
-  std::string configSearch = "config";
-  if (!config.empty())
-  {
-    auto path = fs::path(config);
-    if (path.stem() == config || path.filename() == config)
-    {
-      // Only a stem or a filename, use as search string
-      configSearch = config;
-    }
-    else
-    {
-      // Assume its a full path and do not search for a config path
-      configSearch = "";
-    }
-  }
-
-  std::vector<fs::path> actualConfigFilePaths;
-
-  std::vector<fs::path> configPaths;
-
-  if (!configSearch.empty())
-  {
-    for (const auto& path : F3DConfigFileTools::GetConfigPaths(configSearch))
-    {
-      configPaths.emplace_back(path);
-    }
-  }
-  else
-  {
-    configPaths.emplace_back(config);
-  }
-
-  for (auto configPath : configPaths)
-  {
-    // Recover an absolute canonical path to config file
-    try
-    {
-      configPath = fs::canonical(fs::path(configPath)).string();
-    }
-    catch (const fs::filesystem_error&)
-    {
-      f3d::log::error("Configuration file does not exist: ", configPath.string());
-      return false;
-    }
-
-    // Recover all config files if needed
-    if (fs::is_directory(configPath))
-    {
-      f3d::log::debug("Using config directory ", configPath.string());
-      for (auto& entry : std::filesystem::directory_iterator(configPath))
-      {
-        actualConfigFilePaths.emplace_back(entry);
-      }
-    }
-    else
-    {
-      f3d::log::debug("Using config file ", configPath.string());
-      actualConfigFilePaths.emplace_back(configPath);
-    }
-  }
-
-  if (actualConfigFilePaths.empty())
-  {
-    if (!configSearch.empty())
-    {
-      f3d::log::warn("Configuration file for \"", configSearch, "\" could not be found");
-    }
-    return false;
-  }
-
-  // Read config files
-  for (auto& configFilePath : actualConfigFilePaths)
-  {
-    std::ifstream file;
-    file.open(configFilePath.string().c_str());
-
-    if (!file.is_open())
-    {
-      f3d::log::error("Unable to open the configuration file: ", configFilePath.string());
-      return false;
-    }
-
-    nlohmann::ordered_json json;
-    try
-    {
-      file >> json;
-    }
-    catch (const std::exception& ex)
-    {
-      f3d::log::error("Unable to parse the configuration file ", configFilePath.string());
-      f3d::log::error(ex.what());
-      return false;
-    }
-
-    for (const auto& configBlock : json.items())
-    {
-      ConfigDict entry;
-      for (const auto& item : configBlock.value().items())
-      {
-        if (item.value().is_number() || item.value().is_boolean())
-        {
-          entry[item.key()] = ToString(item.value());
-        }
-        else if (item.value().is_string())
-        {
-          entry[item.key()] = item.value().get<std::string>();
-        }
-        else
-        {
-          f3d::log::error(item.key(), " must be a string, a boolean or a number");
-          return false;
-        }
-      }
-      if (configBlock.key() == "global")
-      {
-        this->GlobalConfigEntries.emplace_back(entry, configFilePath, configBlock.key());
-      }
-      else
-      {
-        this->RegexConfigEntries.emplace_back(entry, configFilePath, configBlock.key());
-      }
-    }
-  }
-
-  return true;
-}
-
-//----------------------------------------------------------------------------
-F3DOptionsParser::F3DOptionsParser() = default;
-
-//----------------------------------------------------------------------------
-F3DOptionsParser::~F3DOptionsParser() = default;
-
-//----------------------------------------------------------------------------
-void F3DOptionsParser::Initialize(int argc, char** argv)
-{
-  this->ConfigOptions = std::make_unique<ConfigurationOptions>(argc, argv);
-}
-
-//----------------------------------------------------------------------------
-void F3DOptionsParser::InitializeDictionaryFromConfigFile(const std::string& userConfigFile)
-{
-  this->ConfigOptions->InitializeDictionaryFromConfigFile(userConfigFile);
-}
-
-//----------------------------------------------------------------------------
-void F3DOptionsParser::UpdateOptions(const std::string& filePath, F3DAppOptions& appOptions,
-  f3d::options& options, bool parseCommandLine)
-{
-  std::vector<std::string> dummyFiles;
-  return this->ConfigOptions->GetOptions(
-    appOptions, options, dummyFiles, filePath, true, parseCommandLine);
-}
-
-//----------------------------------------------------------------------------
-void F3DOptionsParser::GetOptions(
-  F3DAppOptions& appOptions, f3d::options& options, std::vector<std::string>& files)
-{
-  return this->ConfigOptions->GetOptions(appOptions, options, files);
-}
-
-//----------------------------------------------------------------------------
-void F3DOptionsParser::LoadPlugins(const F3DAppOptions& appOptions) const
-{
-  return this->ConfigOptions->LoadPlugins(appOptions);
-}
diff --git a/application/F3DOptionsParser.h b/application/F3DOptionsParser.h
deleted file mode 100644
index f421663ea3..0000000000
--- a/application/F3DOptionsParser.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/**
- * @class   F3DOptionsParser
- * @brief   A class to parse application and library options
- *
- */
-
-#ifndef F3DOptionsParser_h
-#define F3DOptionsParser_h
-
-#include <memory>
-#include <string>
-#include <vector>
-
-class ConfigurationOptions;
-namespace f3d
-{
-class options;
-}
-
-struct F3DAppOptions
-{
-  std::string UserConfigFile = "";
-  std::string ColorMapFile = "";
-  bool DryRun = false;
-  bool GeometryOnly = false;
-  bool GroupGeometries = false;
-  std::string Output = "";
-  std::string ScreenshotFilename = "{app}/{model}_{n}.png";
-  std::string Reference = "";
-  std::string InteractionTestRecordFile = "";
-  std::string InteractionTestPlayFile = "";
-  bool NoBackground = false;
-  bool NoRender = false;
-  bool Watch = false;
-  double RefThreshold = 0.05;
-  double MaxSize = -1.0;
-
-  std::vector<int> Resolution{ 1000, 600 };
-  std::vector<int> Position{ 0 };
-  std::string VerboseLevel = "info";
-  double CameraAzimuthAngle = 0.0;
-  double CameraElevationAngle = 0.0;
-  std::vector<double> CameraFocalPoint = { 0 };
-  std::vector<double> CameraPosition = { 0 };
-  std::vector<double> CameraViewUp = { 0 };
-  std::vector<double> CameraDirection = { 0 };
-  double CameraZoomFactor = 0.0;
-  double CameraViewAngle = 0.0;
-  std::vector<std::string> Plugins;
-  std::string FinalShader = "";
-};
-
-class F3DOptionsParser
-{
-public:
-  void Initialize(int argc, char** argv);
-
-  /**
-   * Find and parse a config file, if any, into the config file dictionary.
-   * If a non-empty configNameis provided, it will be considered instead
-   * of standard settings config file.
-   * supported config are:
-   *  - relative/absolute path to a config file
-   *  - name of file to look for in standard locations
-   *  - name of file without extension to look for in standard locations, .json will be added.
-   */
-  void InitializeDictionaryFromConfigFile(const std::string& config);
-
-  /**
-   * Parse the command line and return the options passed
-   * The provided inputs arguments will also be filled by the
-   * positional inputs or inputs arguments from command line.
-   * This will consider the global config file only
-   * Returns the resulting options.
-   */
-  void GetOptions(
-    F3DAppOptions& appOptions, f3d::options& options, std::vector<std::string>& inputs);
-
-  /**
-   * Use the config file dictionary using the provided filepath
-   * to match the regexp from the config files.
-   * This will not parse the command line.
-   * Returns the resulting options.
-   */
-  void UpdateOptions(const std::string& filePath, F3DAppOptions& appOptions, f3d::options& options,
-    bool parseCommandLine);
-
-  /**
-   * Load the plugins specified in the app options.
-   */
-  void LoadPlugins(const F3DAppOptions& appOptions) const;
-
-  F3DOptionsParser();
-  ~F3DOptionsParser();
-
-  F3DOptionsParser(F3DOptionsParser const&) = delete;
-  void operator=(F3DOptionsParser const&) = delete;
-
-private:
-  std::unique_ptr<ConfigurationOptions> ConfigOptions;
-};
-
-#endif
diff --git a/application/F3DOptionsTools.cxx b/application/F3DOptionsTools.cxx
new file mode 100644
index 0000000000..084c2ac5c6
--- /dev/null
+++ b/application/F3DOptionsTools.cxx
@@ -0,0 +1,565 @@
+#include "F3DOptionsTools.h"
+
+#include "F3DConfig.h"
+#include "F3DException.h"
+#include "F3DPluginsTools.h"
+#include "F3DSystemTools.h"
+
+#include "engine.h"
+#include "interactor.h"
+#include "log.h"
+#include "utils.h"
+
+#include <cassert>
+#include <filesystem>
+#include <iomanip>
+#include <set>
+#include <sstream>
+
+#include "cxxopts.hpp"
+
+namespace fs = std::filesystem;
+
+namespace
+{
+
+/**
+ * A struct to configure a complete cxxopts CLI options
+ * F3D uses exclusively string options except for a few true boolean option (eg: `--version`)
+ * LongName: The long name, eg: `axis`
+ * ShortName: The short name, eg: `x`
+ * HelpText: The help text, for display only when using `--help`
+ * ValueHelper: Used in help but also to discrimate between boolean option or not
+ * ImplicitValue: The implicit value when option is provided without a value
+ */
+struct CLIOption
+{
+  std::string_view LongName;
+  std::string_view ShortName;
+  std::string_view HelpText;
+  std::string_view ValueHelper;
+  std::string_view ImplicitValue;
+};
+
+/**
+ * A struct to group option into categories
+ */
+struct CLIGroup
+{
+  std::string_view GroupName;
+  std::vector<CLIOption> Options;
+};
+
+/**
+ * Declaration of all F3D CLI options except `--input` using above structs
+ * Order of groups matters in the context of `--help`
+ */
+// clang-format off
+#if F3D_MODULE_RAYTRACING
+static inline const std::array<CLIGroup, 9> CLIOptions = {{
+#else
+static inline const std::array<CLIGroup, 8> CLIOptions = {{
+#endif
+  { "Applicative",
+    { { "output", "", "Render to file", "<png file>", "" },
+      { "no-background", "", "No background when render to file", "<bool>", "1" },
+      { "help", "h", "Print help", "", "" }, { "version", "", "Print version details", "", "" },
+      { "readers-list", "", "Print the list of readers", "", "" },
+      { "config", "", "Specify the configuration file to use. absolute/relative path or filename/filestem to search in configuration file locations", "<filePath/filename/fileStem>", "" },
+      { "dry-run", "", "Do not read the configuration file", "<bool>", "1" },
+      { "no-render", "", "Do not read the configuration file", "<bool>", "1" },
+      { "max-size", "", "Maximum size in Mib of a file to load, negative value means unlimited", "<size in Mib>", "" },
+      { "watch", "", "Watch current file and automatically reload it whenever it is modified on disk", "<bool>", "1" },
+      { "load-plugins", "", "List of plugins to load separated with a comma", "<paths or names>", "" },
+      { "scan-plugins", "", "Scan standard directories for plugins and display available plugins (result can be incomplete)", "", "" },
+      { "screenshot-filename", "", "Screenshot filename", "<filename>", "" } } },
+  { "General",
+    { { "verbose", "", "Set verbose level, providing more information about the loaded data in the console output", "{debug, info, warning, error, quiet}", "debug" },
+      { "progress", "", "Show loading progress bar", "<bool>", "1" },
+      { "animation-progress", "", "Show animation progress bar", "<bool>", "1" },
+      { "geometry-only", "", "Do not read materials, cameras and lights from file", "<bool>", "1" },
+      { "group-geometries", "", "When opening multiple files, show them all in the same scene. Force geometry-only. The configuration file for the first file will be loaded.", "<bool>", "1" },
+      { "up", "", "Up direction", "{-X, +X, -Y, +Y, -Z, +Z}", "" },
+      { "axis", "x", "Show axes", "<bool>", "1" }, { "grid", "g", "Show grid", "<bool>", "1" },
+      { "grid-absolute", "", "Position grid at the absolute origin instead of below the model", "<bool>", "1" },
+      { "grid-unit", "", "Size of grid unit square, set to a non-positive value for automatic computation", "<value>", "" },
+      { "grid-subdivisions", "", "Number of grid subdivisions", "<value>", "" },
+      { "grid-color", "", "Color of main grid lines", "<R,G,B>", "" },
+      { "edges", "e", "Show cell edges", "<bool>", "1" },
+      { "camera-index", "", "Select the camera to use", "<index>", "" },
+      { "trackball", "k", "Enable trackball interaction", "<bool>", "1" },
+      { "invert-zoom", "", "Invert zoom direction with right mouse click", "<bool>", "1" },
+      { "animation-autoplay", "", "Automatically start animation", "<bool>", "1" },
+      { "animation-index", "", "Select animation to show", "<index>", "" },
+      { "animation-speed-factor", "", "Set animation speed factor", "<factor>", "" },
+      { "animation-time", "", "Set animation time to load", "<time>", "" },
+      {"animation-frame-rate", "", "Set animation frame rate when playing animation interactively", "<frame rate>", ""},
+      {"font-file", "", "Path to a FreeType compatible font file", "<file_path>", ""} } },
+  { "Material",
+    { {"point-sprites", "o", "Show sphere sprites instead of geometry", "<bool>", "1" },
+      {"point-type", "", "Point sprites type when showing point sprites", "<sphere|gaussian>", ""},
+      {"point-size", "", "Point size when showing vertices or point sprites", "<size>", ""},
+      {"line-width", "", "Line width when showing edges", "<width>", ""},
+      {"backface-type", "", "Backface type, can be default (usually visible), visible or hidden", "<default|visible|hidden>", ""},
+      {"color", "", "Solid color", "<R,G,B>", ""},
+      {"opacity", "", "Opacity", "<opacity>", ""},
+      {"roughness", "", "Roughness coefficient (0.0-1.0)", "<roughness>", ""},
+      {"metallic", "", "Metallic coefficient (0.0-1.0)", "<metallic>", ""},
+      {"hdri-file", "", "Path to an image file that can be used as a light source and skybox", "<file path>", ""},
+      {"hdri-ambient", "f", "Enable HDRI ambient lighting", "<bool>", "1"},
+      {"hdri-skybox", "j", "Enable HDRI skybox background", "<bool>", "1"},
+      {"texture-matcap", "", "Path to a texture file containing a material capture", "<file path>", ""},
+      {"texture-base-color", "", "Path to a texture file that sets the color of the object", "<file path>", ""},
+      {"texture-material", "", "Path to a texture file that sets the Occlusion, Roughness and Metallic values of the object", "<file path>", ""},
+      {"texture-emissive", "", "Path to a texture file that sets the emitted light of the object", "<file path>", ""},
+      {"emissive-factor", "", "Emissive factor. This value is multiplied with the emissive color when an emissive texture is present", "<R,G,B>", ""},
+      {"texture-normal", "", "Path to a texture file that sets the normal map of the object", "<file path>", ""},
+      {"normal-scale", "", "Normal scale affects the strength of the normal deviation from the normal texture", "<normalScale>", ""} } },
+  {"Window",
+    { {"bg-color", "", "Background color", "<R,G,B>", ""},
+      {"resolution", "", "Window resolution", "<width,height>", ""},
+      {"position", "", "Window position", "<x,y>", ""},
+      {"fps", "z", "Display frame per second", "<bool>", "1"},
+      {"filename", "n", "Display filename", "<bool>", "1"},
+      {"metadata", "m", "Display file metadata", "<bool>", "1"},
+      {"blur-background", "u", "Blur background", "<bool>", "1" },
+      {"blur-coc", "", "Blur circle of confusion radius", "<value>", ""},
+      {"light-intensity", "", "Light intensity", "<value>", ""} } },
+  {"Scientific visualization",
+    { {"scalar-coloring", "s", "Color by a scalar array", "<bool>", "1" },
+      {"coloring-array", "", "Name of the array to color with", "<array_name>", "" },
+      {"comp", "y", "Component from the array to color with. -1 means magnitude, -2 or the short option, -y, means direct scalars", "<comp_index>", "-2"},
+      {"cells", "c", "Use an array from the cells", "<bool>", "1"},
+      {"range", "", "Custom range for the coloring by array", "<min,max>", ""},
+      {"bar", "b", "Show scalar bar", "<bool>", "1" },
+      {"colormap-file", "", "Specify a colormap image", "<filePath/filename/fileStem>", ""},
+      {"colormap", "", "Specify a custom colormap (ignored if \"colormap-file\" is specified)", "<color_list>", ""},
+      {"volume", "v", "Show volume if the file is compatible", "<bool>", "1"},
+      {"inverse", "i", "Inverse opacity function for volume rendering", "<bool>", "1"} } },
+  {"Camera",
+    { {"camera-position", "", "Camera position (overrides camera direction and camera zoom factor if any)", "<X,Y,Z>", ""},
+      {"camera-focal-point", "", "Camera focal point", "<X,Y,Z>", ""},
+      {"camera-view-up", "", "Camera view up", "<X,Y,Z>", ""},
+      {"camera-view-angle", "", "Camera view angle (non-zero, in degrees)", "<angle>", ""},
+      {"camera-direction", "", "Camera direction", "<X,Y,Z>", ""},
+      {"camera-zoom-factor", "", "Camera zoom factor (non-zero)", "<factor>", ""},
+      {"camera-azimuth-angle", "", "Camera azimuth angle (in degrees), performed after other camera options", "<angle>", ""},
+      {"camera-elevation-angle", "", "Camera elevation angle (in degrees), performed after other camera options", "<angle>", ""},
+      {"camera-orthographic", "", "Use an orthographic camera", "<bool>", "1"} } },
+
+#if F3D_MODULE_RAYTRACING
+  {"Raytracing",
+    { {"raytracing", "r", "Enable raytracing", "<bool>", "1"},
+      {"samples", "", "Number of samples per pixel", "<samples>", ""},
+      {"denoise", "d", "Denoise the image", "<bool>", "1"} } },
+#endif
+  {"PostFX (OpenGL)",
+    { {"translucency-support", "p", "Enable translucency support, implemented using depth peeling", "<bool>", "1"},
+      {"ambient-occlusion", "q", "Enable ambient occlusion providing approximate shadows for better depth perception, implemented using SSAO", "<bool>", "1"},
+      {"anti-aliasing", "a", "Enable anti-aliasing, implemented using FXAA", "<bool>", "1"},
+      {"tone-mapping", "t", "Enable Tone Mapping, providing balanced coloring", "<bool>", "1"},
+      {"final-shader", "", "Execute the final shader at the end of the rendering pipeline", "<GLSL code>", ""} } },
+  {"Testing",
+    { {"ref", "", "Reference", "<png file>", ""},
+      {"ref-threshold", "", "Testing threshold", "<threshold>", ""},
+      {"interaction-test-record", "", "Path to an interaction log file to record interactions events to", "<file_path>", ""},
+      {"interaction-test-play", "", "Path to an interaction log file to play interaction events from when loading a file", "<file_path>", ""} } }
+}};
+
+/**
+ * True boolean options need to be filtered out in ParseCLIOptions
+ * This is the easiest, compile time way to do it
+ */
+constexpr std::array<std::string_view, 4> CLIBooleans = {"version", "help", "readers-list", "scan-plugins"};
+
+//----------------------------------------------------------------------------
+/**
+ * Collapse a longName and shortName into the expected syntax of cxxopts for name declaration
+ */
+std::string CollapseName(const std::string_view& longName, const std::string_view& shortName)
+{
+  std::stringstream ss;
+  if (shortName != "")
+  {
+    ss << shortName << ",";
+  }
+  ss << longName;
+  return ss.str();
+}
+
+//----------------------------------------------------------------------------
+void PrintHelpPair(
+  std::string_view key, std::string_view help, int keyWidth = 10, int helpWidth = 70)
+{
+  std::stringstream ss;
+  ss << "  " << std::left << std::setw(keyWidth) << key << " " << std::setw(helpWidth) << help;
+  f3d::log::info(ss.str());
+}
+
+//----------------------------------------------------------------------------
+void PrintHelp(const std::string& execName, const cxxopts::Options& cxxOptions)
+{
+  const std::array<std::pair<std::string_view, std::string_view>, 4> examples = {{
+    { execName + " file.vtu -xtgans",
+      "View a unstructured mesh in a typical nice looking sciviz style" },
+    { execName + " file.glb -tuqap --hdri-file=file.hdr --hdri-ambient --hdri-skybox",
+      "View a gltf file in a realistic environment" },
+    { execName + " file.ply -so --point-size=0 --comp=-2",
+      "View a point cloud file with direct scalars rendering" },
+    { execName + " folder", "View all files in folder" },
+  }};
+
+  f3d::log::setUseColoring(false);
+  std::vector<std::string> orderedCLIGroupNames;
+  orderedCLIGroupNames.reserve(::CLIOptions.size());
+  for (const ::CLIGroup& optionGroup : ::CLIOptions)
+  {
+    // This ensure help is provided in the expected group order
+    orderedCLIGroupNames.emplace_back(optionGroup.GroupName);
+  }
+  f3d::log::info(cxxOptions.help(orderedCLIGroupNames));
+  f3d::log::info("Keys:");
+  for (const auto& [key, desc] : f3d::interactor::getDefaultInteractionsInfo())
+  {
+    ::PrintHelpPair(key, desc);
+  }
+
+  f3d::log::info("\nExamples:");
+  for (const auto& [cmd, desc] : examples)
+  {
+    ::PrintHelpPair(cmd, desc, 50);
+  }
+  f3d::log::info("\nReport bugs to https://github.com/f3d-app/f3d/issues");
+  f3d::log::setUseColoring(true);
+  f3d::log::waitForUser();
+}
+
+//----------------------------------------------------------------------------
+void PrintPluginsScan()
+{
+#if F3D_MACOS_BUNDLE
+  f3d::log::error("option not supported with the macOS bundle");
+#else
+  auto appPath = F3DSystemTools::GetApplicationPath();
+  appPath = appPath.parent_path().parent_path();
+
+  appPath /= "share/f3d/plugins";
+
+  auto plugins = f3d::engine::getPluginsList(appPath.string());
+
+  f3d::log::info("Found ", plugins.size(), " plugins:");
+
+  for (const std::string& p : plugins)
+  {
+    f3d::log::info(" - ", p);
+  }
+#endif
+}
+
+//----------------------------------------------------------------------------
+void PrintVersion()
+{
+  f3d::log::setUseColoring(false);
+  f3d::log::info(F3D::AppName + " " + F3D::AppVersion + "\n");
+  f3d::log::info(F3D::AppTitle);
+  auto libInfo = f3d::engine::getLibInfo();
+  f3d::log::info("Version: " + libInfo.VersionFull + ".");
+  f3d::log::info("Build date: " + libInfo.BuildDate + ".");
+  f3d::log::info("Build system: " + libInfo.BuildSystem + ".");
+  f3d::log::info("Compiler: " + libInfo.Compiler + ".");
+  for (const auto& [name, enabled] : libInfo.Modules)
+  {
+    f3d::log::info("Module " + name + ": " + (enabled ? "ON." : "OFF."));
+  }
+  f3d::log::info("VTK version: " + libInfo.VTKVersion + ".");
+  for (const auto& cr : libInfo.Copyrights)
+  {
+    f3d::log::info("Copyright (C) " + cr + ".");
+  }
+  f3d::log::info("License " + libInfo.License + ".");
+  f3d::log::setUseColoring(true);
+  f3d::log::waitForUser();
+}
+
+//----------------------------------------------------------------------------
+void PrintReadersList()
+{
+  size_t nameColSize = 0;
+  size_t extsColSize = 0;
+  size_t mimeColSize = 0;
+  size_t descColSize = 0;
+  size_t plugColSize = 0;
+
+  std::vector<f3d::engine::readerInformation> readersInfo = f3d::engine::getReadersInfo();
+  if (readersInfo.empty())
+  {
+    f3d::log::warn("No registered reader found!");
+    return;
+  }
+  // Compute the size of the 5 columns
+  for (const auto& reader : readersInfo)
+  {
+    // There is at least one MIME type for each extension
+    assert(reader.Extensions.size() >= reader.MimeTypes.size());
+
+    nameColSize = std::max(nameColSize, reader.Name.length());
+    descColSize = std::max(descColSize, reader.Description.length());
+    plugColSize = std::max(plugColSize, reader.PluginName.length());
+
+    for (const auto& ext : reader.Extensions)
+    {
+      extsColSize = std::max(extsColSize, ext.length());
+    }
+    for (const auto& mime : reader.MimeTypes)
+    {
+      mimeColSize = std::max(mimeColSize, mime.length());
+    }
+  }
+  const size_t colGap = 4;
+  nameColSize += colGap;
+  extsColSize += colGap;
+  mimeColSize += colGap;
+  descColSize += colGap;
+  plugColSize += colGap;
+
+  std::string separator =
+    std::string(nameColSize + extsColSize + descColSize + mimeColSize + plugColSize - colGap, '-');
+
+  // Print the rows split in 3 columns
+  std::stringstream headerLine;
+  headerLine << std::left << std::setw(nameColSize) << "Name" << std::setw(plugColSize) << "Plugin"
+             << std::setw(descColSize) << "Description" << std::setw(extsColSize) << "Exts"
+             << std::setw(mimeColSize - colGap) << "Mime-types";
+  f3d::log::info(headerLine.str());
+  f3d::log::info(separator);
+
+  for (const auto& reader : readersInfo)
+  {
+    for (size_t i = 0; i < reader.Extensions.size(); i++)
+    {
+      std::stringstream readerLine;
+      readerLine << std::left;
+      readerLine << std::setw(nameColSize) << (i == 0 ? reader.Name : "");
+      readerLine << std::setw(plugColSize) << (i == 0 ? reader.PluginName : "");
+      readerLine << std::setw(descColSize) << (i == 0 ? reader.Description : "");
+      readerLine << std::setw(extsColSize)
+                 << (i < reader.Extensions.size() ? reader.Extensions[i] : "");
+      readerLine << std::setw(mimeColSize - colGap)
+                 << (i < reader.MimeTypes.size() ? reader.MimeTypes[i] : "");
+
+      f3d::log::info(readerLine.str());
+    }
+  }
+  f3d::log::waitForUser();
+}
+}
+
+//----------------------------------------------------------------------------
+std::pair<std::string, int> F3DOptionsTools::GetClosestOption(const std::string& option, bool checkLib)
+{
+  std::pair<std::string, int> ret = { "", std::numeric_limits<int>::max() };
+  auto checkDistance = [](const std::string& key, const std::string& name, std::pair<std::string, int>& ref) {
+    int distance = f3d::utils::textDistance(key, name);
+    if (distance < ref.second)
+    {
+      ref = { key, distance };
+    }
+  };
+
+  // Check positional arg `--input`
+  checkDistance("input", option, ret);
+
+  // Check true boolean options
+  for (std::string_view key : ::CLIBooleans)
+  {
+    checkDistance(std::string(key), option, ret);
+  }
+
+  // Check cli names in app options
+  for (const auto& [key, value] : F3DOptionsTools::DefaultAppOptions)
+  {
+    checkDistance(key, option, ret);
+  }
+
+  // Check cli names for libf3d options
+  for (const auto& [key, value] : F3DOptionsTools::LibOptionsNames)
+  {
+    checkDistance(std::string(key), option, ret);
+  }
+
+  // Check libf3d option names
+  if (checkLib)
+  {
+    f3d::options opt;
+    for (const std::string& key : opt.getNames())
+    {
+      checkDistance(key, option, ret);
+    }
+  }
+  return ret;
+}
+
+//----------------------------------------------------------------------------
+F3DOptionsTools::OptionsDict F3DOptionsTools::ParseCLIOptions(
+  int argc, char** argv, std::vector<std::string>& positionals)
+{
+  std::string execName = argc > 0 && argv[0][0] ? fs::path(argv[0]).filename().string() : "f3d";
+
+  // cxxopts values need to live somewhere until parsing is done
+  std::vector<std::shared_ptr<cxxopts::Value>> cxxoptsValues;
+  auto cxxoptsInputPositionals = cxxopts::value<std::vector<std::string>>(positionals);
+  try
+  {
+    cxxopts::Options cxxOptions(execName, F3D::AppTitle);
+    cxxOptions.custom_help("[OPTIONS...]");
+
+    for (const ::CLIGroup& optionGroup : ::CLIOptions)
+    {
+      auto group = cxxOptions.add_options(std::string(optionGroup.GroupName));
+
+      // Positional option, `--input` require a custom implementation
+      if (std::string(optionGroup.GroupName) == "Applicative")
+      {
+        group("input", "Input files", cxxoptsInputPositionals, "<files>");
+      }
+
+      // Add each option to cxxopts
+      for (const ::CLIOption& cliOption : optionGroup.Options)
+      {
+        if (cliOption.ValueHelper.empty())
+        {
+          // No ValueHelper means its a true boolean option like `--help` or `--version`
+          group(::CollapseName(cliOption.LongName, cliOption.ShortName), std::string(cliOption.HelpText));
+        }
+        else
+        {
+          // Add the default value to the help text if any
+          std::string defaultValue;
+          std::string helpText(cliOption.HelpText);
+
+          // Recover default value from app options
+          auto appIter = F3DOptionsTools::DefaultAppOptions.find(std::string(cliOption.LongName));
+          if (appIter != F3DOptionsTools::DefaultAppOptions.end())
+          {
+            defaultValue = appIter->second;
+          }
+          else
+          {
+            // Recover default value from lib options
+            auto libIter = F3DOptionsTools::LibOptionsNames.find(cliOption.LongName);
+            if (libIter != F3DOptionsTools::LibOptionsNames.end())
+            {
+              f3d::options opt;
+              defaultValue = opt.getAsString(std::string(libIter->second));
+            }
+          }
+
+          // Add default value to the help text directly
+          // Do not add it as a default value in cxxopts
+          // As it would add it to the parseResults
+          // which we do not want
+          if (!defaultValue.empty())
+          {
+            helpText += " (default: " + defaultValue + ")";
+          }
+
+          // Recover the implicit value and set it if any
+          cxxoptsValues.emplace_back(cxxopts::value<std::string>());
+          auto& val = cxxoptsValues.back();
+          if (!cliOption.ImplicitValue.empty())
+          {
+            val->implicit_value(std::string(cliOption.ImplicitValue));
+          }
+
+          // Add the cxxopts option
+          group(::CollapseName(cliOption.LongName, cliOption.ShortName), helpText, val,
+            std::string(cliOption.ValueHelper));
+        }
+      }
+    }
+
+    // Parse using cxxopts
+    cxxOptions.allow_unrecognised_options();
+    cxxOptions.positional_help("file1 file2 ...");
+    cxxOptions.parse_positional({ "input" });
+    cxxOptions.show_positional_help();
+    auto result = cxxOptions.parse(argc, argv);
+
+    // Check for unknown options and log them
+    auto unmatched = result.unmatched();
+    bool foundUnknownOption = false;
+    for (const std::string& unknownOption : unmatched)
+    {
+      f3d::log::error("Unknown option '", unknownOption, "'");
+      foundUnknownOption = true;
+
+      // check if it's a long option
+      if (unknownOption.substr(0, 2) == "--")
+      {
+        const size_t equalPos = unknownOption.find('=');
+
+        // remove "--" and everything after the first "=" (if any)
+        const std::string unknownName =
+          unknownOption.substr(2, equalPos != std::string::npos ? equalPos - 2 : equalPos);
+
+        auto [closestName, dist] = F3DOptionsTools::GetClosestOption(unknownName);
+        const std::string closestOption =
+          equalPos == std::string::npos ? closestName : closestName + unknownOption.substr(equalPos);
+
+        f3d::log::error("Did you mean '--", closestOption, "'?");
+      }
+    }
+    if (foundUnknownOption)
+    {
+      f3d::log::waitForUser();
+      throw F3DExFailure("unknown options");
+    }
+
+    // Check boolean options and log them if any
+    if (result.count("help") > 0)
+    {
+      ::PrintHelp(execName, cxxOptions);
+      throw F3DExNoProcess("help requested");
+    }
+    if (result.count("version") > 0)
+    {
+      ::PrintVersion();
+      throw F3DExNoProcess("version requested");
+    }
+    if (result.count("scan-plugins") > 0)
+    {
+      ::PrintPluginsScan();
+      throw F3DExNoProcess("scan plugins requested");
+    }
+    if (result.count("readers-list") > 0)
+    {
+      // `--readers-list` needs plugin to be loaded to be useful
+      // Load them manually
+      std::vector<std::string> plugins;
+      if (result.count("load-plugins") > 0)
+      {
+        plugins = f3d::options::parse<std::vector<std::string>>(result["load-plugins"].as<std::string>());
+      }
+      F3DPluginsTools::LoadPlugins(plugins);
+      ::PrintReadersList();
+      throw F3DExNoProcess("reader list requested");
+    }
+
+    // Add each CLI options into a vector of string/string and return it
+    F3DOptionsTools::OptionsDict cliOptionsDict;
+    for (const auto& res : result)
+    {
+      // Discard boolean option like `--version` or `--help`
+      if (std::find(::CLIBooleans.begin(), ::CLIBooleans.end(), res.key()) == ::CLIBooleans.end())
+      {
+        cliOptionsDict.emplace(res.key(), res.value());
+      }
+    }
+    return cliOptionsDict;
+  }
+  catch (const cxxopts::exceptions::exception& ex)
+  {
+    f3d::log::error("Error parsing command line arguments: ", ex.what());
+    throw F3DExFailure("Could not parse command line arguments");
+  }
+}
diff --git a/application/F3DOptionsTools.h b/application/F3DOptionsTools.h
new file mode 100644
index 0000000000..420bce30e1
--- /dev/null
+++ b/application/F3DOptionsTools.h
@@ -0,0 +1,146 @@
+#ifndef F3DOptionsTools_h
+#define F3DOptionsTools_h
+
+/**
+ * @class   F3DOptionsTools
+ * @brief   A namespace to handle and parse F3D Options
+ */
+#include "F3DConfig.h"
+
+#include <filesystem>
+#include <map>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace F3DOptionsTools
+{
+using OptionsDict = std::map<std::string, std::string>;
+using OptionsEntry = std::tuple<OptionsDict, std::filesystem::path, std::string>;
+using OptionsEntries = std::vector<OptionsEntry>;
+
+/**
+ * The "App" CLI options and their default values as string.
+ * Some F3D CLI options are not translated into libf3d options
+ * but into applicative code.
+ * Initialization is string based for easier processing in F3DStarter::UpdateOptions
+ * and ParseCLIOptions
+ */
+static inline const OptionsDict DefaultAppOptions = {
+  { "input", "" },
+  { "output", "" },
+  { "no-background", "false" },
+  { "config", "" },
+  { "dry-run", "false" },
+  { "no-render", "false" },
+  { "max-size", "-1.0" },
+  { "watch", "false" },
+  { "load-plugins", "" },
+  { "screenshot-filename", "{app}/{model}_{n}.png" },
+  { "verbose", "info" },
+  { "geometry-only", "false" },
+  { "group-geometries", "false" },
+  { "resolution", "1000, 600" },
+  { "position", "" },
+  { "colormap-file", "" },
+  { "camera-position", "" },
+  { "camera-focal-point", "" },
+  { "camera-view-up", "" },
+  { "camera-view-angle", "0.0" },
+  { "camera-direction", "" },
+  { "camera-zoom-factor", "0.0" },
+  { "camera-azimuth-angle", "0.0" },
+  { "camera-elevation-angle", "0.0" },
+  { "ref", "" },
+  { "ref-threshold", "0.05" },
+  { "interaction-test-record", "" },
+  { "interaction-test-play", "" },
+};
+
+/**
+ * Mapping of CLI option name to their libf3d options name counterpart
+ */
+static inline const std::map<std::string_view, std::string_view> LibOptionsNames = {
+  { "progress", "ui.loader_progress" },
+  { "animation-progress", "ui.animation_progress" },
+  { "up", "scene.up_direction" },
+  { "axis", "interactor.axis" },
+  { "grid", "render.grid.enable" },
+  { "grid-absolute", "render.grid.absolute" },
+  { "grid-unit", "render.grid.unit" },
+  { "grid-subdivisions", "render.grid.subdivisions" },
+  { "grid-color", "render.grid.color" },
+  { "edges", "render.show_edges" },
+  { "camera-index", "scene.camera.index" },
+  { "trackball", "interactor.trackball" },
+  { "invert-zoom", "interactor.invert_zoom" },
+  { "animation-autoplay", "scene.animation.autoplay" },
+  { "animation-index", "scene.animation.index" },
+  { "animation-speed-factor", "scene.animation.speed_factor" },
+  { "animation-time", "scene.animation.time" },
+  { "animation-frame-rate", "scene.animation.frame_rate" },
+  { "font-file", "ui.font_file" },
+  { "point-sprites", "model.point_sprites.enable" },
+  { "point-type", "model.point_sprites.type" },
+  { "point-size", "render.point_size" },
+  { "line-width", "render.line_width" },
+  { "backface-type", "render.backface_type" },
+  { "color", "model.color.rgb" },
+  { "opacity", "model.color.opacity" },
+  { "roughness", "model.material.roughness" },
+  { "metallic", "model.material.metallic" },
+  { "hdri-file", "render.hdri.file" },
+  { "hdri-ambient", "render.hdri.ambient" },
+  { "hdri-skybox", "render.background.skybox" },
+  { "texture-matcap", "model.matcap.texture" },
+  { "texture-base-color", "model.color.texture" },
+  { "texture-material", "model.material.texture" },
+  { "texture-emissive", "model.emissive.texture" },
+  { "emissive-factor", "model.emissive.factor" },
+  { "texture-normal", "model.normal.texture" },
+  { "normal-scale", "model.normal.scale" },
+  { "bg-color", "render.background.color" },
+  { "fps", "ui.fps" },
+  { "filename", "ui.filename" },
+  { "metadata", "ui.metadata" },
+  { "blur-background", "render.background.blur" },
+  { "blur-coc", "render.background.blur_coc" },
+  { "scalar-coloring", "model.scivis.enable" },
+  { "coloring-array", "model.scivis.array_name" },
+  { "light-intensity", "render.light.intensity" },
+  { "comp", "model.scivis.component" },
+  { "cells", "model.scivis.cells" },
+  { "range", "model.scivis.range" },
+  { "bar", "ui.scalar_bar" },
+  { "colormap", "model.scivis.colormap" },
+  { "volume", "model.volume.enable" },
+  { "inverse", "model.volume.inverse" },
+  { "camera-orthographic", "scene.camera.orthographic" },
+  { "raytracing", "render.raytracing.enable" },
+  { "samples", "render.raytracing.samples" },
+  { "denoise", "render.raytracing.denoise" },
+  { "translucency-support", "render.effect.translucency_support" },
+  { "ambient-occlusion", "render.effect.ambient_occlusion" },
+  { "anti-aliasing", "render.effect.anti_aliasing" },
+  { "tone-mapping", "render.effect.tone_mapping" },
+  { "final-shader", "render.effect.final_shader" },
+};
+
+/**
+ * Browse through all possible option names to find one that have the smallest distance to the
+ * provided option.
+ * If checkLib is true, even check in the libf3d option names
+ * Return a pair containing the closest option name and the associated distance
+ */
+std::pair<std::string, int> GetClosestOption(const std::string& option, bool checkLib = false);
+
+/**
+ * Parse CLI options from provided argc/argv and returns them as a OptionsDict.
+ * Also set positionals vector in the process.
+ * Do not parse option value into actual values.
+ */
+F3DOptionsTools::OptionsDict ParseCLIOptions(
+  int argc, char** argv, std::vector<std::string>& positionals);
+};
+
+#endif
diff --git a/application/F3DPluginsTools.cxx b/application/F3DPluginsTools.cxx
new file mode 100644
index 0000000000..9b15f4285a
--- /dev/null
+++ b/application/F3DPluginsTools.cxx
@@ -0,0 +1,48 @@
+#include "F3DPluginsTools.h"
+
+#include "F3DConfig.h"
+#include "F3DSystemTools.h"
+
+#include <engine.h>
+#include <log.h>
+
+namespace
+{
+//----------------------------------------------------------------------------
+std::vector<std::string> GetPluginSearchPaths()
+{
+  // Recover F3D_PLUGINS_PATH first
+  auto searchPaths = F3DSystemTools::GetVectorEnvironnementVariable("F3D_PLUGINS_PATH");
+#if F3D_MACOS_BUNDLE
+  return searchPaths;
+#else
+  // Add a executable related path
+  auto tmpPath = F3DSystemTools::GetApplicationPath();
+  tmpPath = tmpPath.parent_path().parent_path();
+  tmpPath /= F3D::PluginsInstallDir;
+  searchPaths.push_back(tmpPath.string());
+  return searchPaths;
+#endif
+}
+};
+
+//----------------------------------------------------------------------------
+void F3DPluginsTools::LoadPlugins(const std::vector<std::string>& plugins)
+{
+  try
+  {
+    f3d::engine::autoloadPlugins();
+
+    for (const std::string& plugin : plugins)
+    {
+      if (!plugin.empty())
+      {
+        f3d::engine::loadPlugin(plugin, ::GetPluginSearchPaths());
+      }
+    }
+  }
+  catch (const f3d::engine::plugin_exception& e)
+  {
+    f3d::log::warn("Plugin failed to load: ", e.what());
+  }
+}
diff --git a/application/F3DPluginsTools.h b/application/F3DPluginsTools.h
new file mode 100644
index 0000000000..42af7e4588
--- /dev/null
+++ b/application/F3DPluginsTools.h
@@ -0,0 +1,17 @@
+/**
+ * @class   F3DPluginsTools
+ * @brief   A namespace to load plugins
+ *
+ */
+#ifndef F3DPluginsTools_h
+#define F3DPluginsTools_h
+
+#include <string>
+#include <vector>
+
+namespace F3DPluginsTools
+{
+void LoadPlugins(const std::vector<std::string>& plugins);
+};
+
+#endif
diff --git a/application/F3DStarter.cxx b/application/F3DStarter.cxx
index 63a42c2f43..52f87aa960 100644
--- a/application/F3DStarter.cxx
+++ b/application/F3DStarter.cxx
@@ -2,9 +2,11 @@
 
 #include "F3DColorMapTools.h"
 #include "F3DConfig.h"
+#include "F3DConfigFileTools.h"
 #include "F3DIcon.h"
 #include "F3DNSDelegate.h"
-#include "F3DOptionsParser.h"
+#include "F3DOptionsTools.h"
+#include "F3DPluginsTools.h"
 #include "F3DSystemTools.h"
 
 #define DMON_IMPL
@@ -47,38 +49,75 @@ class F3DStarter::F3DInternals
 public:
   F3DInternals() = default;
 
-  void SetupCamera(const F3DAppOptions& appOptions)
+  // XXX: The values in the following two structs
+  // are left uninitialized as the will all be initialized from
+  // F3DOptionsTools::DefaultAppOptions
+  struct CameraConfiguration
+  {
+    std::vector<double> CameraPosition;
+    std::vector<double> CameraFocalPoint;
+    std::vector<double> CameraViewUp;
+    double CameraViewAngle;
+    std::vector<double> CameraDirection;
+    double CameraZoomFactor;
+    double CameraAzimuthAngle;
+    double CameraElevationAngle;
+  };
+
+  struct F3DAppOptions
+  {
+    std::string Output;
+    bool NoBackground;
+    bool NoRender;
+    double MaxSize;
+    bool Watch;
+    std::vector<std::string> Plugins;
+    std::string ScreenshotFilename;
+    std::string VerboseLevel;
+    bool GeometryOnly;
+    bool GroupGeometries;
+    std::vector<int> Resolution;
+    std::vector<int> Position;
+    std::string ColorMapFile;
+    CameraConfiguration CamConf;
+    std::string Reference;
+    double RefThreshold;
+    std::string InteractionTestRecordFile;
+    std::string InteractionTestPlayFile;
+  };
+
+  void SetupCamera(const CameraConfiguration& camConf)
   {
     f3d::camera& cam = this->Engine->getWindow().getCamera();
-    if (appOptions.CameraPosition.size() == 3)
+    if (camConf.CameraPosition.size() == 3)
     {
       f3d::point3_t pos;
-      std::copy_n(appOptions.CameraPosition.begin(), 3, pos.begin());
+      std::copy_n(camConf.CameraPosition.begin(), 3, pos.begin());
       cam.setPosition(pos);
     }
-    if (appOptions.CameraFocalPoint.size() == 3)
+    if (camConf.CameraFocalPoint.size() == 3)
     {
       f3d::point3_t foc;
-      std::copy_n(appOptions.CameraFocalPoint.begin(), 3, foc.begin());
+      std::copy_n(camConf.CameraFocalPoint.begin(), 3, foc.begin());
       cam.setFocalPoint(foc);
     }
-    if (appOptions.CameraViewUp.size() == 3)
+    if (camConf.CameraViewUp.size() == 3)
     {
       f3d::vector3_t up;
-      std::copy_n(appOptions.CameraViewUp.begin(), 3, up.begin());
+      std::copy_n(camConf.CameraViewUp.begin(), 3, up.begin());
       cam.setViewUp(up);
     }
-    if (appOptions.CameraViewAngle > 0)
+    if (camConf.CameraViewAngle > 0)
     {
-      cam.setViewAngle(appOptions.CameraViewAngle);
+      cam.setViewAngle(camConf.CameraViewAngle);
     }
 
     bool reset = false;
     double zoomFactor = 0.9;
-    if (appOptions.CameraPosition.size() != 3 && appOptions.CameraDirection.size() == 3)
+    if (camConf.CameraPosition.size() != 3 && camConf.CameraDirection.size() == 3)
     {
       f3d::vector3_t dir;
-      std::copy_n(appOptions.CameraDirection.begin(), 3, dir.begin());
+      std::copy_n(camConf.CameraDirection.begin(), 3, dir.begin());
       f3d::point3_t foc;
       f3d::point3_t pos;
       cam.getFocalPoint(foc);
@@ -89,9 +128,9 @@ class F3DStarter::F3DInternals
       cam.setPosition(pos);
       reset = true;
     }
-    if (appOptions.CameraPosition.size() != 3 && appOptions.CameraZoomFactor > 0)
+    if (camConf.CameraPosition.size() != 3 && camConf.CameraZoomFactor > 0)
     {
-      zoomFactor = appOptions.CameraZoomFactor;
+      zoomFactor = camConf.CameraZoomFactor;
       reset = true;
     }
     if (reset)
@@ -99,8 +138,8 @@ class F3DStarter::F3DInternals
       cam.resetToBounds(zoomFactor);
     }
 
-    cam.azimuth(appOptions.CameraAzimuthAngle)
-      .elevation(appOptions.CameraElevationAngle)
+    cam.azimuth(camConf.CameraAzimuthAngle)
+      .elevation(camConf.CameraElevationAngle)
       .setCurrentAsDefault();
   }
 
@@ -153,6 +192,12 @@ class F3DStarter::F3DInternals
       f3d::log::warn("Unrecognized verbose level: ", level,
         ", Ignoring. Possible values are quiet, error, warning, info, debug");
     }
+
+    if (forceStdErr)
+    {
+      f3d::log::info("Output image will be saved to stdout, all log types including debug and info "
+                     "levels are redirected to stderr");
+    }
   }
 
   static void dmonFolderChanged(
@@ -203,7 +248,7 @@ class F3DStarter::F3DInternals
    * - `{n:2}`, `{n:3}`, ...: zero-padded auto-incremented number to make filename unique
    *   (up to 1000000)
    */
-  std::filesystem::path applyFilenameTemplate(const std::string& templateString)
+  fs::path applyFilenameTemplate(const std::string& templateString)
   {
     constexpr size_t maxNumberingAttempts = 1000000;
     const std::regex numberingRe("\\{(n:?([0-9]*))\\}");
@@ -350,7 +395,7 @@ class F3DStarter::F3DInternals
     for (size_t i = 1; i <= maxNumberingAttempts; ++i)
     {
       const std::string candidate = applyNumbering(i);
-      if (!std::filesystem::exists(candidate))
+      if (!fs::exists(candidate))
       {
         return { candidate };
       }
@@ -359,15 +404,214 @@ class F3DStarter::F3DInternals
       std::to_string(maxNumberingAttempts) + " attempts");
   }
 
-  F3DOptionsParser Parser;
+  void UpdateOptions(
+    const std::vector<F3DOptionsTools::OptionsEntries>& entriesVector, const std::string& inputFile)
+  {
+    f3d::log::debug("Updating Options:");
+    // Initialize libf3dOptions
+    f3d::options libOptions;
+    libOptions.ui.dropzone_info = "Drop a file or HDRI to load it\nPress H to show cheatsheet";
+
+    // Copy appOptions
+    F3DOptionsTools::OptionsDict appOptions = F3DOptionsTools::DefaultAppOptions;
+
+    // Logging specific map
+    bool logOptions = this->AppOptions.VerboseLevel == "debug";
+    std::map<std::string, std::tuple<std::string, fs::path, std::string, std::string>> loggingMap;
+
+    // For each config entries, ordered by priority
+    for (const auto& entries : entriesVector)
+    {
+      // For each entry (eg: difference config files)
+      for (auto const& [conf, source, pattern] : entries)
+      {
+        std::regex re(pattern, std::regex_constants::icase);
+        std::smatch matches;
+        // If the source is empty, there is no pattern, all options applies
+        // Note: An empty inputFile matches with ".*"
+        if (source.empty() || std::regex_match(inputFile, matches, re))
+        {
+          // For each option key/value
+          for (auto const& [key, value] : conf)
+          {
+            // Check in appOptions first
+            auto appIter = appOptions.find(key);
+            if (appIter != appOptions.end())
+            {
+              appOptions[key] = value;
+              if (logOptions)
+              {
+                loggingMap.emplace(key, std::tuple(key, source, pattern, value));
+              }
+              continue;
+            }
+
+            std::string libf3dOptionName = key;
+
+            // Convert key into a libf3d option name if possible
+            auto libf3dIter = F3DOptionsTools::LibOptionsNames.find(key);
+            if (libf3dIter != F3DOptionsTools::LibOptionsNames.end())
+            {
+              libf3dOptionName = std::string(libf3dIter->second);
+            }
+
+            try
+            {
+              // Assume this is a libf3d option and set the value
+              libOptions.setAsString(libf3dOptionName, value);
+            }
+            catch (const f3d::options::parsing_exception& ex)
+            {
+              std::string origin =
+                source.empty() ? pattern : source.string() + ":`" + pattern + "`";
+              f3d::log::warn("Could not set '", key, "' to '", value, "' from ", origin,
+                " because: ", ex.what());
+              continue;
+            }
+            catch (const f3d::options::inexistent_exception&)
+            {
+              std::string origin =
+                source.empty() ? pattern : source.string() + ":`" + pattern + "`";
+              auto [closestName, dist] = F3DOptionsTools::GetClosestOption(libf3dOptionName, true);
+              f3d::log::warn("'", key, "' option from ", origin,
+                " does not exists , did you mean '", closestName, "'?");
+              continue;
+            }
+            if (logOptions)
+            {
+              loggingMap.emplace(libf3dOptionName, std::tuple(key, source, pattern, value));
+            }
+          }
+        }
+      }
+    }
+
+    for (const auto& [key, tuple] : loggingMap)
+    {
+      const auto& [name, source, pattern, value] = tuple;
+      std::string origin = source.empty() ? pattern : source.string() + ":`" + pattern + "`";
+      f3d::log::debug(" '", name, "' = '", value, "' from ", origin);
+    }
+
+    // Update typed app options from the string version
+    this->UpdateTypedAppOptions(appOptions);
+
+    // Update Verbose level as soon as possible
+    F3DInternals::SetVerboseLevel(this->AppOptions.VerboseLevel, this->AppOptions.Output == "-");
+
+    // Load any new plugins
+    F3DPluginsTools::LoadPlugins(this->AppOptions.Plugins);
+
+    // Update libf3d options
+    this->LibOptions = libOptions;
+
+    // Update options that depends on both app and libf3d options
+    this->UpdateInterdependentOptions();
+  }
+
+  void UpdateTypedAppOptions(const std::map<std::string, std::string>& appOptions)
+  {
+    // Update typed app options from app options
+    this->AppOptions.Output = f3d::options::parse<std::string>(appOptions.at("output"));
+    this->AppOptions.NoBackground = f3d::options::parse<bool>(appOptions.at("no-background"));
+    this->AppOptions.NoRender = f3d::options::parse<bool>(appOptions.at("no-render"));
+    this->AppOptions.MaxSize = f3d::options::parse<double>(appOptions.at("max-size"));
+    this->AppOptions.Watch = f3d::options::parse<bool>(appOptions.at("watch"));
+    this->AppOptions.Plugins = { f3d::options::parse<std::vector<std::string>>(
+      appOptions.at("load-plugins")) };
+    this->AppOptions.ScreenshotFilename =
+      f3d::options::parse<std::string>(appOptions.at("screenshot-filename"));
+    this->AppOptions.VerboseLevel = f3d::options::parse<std::string>(appOptions.at("verbose"));
+    this->AppOptions.GeometryOnly = f3d::options::parse<bool>(appOptions.at("geometry-only"));
+    this->AppOptions.GroupGeometries = f3d::options::parse<bool>(appOptions.at("group-geometries"));
+    this->AppOptions.Resolution =
+      f3d::options::parse<std::vector<int>>(appOptions.at("resolution"));
+    this->AppOptions.Position = f3d::options::parse<std::vector<int>>(appOptions.at("position"));
+    this->AppOptions.ColorMapFile =
+      f3d::options::parse<std::string>(appOptions.at("colormap-file"));
+
+    this->AppOptions.CamConf = { f3d::options::parse<std::vector<double>>(
+                                   appOptions.at("camera-position")),
+      f3d::options::parse<std::vector<double>>(appOptions.at("camera-focal-point")),
+      f3d::options::parse<std::vector<double>>(appOptions.at("camera-view-up")),
+      f3d::options::parse<double>(appOptions.at("camera-view-angle")),
+      f3d::options::parse<std::vector<double>>(appOptions.at("camera-direction")),
+      f3d::options::parse<double>(appOptions.at("camera-zoom-factor")),
+      f3d::options::parse<double>(appOptions.at("camera-azimuth-angle")),
+      f3d::options::parse<double>(appOptions.at("camera-elevation-angle")) };
+
+    this->AppOptions.Reference = f3d::options::parse<std::string>(appOptions.at("ref"));
+    this->AppOptions.RefThreshold = f3d::options::parse<double>(appOptions.at("ref-threshold"));
+    this->AppOptions.InteractionTestRecordFile =
+      f3d::options::parse<std::string>(appOptions.at("interaction-test-record"));
+    this->AppOptions.InteractionTestPlayFile =
+      f3d::options::parse<std::string>(appOptions.at("interaction-test-play"));
+  }
+
+  void UpdateInterdependentOptions()
+  {
+    // colormap-file and colormap are interdependent
+    const std::string& colorMapFile = this->AppOptions.ColorMapFile;
+    if (!colorMapFile.empty())
+    {
+      std::string fullPath = F3DColorMapTools::Find(colorMapFile);
+
+      if (!fullPath.empty())
+      {
+        this->LibOptions.model.scivis.colormap = F3DColorMapTools::Read(fullPath);
+      }
+      else
+      {
+        f3d::log::error("Cannot find the colormap ", colorMapFile);
+        this->LibOptions.model.scivis.colormap = std::vector<double>{};
+      }
+    }
+  }
+
+  void ApplyPositionAndResolution()
+  {
+    if (!this->AppOptions.NoRender)
+    {
+      f3d::window& window = this->Engine->getWindow();
+      if (this->AppOptions.Resolution.size() == 2)
+      {
+        window.setSize(this->AppOptions.Resolution[0], this->AppOptions.Resolution[1]);
+      }
+      else if (this->AppOptions.Resolution.size() != 0)
+      {
+        f3d::log::warn("Provided resolution could not be applied");
+      }
+
+      if (this->AppOptions.Position.size() == 2)
+      {
+        window.setPosition(this->AppOptions.Position[0], this->AppOptions.Position[1]);
+      }
+      else
+      {
+        if (this->AppOptions.Position.size() != 0)
+        {
+          f3d::log::warn("Provided position could not be applied");
+        }
+
+#ifdef __APPLE__
+        // The default position (50, 50) in VTK on MacOS is not a great fit for F3D as it can be
+        // partially hidden because the position correspond to the upper left corner and the Y
+        // position is defined from the bottom of the screen. Position it somewhere it makes sense.
+        window.setPosition(100, 800);
+#endif
+      }
+    }
+  }
+
   F3DAppOptions AppOptions;
-  f3d::options DynamicOptions;
-  f3d::options FileOptions;
+  f3d::options LibOptions;
+  F3DOptionsTools::OptionsEntries ConfigOptionsEntries;
+  F3DOptionsTools::OptionsEntries CLIOptionsEntries;
+  F3DOptionsTools::OptionsEntries DynamicOptionsEntries;
   std::unique_ptr<f3d::engine> Engine;
   std::vector<fs::path> FilesList;
   dmon_watch_id FolderWatchId;
   bool LoadedFile = false;
-  bool UpdateWithCommandLineParsing = true;
 
   // dmon used atomic and mutex
   std::atomic<int> CurrentFileIndex = -1;
@@ -382,10 +626,6 @@ class F3DStarter::F3DInternals
 F3DStarter::F3DStarter()
   : Internals(std::make_unique<F3DStarter::F3DInternals>())
 {
-  // Set option outside of command line and config file
-  this->Internals->DynamicOptions.ui.dropzone_info =
-    "Drop a file or HDRI to load it\nPress H to show cheatsheet";
-
   // Initialize dmon
   dmon_init();
 }
@@ -400,43 +640,56 @@ F3DStarter::~F3DStarter()
 //----------------------------------------------------------------------------
 int F3DStarter::Start(int argc, char** argv)
 {
-  // Parse command line options
-  std::vector<std::string> files;
-  this->Internals->Parser.Initialize(argc, argv);
-  this->Internals->Parser.GetOptions(
-    this->Internals->AppOptions, this->Internals->DynamicOptions, files);
-
-  const bool renderToStdout = this->Internals->AppOptions.Output == "-";
-
-  // Set verbosity level early from command line
-  F3DInternals::SetVerboseLevel(this->Internals->AppOptions.VerboseLevel, renderToStdout);
-
-  if (renderToStdout)
+  // Parse CLI Options into an option dict
+  std::vector<std::string> inputFiles;
+  F3DOptionsTools::OptionsDict cliOptionsDict =
+    F3DOptionsTools::ParseCLIOptions(argc, argv, inputFiles);
+
+  // Store in a option entries for easier processing
+  this->Internals->CLIOptionsEntries.emplace_back(cliOptionsDict, fs::path(), "CLI options");
+
+  // Check dry-run, config CLI, output and verbose options first
+  // XXX: the local variable are initialized manually for simplicity
+  // but this duplicate the initialization value as it is present in
+  // F3DOptionTools::DefaultAppOptions too
+  bool dryRun = false;
+  if (cliOptionsDict.find("no-render") != cliOptionsDict.end())
+  {
+    dryRun = f3d::options::parse<bool>(cliOptionsDict["no-render"]);
+  }
+  std::string config;
+  if (cliOptionsDict.find("config") != cliOptionsDict.end())
+  {
+    config = f3d::options::parse<std::string>(cliOptionsDict["config"]);
+  }
+  bool renderToStdout = false;
+  if (cliOptionsDict.find("output") != cliOptionsDict.end())
+  {
+    renderToStdout = f3d::options::parse<std::string>(cliOptionsDict["output"]) == "-";
+  }
+  this->Internals->AppOptions.VerboseLevel = "info";
+  if (cliOptionsDict.find("verbose") != cliOptionsDict.end())
   {
-    f3d::log::info("Output image will be saved to stdout, all log types including debug and info "
-                   "levels are redirected to stderr");
+    this->Internals->AppOptions.VerboseLevel =
+      f3d::options::parse<std::string>(cliOptionsDict["verbose"]);
   }
 
-  f3d::log::debug("========== Initializing ==========");
+  // Set verbosity level early from command line
+  F3DInternals::SetVerboseLevel(this->Internals->AppOptions.VerboseLevel, renderToStdout);
 
-  // Load plugins from the app options
-  this->Internals->Parser.LoadPlugins(this->Internals->AppOptions);
+  f3d::log::debug("========== Initializing Options ==========");
 
-  // Read config file if needed
-  if (!this->Internals->AppOptions.DryRun)
+  // Read config files
+  if (!dryRun)
   {
-    // Initialize the config file dictionary
-    this->Internals->Parser.InitializeDictionaryFromConfigFile(
-      this->Internals->AppOptions.UserConfigFile);
-
-    // Parse command line options with config file, global section only
-    this->Internals->Parser.GetOptions(
-      this->Internals->AppOptions, this->Internals->DynamicOptions, files);
-
-    // Set verbosity level again if it was defined in the configuration file global block
-    F3DInternals::SetVerboseLevel(this->Internals->AppOptions.VerboseLevel, renderToStdout);
+    this->Internals->ConfigOptionsEntries = F3DConfigFileTools::ReadConfigFiles(config);
   }
 
+  // Update app and libf3d options based on config entries, with an empty input file
+  // config < cli
+  this->Internals->UpdateOptions(
+    { this->Internals->ConfigOptionsEntries, this->Internals->CLIOptionsEntries }, "");
+
 #if __APPLE__
   // Initialize MacOS delegate
   F3DNSDelegate::InitializeDelegate(this);
@@ -444,18 +697,23 @@ int F3DStarter::Start(int argc, char** argv)
 
   f3d::log::debug("========== Configuring engine ==========");
 
+  const std::string& reference = this->Internals->AppOptions.Reference;
+  const std::string& output = this->Internals->AppOptions.Output;
+
   if (this->Internals->AppOptions.NoRender)
   {
     this->Internals->Engine = std::make_unique<f3d::engine>(f3d::window::Type::NONE);
   }
   else
   {
-    bool offscreen =
-      !this->Internals->AppOptions.Reference.empty() || !this->Internals->AppOptions.Output.empty();
+    bool offscreen = !reference.empty() || !output.empty();
     this->Internals->Engine = std::make_unique<f3d::engine>(
       offscreen ? f3d::window::Type::NATIVE_OFFSCREEN : f3d::window::Type::NATIVE);
 
     f3d::window& window = this->Internals->Engine->getWindow();
+    window.setWindowName(F3D::AppTitle).setIcon(F3DIcon, sizeof(F3DIcon));
+    this->Internals->ApplyPositionAndResolution();
+
     f3d::interactor& interactor = this->Internals->Engine->getInteractor();
     interactor.setKeyPressCallBack(
       [this](int, const std::string& keySym) -> bool
@@ -530,48 +788,13 @@ int F3DStarter::Start(int argc, char** argv)
         this->RequestRender();
         return true;
       });
-    window
-      .setSize(this->Internals->AppOptions.Resolution[0], this->Internals->AppOptions.Resolution[1])
-      .setWindowName(F3D::AppTitle)
-      .setIcon(F3DIcon, sizeof(F3DIcon));
-
-    if (this->Internals->AppOptions.Position.size() == 2)
-    {
-      window.setPosition(
-        this->Internals->AppOptions.Position[0], this->Internals->AppOptions.Position[1]);
-    }
-#ifdef __APPLE__
-    else
-    {
-      // The default position (50, 50) in VTK on MacOS is not a great fit for F3D as it can be
-      // partially hidden because the position correspond to the upper left corner and the Y
-      // position is defined from the bottom of the screen. Position it somewhere it makes sense.
-      window.setPosition(100, 800);
-    }
-#endif
-  }
-
-  // Parse colormap
-  if (!this->Internals->AppOptions.ColorMapFile.empty())
-  {
-    std::string fullPath = F3DColorMapTools::Find(this->Internals->AppOptions.ColorMapFile);
-
-    if (!fullPath.empty())
-    {
-      this->Internals->Engine->getOptions().model.scivis.colormap =
-        F3DColorMapTools::Read(fullPath);
-    }
-    else
-    {
-      f3d::log::error("Cannot find the colormap ", this->Internals->AppOptions.ColorMapFile);
-      this->Internals->Engine->getOptions().model.scivis.colormap = std::vector<double>{};
-    }
   }
 
+  this->Internals->Engine->setOptions(this->Internals->LibOptions);
   f3d::log::debug("Engine configured");
 
-  // Add all files
-  for (auto& file : files)
+  // Add all input files
+  for (auto& file : inputFiles)
   {
     this->AddFile(fs::path(file));
   }
@@ -585,20 +808,24 @@ int F3DStarter::Start(int argc, char** argv)
     f3d::interactor& interactor = this->Internals->Engine->getInteractor();
 
     // Play recording if any
-    if (!this->Internals->AppOptions.InteractionTestPlayFile.empty())
+    const std::string& interactionTestPlayFile =
+      this->Internals->AppOptions.InteractionTestPlayFile;
+    if (!interactionTestPlayFile.empty())
     {
       // For better testing, render once before the interaction
       window.render();
-      if (!interactor.playInteraction(this->Internals->AppOptions.InteractionTestPlayFile))
+      if (!interactor.playInteraction(interactionTestPlayFile))
       {
         return EXIT_FAILURE;
       }
     }
 
     // Start recording if needed
-    if (!this->Internals->AppOptions.InteractionTestRecordFile.empty())
+    const std::string& interactionTestRecordFile =
+      this->Internals->AppOptions.InteractionTestRecordFile;
+    if (!interactionTestRecordFile.empty())
     {
-      if (!interactor.recordInteraction(this->Internals->AppOptions.InteractionTestRecordFile))
+      if (!interactor.recordInteraction(interactionTestRecordFile))
       {
         return EXIT_FAILURE;
       }
@@ -607,7 +834,7 @@ int F3DStarter::Start(int argc, char** argv)
     char* noDataForceRender = std::getenv("CTEST_F3D_NO_DATA_FORCE_RENDER");
 
     // Render and compare with file if needed
-    if (!this->Internals->AppOptions.Reference.empty())
+    if (!reference.empty())
     {
       if (!this->Internals->LoadedFile && !noDataForceRender)
       {
@@ -615,33 +842,32 @@ int F3DStarter::Start(int argc, char** argv)
         return EXIT_FAILURE;
       }
 
-      if (!fs::exists(this->Internals->AppOptions.Reference))
+      if (!fs::exists(reference))
       {
-        if (this->Internals->AppOptions.Output.empty())
+        if (output.empty())
         {
-          f3d::log::error("Reference image ", this->Internals->AppOptions.Reference,
+          f3d::log::error("Reference image ", reference,
             " does not exist, use the output option to output current rendering into an image "
             "file.\n");
         }
         else
         {
-          window.renderToImage(this->Internals->AppOptions.NoBackground)
-            .save(this->Internals->AppOptions.Output);
+          window.renderToImage(this->Internals->AppOptions.NoBackground).save(output);
 
-          f3d::log::error("Reference image " + this->Internals->AppOptions.Reference +
-            " does not exist, current rendering has been outputted to " +
-            this->Internals->AppOptions.Output + ".\n");
+          f3d::log::error("Reference image " + reference +
+            " does not exist, current rendering has been outputted to " + output + ".\n");
         }
         return EXIT_FAILURE;
       }
 
       f3d::image img = window.renderToImage(this->Internals->AppOptions.NoBackground);
-      f3d::image ref(this->Internals->AppOptions.Reference);
+      f3d::image ref(reference);
       f3d::image diff;
       double error;
-      if (!img.compare(ref, this->Internals->AppOptions.RefThreshold, error))
+      const double& threshold = this->Internals->AppOptions.RefThreshold;
+      if (!img.compare(ref, threshold, error))
       {
-        if (this->Internals->AppOptions.Output.empty())
+        if (output.empty())
         {
           f3d::log::error("Use the --output option to be able to output current rendering and diff "
                           "images into files.\n");
@@ -649,9 +875,9 @@ int F3DStarter::Start(int argc, char** argv)
         else
         {
           f3d::log::error("Current rendering difference with reference image: ", error,
-            " is higher than the threshold of ", this->Internals->AppOptions.RefThreshold, ".\n");
+            " is higher than the threshold of ", threshold, ".\n");
 
-          img.save(this->Internals->AppOptions.Output);
+          img.save(output);
         }
         return EXIT_FAILURE;
       }
@@ -667,7 +893,7 @@ int F3DStarter::Start(int argc, char** argv)
       }
     }
     // Render to file if needed
-    else if (!this->Internals->AppOptions.Output.empty())
+    else if (!output.empty())
     {
       if (!this->Internals->LoadedFile && !noDataForceRender)
       {
@@ -686,8 +912,7 @@ int F3DStarter::Start(int argc, char** argv)
       }
       else
       {
-        std::filesystem::path path =
-          this->Internals->applyFilenameTemplate(this->Internals->AppOptions.Output);
+        fs::path path = this->Internals->applyFilenameTemplate(output);
         img.save(path.string());
         f3d::log::debug("Output image saved to ", path);
       }
@@ -712,7 +937,6 @@ int F3DStarter::Start(int argc, char** argv)
 #endif
     }
   }
-
   return EXIT_SUCCESS;
 }
 
@@ -726,24 +950,27 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
   }
 
   f3d::log::debug("========== Loading 3D file ==========");
-  // When loading a file, store any changed options
-  // into the dynamic options and use these dynamic option as the default
-  // for loading the file while still applying file specific options on top of it
 
-  // Recover previous options from the engine
-  const f3d::options& previousOptions = this->Internals->Engine->getOptions();
+  // Recover current options from the engine
+  const f3d::options& dynamicOptions = this->Internals->Engine->getOptions();
 
-  // Detect changed options and apply the change to the dynamic options
+  // Detect interactively changed options and store them into the dynamic options dict
   // options names are shared between options instance
-  std::vector<std::string> optionNames = this->Internals->DynamicOptions.getNames();
+  F3DOptionsTools::OptionsDict dynamicOptionsDict;
+  std::vector<std::string> optionNames = this->Internals->LibOptions.getNames();
   for (const auto& name : optionNames)
   {
-    if (!previousOptions.isSame(this->Internals->FileOptions, name))
+    if (!dynamicOptions.isSame(this->Internals->LibOptions, name))
     {
-      this->Internals->DynamicOptions.copy(previousOptions, name);
+      dynamicOptionsDict[name] = dynamicOptions.getAsString(name);
     }
   }
 
+  // Add the dynamicOptionsDict into the entries, which grows over time if option keep changing and
+  // files keep being loaded
+  this->Internals->DynamicOptionsEntries.emplace_back(
+    dynamicOptionsDict, fs::path(), "dynamic options");
+
   // Recover file information
   f3d::loader& loader = this->Internals->Engine->getLoader();
   fs::path filePath;
@@ -760,6 +987,7 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
     {
       this->Internals->CurrentFileIndex = index;
     }
+    // Create a nice looking filename info eg: "cow.vtp (1/5)"
     // XXX Do not work if CurrentFileIndex + size < 0
     size_t fileIndex = (this->Internals->CurrentFileIndex + size) % size;
     filePath = this->Internals->FilesList[fileIndex];
@@ -772,10 +1000,6 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
   {
     f3d::log::debug("No file to load provided.");
     this->Internals->CurrentFileIndex = -1;
-
-    // Copy dynamic options into files options to get the global config
-    this->Internals->FileOptions = this->Internals->DynamicOptions;
-    this->Internals->Engine->setOptions(this->Internals->FileOptions);
   }
 
   if (this->Internals->CurrentFileIndex >= 0)
@@ -787,24 +1011,27 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
       filePath = this->Internals->FilesList[static_cast<size_t>(this->Internals->CurrentFileIndex)];
     }
 
-    // Update options for the file to load, using dynamic options as default
-    this->Internals->FileOptions = this->Internals->DynamicOptions;
-    F3DAppOptions fileAppOptions = this->Internals->AppOptions;
-    this->Internals->Parser.UpdateOptions(filePath.string(), fileAppOptions,
-      this->Internals->FileOptions, this->Internals->UpdateWithCommandLineParsing);
-    this->Internals->UpdateWithCommandLineParsing = false; // this is done only once
-    this->Internals->Engine->setOptions(this->Internals->FileOptions);
-
-    this->Internals->LoadedFile = false;
+    // Update app and libf3d options based on config entries, selecting block using the input file
+    // config < cli < dynamic
+    this->Internals->UpdateOptions(
+      { this->Internals->ConfigOptionsEntries, this->Internals->CLIOptionsEntries,
+        this->Internals->DynamicOptionsEntries },
+      filePath.string());
+    this->Internals->Engine->setOptions(this->Internals->LibOptions);
+    this->Internals->ApplyPositionAndResolution();
 
     // Load any new plugins the updated app options
-    this->Internals->Parser.LoadPlugins(fileAppOptions);
+    F3DPluginsTools::LoadPlugins(this->Internals->AppOptions.Plugins);
+
+    // Position the loaded file flag before we start loading
+    this->Internals->LoadedFile = false;
 
     // Check the size of the file before loading it
-    // Not considered in the context of GroupGeometries
+    // XXX: Not considered in the context of GroupGeometries
     static constexpr int BYTES_IN_MIB = 1048576;
-    if (fileAppOptions.MaxSize >= 0.0 &&
-      fs::file_size(filePath) > static_cast<std::uintmax_t>(fileAppOptions.MaxSize * BYTES_IN_MIB))
+    if (this->Internals->AppOptions.MaxSize >= 0.0 &&
+      fs::file_size(filePath) >
+        static_cast<std::uintmax_t>(this->Internals->AppOptions.MaxSize * BYTES_IN_MIB))
     {
       f3d::log::info("No file loaded, file is bigger than max size");
     }
@@ -812,8 +1039,8 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
     {
       try
       {
-        if (loader.hasSceneReader(filePath.string()) && !fileAppOptions.GeometryOnly &&
-          !fileAppOptions.GroupGeometries)
+        if (loader.hasSceneReader(filePath.string()) && !this->Internals->AppOptions.GeometryOnly &&
+          !this->Internals->AppOptions.GroupGeometries)
         {
           loader.loadScene(filePath.string());
           this->Internals->LoadedFile = true;
@@ -821,7 +1048,7 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
         else if (loader.hasGeometryReader(filePath.string()))
         {
           // In GroupGeometries, just load all the files from the list
-          if (fileAppOptions.GroupGeometries)
+          if (this->Internals->AppOptions.GroupGeometries)
           {
             int nGeom = 0;
             for (size_t i = 0; i < size; i++)
@@ -868,7 +1095,7 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
       if (!this->Internals->AppOptions.NoRender)
       {
         // Setup the camera according to options
-        this->Internals->SetupCamera(fileAppOptions);
+        this->Internals->SetupCamera(this->Internals->AppOptions.CamConf);
 
         this->Internals->Engine->getWindow().setWindowName(
           filePath.filename().string() + " - " + F3D::AppName);
@@ -895,6 +1122,8 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
     loader.loadGeometry("", true);
   }
 
+  // XXX: We can force dropzone and filename_info because they cannot be set
+  // manually by the user for now
   f3d::options& options = this->Internals->Engine->getOptions();
   options.ui.dropzone = !this->Internals->LoadedFile;
   options.ui.filename_info = filenameInfo;
@@ -926,23 +1155,23 @@ void F3DStarter::SaveScreenshot(const std::string& filenameTemplate, bool minima
       char* val = std::getenv(candidate);
       if (val != nullptr)
       {
-        std::filesystem::path path(val);
-        if (std::filesystem::is_directory(path))
+        fs::path path(val);
+        if (fs::is_directory(path))
         {
           return path;
         }
       }
     }
 
-    return std::filesystem::current_path();
+    return fs::current_path();
   };
 
-  std::filesystem::path pathTemplate = std::filesystem::path(filenameTemplate).make_preferred();
-  std::filesystem::path fullPathTemplate =
+  fs::path pathTemplate = fs::path(filenameTemplate).make_preferred();
+  fs::path fullPathTemplate =
     pathTemplate.is_absolute() ? pathTemplate : getScreenshotDir() / pathTemplate;
-  std::filesystem::path path = this->Internals->applyFilenameTemplate(fullPathTemplate.string());
+  fs::path path = this->Internals->applyFilenameTemplate(fullPathTemplate.string());
 
-  std::filesystem::create_directories(std::filesystem::path(path).parent_path());
+  fs::create_directories(fs::path(path).parent_path());
   f3d::log::info("saving screenshot to " + path.string());
 
   f3d::options& options = this->Internals->Engine->getOptions();
diff --git a/application/F3DSystemTools.cxx b/application/F3DSystemTools.cxx
index a2ba31b761..6b804d3d92 100644
--- a/application/F3DSystemTools.cxx
+++ b/application/F3DSystemTools.cxx
@@ -84,3 +84,65 @@ std::vector<std::string> GetVectorEnvironnementVariable(const std::string& envVa
   return tokens;
 }
 }
+
+//----------------------------------------------------------------------------
+fs::path F3DSystemTools::GetUserConfigFileDirectory()
+{
+  std::string applicationName = "f3d";
+  fs::path dirPath;
+#if defined(_WIN32)
+  const char* appData = std::getenv("APPDATA");
+  if (!appData)
+  {
+    return {};
+  }
+  dirPath = fs::path(appData);
+#else
+  // Implementing XDG specifications
+  const char* xdgConfigHome = std::getenv("XDG_CONFIG_HOME");
+  if (xdgConfigHome && strlen(xdgConfigHome) > 0)
+  {
+    dirPath = fs::path(xdgConfigHome);
+  }
+  else
+  {
+    const char* home = std::getenv("HOME");
+    if (!home || strlen(home) == 0)
+    {
+      return {};
+    }
+    dirPath = fs::path(home);
+    dirPath /= ".config";
+  }
+#endif
+  dirPath /= applicationName;
+  return dirPath;
+}
+
+//----------------------------------------------------------------------------
+fs::path F3DSystemTools::GetBinaryResourceDirectory()
+{
+  fs::path dirPath;
+  try
+  {
+    dirPath = F3DSystemTools::GetApplicationPath();
+
+    // transform path to exe to path to install
+    // /install/bin/f3d -> /install
+    dirPath = fs::canonical(dirPath).parent_path().parent_path();
+
+    // Add binary specific paths
+#if F3D_MACOS_BUNDLE
+    dirPath /= "Resources";
+#else
+    dirPath /= "share/f3d";
+#endif
+  }
+  catch (const fs::filesystem_error&)
+  {
+    f3d::log::debug("Cannot recover binary configuration file directory: ", dirPath.string());
+    return {};
+  }
+
+  return dirPath;
+}
diff --git a/application/F3DSystemTools.h b/application/F3DSystemTools.h
index 69ad2e7042..bf360916ba 100644
--- a/application/F3DSystemTools.h
+++ b/application/F3DSystemTools.h
@@ -15,6 +15,8 @@ namespace F3DSystemTools
 {
 std::filesystem::path GetApplicationPath();
 std::vector<std::string> GetVectorEnvironnementVariable(const std::string& envVar);
+std::filesystem::path GetUserConfigFileDirectory();
+std::filesystem::path GetBinaryResourceDirectory();
 }
 
 #endif
diff --git a/application/testing/CMakeLists.txt b/application/testing/CMakeLists.txt
index c5ae16c105..a49c0462ee 100644
--- a/application/testing/CMakeLists.txt
+++ b/application/testing/CMakeLists.txt
@@ -121,7 +121,7 @@ f3d_test(NAME TestOBJ DATA suzanne.obj ARGS --geometry-only)
 f3d_test(NAME TestSTL DATA suzanne.stl)
 f3d_test(NAME TestVTU DATA dragon.vtu)
 f3d_test(NAME TestVTP DATA cow.vtp)
-f3d_test(NAME TestVTR DATA RectGrid2.vtr ARGS --scalars --roughness=1)
+f3d_test(NAME TestVTR DATA RectGrid2.vtr ARGS --scalar-coloring --roughness=1)
 f3d_test(NAME TestVTS DATA bluntfin.vts)
 f3d_test(NAME TestVTM DATA mb.vtm)
 f3d_test(NAME TestVTK DATA cow.vtk)
@@ -142,17 +142,17 @@ f3d_test(NAME TestPointCloudUG DATA pointsCloud.vtu ARGS -o --point-size=20)
 f3d_test(NAME TestPointCloudVolume DATA bluntfin.vts ARGS -sob)
 f3d_test(NAME TestPointCloudDefaultScene DATA pointsCloud.vtp ARGS --point-size=20)
 f3d_test(NAME Test3DSImporter DATA iflamigm.3ds ARGS --up=+Z)
-f3d_test(NAME TestScalars DATA suzanne.ply ARGS --scalars=Normals --comp=1)
-f3d_test(NAME TestScalarsCell DATA f3d.vtp ARGS --scalars --cells --comp=-2 --up=+Z)
-f3d_test(NAME TestScalarsRange DATA suzanne.ply ARGS --scalars=Normals --comp=1 --range=0,1)
-f3d_test(NAME TestScalarsWithBar DATA suzanne.ply ARGS -b --scalars=Normals --comp=0)
+f3d_test(NAME TestScalars DATA suzanne.ply ARGS -s --coloring-array=Normals --comp=1)
+f3d_test(NAME TestScalarsCell DATA f3d.vtp ARGS --scalar-coloring --cells --comp=-2 --up=+Z)
+f3d_test(NAME TestScalarsRange DATA suzanne.ply ARGS -s --coloring-array=Normals --comp=1 --range=0,1)
+f3d_test(NAME TestScalarsWithBar DATA suzanne.ply ARGS -b -s --coloring-array=Normals --comp=0)
 f3d_test(NAME TestGLTFImporter DATA f3d.glb)
 f3d_test(NAME TestGLTFImporterWithAnimation DATA BoxAnimated.gltf ARGS --animation-time=2 --animation-progress)
 f3d_test(NAME TestGLTFSkin DATA SimpleSkin.gltf)
 f3d_test(NAME TestGLTFReaderWithAnimation DATA BoxAnimated.gltf ARGS --geometry-only --animation-time=2 --animation-progress)
-f3d_test(NAME TestDicom DATA IM-0001-1983.dcm ARGS --scalars --roughness=1)
-f3d_test(NAME TestMHD DATA HeadMRVolume.mhd ARGS --scalars --roughness=1)
-f3d_test(NAME TestVTICell DATA waveletMaterial.vti ARGS --scalars=Material -c --roughness=1)
+f3d_test(NAME TestDicom DATA IM-0001-1983.dcm ARGS --scalar-coloring --roughness=1)
+f3d_test(NAME TestMHD DATA HeadMRVolume.mhd ARGS --scalar-coloring --roughness=1)
+f3d_test(NAME TestVTICell DATA waveletMaterial.vti ARGS -s --coloring-array=Material -c --roughness=1)
 f3d_test(NAME TestSSAO LONG_TIMEOUT DATA suzanne.ply ARGS -q)
 f3d_test(NAME TestDepthPeeling DATA suzanne.ply ARGS -sp --opacity=0.9)
 f3d_test(NAME TestBackground DATA suzanne.ply ARGS --bg-color=0.8,0.2,0.9 THRESHOLD 0.1) # Threshold is needed for legacy image comparison for VTK 9.3
@@ -161,7 +161,7 @@ f3d_test(NAME TestFilename DATA suzanne.ply ARGS -n)
 f3d_test(NAME TestFilenameWhiteBg DATA suzanne.ply ARGS -n --bg-color=1,1,1)
 f3d_test(NAME TestCityGML DATA Part-4-Buildings-V4-one.gml)
 f3d_test(NAME TestPTS DATA samplePTS.pts)
-f3d_test(NAME TestColormap DATA IM-0001-1983.dcm ARGS --scalars --roughness=1 --colormap=0,1,0,0,1,0,1,0)
+f3d_test(NAME TestColormap DATA IM-0001-1983.dcm ARGS --scalar-coloring --roughness=1 --colormap=0,1,0,0,1,0,1,0)
 f3d_test(NAME TestCameraConfiguration DATA suzanne.obj ARGS --camera-position=0,0,-10 -x --camera-view-up=1,0,0 --camera-focal-point=1,0,0 --camera-view-angle=20 --camera-azimuth-angle=40 --camera-elevation-angle=-80 --camera-direction=12,34,56 --camera-zoom-factor=78)
 f3d_test(NAME TestCameraDirection DATA suzanne.obj ARGS --camera-direction=-1,-1,1)
 f3d_test(NAME TestCameraClipping DATA checkerboard_colorful.obj CONFIG ${F3D_SOURCE_DIR}/testing/configs/checkerboard_colorful.json RESOLUTION 800,600)
@@ -174,7 +174,7 @@ f3d_test(NAME TestVolumeMag DATA vase_4comp.vti ARGS -vb LONG_TIMEOUT)
 f3d_test(NAME TestVolumeComp DATA vase_4comp.vti ARGS -vb --comp=3 LONG_TIMEOUT)
 f3d_test(NAME TestVolumeDirect DATA vase_4comp.vti ARGS -vb --comp=-2 LONG_TIMEOUT)
 f3d_test(NAME TestVolumeCells DATA waveletArrays.vti ARGS -vb --cells LONG_TIMEOUT)
-f3d_test(NAME TestVolumeNonScalars DATA waveletArrays.vti ARGS -vb --scalars=RandomPointScalars LONG_TIMEOUT)
+f3d_test(NAME TestVolumeNonScalars DATA waveletArrays.vti ARGS -vb -s --coloring-array=RandomPointScalars LONG_TIMEOUT)
 f3d_test(NAME TestTextureNormal DATA WaterBottle.glb ARGS --geometry-only --texture-normal=${F3D_SOURCE_DIR}/testing/data/normal.png --normal-scale=0.1)
 f3d_test(NAME TestTextureMaterial DATA WaterBottle.glb ARGS --geometry-only --texture-material=${F3D_SOURCE_DIR}/testing/data/red_mod.jpg --roughness=1 --metallic=1)
 f3d_test(NAME TestTextureMaterialWithOptions DATA WaterBottle.glb ARGS --geometry-only --texture-material=${F3D_SOURCE_DIR}/testing/data/red_mod.jpg --roughness=0.5 --metallic=0.5)
@@ -197,32 +197,35 @@ f3d_test(NAME TestMaxSizeAbove DATA WaterBottle.glb ARGS --max-size=0.2 REGEXP "
 f3d_test(NAME TestAlternativeOptionSyntax DATA WaterBottle.glb ARGS --max-size 0.2 REGEXP "No file loaded, file is bigger than max size" NO_BASELINE)
 f3d_test(NAME TestNonExistentFile DATA nonExistentFile.vtp ARGS --filename WILL_FAIL)
 f3d_test(NAME TestUnsupportedFile DATA unsupportedFile.dummy ARGS --filename WILL_FAIL)
-f3d_test(NAME TestComponentName DATA from_abq.vtu ARGS --scalars --bar --comp=2)
+f3d_test(NAME TestComponentName DATA from_abq.vtu ARGS --scalar-coloring --bar --comp=2)
 f3d_test(NAME TestNoRender DATA dragon.vtu NO_RENDER)
 f3d_test(NAME TestNoRenderWithOptions DATA dragon.vtu ARGS --hdri-ambient --axis NO_RENDER) # These options causes issues if not handled correctly
 f3d_test(NAME TestNoFile NO_DATA_FORCE_RENDER)
 f3d_test(NAME TestGroupGeometries DATA mb/recursive ARGS --group-geometries)
-f3d_test(NAME TestGroupGeometriesColoring DATA mb/recursive ARGS --group-geometries --scalars=Polynomial -b)
+f3d_test(NAME TestGroupGeometriesColoring DATA mb/recursive ARGS --group-geometries -s --coloring-array=Polynomial -b)
+f3d_test(NAME TestMultiInputPositionals ARGS ${F3D_SOURCE_DIR}/testing/data/mb/recursive/mb_0_0.vtu ${F3D_SOURCE_DIR}/testing/data/mb/recursive/mb_1_0.vtp --group-geometries -s --coloring-array=Polynomial -b)
+f3d_test(NAME TestMultiInputArg ARGS --input ${F3D_SOURCE_DIR}/testing/data/mb/recursive/mb_0_0.vtu ${F3D_SOURCE_DIR}/testing/data/mb/recursive/mb_1_0.vtp --group-geometries -s --coloring-array=Polynomial -b)
+f3d_test(NAME TestMultiInputMultiArgs ARGS --input ${F3D_SOURCE_DIR}/testing/data/mb/recursive/mb_0_0.vtu --input ${F3D_SOURCE_DIR}/testing/data/mb/recursive/mb_1_0.vtp --group-geometries -s --coloring-array=Polynomial -b)
 f3d_test(NAME TestInvalidUpDirection DATA suzanne.ply ARGS -g --up=W REGEXP "W is not a valid up direction" NO_BASELINE)
 f3d_test(NAME TestUpDirectionNoSign DATA suzanne.ply ARGS --up=X)
 f3d_test(NAME TestTextureMatCap DATA suzanne.ply ARGS --texture-matcap=${F3D_SOURCE_DIR}/testing/data/skin.png)
 f3d_test(NAME TestTextureMatCapWithTCoords DATA WaterBottle.glb ARGS --geometry-only --texture-matcap=${F3D_SOURCE_DIR}/testing/data/skin.png)
-f3d_test(NAME TestConfigOrder DATA suzanne.ply ARGS CONFIG ${F3D_SOURCE_DIR}/testing/data/config-order.json)
+f3d_test(NAME TestConfigOrder DATA suzanne.ply ARGS CONFIG ${F3D_SOURCE_DIR}/testing/configs/config_order.json) # `.+` > `.*` alphabetically but overridden by the order
 f3d_test(NAME TestOutputStream DATA suzanne.ply ARGS --verbose=quiet --output=- REGEXP "^.PNG" NO_BASELINE NO_OUTPUT)
 f3d_test(NAME TestOutputStreamInfo DATA suzanne.ply ARGS --verbose=info --output=- REGEXP "redirected to stderr" NO_BASELINE NO_OUTPUT)
 
 # Color map files testing
-f3d_test(NAME TestColorMapFileFullPath DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/viridis8.png --scalars --comp=1)
-f3d_test(NAME TestColorMapInvalid DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/invalid.png --scalars REGEXP "Cannot read colormap at" NO_BASELINE)
-f3d_test(NAME TestColorMapNonExistent DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/non_existent.png --scalars REGEXP "Cannot find the colormap" NO_BASELINE)
-f3d_test(NAME TestColorMapGrayscale DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/white_grayscale.png --scalars REGEXP "The specified color map must have at least 3 channels" NO_BASELINE)
-f3d_test(NAME TestColorMapMore1pxWarning DATA dragon.vtu ARGS --verbose=warning --colormap-file=${F3D_SOURCE_DIR}/testing/data/16bit.png --scalars REGEXP "The specified color map height is not equal to 1" NO_BASELINE)
-f3d_test(NAME TestColorMap16bits DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/viridis16.png --scalars --comp=1)
-f3d_test(NAME TestColorMap32bits DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/viridis32.hdr --scalars --comp=1)
+f3d_test(NAME TestColorMapFileFullPath DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/viridis8.png --scalar-coloring --comp=1)
+f3d_test(NAME TestColorMapInvalid DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/invalid.png --scalar-coloring REGEXP "Cannot read colormap at" NO_BASELINE)
+f3d_test(NAME TestColorMapNonExistent DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/non_existent.png --scalar-coloring REGEXP "Cannot find the colormap" NO_BASELINE)
+f3d_test(NAME TestColorMapGrayscale DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/white_grayscale.png --scalar-coloring REGEXP "The specified color map must have at least 3 channels" NO_BASELINE)
+f3d_test(NAME TestColorMapMore1pxWarning DATA dragon.vtu ARGS --verbose=warning --colormap-file=${F3D_SOURCE_DIR}/testing/data/16bit.png --scalar-coloring REGEXP "The specified color map height is not equal to 1" NO_BASELINE)
+f3d_test(NAME TestColorMap16bits DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/viridis16.png --scalar-coloring --comp=1)
+f3d_test(NAME TestColorMap32bits DATA dragon.vtu ARGS --colormap-file=${F3D_SOURCE_DIR}/testing/data/viridis32.hdr --scalar-coloring --comp=1)
 if(NOT F3D_MACOS_BUNDLE)
   file(COPY "${F3D_SOURCE_DIR}/resources/colormaps/" DESTINATION "${CMAKE_BINARY_DIR}/share/f3d/colormaps")
-  f3d_test(NAME TestColorMapStem DATA dragon.vtu ARGS --colormap-file=magma --scalars --comp=1)
-  f3d_test(NAME TestColorMapFile DATA dragon.vtu ARGS --colormap-file=magma.png --scalars --comp=1)
+  f3d_test(NAME TestColorMapStem DATA dragon.vtu ARGS --colormap-file=magma --scalar-coloring --comp=1)
+  f3d_test(NAME TestColorMapFile DATA dragon.vtu ARGS --colormap-file=magma.png --scalar-coloring --comp=1)
 endif()
 
 # Screenshot Interaction
@@ -312,7 +315,7 @@ if(NOT F3D_MACOS_BUNDLE)
   f3d_test(NAME TestDefaultConfigFileVTU DATA dragon.vtu CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
   f3d_test(NAME TestDefaultConfigFileVTI DATA vase_4comp.vti CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
   f3d_test(NAME TestDefaultConfigFileSTL DATA suzanne.stl CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
-  f3d_test(NAME TestDefaultConfigFileTIFF DATA f3d.tif CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
+  f3d_test(NAME TestDefaultConfigFileTIFF DATA f3d.tif CONFIG config_build LONG_TIMEOUT TONE_MAPPING) # Note: This tests config file order as camera_direction is set in different files
   f3d_test(NAME TestDefaultConfigFilePLY DATA suzanneRGBA.ply CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
   f3d_test(NAME TestDefaultConfigFileAndCommand DATA suzanne.stl ARGS --up=-Y --camera-direction=-1,0.5,-1 CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
   f3d_test(NAME TestDefaultConfigTranslucent DATA red_translucent_monkey.gltf CONFIG config_build LONG_TIMEOUT TONE_MAPPING)
@@ -368,13 +371,13 @@ if(F3D_MODULE_RAYTRACING)
   f3d_test(NAME TestInteractionCheatsheetRaytracing DATA cow.vtp INTERACTION) #H
   f3d_test(NAME TestInteractionCheatsheetWhiteBGRaytracing DATA cow.vtp ARGS --bg-color=1,1,1 INTERACTION) #H
   f3d_test(NAME TestInteractionCheatsheetBlackBGRaytracing DATA cow.vtp ARGS --bg-color=0,0,0 INTERACTION) #H
-  f3d_test(NAME TestInteractionCheatsheetScalarsRaytracing DATA dragon.vtu ARGS --scalars --comp=-2 INTERACTION) #HSSS
+  f3d_test(NAME TestInteractionCheatsheetScalarsRaytracing DATA dragon.vtu ARGS --scalar-coloring --comp=-2 INTERACTION) #HSSS
   f3d_test(NAME TestInteractionNoFileCheatsheetRaytracing INTERACTION NO_DATA_FORCE_RENDER) #HXZM
 else()
   f3d_test(NAME TestInteractionCheatsheet DATA cow.vtp INTERACTION) #H
   f3d_test(NAME TestInteractionCheatsheetWhiteBG DATA cow.vtp ARGS --bg-color=1,1,1 INTERACTION) #H
   f3d_test(NAME TestInteractionCheatsheetBlackBG DATA cow.vtp ARGS --bg-color=0,0,0 INTERACTION) #H
-  f3d_test(NAME TestInteractionCheatsheetScalars DATA dragon.vtu ARGS --scalars --comp=-2 INTERACTION) #HSSS
+  f3d_test(NAME TestInteractionCheatsheetScalars DATA dragon.vtu ARGS --scalar-coloring --comp=-2 INTERACTION) #HSSS
   f3d_test(NAME TestInteractionNoFileCheatsheet INTERACTION NO_DATA_FORCE_RENDER) #HXZM
 endif()
 
@@ -561,7 +564,7 @@ endif()
 
 if(F3D_PLUGIN_BUILD_DRACO)
   f3d_test(NAME TestDRACO DATA suzanne.drc ARGS --load-plugins=draco)
-  f3d_test(NAME TestDRACOColoring DATA suzanne.drc ARGS --scalars --comp=0 --load-plugins=draco)
+  f3d_test(NAME TestDRACOColoring DATA suzanne.drc ARGS --scalar-coloring --comp=0 --load-plugins=draco)
 
   # Needs https://gitlab.kitware.com/vtk/vtk/-/merge_requests/10884
   if(VTK_VERSION VERSION_GREATER_EQUAL 9.3.20240214)
@@ -714,17 +717,17 @@ f3d_test(NAME TestInteractionCycleComp DATA dragon.vtu INTERACTION) #SYYYY
 f3d_test(NAME TestInteractionCycleScalars DATA dragon.vtu INTERACTION) #BSSSS
 f3d_test(NAME TestInteractionVolumeInverse DATA HeadMRVolume.mhd ARGS --camera-position=127.5,-400,127.5 --camera-view-up=0,0,1 INTERACTION) #VI
 f3d_test(NAME TestInteractionPointCloud DATA pointsCloud.vtp ARGS --point-size=20 INTERACTION) #O
-f3d_test(NAME TestInteractionDirectory DATA mb INTERACTION ARGS --scalars) #Right;Right;Right;Left;Up;
-f3d_test(NAME TestInteractionDirectoryLoop DATA mb INTERACTION ARGS --scalars) #Left;Left;Left;
+f3d_test(NAME TestInteractionDirectory DATA mb INTERACTION ARGS --scalar-coloring) #Right;Right;Right;Left;Up;
+f3d_test(NAME TestInteractionDirectoryLoop DATA mb INTERACTION ARGS --scalar-coloring) #Left;Left;Left;
 f3d_test(NAME TestInteractionDirectoryEmpty DATA mb INTERACTION NO_DATA_FORCE_RENDER) #Right;Right;Right;
 f3d_test(NAME TestInteractionDirectoryEmptyVerbose DATA mb ARGS --verbose NO_BASELINE INTERACTION REGEXP "is not a file of a supported file format") #Right;Right;Right;HMCSY
 f3d_test(NAME TestInteractionAnimationNotStopped DATA InterpolationTest.glb NO_BASELINE INTERACTION)#Space;
 f3d_test(NAME TestInteractionResetCamera DATA dragon.vtu INTERACTION)#MouseMovements;Return;
-f3d_test(NAME TestInteractionTensorsCycleComp DATA tensors.vti ARGS --scalars --comp=-2  INTERACTION) #SYYYYYYYYYY
-f3d_test(NAME TestInteractionCycleScalarsCompCheck DATA dragon.vtu ARGS -b --scalars --comp=2 INTERACTION) #S
+f3d_test(NAME TestInteractionTensorsCycleComp DATA tensors.vti ARGS --scalar-coloring --comp=-2  INTERACTION) #SYYYYYYYYYY
+f3d_test(NAME TestInteractionCycleScalarsCompCheck DATA dragon.vtu ARGS -b --scalar-coloring --comp=2 INTERACTION) #S
 f3d_test(NAME TestInteractionConfigFileNoColorBar DATA multi CONFIG ${F3D_SOURCE_DIR}/testing/configs/complex.json INTERACTION) #Right;Right;Left
-f3d_test(NAME TestInteractionConfigFileMulti DATA multi CONFIG ${F3D_SOURCE_DIR}/testing/configs/complex.json INTERACTION) #XG;Right;N;Right;Right
-f3d_test(NAME TestInteractionConfigFileAndCommand DATA multi ARGS -o CONFIG ${F3D_SOURCE_DIR}/testing/configs/complex.json INTERACTION) #O;Left
+f3d_test(NAME TestInteractionConfigFileMulti DATA multi CONFIG ${F3D_SOURCE_DIR}/testing/configs/complex.json INTERACTION) #SY;Right;XG;Right;N;Right;Right
+f3d_test(NAME TestInteractionConfigFileAndCommand DATA multi ARGS -o CONFIG ${F3D_SOURCE_DIR}/testing/configs/complex.json INTERACTION) #OX;Right;N;Right;Right;Right
 f3d_test(NAME TestInteractionDumpSceneState DATA dragon.vtu NO_BASELINE INTERACTION REGEXP "Camera position: 2.23745,3.83305,507.598")#?
 f3d_test(NAME TestInteractionCycleVerbose DATA dragon.vtu ARGS --verbose -s NO_BASELINE INTERACTION REGEXP "Not coloring")#SSSSYC
 f3d_test(NAME TestInteractionEmptyDrop INTERACTION REGEXP "Drop event without any provided files.")#DropEvent Empty;
@@ -791,6 +794,8 @@ f3d_test(NAME TestInteractionPlay DATA cow.vtp ARGS --interaction-test-play=${CM
 
 # Window position test
 f3d_test(NAME TestPosition DATA dragon.vtu ARGS --position=100,100 NO_BASELINE)
+f3d_test(NAME TestInvalidPosition DATA dragon.vtu ARGS --position=100,100,300 REGEXP "Provided position could not be applied" NO_BASELINE)
+f3d_test(NAME TestInvalidResolution DATA dragon.vtu RESOLUTION 800 REGEXP "Provided resolution could not be applied" NO_BASELINE)
 
 # Simple verbosity test
 f3d_test(NAME TestVerbose DATA dragon.vtu ARGS --verbose REGEXP "Number of points: 13268\nNumber of cells: 26532" NO_BASELINE)
@@ -811,7 +816,7 @@ f3d_test(NAME TestVerboseDebug DATA dragon.vtu ARGS --verbose REGEXP "Number of
 f3d_test(NAME TestVerboseInvalid DATA dragon.vtu ARGS --verbose=invalid REGEXP "Unrecognized verbose level" NO_BASELINE)
 
 # Unknown scalar array verbosity test
-f3d_test(NAME TestVerboseWrongArray DATA dragon.vtu ARGS --scalars=dummy --verbose REGEXP "Unknown scalar array: dummy" NO_BASELINE)
+f3d_test(NAME TestVerboseWrongArray DATA dragon.vtu ARGS -s --coloring-array=dummy --verbose REGEXP "Unknown scalar array: dummy" NO_BASELINE)
 
 # Default scalar array verbosity test
 f3d_test(NAME TestVerboseDefaultScalar DATA HeadMRVolume.mhd ARGS -s --verbose REGEXP "Coloring using point array named MetaImage, Magnitude" NO_BASELINE)
@@ -820,7 +825,7 @@ f3d_test(NAME TestVerboseDefaultScalar DATA HeadMRVolume.mhd ARGS -s --verbose R
 f3d_test(NAME TestIncorrectComponent DATA dragon.vtu ARGS -s --comp=4 REGEXP "Invalid component index: 4" NO_BASELINE)
 
 # Incorrect color map
-f3d_test(NAME TestIncorrectColormap DATA IM-0001-1983.dcm ARGS --scalars --roughness=1 --colormap=0,1,0,0,1,0,1 REGEXP "Specified color map list count is not a multiple of 4, ignoring it." NO_BASELINE)
+f3d_test(NAME TestIncorrectColormap DATA IM-0001-1983.dcm ARGS --scalar-coloring --roughness=1 --colormap=0,1,0,0,1,0,1 REGEXP "Specified color map list count is not a multiple of 4, ignoring it." NO_BASELINE)
 
 # Test opening a directory
 f3d_test(NAME TestVerboseDirectory DATA mb REGEXP "Loading 3D geometry: .*mb_._0.vt." NO_RENDER)
@@ -843,10 +848,10 @@ f3d_test(NAME TestNoRenderBBox DATA suzanne.ply NO_RENDER REGEXP "Scene bounding
 f3d_test(NAME TestVerboseScalars DATA suzanne.ply ARGS -s --verbose REGEXP "Coloring using point array named Normals, Magnitude." NO_BASELINE)
 
 # Test direct scalars surface rendering with a 9 comp array
-f3d_test(NAME TestTensorsDirect DATA tensors.vti ARGS --scalars=tensors1 --comp=-2 REGEXP "Direct scalars rendering not supported by array with more than 4 components" NO_BASELINE)
+f3d_test(NAME TestTensorsDirect DATA tensors.vti ARGS -s --coloring-array=tensors1 --comp=-2 REGEXP "Direct scalars rendering not supported by array with more than 4 components" NO_BASELINE)
 
 # Test direct scalars volume rendering with a 9 comp array
-f3d_test(NAME TestTensorsVolumeDirect DATA tensors.vti ARGS -v --scalars=tensors1 --comp=-2 REGEXP "Direct scalars rendering not supported by array with more than 4 components" NO_BASELINE)
+f3d_test(NAME TestTensorsVolumeDirect DATA tensors.vti ARGS -v -s --coloring-array=tensors1 --comp=-2 REGEXP "Direct scalars rendering not supported by array with more than 4 components" NO_BASELINE)
 
 # Test volume rendering without any array
 f3d_test(NAME TestVerboseVolumeNoArray DATA cow.vtp ARGS -v REGEXP "Cannot use volume with this dataset" NO_BASELINE)
@@ -860,6 +865,10 @@ f3d_test(NAME TestVerboseNonExistentFile DATA nonExistentFile.vtp REGEXP "File .
 # Test non existent font file, do not create nonExistentFile.ttf
 f3d_test(NAME TestVerboseNonExistentFont DATA suzanne.ply ARGS -n --font-file=${F3D_SOURCE_DIR}/testing/data/nonExistentFile.ttf REGEXP "Cannot find \".*nonExistentFile.ttf\" font file" NO_BASELINE)
 
+# Test scalar rendering without any array
+f3d_test(NAME TestVerboseOptionsCLI ARGS -x --verbose=debug REGEXP "'axis' = '1' from CLI options" NO_BASELINE)
+f3d_test(NAME TestVerboseOptionsConfig ARGS --verbose=debug CONFIG ${F3D_SOURCE_DIR}/testing/configs/complex.json REGEXP "'interactor.axis' = 'true'" NO_BASELINE)
+
 # Test quiet with a non existent file
 f3d_test(NAME TestQuietNonExistentFile DATA nonExistentFile.vtp ARGS --verbose=quiet --no-render REGEXP_FAIL "File .*nonExistentFile.vtp does not exist")
 
@@ -889,6 +898,9 @@ f3d_test(NAME TestNonExistentInteraction DATA cow.vtp INTERACTION REGEXP "Intera
 # Test unknown options, do not add a --colour option
 f3d_test(NAME TestUnknownOptionVerbose ARGS --colour=a=b REGEXP "Did you mean '--color=a=b'?")
 f3d_test(NAME TestUnknownOptionExitCode ARGS --colour=1,0,0 WILL_FAIL)
+f3d_test(NAME TestUnknownAppOptionVerbose ARGS --revolution=17,32 REGEXP "Did you mean '--resolution=17,32'?")
+f3d_test(NAME TestUnknownBooleanOptionVerbose ARGS --helpo REGEXP "Did you mean '--help'?")
+f3d_test(NAME TestUnknownInputOptionVerbose ARGS --inprut=file REGEXP "Did you mean '--input=file'?")
 
 # Test non-existent config filepath, do not add a dummy.json
 f3d_test(NAME TestNonExistentConfigFilePath DATA cow.vtp CONFIG "${F3D_SOURCE_DIR}/testing/configs/dummy.json" REGEXP "Configuration file does not exist" NO_BASELINE)
@@ -902,6 +914,12 @@ f3d_test(NAME TestInvalidConfigFile DATA cow.vtp CONFIG ${F3D_SOURCE_DIR}/testin
 # Test invalid value in config file
 f3d_test(NAME TestConfigFileInvalidValue DATA cow.vtp CONFIG ${F3D_SOURCE_DIR}/testing/configs/invalid_value.json REGEXP "must be a string, a boolean or a number" NO_BASELINE)
 
+# Test non-parsable value in config file
+f3d_test(NAME TestConfigFileNonParsableValue DATA cow.vtp CONFIG ${F3D_SOURCE_DIR}/testing/configs/nonparsable_value.json REGEXP "Cannot parse nonparsable into an int" NO_BASELINE)
+
+# Test inexistent key in config file
+f3d_test(NAME TestConfigFileInexistentKey DATA cow.vtp CONFIG ${F3D_SOURCE_DIR}/testing/configs/inexistent_key.json REGEXP "does not exists , did you mean 'scene.animation.index" NO_BASELINE)
+
 # Test quiet in config file
 f3d_test(NAME TestConfigFileQuiet DATA nonExistentFile.vtp CONFIG ${F3D_SOURCE_DIR}/testing/configs/quiet.json REGEXP_FAIL "File .*/testing/data/nonExistentFile.vtp does not exist" NO_BASELINE)
 
@@ -918,6 +936,11 @@ f3d_test(NAME TestVersion ARGS --version REGEXP "Version:")
 # Test readers-list display
 f3d_test(NAME TestReadersList ARGS --readers-list REGEXP_FAIL "No registered reader found")
 
+# Test multi plugin readers-lists
+if(F3D_PLUGIN_BUILD_ALEMBIC AND F3D_PLUGIN_BUILD_ASSIMP)
+  f3d_test(NAME TestReadersListMultiplePlugins ARGS --readers-list --load-plugins=assimp,alembic NO_BASELINE REGEXP_FAIL "Plugin failed to load")
+endif()
+
 # Test that f3d can try to read a system config file
 add_test(NAME f3d::TestNoDryRun COMMAND $<TARGET_FILE:f3d> --no-render)
 set_tests_properties(f3d::TestNoDryRun PROPERTIES TIMEOUT 4)
@@ -926,6 +949,9 @@ set_tests_properties(f3d::TestNoDryRun PROPERTIES TIMEOUT 4)
 add_test(NAME f3d::TestInvalidCLIArgs COMMAND $<TARGET_FILE:f3d> --up)
 set_tests_properties(f3d::TestInvalidCLIArgs PROPERTIES PASS_REGULAR_EXPRESSION "Error parsing command line arguments")
 
+# Test that f3d resolution can be controlled from config file
+add_test(NAME f3d::TestConfigResolution COMMAND $<TARGET_FILE:f3d> --config=${F3D_SOURCE_DIR}/testing/configs/resolution.json ${F3D_SOURCE_DIR}/testing/data/suzanne.stl --output=${CMAKE_BINARY_DIR}/Testing/Temporary/TestConfigResolution.png --ref=${F3D_SOURCE_DIR}/testing/baselines/TestConfigResolution.png)
+
 # Test failure without a reference, please do not create a TestNoRef.png file
 f3d_test(NAME TestNoRef DATA cow.vtp WILL_FAIL)
 
diff --git a/doc/libf3d/OPTIONS.md b/doc/libf3d/OPTIONS.md
index ec2cfca05f..8302adee48 100644
--- a/doc/libf3d/OPTIONS.md
+++ b/doc/libf3d/OPTIONS.md
@@ -50,10 +50,11 @@ model.material.roughness|double<br>0.3<br>render|Set the *roughness coefficient*
 model.material.texture|string<br>-<br>render|Path to a texture file that sets the Occlusion, Roughness and Metallic values of the object. Multiplied with the `model.material.roughness` and `model.material.metallic`, set both of them to 1.0 to get a true result.|\-\-texture-material
 model.normal.scale|double<br>1.0<br>render|Normal scale affects the strength of the normal deviation from the normal texture.|\-\-normal-scale
 model.normal.texture|string<br>-<br>render|Path to a texture file that sets the normal map of the object.|\-\-texture-normal
+model.scivis.enable|bool<br>false<br>render|*Color by an array* present in on the data. If `model.scivis.array_name` is set to <empty>, the first available array will be used.|\-\-scalar-coloring
 model.scivis.cells|bool<br>false<br>render|Color the data with value found *on the cells* instead of points|\-\-cells
 model.scivis.colormap|vector\<double\><br>\<inferno\><br>render|Set a *custom colormap for the coloring*.<br>This is a list of colors in the format `val1,red1,green1,blue1,...,valN,redN,greenN,blueN`<br>where all values are in the range (0,1).|\-\-colormap
 model.scivis.component|int<br>-1<br>render|Specify the component to color with. -1 means *magnitude*. -2 means *direct values*.|\-\-comp
-model.scivis.array_name|string<br>\<reserved\><br>render|*Color by a specific data array* present in on the data. Set to <empty> to let libf3d find the first available array.|\-\-scalars
+model.scivis.array_name|string<br>-<br>render|Select the name of the array to color with.|\-\-coloring-array
 model.scivis.range|vector\<double\><br>-<br>render|Set a *custom range for the coloring*.|\-\-range
 model.point_sprites.enable|bool<br>false<br>render|Show sphere *points sprites* instead of the geometry.|\-\-point-sprites
 model.point_sprites.type|string<br>sphere<br>render|Set the sprites type when showing point sprites (can be `sphere` or `gaussian`).|\-\-point-type
diff --git a/doc/user/CONFIGURATION_FILE.md b/doc/user/CONFIGURATION_FILE.md
index bb64ca57c7..072efab115 100644
--- a/doc/user/CONFIGURATION_FILE.md
+++ b/doc/user/CONFIGURATION_FILE.md
@@ -1,25 +1,23 @@
 # Configuration File
 
-Almost all the command-line options can be controlled using configuration files.
+Almost all the command-line [options](OPTIONS.md) can be controlled using configuration files.
 Configuration files uses the "long" version of the command-line options in a JSON
-formatted file to provide values for these options.
+formatted file to provide values for these options. It is also possible to use
+the [libf3d options](../libf3d/OPTIONS.md) syntax.
 
 These options can be organized by block using a regular expression for each block
 in order to provide different default values for the different filetypes.
 
-A special block, named `global`, will apply to all files.
-Using a command-line option will override the corresponding value in the config file.
+Using a command-line option will override similar option set in any config files.
 
-The `global` block and command-line options are only taken into account on the first load
-and not on subsequent loads, when switching between files.
-The regular expression blocks are always taken into account, even when loading further files.
-Please note the regular expressions are not case-sensitive.
+Some options are only taken into account on the first load and not on subsequent loads, 
+when switching between files.
 
 A typical config file may look like this:
 
 ```javascript
 {
-   "global": {
+   ".*": {
        "bg-color": "0.7,0.7,0.7",
        "color": "0.5,0.1,0.1",
        "anti-aliasing": true,
@@ -29,7 +27,7 @@ A typical config file may look like this:
        "bar": true,
        "roughness": 0.2,
        "grid": true,
-       "scalars": true
+       "scalar-coloring": true
    },
    ".*vt.": {
        "edges": true
@@ -44,23 +42,23 @@ A typical config file may look like this:
    }
 }
 ```
-Here, the first block defines a basic global configuration with many desired options for all files.
+Here, the first block defines a basic configuration with many desired options for all files.
 The second block specifies that all files ending with vt., eg: vtk, vtp, vtu, ... will be shown with edges visibility turned on.
 The third block specifies raytracing usage for .gltf and .glb files.
 The last block specifies that volume rendering should be used with .mhd files.
 
 Single .json file for configuration is supported, as well a config directory containing multiple .json config files.
 In the case of config directory, .json file are read in alphabetical order and an option in a block can be overridden
-by the same option being set in the same block in another .json file read after.
+by the same option being set in another block in another .json file read after.
 
 F3D provides a default config directory for generic usage (`config.d`) and a thumbnail specific config directory (`thumbnail.d`).
-You can edit the file contained in these directory or copy then into specific locations (see below) in order to customize F3D behavior.
+You can edit the file contained in these directory or add your own in specific directories (see below).
 
 The following command-line options <b> cannot </b> be set via config file:
-`help`, `version`, `readers-list`, `config`, `dry-run`.
+`help`, `version`, `readers-list`, `config`, `dry-run` and `input`.
 
-The following command-line options <b>can only</b> be set in the global block of the config file:
-`no-render`, `inputs`, `output`, `verbose`, `resolution`, `position` and all testing options.
+The following command-line options <b>are only taken on the first load</b>:
+`no-render`, `output`, and all testing options.
 
 Boolean options that have been turned on in the configuration file can be turned
 off on the command line if needed, eg: `--point-sprites=false`.
@@ -80,5 +78,4 @@ On Linux, they will be installed in `[install_dir]/share/f3d/configs/`, on Windo
 Please note there is a command line option to control the configuration file to read. Using it, one can specify an absolute/relative path for the configuration path, but also
 only the filename or filestem (`.json` and `.d`  will be added) to look for in the locations listed above, , eg: `f3d --config=custom_config` will look
 for `custom_config.json` and `custom_config.d` in locations listed above.
-
-Please note <b>only one</b> config file or directory will be found and parsed.
+When specifying an absolute/relative path for the configuration file, a single file is read. If not, all files from locations listed above, with the overriding logic specified above.
diff --git a/doc/user/INTERACTIONS.md b/doc/user/INTERACTIONS.md
index 53778edbe0..4634b623b7 100644
--- a/doc/user/INTERACTIONS.md
+++ b/doc/user/INTERACTIONS.md
@@ -75,9 +75,7 @@ Other hotkeys are available:
 * <kbd>F12</kbd>: take a screenshot, ie. render the current view to an image file.
 * <kbd>F11</kbd>: take a "minimal" screenshot, ie. render the current view with no grid and no overlays to an image file with a transparent background.
 
-When loading another file or reloading, options that have been changed interactively are kept but can be overridden
-if a dedicated regular expression block in the configuration file is present, see the [configuration file](CONFIGURATION_FILE.md)
-documentation for more info.
+When loading another file or reloading, options that have been changed interactively are kept as is.
 
 ## Cycling Coloring
 
diff --git a/doc/user/OPTIONS.md b/doc/user/OPTIONS.md
index 1e82b44632..e43f39dd30 100644
--- a/doc/user/OPTIONS.md
+++ b/doc/user/OPTIONS.md
@@ -8,6 +8,7 @@ F3D behavior can be fully controlled from the command line using the following o
 
 Options|Default|Description
 ------|------|------
+\-\-input=\<input file\>||The input file or files to read, can also be provided as a positional argument.
 \-\-output=\<png file\>||Instead of showing a render view and render into it, *render directly into a png file*. When used with \-\-ref option, only outputs on failure. If `-` is specified instead of a filename, the PNG file is streamed to the stdout. Can use [template variables](#filename-templating).
 \-\-no-background||Use with \-\-output to output a png file with a transparent background.
 -h, \-\-help||Print *help* and exit. Ignore `--verbose`.
@@ -85,7 +86,8 @@ Options|Default|Description
 
 Options|Default|Description
 ------|------|------
--s, \-\-scalars=\<array_name\>||Specify an array to *Color* with if present in the file. If no array_name is provided, the first in alphabetical order will be picked if any are available. <br>Requires a default scene.<br>Use \-\-verbose to recover the usable array names.
+-s, \-\-scalar-coloring||Enable scalar coloring if present in the file. If no `--coloring-array` is provided, the first in alphabetical order will be picked if any are available. <br>Requires a default scene.
+\-\-coloring-array=\<array_name\>||The coloring array name to use when coloring.<br>Use \-\-verbose to recover the usable array names.
 -y, \-\-comp=\<comp_index\>|-1|Specify the *component from the scalar* array to color with.<br>Use with the scalar option. -1 means *magnitude*. -2 or the short option, -y, means *direct values*.<br>When using *direct values*, components are used as L, LA, RGB, RGBA values depending on the number of components.
 -c, \-\-cells||Specify that the scalar array is to be found *on the cells* instead of on the points.<br>Use with the scalar option.
 \-\-range=\<min,max\>||Set a *custom range for the coloring* by the array.<br>Use with the scalar option.
@@ -146,8 +148,7 @@ Some rendering options are not compatible between them, here is the precedence o
 
 ## Options syntax
 
-The `--options=value` syntax is used everywhere in this documentation, however, the syntax `--options value` can also be used, with the exception of options that have implicit values,
-`--verbose`, `--comp` and `--scalars`.
+As documented, only the `--options=value` syntax is supported. The syntax `--options value` is not supported.
 
 ## Filename templating
 
@@ -167,4 +168,3 @@ The destination filename used by `--output` or to save screenshots can use the f
 
 For example the screenshot filename is configured as `{app}/{model}_{n}.png` by default, meaning that, assuming the model `hello.glb` is being viewed,
 consecutive screenshots are going to be saved as `F3D/hello_1.png`, `F3D/hello_2.png`, `F3D/hello_3.png`, ...
-
diff --git a/library/options.json b/library/options.json
index 431cf60972..f5e63f1d2a 100644
--- a/library/options.json
+++ b/library/options.json
@@ -249,13 +249,17 @@
       }
     },
     "scivis": {
+      "enable": {
+        "type": "bool",
+        "default_value": "false"
+      },
       "cells": {
         "type": "bool",
         "default_value": "false"
       },
       "array_name": {
         "type": "string",
-        "default_value": "f3d_reserved"
+        "default_value": ""
       },
       "component": {
         "type": "int",
diff --git a/library/src/interactor_impl.cxx b/library/src/interactor_impl.cxx
index 1dbaac70c7..34a4fa6fb8 100644
--- a/library/src/interactor_impl.cxx
+++ b/library/src/interactor_impl.cxx
@@ -360,6 +360,7 @@ class interactor_impl::internals
     if (checkColoring)
     {
       // Resynchronise renderer coloring status with options
+      self->Options.model.scivis.enable = renWithColor->GetColoringEnabled();
       self->Options.model.scivis.cells = renWithColor->GetColoringUseCell();
       self->Options.model.scivis.array_name = renWithColor->GetColoringArrayName();
       self->Options.model.scivis.component = renWithColor->GetColoringComponent();
diff --git a/library/src/window_impl.cxx b/library/src/window_impl.cxx
index 92f08d8e55..1f056db012 100644
--- a/library/src/window_impl.cxx
+++ b/library/src/window_impl.cxx
@@ -416,8 +416,8 @@ void window_impl::UpdateDynamicOptions()
     renderer->SetNormalScale(opt.model.normal.scale);
     renderer->SetTextureMatCap(opt.model.matcap.texture);
 
-    renderer->SetColoring(
-      opt.model.scivis.cells, opt.model.scivis.array_name, opt.model.scivis.component);
+    renderer->SetColoring(opt.model.scivis.enable, opt.model.scivis.cells,
+      opt.model.scivis.array_name, opt.model.scivis.component);
     renderer->SetScalarBarRange(opt.model.scivis.range);
     renderer->SetColormap(opt.model.scivis.colormap);
     renderer->ShowScalarBar(opt.ui.scalar_bar);
diff --git a/resources/configs/config.d/10_global.json b/resources/configs/config.d/05_all.json
similarity index 88%
rename from resources/configs/config.d/10_global.json
rename to resources/configs/config.d/05_all.json
index b579820c98..5a3c4bbc75 100644
--- a/resources/configs/config.d/10_global.json
+++ b/resources/configs/config.d/05_all.json
@@ -1,5 +1,5 @@
 {
-  "global":
+  ".*":
   {
     "axis": true,
     "tone-mapping": true,
@@ -7,7 +7,7 @@
     "progress": true,
     "anti-aliasing": true,
     "filename": true,
-    "scalars": "",
+    "scalar-coloring": true,
     "camera-direction": "-1,-0.5,-1",
     "hdri-ambient": true,
     "translucency-support": true,
diff --git a/resources/configs/thumbnail.d/10_global.json b/resources/configs/thumbnail.d/05_all.json
similarity index 86%
rename from resources/configs/thumbnail.d/10_global.json
rename to resources/configs/thumbnail.d/05_all.json
index 3a8353461c..7c337897e7 100644
--- a/resources/configs/thumbnail.d/10_global.json
+++ b/resources/configs/thumbnail.d/05_all.json
@@ -1,5 +1,5 @@
 {
-  "global":
+  ".*":
   {
     "anti-aliasing": true,
     "camera-direction": "-1,-0.5,-1",
@@ -7,7 +7,7 @@
     "max-size":100,
     "no-background": true,
     "verbose": "quiet",
-    "scalars": "",
+    "scalar-coloring": true,
     "tone-mapping": true,
     "translucency-support": true
   }
diff --git a/testing/baselines/TestConfigResolution.png b/testing/baselines/TestConfigResolution.png
new file mode 100644
index 0000000000..abd7e27bde
--- /dev/null
+++ b/testing/baselines/TestConfigResolution.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0ee8a95295de3d53c9176d5d441ab9a890f622be6ff05ac769a5e0100c5c4ad
+size 14039
diff --git a/testing/baselines/TestInteractionConfigFileAndCommand.png b/testing/baselines/TestInteractionConfigFileAndCommand.png
index 914a83e32c..de599d7f0f 100644
--- a/testing/baselines/TestInteractionConfigFileAndCommand.png
+++ b/testing/baselines/TestInteractionConfigFileAndCommand.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:17bf15bce32f4e6d8c8f2ea65e9bb862d3301320785da7d19137d23b67065d4a
-size 30155
+oid sha256:bd58f6ec010c36fbc9b88e79db89b5720fa56a27bf2ac83a5d1de62af31803b0
+size 33461
diff --git a/testing/baselines/TestInteractionConfigFileMulti.png b/testing/baselines/TestInteractionConfigFileMulti.png
index 914a83e32c..b3ca820d35 100644
--- a/testing/baselines/TestInteractionConfigFileMulti.png
+++ b/testing/baselines/TestInteractionConfigFileMulti.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:17bf15bce32f4e6d8c8f2ea65e9bb862d3301320785da7d19137d23b67065d4a
-size 30155
+oid sha256:62c49ebe277feaf901997aa29987e3a2d91be68ce2a0b83e248dfcb37a74f1aa
+size 23432
diff --git a/testing/baselines/TestMultiInputArg.png b/testing/baselines/TestMultiInputArg.png
new file mode 100644
index 0000000000..ee490b03f5
--- /dev/null
+++ b/testing/baselines/TestMultiInputArg.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed967b1fa921b99bb161d2a0a4fc233fcf446f9b41b4a67e6b911f884125fd03
+size 19417
diff --git a/testing/baselines/TestMultiInputMultiArgs.png b/testing/baselines/TestMultiInputMultiArgs.png
new file mode 100644
index 0000000000..ee490b03f5
--- /dev/null
+++ b/testing/baselines/TestMultiInputMultiArgs.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed967b1fa921b99bb161d2a0a4fc233fcf446f9b41b4a67e6b911f884125fd03
+size 19417
diff --git a/testing/baselines/TestMultiInputPositionals.png b/testing/baselines/TestMultiInputPositionals.png
new file mode 100644
index 0000000000..ee490b03f5
--- /dev/null
+++ b/testing/baselines/TestMultiInputPositionals.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed967b1fa921b99bb161d2a0a4fc233fcf446f9b41b4a67e6b911f884125fd03
+size 19417
diff --git a/testing/configs/complex.json b/testing/configs/complex.json
index 5d9914e731..7bded1e66c 100644
--- a/testing/configs/complex.json
+++ b/testing/configs/complex.json
@@ -1,14 +1,14 @@
 {
-  "global":
+  ".*":
   {
-    "scalars": "",
-    "axis": true,
+    "scalar-coloring": true,
+    "interactor.axis": true,
     "grid": true
   },
   ".*(vt.)":
   {
     "bar": true,
-    "ambient-occlusion": true,
+    "render.effect.ambient_occlusion": true,
     "filename": true
   },
   ".*(vti)":
diff --git a/testing/configs/config_order.json b/testing/configs/config_order.json
new file mode 100644
index 0000000000..98246b9845
--- /dev/null
+++ b/testing/configs/config_order.json
@@ -0,0 +1,8 @@
+{
+  ".+": {
+    "bg-color": "1.0, 0.0, 0.0"
+  },
+  ".*": {
+    "bg-color": "0.0, 0.0, 0.25"
+  }
+}
diff --git a/testing/configs/hdri.json.in b/testing/configs/hdri.json.in
index e5f60bacf1..d18f345016 100644
--- a/testing/configs/hdri.json.in
+++ b/testing/configs/hdri.json.in
@@ -1,5 +1,5 @@
 {
-  "global":
+  ".*":
   {
     "hdri-ambient": true,
     "hdri-skybox": true,
diff --git a/testing/configs/inexistent_key.json b/testing/configs/inexistent_key.json
new file mode 100644
index 0000000000..01d980cb1c
--- /dev/null
+++ b/testing/configs/inexistent_key.json
@@ -0,0 +1,6 @@
+{
+    ".*":
+    {
+      "scene.animation.inexistent": 0
+    }
+}
diff --git a/testing/configs/invalid_value.json b/testing/configs/invalid_value.json
index b304af17a7..9907c46c22 100644
--- a/testing/configs/invalid_value.json
+++ b/testing/configs/invalid_value.json
@@ -1,5 +1,5 @@
 {
-    "global":
+    ".*":
     {
       "verbose": {"foo": "bar"}
     }
diff --git a/testing/configs/nonparsable_value.json b/testing/configs/nonparsable_value.json
new file mode 100644
index 0000000000..5ba5f091b3
--- /dev/null
+++ b/testing/configs/nonparsable_value.json
@@ -0,0 +1,6 @@
+{
+    ".*":
+    {
+      "scene.animation.index": "nonparsable"
+    }
+}
diff --git a/testing/configs/quiet.json b/testing/configs/quiet.json
index 8cc7f87772..7789d4fe73 100644
--- a/testing/configs/quiet.json
+++ b/testing/configs/quiet.json
@@ -1,5 +1,5 @@
 {
-  "global":
+  ".*":
   {
     "verbose": "quiet",
     "no-render": true
diff --git a/testing/configs/resolution.json b/testing/configs/resolution.json
new file mode 100644
index 0000000000..86d68ed620
--- /dev/null
+++ b/testing/configs/resolution.json
@@ -0,0 +1,10 @@
+{
+  ".*":
+  {
+    "resolution": "400,400"
+  },
+  ".*(stl)":
+  {
+    "resolution": "200,200"
+  }
+}
diff --git a/testing/configs/verbose.json b/testing/configs/verbose.json
index c545cb33c6..973473df82 100644
--- a/testing/configs/verbose.json
+++ b/testing/configs/verbose.json
@@ -1,5 +1,5 @@
 {
-  "global":
+  ".*":
   {
     "verbose": true
   }
diff --git a/testing/data/config-order.json b/testing/data/config-order.json
deleted file mode 100644
index 6f0d2a0215..0000000000
--- a/testing/data/config-order.json
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0402c6dc8183ec7c46d4cb71bff46451f6ab0fa4294b9725657d3a3d8638f5d1
-size 269
diff --git a/testing/recordings/TestInteractionConfigFileAndCommand.log b/testing/recordings/TestInteractionConfigFileAndCommand.log
index 9aa64948ec..f7652cd4dc 100644
--- a/testing/recordings/TestInteractionConfigFileAndCommand.log
+++ b/testing/recordings/TestInteractionConfigFileAndCommand.log
@@ -1,9 +1,38 @@
 # StreamVersion 1.2
-ExposeEvent 0 599 0 0 0 0 0
-RenderEvent 0 599 0 0 0 0 0
-KeyPressEvent 644 453 0 111 1 o 0
-CharEvent 644 453 0 111 1 o 0
-KeyReleaseEvent 644 453 0 111 1 o 0
-KeyPressEvent 644 453 0 0 1 Left 0
-CharEvent 644 453 0 0 1 Left 0
-KeyReleaseEvent 644 453 0 0 1 Left 0
+ConfigureEvent 1249 1374 0 0 0 0 0
+ExposeEvent 0 1406 0 0 0 0 0
+RenderEvent 0 1406 0 0 0 0 0
+TimerEvent 0 1406 0 0 0 0 0
+KeyPressEvent 345 106 0 111 1 o 0
+CharEvent 345 106 0 111 1 o 0
+TimerEvent 345 106 0 111 1 o 0
+KeyReleaseEvent 345 106 0 111 1 o 0
+TimerEvent 345 106 0 111 1 o 0
+KeyPressEvent 345 106 0 120 1 x 0
+CharEvent 345 106 0 120 1 x 0
+TimerEvent 345 106 0 120 1 x 0
+KeyReleaseEvent 345 106 0 120 1 x 0
+TimerEvent 345 106 0 120 1 x 0
+KeyPressEvent 345 106 0 0 1 Right 0
+CharEvent 345 106 0 0 1 Right 0
+TimerEvent 345 106 0 0 1 Right 0
+KeyReleaseEvent 345 106 0 0 1 Right 0
+TimerEvent 345 106 0 0 1 Right 0
+KeyPressEvent 345 106 0 110 1 n 0
+CharEvent 345 106 0 110 1 n 0
+TimerEvent 345 106 0 110 1 n 0
+KeyReleaseEvent 345 106 0 110 1 n 0
+TimerEvent 345 106 0 110 1 n 0
+KeyPressEvent 345 106 0 0 1 Right 0
+CharEvent 345 106 0 0 1 Right 0
+KeyReleaseEvent 345 106 0 0 1 Right 0
+TimerEvent 345 106 0 0 1 Right 0
+KeyPressEvent 345 106 0 0 1 Right 0
+CharEvent 345 106 0 0 1 Right 0
+TimerEvent 345 106 0 0 1 Right 0
+KeyReleaseEvent 345 106 0 0 1 Right 0
+TimerEvent 345 106 0 0 1 Right 0
+KeyPressEvent 345 106 0 0 1 Right 0
+CharEvent 345 106 0 0 1 Right 0
+TimerEvent 345 106 0 0 1 Right 0
+KeyReleaseEvent 345 106 0 0 1 Right 0
diff --git a/vtkext/private/module/Testing/TestF3DRendererWithColoring.cxx b/vtkext/private/module/Testing/TestF3DRendererWithColoring.cxx
index 7fc999dac5..fcb9fc6a5e 100644
--- a/vtkext/private/module/Testing/TestF3DRendererWithColoring.cxx
+++ b/vtkext/private/module/Testing/TestF3DRendererWithColoring.cxx
@@ -14,7 +14,7 @@ int TestF3DRendererWithColoring(int argc, char* argv[])
   renderer->ShowGrid(true);
 
   // Check error paths
-  if (renderer->GetColoringArrayName() != F3D_RESERVED_STRING)
+  if (!renderer->GetColoringArrayName().empty())
   {
     std::cerr << "Unexpected coloring information without an importer" << std::endl;
     return EXIT_FAILURE;
@@ -37,7 +37,7 @@ int TestF3DRendererWithColoring(int argc, char* argv[])
   importer->Update();
 
   // Check invalid array code path
-  renderer->SetColoring(false, "Invalid", 0);
+  renderer->SetColoring(true, false, "Invalid", 0);
   renderer->SetUseVolume(false);
   renderer->UpdateActors();
   renderer->CycleScalars(vtkF3DRendererWithColoring::CycleType::COMPONENT);
@@ -51,7 +51,7 @@ int TestF3DRendererWithColoring(int argc, char* argv[])
   }
 
   // Check invalid component code path
-  renderer->SetColoring(false, "Momentum", 5);
+  renderer->SetColoring(true, false, "Momentum", 5);
   renderer->UpdateActors();
   renderer->SetUseVolume(true);
   renderer->UpdateActors();
diff --git a/vtkext/private/module/vtkF3DConfigure.h.in b/vtkext/private/module/vtkF3DConfigure.h.in
index cb221b6557..441a94c64f 100644
--- a/vtkext/private/module/vtkF3DConfigure.h.in
+++ b/vtkext/private/module/vtkF3DConfigure.h.in
@@ -3,7 +3,6 @@
 
 #include <string>
 
-static const std::string F3D_RESERVED_STRING = "f3d_reserved";
 static const std::string F3D_EXIT_HOTKEY_SYM = "Escape";
 
 // TODO: Use CMake definitions and get rid of these
diff --git a/vtkext/private/module/vtkF3DRendererWithColoring.cxx b/vtkext/private/module/vtkF3DRendererWithColoring.cxx
index aeb8ffe807..fd40d8ee98 100644
--- a/vtkext/private/module/vtkF3DRendererWithColoring.cxx
+++ b/vtkext/private/module/vtkF3DRendererWithColoring.cxx
@@ -473,7 +473,7 @@ vtkF3DRendererWithColoring::CycleType vtkF3DRendererWithColoring::CheckColoring(
   assert(this->Importer);
 
   // Never force change of anything if we are currently not coloring
-  if (this->ArrayIndexForColoring == -1)
+  if (this->ArrayIndexForColoring < 0)
   {
     return CycleType::NONE;
   }
@@ -501,7 +501,7 @@ vtkF3DRendererWithColoring::CycleType vtkF3DRendererWithColoring::CheckColoring(
 }
 
 //----------------------------------------------------------------------------
-void vtkF3DRendererWithColoring::SetColoring(
+void vtkF3DRendererWithColoring::SetColoring(bool enable,
   bool useCellData, const std::string& arrayName, int component)
 {
   if (!this->Importer)
@@ -511,13 +511,16 @@ void vtkF3DRendererWithColoring::SetColoring(
 
   // XXX This should be reworked to avoid handling multiple information in one parameters
   // while still being future-proof and flexible enough.
-  if (this->GetColoringUseCell() != useCellData || this->GetColoringArrayName() != arrayName ||
-    this->GetColoringComponent() != component)
+  if (enable != (this->ArrayIndexForColoring >= 0)
+      || useCellData != this->UseCellColoring
+      || component != this->ComponentForColoring
+      || arrayName != this->GetColoringArrayName())
   {
     this->UseCellColoring = useCellData;
+    this->ComponentForColoring = component;
 
     int nIndexes = this->Importer->GetNumberOfIndexesForColoring(this->UseCellColoring);
-    if (arrayName == F3D_RESERVED_STRING)
+    if (!enable)
     {
       // Not coloring
       this->ArrayIndexForColoring = -1;
@@ -544,8 +547,6 @@ void vtkF3DRendererWithColoring::SetColoring(
       }
     }
 
-    this->ComponentForColoring = component;
-
     this->ColorTransferFunctionConfigured = false;
     this->GeometryMappersConfigured = false;
     this->PointSpritesMappersConfigured = false;
@@ -555,6 +556,12 @@ void vtkF3DRendererWithColoring::SetColoring(
   }
 }
 
+//----------------------------------------------------------------------------
+bool vtkF3DRendererWithColoring::GetColoringEnabled()
+{
+  return this->ArrayIndexForColoring >= 0;
+}
+
 //----------------------------------------------------------------------------
 bool vtkF3DRendererWithColoring::GetColoringUseCell()
 {
@@ -566,7 +573,7 @@ std::string vtkF3DRendererWithColoring::GetColoringArrayName()
 {
   if (!this->Importer)
   {
-    return F3D_RESERVED_STRING;
+    return "";
   }
 
   vtkF3DGenericImporter::ColoringInfo info;
@@ -576,7 +583,7 @@ std::string vtkF3DRendererWithColoring::GetColoringArrayName()
   }
   else
   {
-    return F3D_RESERVED_STRING;
+    return "";
   }
 }
 
diff --git a/vtkext/private/module/vtkF3DRendererWithColoring.h b/vtkext/private/module/vtkF3DRendererWithColoring.h
index 9bbdbd2412..ff4459f9e9 100644
--- a/vtkext/private/module/vtkF3DRendererWithColoring.h
+++ b/vtkext/private/module/vtkF3DRendererWithColoring.h
@@ -157,17 +157,18 @@ class vtkF3DRendererWithColoring : public vtkF3DRenderer
   void SetImporter(vtkF3DGenericImporter* importer);
 
   /**
-   * Set the coloring, call after SetColoringAttributes.
+   * Set coloring information.
    * This method will try to find the corresponding array in the coloring attributes and will
    * position ArrayIndexForColoring and DataForColoring accordingly.
    */
-  void SetColoring(bool useCellData, const std::string& arrayName, int component);
+  void SetColoring(bool enable, bool useCellData, const std::string& arrayName, int component);
 
   ///@{
   /**
    * Get current coloring information,
    * Useful after using Cycle methods
    */
+  bool GetColoringEnabled();
   bool GetColoringUseCell();
   std::string GetColoringArrayName();
   int GetColoringComponent();
diff --git a/webassembly/app.html b/webassembly/app.html
index c7d3edd713..9b5c6dad6d 100644
--- a/webassembly/app.html
+++ b/webassembly/app.html
@@ -94,6 +94,7 @@ <h1 class="title">F3D Web</h1>
         options.set_color('render.background.color', 0, 0, 0);
 
         // setup coloring
+        options.toggle('model.scivis.enable');
         options.set_string('model.scivis.array_name', 'Colors');
         options.set_integer('model.scivis.component', -2);
         options.toggle('model.scivis.cells');