diff --git a/.github/workflows/style-checks.yml b/.github/workflows/style-checks.yml
index 45257e5629..0320ad4bde 100644
--- a/.github/workflows/style-checks.yml
+++ b/.github/workflows/style-checks.yml
@@ -10,8 +10,9 @@ jobs:
     - name: C++ Formatting
       uses: DoozyX/clang-format-lint-action@v0.16.1
       with:
-        source: 'library application python plugins'
-        extensions: 'h,cxx'
+        source: 'library application python plugins examples'
+        extensions: 'h,cxx,in'
+        exclude: '**/*.py.in'
         clangFormatVersion: 14 # Last Ubuntu LTS version (22.04)
     - name: Python Formatting
       uses: psf/black@stable
diff --git a/application/F3DConfig.h.in b/application/F3DConfig.h.in
index 35803c22be..fd22136008 100644
--- a/application/F3DConfig.h.in
+++ b/application/F3DConfig.h.in
@@ -5,11 +5,11 @@
 
 namespace F3D
 {
-  const std::string AppName = "@PROJECT_NAME@";
-  const std::string AppTitle = "@PROJECT_DESCRIPTION@";
-  const std::string AppVersion = "@F3D_VERSION@";
-  const std::string AppVersionFull = "@F3D_VERSION_FULL@";
-  const std::string PluginsInstallDir = "@F3D_PLUGINS_INSTALL_DIR@";
+const std::string AppName = "@PROJECT_NAME@";
+const std::string AppTitle = "@PROJECT_DESCRIPTION@";
+const std::string AppVersion = "@F3D_VERSION@";
+const std::string AppVersionFull = "@F3D_VERSION_FULL@";
+const std::string PluginsInstallDir = "@F3D_PLUGINS_INSTALL_DIR@";
 }
 
 // TODO: Use CMake definitions and get rid of these
diff --git a/application/F3DOptionsParser.cxx b/application/F3DOptionsParser.cxx
index 0bff935459..8c082e91b4 100644
--- a/application/F3DOptionsParser.cxx
+++ b/application/F3DOptionsParser.cxx
@@ -316,6 +316,13 @@ void ConfigurationOptions::GetOptions(F3DAppOptions& appOptions, f3d::options& o
   // 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);
@@ -338,70 +345,70 @@ void ConfigurationOptions::GetOptions(F3DAppOptions& appOptions, f3d::options& o
 
     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", options.getAsBoolRef("ui.loader-progress"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "animation-progress", "", "Show animation progress bar", options.getAsBoolRef("ui.animation-progress"), HasDefault::YES, MayHaveConfig::YES);
+    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", options.getAsStringRef("scene.up-direction"), HasDefault::YES, MayHaveConfig::YES, "{-X, +X, -Y, +Y, -Z, +Z}");
-    this->DeclareOption(grp1, "axis", "x", "Show axes", options.getAsBoolRef("interactor.axis"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid", "g", "Show grid", options.getAsBoolRef("render.grid.enable"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid-absolute", "", "Position grid at the absolute origin instead of below the model", options.getAsBoolRef("render.grid.absolute"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid-unit", "", "Size of grid unit square, set to a non-positive value for automatic computation", options.getAsDoubleRef("render.grid.unit"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid-subdivisions", "", "Number of grid subdivisions", options.getAsIntRef("render.grid.subdivisions"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "grid-color", "", "Color of main grid lines", options.getAsDoubleVectorRef("render.grid.color"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "edges", "e", "Show cell edges", options.getAsBoolRef("render.show-edges"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "camera-index", "", "Select the camera to use", options.getAsIntRef("scene.camera.index"), HasDefault::YES, MayHaveConfig::YES, "<index>");
-    this->DeclareOption(grp1, "trackball", "k", "Enable trackball interaction", options.getAsBoolRef("interactor.trackball"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "invert-zoom", "", "Invert zoom direction with right mouse click", options.getAsBoolRef("interactor.invert-zoom"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "animation-autoplay", "", "Automatically start animation", options.getAsBoolRef("scene.animation.autoplay"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp1, "animation-index", "", "Select animation to show", options.getAsIntRef("scene.animation.index"), HasDefault::YES, MayHaveConfig::YES, "<index>");
-    this->DeclareOption(grp1, "animation-speed-factor", "", "Set animation speed factor", options.getAsDoubleRef("scene.animation.speed-factor"), HasDefault::YES, MayHaveConfig::YES, "<factor>");
-    this->DeclareOption(grp1, "animation-time", "", "Set animation time to load", options.getAsDoubleRef("scene.animation.time"), HasDefault::YES, MayHaveConfig::YES, "<time>");
-    this->DeclareOption(grp1, "animation-frame-rate", "", "Set animation frame rate when playing animation interactively", options.getAsDoubleRef("scene.animation.frame-rate"), HasDefault::YES, MayHaveConfig::YES, "<frame rate>");
-    this->DeclareOption(grp1, "font-file", "", "Path to a FreeType compatible font file", options.getAsStringRef("ui.font-file"), LocalHasDefaultNo, MayHaveConfig::NO, "<file_path>");
+    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", options.getAsBoolRef("model.point-sprites.enable"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp2, "point-type", "", "Point sprites type when showing point sprites", options.getAsStringRef("model.point-sprites.type"), HasDefault::YES, MayHaveConfig::YES, "<sphere|gaussian>");
-    this->DeclareOption(grp2, "point-size", "", "Point size when showing vertices or point sprites", options.getAsDoubleRef("render.point-size"), HasDefault::YES, MayHaveConfig::YES, "<size>");
-    this->DeclareOption(grp2, "line-width", "", "Line width when showing edges", options.getAsDoubleRef("render.line-width"), HasDefault::YES, MayHaveConfig::YES, "<width>");
-    this->DeclareOption(grp2, "backface-type", "", "Backface type, can be default (usually visible), visible or hidden", options.getAsStringRef("render.backface-type"), HasDefault::YES, MayHaveConfig::YES, "<default|visible|hidden>");
-    this->DeclareOption(grp2, "color", "", "Solid color", options.getAsDoubleVectorRef("model.color.rgb"), HasDefault::YES, MayHaveConfig::YES, "<R,G,B>");
-    this->DeclareOption(grp2, "opacity", "", "Opacity", options.getAsDoubleRef("model.color.opacity"), HasDefault::YES, MayHaveConfig::YES, "<opacity>");
-    this->DeclareOption(grp2, "roughness", "", "Roughness coefficient (0.0-1.0)", options.getAsDoubleRef("model.material.roughness"), HasDefault::YES, MayHaveConfig::YES, "<roughness>");
-    this->DeclareOption(grp2, "metallic", "", "Metallic coefficient (0.0-1.0)", options.getAsDoubleRef("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", options.getAsStringRef("render.hdri.file"), LocalHasDefaultNo, MayHaveConfig::YES, "<file path>");
-    this->DeclareOption(grp2, "hdri-ambient", "f", "Enable HDRI ambient lighting", options.getAsBoolRef("render.hdri.ambient"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp2, "hdri-skybox", "j", "Enable HDRI skybox background", options.getAsBoolRef("render.background.skybox"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp2, "texture-matcap", "", "Path to a texture file containing a material capture", options.getAsStringRef("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", options.getAsStringRef("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", options.getAsStringRef("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", options.getAsStringRef("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", options.getAsDoubleVectorRef("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", options.getAsStringRef("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", options.getAsDoubleRef("model.normal.scale"), HasDefault::YES, MayHaveConfig::YES, "<normalScale>");
+    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", options.getAsDoubleVectorRef("render.background.color"), HasDefault::YES, MayHaveConfig::YES, "<R,G,B>");
+    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", options.getAsBoolRef("ui.fps"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp3, "filename", "n", "Display filename", options.getAsBoolRef("ui.filename"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp3, "metadata", "m", "Display file metadata", options.getAsBoolRef("ui.metadata"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp3, "blur-background", "u", "Blur background", options.getAsBoolRef("render.background.blur"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp3, "blur-coc", "", "Blur circle of confusion radius", options.getAsDoubleRef("render.background.blur.coc"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp3, "light-intensity", "", "Light intensity", options.getAsDoubleRef("render.light.intensity"), HasDefault::YES, MayHaveConfig::YES, "<intensity>");
+    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", options.getAsStringRef("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", options.getAsIntRef("model.scivis.component"), HasDefault::YES, MayHaveConfig::YES, "<comp_index>", HasImplicitValue::YES, "-2");
-    this->DeclareOption(grp4, "cells", "c", "Use a scalar array from the cells", options.getAsBoolRef("model.scivis.cells"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp4, "range", "", "Custom range for the coloring by array", options.getAsDoubleVectorRef("model.scivis.range"), HasDefault::YES, MayHaveConfig::YES, "<min,max>");
-    this->DeclareOption(grp4, "bar", "b", "Show scalar bar", options.getAsBoolRef("ui.bar"), HasDefault::YES, MayHaveConfig::YES);
+    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)", options.getAsDoubleVectorRef("model.scivis.colormap"), HasDefault::YES, MayHaveConfig::YES, "<color_list>");
-    this->DeclareOption(grp4, "volume", "v", "Show volume if the file is compatible", options.getAsBoolRef("model.volume.enable"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp4, "inverse", "i", "Inverse opacity function for volume rendering", options.getAsBoolRef("model.volume.inverse"), HasDefault::YES, MayHaveConfig::YES);
+    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>");
@@ -412,21 +419,21 @@ void ConfigurationOptions::GetOptions(F3DAppOptions& appOptions, f3d::options& o
     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", options.getAsBoolRef("scene.camera.orthographic"), HasDefault::YES, MayHaveConfig::YES);
+    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", options.getAsBoolRef("render.raytracing.enable"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp5, "samples", "", "Number of samples per pixel", options.getAsIntRef("render.raytracing.samples"), HasDefault::YES, MayHaveConfig::YES, "<samples>");
-    this->DeclareOption(grp5, "denoise", "d", "Denoise the image", options.getAsBoolRef("render.raytracing.denoise"), HasDefault::YES, MayHaveConfig::YES);
+    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", options.getAsBoolRef("render.effect.translucency-support"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp6, "ambient-occlusion", "q", "Enable ambient occlusion providing approximate shadows for better depth perception, implemented using SSAO", options.getAsBoolRef("render.effect.ambient-occlusion"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp6, "anti-aliasing", "a", "Enable anti-aliasing, implemented using FXAA", options.getAsBoolRef("render.effect.anti-aliasing"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp6, "tone-mapping", "t", "Enable Tone Mapping, providing balanced coloring", options.getAsBoolRef("render.effect.tone-mapping"), HasDefault::YES, MayHaveConfig::YES);
-    this->DeclareOption(grp6, "final-shader", "", "Execute the final shader at the end of the rendering pipeline", options.getAsStringRef("render.effect.final-shader"), LocalHasDefaultNo, MayHaveConfig::YES, "<GLSL code>");
+    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>");
@@ -440,7 +447,10 @@ void ConfigurationOptions::GetOptions(F3DAppOptions& appOptions, f3d::options& o
     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)
@@ -510,12 +520,16 @@ void ConfigurationOptions::GetOptions(F3DAppOptions& appOptions, f3d::options& o
     {
       // 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 options: ", ex.what());
-    throw;
+    f3d::log::error("Error parsing command line arguments: ", ex.what());
+    throw F3DExFailure("Could not parse command line arguments");
   }
 }
 
diff --git a/application/F3DStarter.cxx b/application/F3DStarter.cxx
index 11a37fab77..59bc928857 100644
--- a/application/F3DStarter.cxx
+++ b/application/F3DStarter.cxx
@@ -383,8 +383,8 @@ F3DStarter::F3DStarter()
   : Internals(std::make_unique<F3DStarter::F3DInternals>())
 {
   // Set option outside of command line and config file
-  this->Internals->DynamicOptions.set(
-    "ui.dropzone-info", "Drop a file or HDRI to load it\nPress H to show cheatsheet");
+  this->Internals->DynamicOptions.ui.dropzone_info =
+    "Drop a file or HDRI to load it\nPress H to show cheatsheet";
 
   // Initialize dmon
   dmon_init();
@@ -510,9 +510,10 @@ int F3DStarter::Start(int argc, char** argv)
             // TODO: add a image::canRead
 
             // Load the file as an HDRI instead of adding it.
-            this->Internals->Engine->getOptions().set("render.hdri.file", file);
-            this->Internals->Engine->getOptions().set("render.hdri.ambient", true);
-            this->Internals->Engine->getOptions().set("render.background.skybox", true);
+            f3d::options& options = this->Internals->Engine->getOptions();
+            options.render.hdri.file = file;
+            options.render.hdri.ambient = true;
+            options.render.background.skybox = true;
 
             // Rendering now is needed for correct lighting
             this->Render();
@@ -557,13 +558,13 @@ int F3DStarter::Start(int argc, char** argv)
 
     if (!fullPath.empty())
     {
-      this->Internals->Engine->getOptions().set(
-        "model.scivis.colormap", F3DColorMapTools::Read(fullPath));
+      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().set("model.scivis.colormap", std::vector<double>{});
+      this->Internals->Engine->getOptions().model.scivis.colormap = std::vector<double>{};
     }
   }
 
@@ -894,8 +895,9 @@ void F3DStarter::LoadFile(int index, bool relativeIndex)
     loader.loadGeometry("", true);
   }
 
-  this->Internals->Engine->getOptions().set("ui.dropzone", !this->Internals->LoadedFile);
-  this->Internals->Engine->getOptions().set("ui.filename-info", filenameInfo);
+  f3d::options& options = this->Internals->Engine->getOptions();
+  options.ui.dropzone = !this->Internals->LoadedFile;
+  options.ui.filename_info = filenameInfo;
 }
 
 //----------------------------------------------------------------------------
@@ -949,14 +951,14 @@ void F3DStarter::SaveScreenshot(const std::string& filenameTemplate, bool minima
   bool noBackground = this->Internals->AppOptions.NoBackground;
   if (minimal)
   {
-    options.set("ui.bar", false);
-    options.set("ui.cheatsheet", false);
-    options.set("ui.filename", false);
-    options.set("ui.fps", false);
-    options.set("ui.metadata", false);
-    options.set("ui.animation-progress", false);
-    options.set("interactor.axis", false);
-    options.set("render.grid.enable", false);
+    options.ui.scalar_bar = false;
+    options.ui.cheatsheet = false;
+    options.ui.filename = false;
+    options.ui.fps = false;
+    options.ui.metadata = false;
+    options.ui.animation_progress = false;
+    options.interactor.axis = false;
+    options.render.grid.enable = false;
     noBackground = true;
   }
 
@@ -964,7 +966,7 @@ void F3DStarter::SaveScreenshot(const std::string& filenameTemplate, bool minima
   this->Internals->addOutputImageMetadata(img);
   img.save(path.string(), f3d::image::SaveFormat::PNG);
 
-  options.getAsDoubleRef("render.light.intensity") *= 5;
+  options.render.light.intensity *= 5;
   this->Render();
 
   this->Internals->Engine->setOptions(optionsCopy);
diff --git a/application/testing/CMakeLists.txt b/application/testing/CMakeLists.txt
index 2808a6b327..e90dc18e75 100644
--- a/application/testing/CMakeLists.txt
+++ b/application/testing/CMakeLists.txt
@@ -915,6 +915,10 @@ f3d_test(NAME TestReadersList ARGS --readers-list REGEXP_FAIL "No registered rea
 add_test(NAME f3d::TestNoDryRun COMMAND $<TARGET_FILE:f3d> --no-render)
 set_tests_properties(f3d::TestNoDryRun PROPERTIES TIMEOUT 4)
 
+# Test invalid CLI args
+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 failure without a reference, please do not create a TestNoRef.png file
 f3d_test(NAME TestNoRef DATA cow.vtp WILL_FAIL)
 
diff --git a/cmake/f3dOptions.cmake b/cmake/f3dOptions.cmake
new file mode 100644
index 0000000000..125d596803
--- /dev/null
+++ b/cmake/f3dOptions.cmake
@@ -0,0 +1,156 @@
+#[==[
+@file f3dOptions.cmake
+
+This module contains all the methods required to parse a JSON file specifying options
+and generate the associated CXX code.
+#]==]
+
+#[==[
+@brief generate public and private headers for a provided options.json
+
+~~~
+f3d_generate_options(
+  INPUT_JSON "path/to/options.json"
+  INPUT_PUBLIC_HEADER "path/to/options.h.in"
+  INPUT_PRIVATE_HEADER "path/to/options_tools.h.in"
+  DESTINATION "path/to/destination/folder"
+  OUTPUT_NAME "options"
+	)
+~~~
+
+#]==]
+
+function (f3d_generate_options)
+  cmake_parse_arguments(PARSE_ARGV 0 _f3d_generate_options
+    ""
+    "INPUT_JSON;INPUT_PUBLIC_HEADER;INPUT_PRIVATE_HEADER;DESTINATION;OUTPUT_NAME"
+    "")
+
+  if (_f3d_generate_options_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "Unparsed arguments for f3d_generate_options: "
+      "${_f3d_generate_options_UNPARSED_ARGUMENTS}")
+  endif ()
+
+  if (NOT DEFINED _f3d_generate_options_INPUT_JSON)
+    message(FATAL_ERROR
+      "Missing INPUT_JSON argument for f3d_generate_options")
+  endif ()
+
+  if (NOT DEFINED _f3d_generate_options_INPUT_PUBLIC_HEADER)
+    message(FATAL_ERROR
+      "Missing INPUT_PUBLIC_HEADER argument for f3d_generate_options")
+  endif ()
+
+  if (NOT DEFINED _f3d_generate_options_INPUT_PRIVATE_HEADER)
+    message(FATAL_ERROR
+      "Missing INPUT_PRIVATE_HEADER argument for f3d_generate_options")
+  endif ()
+
+  if (NOT DEFINED _f3d_generate_options_DESTINATION)
+    message(FATAL_ERROR
+      "Missing DESTINATION argument for f3d_generate_options")
+  endif ()
+
+  if (NOT DEFINED _f3d_generate_options_OUTPUT_NAME)
+    message(FATAL_ERROR
+      "Missing OUTPUT_NAME argument for f3d_generate_options")
+  endif ()
+
+
+  # Parse options.json and generate headers
+  set(_option_basename "")
+  set(_option_indent "")
+
+  # Add a configure depends on the input file
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${_f3d_generate_options_INPUT_JSON})
+
+  ## Read the .json file and complete the struct
+  file(READ ${_f3d_generate_options_INPUT_JSON} _options_json)
+  _parse_json_option(${_options_json})
+
+  list(JOIN _options_setter ";\n    else " _options_setter)
+  list(JOIN _options_getter ";\n  else " _options_getter)
+  list(JOIN _options_string_setter ";\n  else " _options_string_setter)
+  list(JOIN _options_string_getter ";\n  else " _options_string_getter)
+  list(JOIN _options_lister ",\n  " _options_lister)
+
+  configure_file(
+    "${_f3d_generate_options_INPUT_PUBLIC_HEADER}"
+    "${_f3d_generate_options_DESTINATION}/public/${_f3d_generate_options_OUTPUT_NAME}.h")
+
+  configure_file(
+    "${_f3d_generate_options_INPUT_PRIVATE_HEADER}"
+    "${_f3d_generate_options_DESTINATION}/private/${_f3d_generate_options_OUTPUT_NAME}_tools.h")
+
+endfunction()
+
+#[==[
+@brief internal recursive method use to parse json structure and generate variables
+#]==]
+function(_parse_json_option _top_json)
+  # TODO Add a deprecation mechanism
+  string(JSON _options_length LENGTH ${_top_json})
+  MATH(EXPR _options_length "${_options_length} - 1")
+  foreach(_json_idx RANGE ${_options_length})
+    # Recover the json element name
+    string(JSON _member_name MEMBER ${_top_json} ${_json_idx})
+    # Read the json element
+    string(JSON _cur_json GET ${_top_json} ${_member_name})
+    # Recover its type and default if it is a leaf option
+    string(JSON _option_type ERROR_VARIABLE _type_error GET ${_cur_json} "type")
+    string(JSON _option_default_value ERROR_VARIABLE _default_value_error GET ${_cur_json} "default_value")
+    if(_type_error STREQUAL "NOTFOUND" AND _default_value_error STREQUAL "NOTFOUND")
+       # Leaf option found!
+       set(_option_name "${_option_basename}${_member_name}")
+
+       # Identify types
+       set(_option_actual_type ${_option_type})
+       set(_option_variant_type ${_option_type})
+       set(_option_default_value_start "")
+       set(_option_default_value_end "")
+       if(_option_type STREQUAL "double_vector")
+         set(_option_actual_type "std::vector<double>")
+         set(_option_variant_type "std::vector<double>")
+         set(_option_default_value_start "{")
+         set(_option_default_value_end "}")
+       elseif(_option_type STREQUAL "string")
+         set(_option_actual_type "std::string")
+         set(_option_variant_type "std::string")
+         set(_option_default_value_start "\"")
+         set(_option_default_value_end "\"")
+       elseif(_option_type STREQUAL "ratio")
+         set(_option_actual_type "f3d::ratio_t")
+         set(_option_variant_type "double")
+       endif()
+
+       # Add option to struct and methods
+       string(APPEND _options_struct "${_option_indent}  ${_option_actual_type} ${_member_name} = ${_option_default_value_start}${_option_default_value}${_option_default_value_end};\n")
+       list(APPEND _options_setter "if (name == \"${_option_name}\") opt.${_option_name} = std::get<${_option_variant_type}>(value)")
+       list(APPEND _options_getter "if (name == \"${_option_name}\") return opt.${_option_name}")
+       list(APPEND _options_string_setter "if (name == \"${_option_name}\") opt.${_option_name} = options_tools::parse<${_option_actual_type}>(str)")
+       list(APPEND _options_string_getter "if (name == \"${_option_name}\") return options_tools::format(opt.${_option_name})")
+       list(APPEND _options_lister "\"${_option_name}\"")
+
+    else()
+      # Group found, add in the struct and recurse
+      set(_option_prevname ${_option_basename})
+      set(_option_previndent ${_option_indent})
+      string(APPEND _option_indent "  ")
+      string(APPEND _option_basename "${_member_name}.")
+      string(APPEND _options_struct "${_option_indent}struct ${_member_name} {\n")
+      _parse_json_option(${_cur_json})
+      string(APPEND _options_struct "${_option_indent}} ${_member_name};\n\n")
+      set(_option_indent ${_option_previndent})
+      set(_option_basename ${_option_prevname})
+    endif()
+  endforeach()
+  # Set appended variables and list in the parent before leaving the recursion
+  # Always use quotes for string variable as it contains semi-colons
+  set(_options_struct "${_options_struct}" PARENT_SCOPE)
+  set(_options_setter ${_options_setter} PARENT_SCOPE)
+  set(_options_getter ${_options_getter} PARENT_SCOPE)
+  set(_options_string_setter ${_options_string_setter} PARENT_SCOPE)
+  set(_options_string_getter ${_options_string_getter} PARENT_SCOPE)
+  set(_options_lister ${_options_lister} PARENT_SCOPE)
+endfunction()
diff --git a/doc/libf3d/OPTIONS.md b/doc/libf3d/OPTIONS.md
index 6d7b1caa9c..ec2cfca05f 100644
--- a/doc/libf3d/OPTIONS.md
+++ b/doc/libf3d/OPTIONS.md
@@ -1,6 +1,9 @@
 # Options exhaustive list
 
-An option is a string used as a key associated with a value, which are stored in an `options` instance.
+An option is a specific value stored in different struct in an `options` instance.
+They can be accessed directly through the structs, through a string API or through a std::variant API, the last one require C++17.
+If your compiler does not support C++17, you can disable this API by defining `F3D_DISABLE_CXX17_API`.
+
 The possible option are listed below and are organized by categories and subcategories, here is a non-exhaustive explanation of the categories.
 
  * `scene` options are related to how the scene is being displayed
@@ -19,10 +22,10 @@ Option|Type<br>Default<br>Trigger|Description|F3D option
 :---:|:---:|:---|:---:
 scene.animation.autoplay|bool<br>false<br>load|Automatically start animation.|\-\-animation-autoplay
 scene.animation.index|int<br>0<br>load|Select the animation to load.<br>Any negative value means all animations (glTF only).<br>The default scene always has at most one animation.|\-\-animation-index
-scene.animation.speed-factor|double<br>1<br>render|Set the animation speed factor to slow, speed up or even invert animation.|\-\-animation-speed-factor
-scene.animation.frame-rate|double<br>60<br>render|Set the animation frame rate used to play the animation interactively.|\-\-animation-frame-rate
+scene.animation.speed_factor|double<br>1<br>render|Set the animation speed factor to slow, speed up or even invert animation.|\-\-animation-speed-factor
+scene.animation.frame_rate|double<br>60<br>render|Set the animation frame rate used to play the animation interactively.|\-\-animation-frame-rate
 scene.camera.index|int<br>-1<br>load|Select the scene camera to use when available in the file.<br>Any negative value means automatic camera.<br>The default scene always uses automatic camera.|\-\-camera-index
-scene.up-direction|string<br>+Y<br>load|Define the Up direction|\-\-up
+scene.up_direction|string<br>+Y<br>load|Define the Up direction|\-\-up
 scene.camera.orthographic|bool<br>false<br>load|Toggles between orthographic projection and parallel mode.|\-\-camera\-orthographic
 
 ## Interactor Options
@@ -50,10 +53,10 @@ model.normal.texture|string<br>-<br>render|Path to a texture file that sets the
 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>\<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.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
+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
 model.volume.enable|bool<br>false<br>render|Enable *volume rendering*. It is only available for 3D image data (vti, dcm, nrrd, mhd files) and will display nothing with other default scene formats.|\-\-volume
 model.volume.inverse|bool<br>false<br>render|Inverse the linear opacity function.|\-\-inverse
 
@@ -61,14 +64,14 @@ model.volume.inverse|bool<br>false<br>render|Inverse the linear opacity function
 
 Option|Type<br>Default<br>Trigger|Description|F3D option
 :---:|:---:|:---|:---:
-render.effect.translucency-support|bool<br>false<br>render|Enable *translucency support*. This is a technique used to correctly render translucent objects, implemented using depth peeling|\-\-translucency-support
-render.effect.anti-aliasing|bool<br>false<br>render|Enable *anti-aliasing*. This technique is used to reduce aliasing, implemented using FXAA.|\-\-anti-aliasing
-render.effect.ambient-occlusion|bool<br>false<br>render|Enable *ambient occlusion*. This is a technique providing approximate shadows, used to improve the depth perception of the object. Implemented using SSAO|\-\-ambient-occlusion
-render.effect.tone-mapping|bool<br>false<br>render|Enable generic filmic *Tone Mapping Pass*. This technique is used to map colors properly to the monitor colors.|\-\-tone-mapping
-render.effect.final-shader|string<br>""<br>render|Add a final shader to the output image|\-\-final-shader. See [user documentation](../user/FINAL_SHADER.md).
-render.line-width|double<br>1.0<br>render|Set the *width* of lines when showing edges.|\-\-line-width
-render.show-edges|bool<br>false<br>render|Show the *cell edges*|\-\-edges
-render.point-size|double<br>10.0<br>render|Set the *size* of points when showing vertices and point sprites.|\-\-point-size
+render.effect.translucency_support|bool<br>false<br>render|Enable *translucency support*. This is a technique used to correctly render translucent objects, implemented using depth peeling|\-\-translucency-support
+render.effect.anti_aliasing|bool<br>false<br>render|Enable *anti-aliasing*. This technique is used to reduce aliasing, implemented using FXAA.|\-\-anti-aliasing
+render.effect.ambient_occlusion|bool<br>false<br>render|Enable *ambient occlusion*. This is a technique providing approximate shadows, used to improve the depth perception of the object. Implemented using SSAO|\-\-ambient_occlusion
+render.effect.tone_mapping|bool<br>false<br>render|Enable generic filmic *Tone Mapping Pass*. This technique is used to map colors properly to the monitor colors.|\-\-tone-mapping
+render.effect.final_shader|string<br>""<br>render|Add a final shader to the output image|\-\-final-shader. See [user documentation](../user/FINAL_SHADER.md).
+render.line_width|double<br>1.0<br>render|Set the *width* of lines when showing edges.|\-\-line-width
+render.show_edges|bool<br>false<br>render|Show the *cell edges*|\-\-edges
+render.point_size|double<br>10.0<br>render|Set the *size* of points when showing vertices and point sprites.|\-\-point-size
 render.grid.enable|bool<br>false<br>render|Show *a grid* aligned with the horizontal (orthogonal to the Up direction) plane.|\-\-grid
 render.grid.absolute|bool<br>false<br>render|Position the grid at the *absolute origin* of the model's coordinate system instead of below the model.|\-\-grid
 render.grid.unit|double<br>0<br>render|Set the size of the *unit square* for the grid. If set to non-positive (the default) a suitable value will be automatically computed.|\-\-grid\-unit
@@ -89,14 +92,59 @@ render.light.intensity|double<br>1.0<br>render|Adjust the intensity of every lig
 
 Option|Type<br>Default<br>Trigger|Description|F3D option
 :---:|:---:|:---|:---:
-ui.bar|bool<br>false<br>render|Show *scalar bar* of the coloring by data array.|\-\-bar
+ui.scalar_bar|bool<br>false<br>render|Show *scalar bar* of the coloring by data array.|\-\-bar
 ui.cheatsheet|bool<br>false<br>render|Show a interactor cheatsheet
 ui.filename|bool<br>false<br>render|Display the *filename info content* on top of the window.|\-\-filename
-ui.filename-info|string<br>-<br>render|Content of *filename info* to display.
-ui.font-file|string<br>-<br>render|Use the provided FreeType compatible font file to display text.<br>Can be useful to display non-ASCII filenames.|\-\-font-file
+ui.filename_info|string<br>-<br>render|Content of *filename info* to display.
+ui.font_file|string<br>-<br>render|Use the provided FreeType compatible font file to display text.<br>Can be useful to display non-ASCII filenames.|\-\-font-file
 ui.fps|bool<br>false<br>render|Display a *frame per second counter*.|\-\-fps
-ui.loader-progress|bool<br>false<br>load|Show a *progress bar* when loading the file.|\-\-progress
-ui.animation-progress|bool<br>false<br>load|Show a *progress bar* when playing the animation.|\-\-animation-progress
+ui.loader_progress|bool<br>false<br>load|Show a *progress bar* when loading the file.|\-\-progress
+ui.animation_progress|bool<br>false<br>load|Show a *progress bar* when playing the animation.|\-\-animation-progress
 ui.metadata|bool<br>false<br>render|Display the *metadata*.|\-\-metadata
 ui.dropzone|bool<br>false<br>render|Show a drop zone.
-ui.dropzone-info|string<br>-<br>render|Content of the drop zone text to display.
+ui.dropzone_info|string<br>-<br>render|Content of the drop zone text to display.
+
+# APIs
+
+There are three APIs to access the options
+
+## Struct API
+
+The most straightforward and easy to use API, just access it through the structs available in the options instance, eg:
+
+```cpp
+  f3d::engine eng(f3d::window::Type::NATIVE);
+  f3d::options& opt = eng.getOptions();
+  opt.render.show_edges = true;
+  opt.render.grid.enable = true;
+  opt.ui.metadata = true;
+  opt.model.material.roughness = 0.6;
+```
+
+## String API
+
+The most generic and flexible API, as it rely on parsing and string generation.
+The documentation about option parsing is upcoming.
+
+```cpp
+  f3d::engine eng(f3d::window::Type::NATIVE);
+  f3d::options& opt = eng.getOptions();
+  opt.setAsString("render.show_edges", "true");
+  opt.setAsString("render.grid.enable", "true");
+  opt.setAsString("ui.metadata", "true");
+  opt.setAsString("model.material.roughness", "0.6");
+```
+
+## Variant API
+
+An API that is similar to the F3D 2.0 options API thanks to std::variant, requires C++17.
+If your compiler does not support C++17, you can disable this API by defining `F3D_DISABLE_CXX17_API`.
+
+```cpp
+  f3d::engine eng(f3d::window::Type::NATIVE);
+  f3d::options& opt = eng.getOptions();
+  opt.set("render.show_edges", true);
+  opt.set("render.grid.enable", true);
+  opt.set("ui.metadata", true);
+  opt.set("model.material.roughness", 0.6);
+```
diff --git a/doc/libf3d/OVERVIEW.md b/doc/libf3d/OVERVIEW.md
index 8007601788..ed0fad0a9e 100644
--- a/doc/libf3d/OVERVIEW.md
+++ b/doc/libf3d/OVERVIEW.md
@@ -108,9 +108,9 @@ f3d::engine::autoloadPlugins();
 f3d::engine eng();
 
 // Recover the options and set the wanted value
-eng.getOptions()
-  .set("render.effect.ambient-occlusion", true)
-  .set("render.effect.anti-aliasing", true);
+options& opt = eng.getOptions();
+opt.render.effect.ambient_occlusion = true;
+opt.render.effect.anti_aliasing = true;
 
 // Standard libf3d usage
 eng.getLoader().loadGeometry("path/to/file.ext");
diff --git a/examples/libf3d/cpp/CMakeLists.txt b/examples/libf3d/cpp/CMakeLists.txt
index 6587234dd0..611d0e12a7 100644
--- a/examples/libf3d/cpp/CMakeLists.txt
+++ b/examples/libf3d/cpp/CMakeLists.txt
@@ -8,3 +8,6 @@ add_subdirectory(check-engine)
 add_subdirectory(multi-geom)
 add_subdirectory(render-image)
 add_subdirectory(render-interact)
+add_subdirectory(use-options-string)
+add_subdirectory(use-options-struct)
+add_subdirectory(use-options-variant)
diff --git a/examples/libf3d/cpp/check-engine/CMakeLists.txt b/examples/libf3d/cpp/check-engine/CMakeLists.txt
index d713a95210..88c4ff1a9d 100644
--- a/examples/libf3d/cpp/check-engine/CMakeLists.txt
+++ b/examples/libf3d/cpp/check-engine/CMakeLists.txt
@@ -20,9 +20,7 @@ check_variable_defined(f3d_BINDINGS_JAVA)
 
 add_executable(check-engine main.cxx)
 target_link_libraries(check-engine f3d::libf3d)
-
-# make sure the libf3d API is compatible with C++11
-set_target_properties(check-engine PROPERTIES CXX_STANDARD 11)
+set_target_properties(check-engine PROPERTIES CXX_STANDARD 17)
 
 if(BUILD_TESTING)
   enable_testing()
diff --git a/examples/libf3d/cpp/multi-geom/main.cxx b/examples/libf3d/cpp/multi-geom/main.cxx
index fc62542e13..9b9d589055 100644
--- a/examples/libf3d/cpp/multi-geom/main.cxx
+++ b/examples/libf3d/cpp/multi-geom/main.cxx
@@ -1,7 +1,6 @@
 #include <f3d/engine.h>
 #include <f3d/image.h>
 #include <f3d/log.h>
-#include <f3d/options.h>
 #include <f3d/window.h>
 
 #include <filesystem>
diff --git a/examples/libf3d/cpp/render-image/CMakeLists.txt b/examples/libf3d/cpp/render-image/CMakeLists.txt
index 1c2645fc3e..c6dfd39c25 100644
--- a/examples/libf3d/cpp/render-image/CMakeLists.txt
+++ b/examples/libf3d/cpp/render-image/CMakeLists.txt
@@ -6,11 +6,11 @@ find_package(f3d REQUIRED COMPONENTS library)
 
 add_executable(render-image main.cxx)
 target_link_libraries(render-image f3d::libf3d)
-set_target_properties(render-image PROPERTIES CXX_STANDARD 11)
+set_target_properties(render-image PROPERTIES CXX_STANDARD 17)
 
 add_executable(check-image check.cxx)
 target_link_libraries(check-image f3d::libf3d)
-set_target_properties(check-image PROPERTIES CXX_STANDARD 11)
+set_target_properties(check-image PROPERTIES CXX_STANDARD 17)
 
 # Simple testing
 if(BUILD_TESTING)
diff --git a/examples/libf3d/cpp/render-interact/CMakeLists.txt b/examples/libf3d/cpp/render-interact/CMakeLists.txt
index e62d7a78b7..a3b4d188f5 100644
--- a/examples/libf3d/cpp/render-interact/CMakeLists.txt
+++ b/examples/libf3d/cpp/render-interact/CMakeLists.txt
@@ -6,7 +6,7 @@ find_package(f3d REQUIRED COMPONENTS library)
 
 add_executable(render-interact main.cxx)
 target_link_libraries(render-interact f3d::libf3d)
-set_target_properties(render-interact PROPERTIES CXX_STANDARD 11)
+set_target_properties(render-interact PROPERTIES CXX_STANDARD 17)
 
 # Simple testing
 if(BUILD_TESTING)
diff --git a/examples/libf3d/cpp/render-interact/main.cxx b/examples/libf3d/cpp/render-interact/main.cxx
index 28accf4bc1..3e20259df1 100644
--- a/examples/libf3d/cpp/render-interact/main.cxx
+++ b/examples/libf3d/cpp/render-interact/main.cxx
@@ -1,7 +1,6 @@
 #include <f3d/engine.h>
 #include <f3d/image.h>
 #include <f3d/log.h>
-#include <f3d/options.h>
 #include <f3d/window.h>
 
 int main(int argc, char** argv)
diff --git a/examples/libf3d/cpp/use-options-string/CMakeLists.txt b/examples/libf3d/cpp/use-options-string/CMakeLists.txt
new file mode 100644
index 0000000000..6245f166be
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-string/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(use-options-string)
+
+find_package(f3d REQUIRED COMPONENTS library)
+
+add_executable(use-options-string main.cxx)
+target_compile_definitions(use-options-string PRIVATE F3D_DISABLE_CXX17_API)
+target_link_libraries(use-options-string f3d::libf3d)
+set_target_properties(use-options-string PROPERTIES CXX_STANDARD 11)
+
+# Simple testing
+if(BUILD_TESTING)
+  enable_testing()
+  add_test(NAME test_use-options-string COMMAND "$<TARGET_FILE:use-options-string>" "${CMAKE_CURRENT_SOURCE_DIR}/data/cow.vtp")
+  set_tests_properties(test_use-options-string PROPERTIES
+    PASS_REGULAR_EXPRESSION "Number of points: 2903")
+endif()
diff --git a/examples/libf3d/cpp/use-options-string/data/cow.vtp b/examples/libf3d/cpp/use-options-string/data/cow.vtp
new file mode 100644
index 0000000000..9c90a60654
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-string/data/cow.vtp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5aa4901d186902f90e17bf3b5917541cb6cb8cf223bfeea736631df4c047652
+size 60449
diff --git a/examples/libf3d/cpp/use-options-string/main.cxx b/examples/libf3d/cpp/use-options-string/main.cxx
new file mode 100644
index 0000000000..56a0ff242c
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-string/main.cxx
@@ -0,0 +1,45 @@
+#include <f3d/engine.h>
+#include <f3d/image.h>
+#include <f3d/log.h>
+#include <f3d/options.h>
+#include <f3d/window.h>
+
+int main(int argc, char** argv)
+{
+  // Check inputs
+  if (argc != 2)
+  {
+    return EXIT_FAILURE;
+  }
+
+  // Load static plugins
+  f3d::engine::autoloadPlugins();
+
+  // Enable debug logging
+  f3d::log::setVerboseLevel(f3d::log::VerboseLevel::DEBUG);
+
+  // Create a native window engine
+  f3d::engine eng(f3d::window::Type::NATIVE);
+
+  // Modify options use struct API
+  f3d::options& opt = eng.getOptions();
+  opt.setAsString("render.show_edges", "true")
+    .setAsString("render.line_width", "10")
+    .setAsString("render.grid.enable", "1");
+
+  // Load a model
+  const f3d::loader& load = eng.getLoader().loadGeometry(std::string(argv[1]));
+
+  // Render
+  f3d::window& win = eng.getWindow();
+  win.render();
+
+  // Create a timer to stop interaction after one second
+  f3d::interactor& inter = eng.getInteractor();
+  inter.createTimerCallBack(1000, [&inter]() { inter.stop(); });
+
+  // Start interaction
+  inter.start();
+
+  return EXIT_SUCCESS;
+}
diff --git a/examples/libf3d/cpp/use-options-struct/CMakeLists.txt b/examples/libf3d/cpp/use-options-struct/CMakeLists.txt
new file mode 100644
index 0000000000..f5a3ae63d1
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-struct/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(use-options-struct)
+
+find_package(f3d REQUIRED COMPONENTS library)
+
+add_executable(use-options-struct main.cxx)
+target_compile_definitions(use-options-struct PRIVATE F3D_DISABLE_CXX17_API)
+target_link_libraries(use-options-struct f3d::libf3d)
+set_target_properties(use-options-struct PROPERTIES CXX_STANDARD 11)
+
+# Simple testing
+if(BUILD_TESTING)
+  enable_testing()
+  add_test(NAME test_use-options-struct COMMAND "$<TARGET_FILE:use-options-struct>" "${CMAKE_CURRENT_SOURCE_DIR}/data/cow.vtp")
+  set_tests_properties(test_use-options-struct PROPERTIES
+    PASS_REGULAR_EXPRESSION "Number of points: 2903")
+endif()
diff --git a/examples/libf3d/cpp/use-options-struct/data/cow.vtp b/examples/libf3d/cpp/use-options-struct/data/cow.vtp
new file mode 100644
index 0000000000..9c90a60654
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-struct/data/cow.vtp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5aa4901d186902f90e17bf3b5917541cb6cb8cf223bfeea736631df4c047652
+size 60449
diff --git a/examples/libf3d/cpp/use-options-struct/main.cxx b/examples/libf3d/cpp/use-options-struct/main.cxx
new file mode 100644
index 0000000000..f78ac1cf31
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-struct/main.cxx
@@ -0,0 +1,45 @@
+#include <f3d/engine.h>
+#include <f3d/image.h>
+#include <f3d/log.h>
+#include <f3d/options.h>
+#include <f3d/window.h>
+
+int main(int argc, char** argv)
+{
+  // Check inputs
+  if (argc != 2)
+  {
+    return EXIT_FAILURE;
+  }
+
+  // Load static plugins
+  f3d::engine::autoloadPlugins();
+
+  // Enable debug logging
+  f3d::log::setVerboseLevel(f3d::log::VerboseLevel::DEBUG);
+
+  // Create a native window engine
+  f3d::engine eng(f3d::window::Type::NATIVE);
+
+  // Modify options use struct API
+  f3d::options& opt = eng.getOptions();
+  opt.render.show_edges = true;
+  opt.render.line_width = 10;
+  opt.render.grid.enable = true;
+
+  // Load a model
+  const f3d::loader& load = eng.getLoader().loadGeometry(std::string(argv[1]));
+
+  // Render
+  f3d::window& win = eng.getWindow();
+  win.render();
+
+  // Create a timer to stop interaction after one second
+  f3d::interactor& inter = eng.getInteractor();
+  inter.createTimerCallBack(1000, [&inter]() { inter.stop(); });
+
+  // Start interaction
+  inter.start();
+
+  return EXIT_SUCCESS;
+}
diff --git a/examples/libf3d/cpp/use-options-variant/CMakeLists.txt b/examples/libf3d/cpp/use-options-variant/CMakeLists.txt
new file mode 100644
index 0000000000..3a02711ef4
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-variant/CMakeLists.txt
@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(use-options-variant)
+
+find_package(f3d REQUIRED COMPONENTS library)
+
+add_executable(use-options-variant main.cxx)
+target_link_libraries(use-options-variant f3d::libf3d)
+set_target_properties(use-options-variant PROPERTIES CXX_STANDARD 17)
+
+# Simple testing
+if(BUILD_TESTING)
+  enable_testing()
+  add_test(NAME test_use-options-variant COMMAND "$<TARGET_FILE:use-options-variant>" "${CMAKE_CURRENT_SOURCE_DIR}/data/cow.vtp")
+  set_tests_properties(test_use-options-variant PROPERTIES
+    PASS_REGULAR_EXPRESSION "Number of points: 2903")
+endif()
diff --git a/examples/libf3d/cpp/use-options-variant/data/cow.vtp b/examples/libf3d/cpp/use-options-variant/data/cow.vtp
new file mode 100644
index 0000000000..9c90a60654
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-variant/data/cow.vtp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5aa4901d186902f90e17bf3b5917541cb6cb8cf223bfeea736631df4c047652
+size 60449
diff --git a/examples/libf3d/cpp/use-options-variant/main.cxx b/examples/libf3d/cpp/use-options-variant/main.cxx
new file mode 100644
index 0000000000..6118d256fa
--- /dev/null
+++ b/examples/libf3d/cpp/use-options-variant/main.cxx
@@ -0,0 +1,43 @@
+#include <f3d/engine.h>
+#include <f3d/image.h>
+#include <f3d/log.h>
+#include <f3d/options.h>
+#include <f3d/window.h>
+
+int main(int argc, char** argv)
+{
+  // Check inputs
+  if (argc != 2)
+  {
+    return EXIT_FAILURE;
+  }
+
+  // Load static plugins
+  f3d::engine::autoloadPlugins();
+
+  // Enable debug logging
+  f3d::log::setVerboseLevel(f3d::log::VerboseLevel::DEBUG);
+
+  // Create a native window engine
+  f3d::engine eng(f3d::window::Type::NATIVE);
+
+  // Modify options
+  f3d::options& opt = eng.getOptions();
+  opt.set("render.show_edges", true).set("render.line_width", 10.0).set("render.grid.enable", true);
+
+  // Load a model
+  const f3d::loader& load = eng.getLoader().loadGeometry(std::string(argv[1]));
+
+  // Render
+  f3d::window& win = eng.getWindow();
+  win.render();
+
+  // Create a timer to stop interaction after one second
+  f3d::interactor& inter = eng.getInteractor();
+  inter.createTimerCallBack(1000, [&inter]() { inter.stop(); });
+
+  // Start interaction
+  inter.start();
+
+  return EXIT_SUCCESS;
+}
diff --git a/examples/libf3d/python/render-terminal/render_terminal.py b/examples/libf3d/python/render-terminal/render_terminal.py
index 30723fb209..31f91c655c 100644
--- a/examples/libf3d/python/render-terminal/render_terminal.py
+++ b/examples/libf3d/python/render-terminal/render_terminal.py
@@ -12,10 +12,10 @@
 def main():
     model_path = TEST_DATA_DIR / "suzanne.obj"
     options = {
-        "scene.up-direction": "+Y",
-        "render.effect.tone-mapping": True,
-        "render.effect.ambient-occlusion": True,
-        "render.effect.translucency-support": True,
+        "scene.up_direction": "+Y",
+        "render.effect.tone_mapping": True,
+        "render.effect.ambient_occlusion": True,
+        "render.effect.translucency_support": True,
         "render.effect.anti-aliasing": True,
     }
     anim_fps = 30
diff --git a/java/CMakeLists.txt b/java/CMakeLists.txt
index 2edeb39db5..db4d47805d 100644
--- a/java/CMakeLists.txt
+++ b/java/CMakeLists.txt
@@ -35,7 +35,7 @@ endif()
 
 set_target_properties(javaf3d PROPERTIES
   CXX_VISIBILITY_PRESET hidden
-  CXX_STANDARD 11
+  CXX_STANDARD 17
   OUTPUT_NAME "f3d-java"
   )
 
diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt
index 5f46f3d01a..e18be8807e 100644
--- a/library/CMakeLists.txt
+++ b/library/CMakeLists.txt
@@ -33,6 +33,15 @@ configure_file(
   "${CMAKE_CURRENT_BINARY_DIR}/src/config.cxx"
   @ONLY)
 
+include(f3dOptions)
+f3d_generate_options(
+  INPUT_JSON "${CMAKE_CURRENT_SOURCE_DIR}/options.json"
+  INPUT_PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/public/options.h.in"
+  INPUT_PRIVATE_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/private/options_tools.h.in"
+  DESTINATION "${CMAKE_CURRENT_BINARY_DIR}"
+  OUTPUT_NAME "options"
+  )
+
 # Define libf3d target
 set(F3D_SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/src/animationManager.cxx
@@ -55,17 +64,17 @@ set(F3D_SOURCE_FILES
 
 # List of headers that will be installed
 set(F3D_PUBLIC_HEADERS
-  ${CMAKE_CURRENT_SOURCE_DIR}/plugin/reader.h
+  ${CMAKE_CURRENT_BINARY_DIR}/public/export.h
+  ${CMAKE_CURRENT_BINARY_DIR}/public/options.h
   ${CMAKE_CURRENT_SOURCE_DIR}/plugin/plugin.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/plugin/reader.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/camera.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/engine.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/exception.h
-  ${CMAKE_CURRENT_BINARY_DIR}/public/export.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/image.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/interactor.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/loader.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/log.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/public/options.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/utils.h
   ${CMAKE_CURRENT_SOURCE_DIR}/public/window.h
@@ -152,8 +161,7 @@ list(JOIN F3D_STATIC_PLUGIN_MAP "\n  " F3D_STATIC_PLUGIN_MAP)
 
 configure_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/src/factory.cxx.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/src/factory.cxx"
-  @ONLY)
+  "${CMAKE_CURRENT_BINARY_DIR}/src/factory.cxx")
 
 # libf3d links with the static plugins.
 list(TRANSFORM F3D_STATIC_PLUGIN_TARGETS PREPEND "f3d-plugin-")
diff --git a/library/options.json b/library/options.json
new file mode 100644
index 0000000000..431cf60972
--- /dev/null
+++ b/library/options.json
@@ -0,0 +1,308 @@
+{
+  "scene": {
+    "up_direction": {
+      "type": "string",
+      "default_value": "+Y"
+    },
+    "animation": {
+      "autoplay": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "index": {
+        "type": "int",
+        "default_value": "0"
+      },
+      "speed_factor": {
+        "type": "ratio",
+        "default_value": "1.0"
+      },
+      "time": {
+        "type": "double",
+        "default_value": "0.0"
+      },
+      "frame_rate": {
+        "type": "double",
+        "default_value": "60.0"
+      }
+    },
+    "camera": {
+      "index": {
+        "type": "int",
+        "default_value": "-1"
+      },
+      "orthographic": {
+        "type": "bool",
+        "default_value": "false"
+      }
+    }
+  },
+  "render": {
+    "show_edges": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "line_width": {
+      "type": "double",
+      "default_value": "1.0"
+    },
+    "point_size": {
+      "type": "double",
+      "default_value": "10.0"
+    },
+    "backface_type": {
+      "type": "string",
+      "default_value": "default"
+    },
+    "grid": {
+      "enable": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "absolute": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "unit": {
+        "type": "double",
+        "default_value": "0.0"
+      },
+      "subdivisions": {
+        "type": "int",
+        "default_value": "10"
+      },
+      "color": {
+        "type": "double_vector",
+        "default_value": "0.0, 0.0, 0.0"
+      }
+    },
+    "raytracing": {
+      "enable": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "denoise": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "samples": {
+        "type": "int",
+        "default_value": "5"
+      }
+    },
+    "effect": {
+      "translucency_support": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "anti_aliasing": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "ambient_occlusion": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "tone_mapping": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "final_shader": {
+        "type": "string",
+        "default_value": ""
+      }
+    },
+    "hdri": {
+      "file": {
+        "type": "string",
+        "default_value": ""
+      },
+      "ambient": {
+        "type": "bool",
+        "default_value": "false"
+      }
+    },
+    "background": {
+      "color": {
+        "type": "double_vector",
+        "default_value": "0.2, 0.2, 0.2"
+      },
+      "skybox": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "blur": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "blur_coc": {
+        "type": "double",
+        "default_value": "20.0"
+      }
+    },
+    "light": {
+      "intensity": {
+        "type": "double",
+        "default_value": "1.0"
+      }
+    }
+  },
+  "ui": {
+    "scalar_bar": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "filename": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "filename_info": {
+      "type": "string",
+      "default_value": ""
+    },
+    "fps": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "cheatsheet": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "dropzone": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "dropzone_info": {
+      "type": "string",
+      "default_value": ""
+    },
+    "metadata": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "font_file": {
+      "type": "string",
+      "default_value": ""
+    },
+    "loader_progress": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "animation_progress": {
+      "type": "bool",
+      "default_value": "false"
+    }
+  },
+  "model": {
+    "matcap": {
+      "texture": {
+        "type": "string",
+        "default_value": ""
+      }
+    },
+    "color": {
+      "opacity": {
+        "type": "double",
+        "default_value": "1.0"
+      },
+      "rgb": {
+        "type": "double_vector",
+        "default_value": "1.0, 1.0, 1.0"
+      },
+      "texture": {
+        "type": "string",
+        "default_value": ""
+      }
+    },
+    "emissive": {
+      "factor": {
+        "type": "double_vector",
+        "default_value": "1.0, 1.0, 1.0"
+      },
+      "texture": {
+        "type": "string",
+        "default_value": ""
+      }
+    },
+    "normal": {
+      "scale": {
+        "type": "double",
+        "default_value": "1.0"
+      },
+      "texture": {
+        "type": "string",
+        "default_value": ""
+      }
+    },
+    "material": {
+      "metallic": {
+        "type": "double",
+        "default_value": "0.0"
+      },
+      "roughness": {
+        "type": "double",
+        "default_value": "0.3"
+      },
+      "texture": {
+        "type": "string",
+        "default_value": ""
+      }
+    },
+    "scivis": {
+      "cells": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "array_name": {
+        "type": "string",
+        "default_value": "f3d_reserved"
+      },
+      "component": {
+        "type": "int",
+        "default_value": "-1"
+      },
+      "colormap": {
+        "type": "double_vector",
+        "default_value": "0.0, 0.0, 0.0, 0.0, 0.4, 0.9, 0.0, 0.0, 0.8, 0.9, 0.9, 0.0, 1.0, 1.0, 1.0, 1.0"
+      },
+      "range": {
+        "type": "double_vector",
+        "default_value": "0.0"
+      }
+    },
+    "point_sprites": {
+      "enable": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "type": {
+        "type": "string",
+        "default_value": "sphere"
+      }
+    },
+    "volume": {
+      "enable": {
+        "type": "bool",
+        "default_value": "false"
+      },
+      "inverse": {
+        "type": "bool",
+        "default_value": "false"
+      }
+    }
+  },
+  "interactor": {
+    "axis": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "trackball": {
+      "type": "bool",
+      "default_value": "false"
+    },
+    "invert_zoom": {
+      "type": "bool",
+      "default_value": "false"
+    }
+  }
+}
diff --git a/library/private/options_tools.h.in b/library/private/options_tools.h.in
new file mode 100644
index 0000000000..aa10b0c529
--- /dev/null
+++ b/library/private/options_tools.h.in
@@ -0,0 +1,275 @@
+#ifndef f3d_options_tools_h
+#define f3d_options_tools_h
+
+#include "options.h"
+#include "types.h"
+
+#include <sstream>
+
+namespace f3d
+{
+namespace options_tools
+{
+// TODO expose parse methods in options API ?
+
+//----------------------------------------------------------------------------
+/**
+ * Not implemented generic templated parse method
+ */
+template<typename T>
+T parse(const std::string& str) = delete;
+
+//----------------------------------------------------------------------------
+/**
+ * Parse provided string into a bool
+ * Numerical and boolaplha are both supported
+ */
+template<>
+bool parse(const std::string& str)
+{
+  // TODO implement proper parsing, eg "True", "TRUE", "ON", "On", ...
+  bool b1;
+  bool b2;
+  std::istringstream(str) >> b1;
+  std::istringstream(str) >> std::boolalpha >> b2;
+  return b1 || b2;
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Parse provided string into an int
+ * Rely on std::stoi for parsing
+ * Can throw options::parsing_exception in case of failure to parse
+ */
+template<>
+int parse(const std::string& str)
+{
+  // TODO implement more parsing possibilities ?
+  try
+  {
+    return std::stoi(str);
+  }
+  catch (std::invalid_argument const&)
+  {
+    throw options::parsing_exception("Cannot parse " + str + " into an int");
+  }
+  catch (std::out_of_range const&)
+  {
+    throw options::parsing_exception(
+      "Cannot parse " + str + " into an int as it would go out of range");
+  }
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Parse provided string into a double
+ * Rely on std::stod for parsing
+ * Can throw options::parsing_exception in case of failure to parse
+ */
+template<>
+double parse(const std::string& str)
+{
+  // TODO implement more parsing possibilities ?
+  try
+  {
+    return std::stod(str);
+  }
+  catch (std::invalid_argument const&)
+  {
+    throw options::parsing_exception("Cannot parse " + str + " into a double");
+  }
+  catch (std::out_of_range const&)
+  {
+    throw options::parsing_exception(
+      "Cannot parse " + str + " into a double as it would go out of range");
+  }
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Parse provided string into a ratio_t
+ * Rely on <double> version for parsing
+ * Can throw options::parsing_exception in case of failure to parse
+ */
+template<>
+ratio_t parse(const std::string& str)
+{
+  // TODO implement proper ratio parsing
+  return options_tools::parse<double>(str);
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Return provided string
+ */
+template<>
+std::string parse(const std::string& str)
+{
+  return str;
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Parse provided string into a double vector
+ * Split the string using ',', then rely on double version for parsing each token
+ * Can throw options::parsing_exception in case of failure to parse
+ */
+template<>
+std::vector<double> parse(const std::string& str)
+{
+  // TODO implement more parsing possibilities, eg different types of tokens
+  std::vector<double> vec;
+  std::istringstream split(str);
+  for (std::string each; std::getline(split, each, ',');)
+  {
+    vec.emplace_back(options_tools::parse<double>(each));
+  }
+  return vec;
+}
+
+// TODO Improve string generation
+//----------------------------------------------------------------------------
+/**
+ * Generic templated string generation from provided value
+ * rely on std::to_string
+ */
+template<typename T>
+std::string format(const T& var)
+{
+  return std::to_string(var);
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Format provided var into a string from provided boolean
+ * using boolalpha formatting, eg: "true" or "false"
+ */
+template<>
+std::string format(const bool& var)
+{
+  std::stringstream stream;
+  stream << std::boolalpha << var;
+  return stream.str();
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Format provided var into a string from provided double
+ * using ostringstream with std::noshowpoint
+ */
+template<>
+std::string format(const double& var)
+{
+  std::ostringstream stream;
+  stream << std::noshowpoint << var;
+  return stream.str();
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Format provided var into a string from provided ratio_t
+ * rely on format(double&)
+ */
+template<>
+std::string format(const ratio_t& var)
+{
+  // TODO generate a proper ratio string
+  double val = var;
+  return options_tools::format(val);
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Generate (returns) a string from provided string
+ */
+template<>
+std::string format(const std::string& var)
+{
+  return var;
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Format provided var into a string from provided double vector
+ * rely on format(double&) and add `, ` between the double values
+ */
+template<>
+std::string format(const std::vector<double>& var)
+{
+  std::ostringstream stream;
+  unsigned int i = 0;
+  for (auto& elem : var)
+  {
+    stream << ((i > 0) ? ", " : "") << options_tools::format(elem);
+    i++;
+  }
+  return stream.str();
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Generated method, see `options::set`
+ */
+void set(options& opt, const std::string& name, const option_variant_t& value)
+{
+  try
+  {
+    // clang-format off
+    ${_options_setter};
+    // clang-format on
+    else throw options::inexistent_exception("Option " + name + " does not exist");
+  }
+  catch (const std::bad_variant_access&)
+  {
+    throw options::incompatible_exception("Trying to set " + name + " with incompatible type");
+  }
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Generated method, see `options::get`
+ */
+option_variant_t get(const options& opt, const std::string& name)
+{
+  // clang-format off
+  ${_options_getter};
+  // clang-format on
+  else throw options::inexistent_exception("Option " + name + " does not exist");
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Generated method, see `options::getNames`
+ */
+std::vector<std::string> getNames()
+{
+  // clang-format off
+  return { ${_options_lister} };
+  // clang-format on
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Generated method, see `options::setAsString`
+ */
+void setAsString(options& opt, const std::string& name, const std::string& str)
+{
+  // clang-format off
+  ${_options_string_setter};
+  // clang-format on
+  else throw options::inexistent_exception("Option " + name + " does not exist");
+}
+//----------------------------------------------------------------------------
+/**
+ * Generated method, see `options::getAsString`
+ */
+std::string getAsString(const options& opt, const std::string& name)
+{
+  // clang-format off
+  ${_options_string_getter};
+  // clang-format on
+  else throw options::inexistent_exception("Option " + name + " does not exist");
+}
+} // option_tools
+} // f3d
+#endif // f3d_options_tools_h
diff --git a/library/public/options.h b/library/public/options.h
deleted file mode 100644
index c5411bc4ed..0000000000
--- a/library/public/options.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#ifndef f3d_options_h
-#define f3d_options_h
-
-#include "exception.h"
-#include "export.h"
-
-#include <string>
-#include <vector>
-
-namespace f3d
-{
-/**
- * @class   options
- * @brief   Class used to control the different options
- *
- * A class to control the different options of f3d.
- * See the README_libf3d.md for the full listing of options
- */
-class F3D_EXPORT options
-{
-public:
-  ///@{ @name Constructors
-  /**
-   * Default/Copy/move constructors/operators.
-   */
-  options();
-  ~options();
-  options(const options& opt);
-  options& operator=(const options& opt) noexcept;
-  options(options&& other) noexcept;
-  options& operator=(options&& other) noexcept;
-  ///@}
-
-  ///@{ @name Setters
-  /**
-   * Setters for all supported types.
-   */
-  options& set(const std::string& name, bool value);
-  options& set(const std::string& name, int value);
-  options& set(const std::string& name, double value);
-  options& set(const std::string& name, const std::string& value);
-  options& set(const std::string& name, const char* value);
-  options& set(const std::string& name, const std::vector<int>& values);
-  options& set(const std::string& name, const std::vector<double>& values);
-  options& set(const std::string& name, std::initializer_list<int> values);
-  options& set(const std::string& name, std::initializer_list<double> values);
-  ///@}
-
-  ///@{ @name Reference Getters
-  /**
-   * Copy the option value into the provided reference, for all supported types.
-   */
-  void get(const std::string& name, bool& value) const;
-  void get(const std::string& name, int& value) const;
-  void get(const std::string& name, double& value) const;
-  void get(const std::string& name, std::string& value) const;
-  void get(const std::string& name, std::vector<int>& value) const;
-  void get(const std::string& name, std::vector<double>& value) const;
-  ///@}
-
-  ///@{ @name Explicit Copy Getters
-  /**
-   * Explicit getters for all supported types.
-   */
-  bool getAsBool(const std::string& name) const;
-  int getAsInt(const std::string& name) const;
-  double getAsDouble(const std::string& name) const;
-  std::string getAsString(const std::string& name) const;
-  std::vector<int> getAsIntVector(const std::string& name) const;
-  std::vector<double> getAsDoubleVector(const std::string& name) const;
-  ///@}
-
-  ///@{ @name Explicit Reference Getters
-  /**
-   * Explicit getters to actual reference to the options variable, for all supported types.
-   * Modifying the returned reference will modify the option.
-   * Throw an options::incompatible_exception if the type is not compatible with the option.
-   * Throw an options::inexistent_exception if option does not exist.
-   */
-  bool& getAsBoolRef(const std::string& name);
-  int& getAsIntRef(const std::string& name);
-  double& getAsDoubleRef(const std::string& name);
-  std::string& getAsStringRef(const std::string& name);
-  std::vector<int>& getAsIntVectorRef(const std::string& name);
-  std::vector<double>& getAsDoubleVectorRef(const std::string& name);
-  ///@}
-
-  /**
-   * A boolean option specific method to toggle it.
-   */
-  options& toggle(const std::string& name);
-
-  /**
-   * Compare an option between this and a provided other.
-   * Return true is they are the same value, false otherwise.
-   * Throw an options::inexistent_exception if option does not exist.
-   */
-  bool isSame(const options& other, const std::string& name) const;
-
-  /**
-   * Copy the value of an option from this to the provided other.
-   * Throw an options::inexistent_exception if option does not exist.
-   */
-  options& copy(const options& other, const std::string& name);
-
-  /**
-   * Get all available option names.
-   */
-  std::vector<std::string> getNames();
-
-  /**
-   * Get the closest option name and its Levenshtein distance.
-   */
-  std::pair<std::string, unsigned int> getClosestOption(const std::string& option) const;
-
-  /**
-   * An exception that can be thrown by the options
-   * when a provided option type is incompatible with
-   * its internal type.
-   */
-  struct incompatible_exception : public exception
-  {
-    explicit incompatible_exception(const std::string& what = "");
-  };
-
-  /**
-   * An exception that can be thrown by the options
-   * when a provided option does not exist.
-   */
-  struct inexistent_exception : public exception
-  {
-    explicit inexistent_exception(const std::string& what = "");
-  };
-
-private:
-  class internals;
-  internals* Internals;
-};
-}
-
-#endif
diff --git a/library/public/options.h.in b/library/public/options.h.in
new file mode 100644
index 0000000000..8ad6ca64af
--- /dev/null
+++ b/library/public/options.h.in
@@ -0,0 +1,142 @@
+#ifndef f3d_options_h
+#define f3d_options_h
+
+#include "exception.h"
+#include "export.h"
+#include "types.h"
+
+#include <array>
+#include <string>
+#include <vector>
+
+#ifndef F3D_DISABLE_CXX17_API
+#include <variant>
+#endif
+
+namespace f3d
+{
+#ifndef F3D_DISABLE_CXX17_API
+// Declared here for simplicity
+using option_variant_t = std::variant<bool, int, double, std::string, std::vector<double>>;
+#endif
+
+/**
+ * @class   options
+ * @brief   Class used to control the different options
+ *
+ * A class to control the different options of f3d.
+ * See the README_libf3d.md for the full listing of options.
+ * The struct below can also be consulted.
+ */
+class F3D_EXPORT options
+{
+public:
+  ///@{ @name Constructors
+  /**
+   * Default/Copy/move constructors/operators.
+   */
+  options();
+  ~options() = default;
+  options(const options& opt) = default;
+  options& operator=(const options& opt) noexcept = default;
+  options(options&& other) noexcept = default;
+  options& operator=(options&& other) noexcept = default;
+  ///@}
+
+#ifndef F3D_DISABLE_CXX17_API
+  /**
+   * Set an option as a variant based on its name
+   * Please note that, on Windows, using an explicit std::string may be required:
+   * https://stackoverflow.com/questions/60681710/prefer-stdstring-in-stdvariantbool-stdstring-for-const-char
+   * Throw an options::inexistent_exception if option does not exist.
+   * Throw an options::incompatible_exception if value is not compatible with option.
+   */
+  options& set(const std::string& name, const option_variant_t& value);
+
+  /**
+   * Get an option as a variant based on its name
+   * Throw an options::inexistent_exception if option does not exist.
+   */
+  option_variant_t get(const std::string& name) const;
+#endif
+
+  ///@{
+  /**
+   * Set/Get an option as a string based on its name
+   * The setter use specific parsing, see the related doc
+   * TODO add parsing documentation
+   * Throw an options::inexistent_exception if option does not exist.
+   */
+  options& setAsString(const std::string& name, const std::string& str);
+  std::string getAsString(const std::string& name) const;
+  ///@}
+
+  /**
+   * A boolean option specific method to toggle it.
+   * Throw an options::inexistent_exception if option does not exist.
+   * Throw an options::incompatible_exception if option is not boolean.
+   */
+  options& toggle(const std::string& name);
+
+  /**
+   * Compare an option between this and a provided other.
+   * Return true is they are the same value, false otherwise.
+   * Throw an options::inexistent_exception if option does not exist.
+   */
+  bool isSame(const options& other, const std::string& name) const;
+
+  /**
+   * Copy the value of an option from this to the provided other.
+   * Throw an options::inexistent_exception if option does not exist.
+   */
+  options& copy(const options& other, const std::string& name);
+
+  /**
+   * Get all available option names.
+   * XXX: Should we add a getNamesStruct with the same structure as the struct below ?
+   */
+  std::vector<std::string> getNames() const;
+
+  /**
+   * Get the closest option name and its Levenshtein distance.
+   */
+  std::pair<std::string, unsigned int> getClosestOption(const std::string& option) const;
+
+  /**
+   * An exception that can be thrown by the options
+   * when parsing of a string into an option value fails
+   */
+  struct parsing_exception : public exception
+  {
+    explicit parsing_exception(const std::string& what = "");
+  };
+
+  /**
+   * An exception that can be thrown by the options
+   * when an operation on a specific option is incompatible with
+   * its internal type.
+   */
+  struct incompatible_exception : public exception
+  {
+    explicit incompatible_exception(const std::string& what = "");
+  };
+
+  /**
+   * An exception that can be thrown by the options
+   * when a provided option does not exist.
+   */
+  struct inexistent_exception : public exception
+  {
+    explicit inexistent_exception(const std::string& what = "");
+  };
+
+  /**
+   * The complete generated options struct
+   */
+  // clang-format off
+  ${_options_struct}
+  // clang-format on
+};
+}
+
+#endif
diff --git a/library/public/types.h b/library/public/types.h
index 200a424118..4c7a42c8ca 100644
--- a/library/public/types.h
+++ b/library/public/types.h
@@ -38,6 +38,26 @@ struct F3D_EXPORT vector3_t : std::array<double, 3>
  */
 using angle_deg_t = double;
 
+/**
+ * Describe a ratio.
+ */
+class ratio_t
+{
+public:
+  ratio_t() = default;
+  ratio_t(double val)
+    : Value(val)
+  {
+  }
+  operator double() const
+  {
+    return this->Value;
+  }
+
+private:
+  double Value;
+};
+
 /**
  * Describe a 3D surfacic mesh.
  * A valid mesh fulfills these requirements:
diff --git a/library/src/animationManager.cxx b/library/src/animationManager.cxx
index c7d1198c76..abf696530f 100644
--- a/library/src/animationManager.cxx
+++ b/library/src/animationManager.cxx
@@ -50,8 +50,7 @@ bool animationManager::Initialize(
     progressRep->SetShowBorderToOff();
     progressRep->DrawFrameOff();
     progressRep->SetPadding(0.0, 0.0);
-    progressRep->SetVisibility(options->getAsBool("ui.animation-progress"));
-
+    progressRep->SetVisibility(options->ui.animation_progress);
     this->ProgressWidget->On();
   }
   else
@@ -59,8 +58,8 @@ bool animationManager::Initialize(
     this->ProgressWidget = nullptr;
   }
 
-  int animationIndex = options->getAsInt("scene.animation.index");
-  double animationTime = options->getAsDouble("scene.animation.time");
+  int animationIndex = options->scene.animation.index;
+  double animationTime = options->scene.animation.time;
 
   if (this->AvailAnimations <= 0)
   {
@@ -86,7 +85,7 @@ bool animationManager::Initialize(
   }
   log::debug("");
 
-  this->AnimationIndex = options->getAsInt("scene.animation.index");
+  this->AnimationIndex = options->scene.animation.index;
   if (this->AnimationIndex > 0 && this->AnimationIndex >= this->AvailAnimations)
   {
     log::warn(
@@ -110,7 +109,7 @@ bool animationManager::Initialize(
       // Discard timesteps, F3D only cares about real elapsed time using time range
       // Specifying the frame rate in the next call is not needed after VTK 9.2.20230603 :
       // VTK_VERSION_CHECK(9, 2, 20230603)
-      double frameRate = this->Options->getAsDouble("scene.animation.frame-rate");
+      double frameRate = options->scene.animation.frame_rate;
       this->Importer->GetTemporalInformation(
         animIndex, frameRate, nbTimeSteps, timeRange, timeSteps);
 
@@ -132,7 +131,7 @@ bool animationManager::Initialize(
     log::debug("Animation(s) time range is: [", this->TimeRange[0], ", ", this->TimeRange[1], "].");
   }
 
-  bool autoplay = options->getAsBool("scene.animation.autoplay");
+  bool autoplay = options->scene.animation.autoplay;
   if (autoplay)
   {
     this->StartAnimation();
@@ -181,12 +180,12 @@ void animationManager::ToggleAnimation()
       // Always reset previous tick when starting the animation
       this->PreviousTick = std::chrono::steady_clock::now();
 
-      double frameRate = this->Options->getAsDouble("scene.animation.frame-rate");
+      double frameRate = this->Options->scene.animation.frame_rate;
       this->CallBackId =
         this->Interactor->createTimerCallBack(1000.0 / frameRate, [this]() { this->Tick(); });
     }
 
-    if (this->Playing && this->Options->getAsInt("scene.camera.index") >= 0)
+    if (this->Playing && this->Options->scene.camera.index >= 0)
     {
       this->Interactor->disableCameraMovement();
     }
@@ -210,7 +209,7 @@ void animationManager::Tick()
 
   // Convert to a usable time in seconds
   double elapsedTime = static_cast<double>(timeInMS) / 1000.0;
-  double animationSpeedFactor = this->Options->getAsDouble("scene.animation.speed-factor");
+  double animationSpeedFactor = this->Options->scene.animation.speed_factor;
 
   // elapsedTime can be negative
   elapsedTime *= animationSpeedFactor;
diff --git a/library/src/config.cxx.in b/library/src/config.cxx.in
index 795a5c579e..1dc7f1404e 100644
--- a/library/src/config.cxx.in
+++ b/library/src/config.cxx.in
@@ -4,7 +4,7 @@
 
 namespace f3d::detail
 {
-const std::string LibVersion = "@F3D_VERSION@"; // Version is synchronized with F3D
+const std::string LibVersion = "@F3D_VERSION@";          // Version is synchronized with F3D
 const std::string LibVersionFull = "@F3D_VERSION_FULL@"; // Version is synchronized with F3D
 const std::string LibBuildSystem = "@CMAKE_SYSTEM_NAME@ @F3D_SYSTEM_PROCESSOR@";
 const std::string LibBuildDate = "@F3D_BUILD_DATE@";
diff --git a/library/src/factory.cxx.in b/library/src/factory.cxx.in
index 1e1c09ac7f..97a58bffee 100644
--- a/library/src/factory.cxx.in
+++ b/library/src/factory.cxx.in
@@ -1,8 +1,9 @@
 #include "factory.h"
 
 #include "log.h"
-
-@F3D_STATIC_PLUGIN_EXTERN@
+// clang-format off
+${F3D_STATIC_PLUGIN_EXTERN}
+// clang-format on
 
 namespace f3d
 {
@@ -16,7 +17,9 @@ factory* factory::instance()
 //----------------------------------------------------------------------------
 factory::factory()
 {
-  @F3D_STATIC_PLUGIN_MAP@
+  // clang-format off
+  ${F3D_STATIC_PLUGIN_MAP}
+  // clang-format on
 }
 
 //----------------------------------------------------------------------------
@@ -58,11 +61,11 @@ reader* factory::getReader(const std::string& fileName)
 }
 
 //----------------------------------------------------------------------------
-void factory::load(plugin * r)
+void factory::load(plugin* plug)
 {
-  if (!this->registerOnce(r))
+  if (!this->registerOnce(plug))
   {
-    log::debug("A plugin named \"" + r->getName() + "\" is already registered.");
+    log::debug("A plugin named \"" + plug->getName() + "\" is already registered.");
   }
 }
 
@@ -76,25 +79,24 @@ void factory::autoload()
 }
 
 //----------------------------------------------------------------------------
-bool factory::registerOnce(plugin* p)
+bool factory::registerOnce(plugin* plug)
 {
-  if (std::find(this->Plugins.begin(), this->Plugins.end(), p) == this->Plugins.end())
+  if (std::find(this->Plugins.begin(), this->Plugins.end(), plug) == this->Plugins.end())
   {
-    this->Plugins.push_back(p);
+    this->Plugins.push_back(plug);
 
-    log::debug("Loading plugin \"" + p->getName() + "\"");
-    log::debug("  Version: " + p->getVersion());
-    log::debug("  Description: " + p->getDescription());
+    log::debug("Loading plugin \"" + plug->getName() + "\"");
+    log::debug("  Version: " + plug->getVersion());
+    log::debug("  Description: " + plug->getDescription());
     log::debug("  Readers:");
 
-    for (auto r : p->getReaders())
+    for (auto read : plug->getReaders())
     {
-      log::debug("    " + r->getLongDescription());
+      log::debug("    " + read->getLongDescription());
     }
 
     return true;
   }
-
   return false;
 }
 }
diff --git a/library/src/interactor_impl.cxx b/library/src/interactor_impl.cxx
index a3cc2c00d4..1dbaac70c7 100644
--- a/library/src/interactor_impl.cxx
+++ b/library/src/interactor_impl.cxx
@@ -172,7 +172,7 @@ class interactor_impl::internals
     {
       case 'W':
         self->AnimationManager->CycleAnimation();
-        self->Options.set("scene.animation.index", self->AnimationManager->GetAnimationIndex());
+        self->Options.scene.animation.index = self->AnimationManager->GetAnimationIndex();
         ren->SetAnimationnameInfo(self->AnimationManager->GetAnimationName());
         render = true;
         break;
@@ -204,90 +204,92 @@ class interactor_impl::internals
         }
         break;
       case 'B':
-        self->Options.toggle("ui.bar");
+        self->Options.ui.scalar_bar = !self->Options.ui.scalar_bar;
         render = true;
         break;
       case 'P':
-        self->Options.toggle("render.effect.translucency-support");
+        self->Options.render.effect.translucency_support =
+          !self->Options.render.effect.translucency_support;
         render = true;
         break;
       case 'Q':
-        self->Options.toggle("render.effect.ambient-occlusion");
+        self->Options.render.effect.ambient_occlusion =
+          !self->Options.render.effect.ambient_occlusion;
         render = true;
         break;
       case 'A':
-        self->Options.toggle("render.effect.anti-aliasing");
+        self->Options.render.effect.anti_aliasing = !self->Options.render.effect.anti_aliasing;
         render = true;
         break;
       case 'T':
-        self->Options.toggle("render.effect.tone-mapping");
+        self->Options.render.effect.tone_mapping = !self->Options.render.effect.tone_mapping;
         render = true;
         break;
       case 'E':
-        self->Options.toggle("render.show-edges");
+        self->Options.render.show_edges = !self->Options.render.show_edges;
         render = true;
         break;
       case 'X':
-        self->Options.toggle("interactor.axis");
+        self->Options.interactor.axis = !self->Options.interactor.axis;
         render = true;
         break;
       case 'G':
-        self->Options.toggle("render.grid.enable");
+        self->Options.render.grid.enable = !self->Options.render.grid.enable;
         render = true;
         break;
       case 'N':
-        self->Options.toggle("ui.filename");
+        self->Options.ui.filename = !self->Options.ui.filename;
         render = true;
         break;
       case 'M':
-        self->Options.toggle("ui.metadata");
+        self->Options.ui.metadata = !self->Options.ui.metadata;
         render = true;
         break;
       case 'Z':
-        self->Options.toggle("ui.fps");
+        self->Options.ui.fps = !self->Options.ui.fps;
         self->Window.render();
         self->Window.render();
         // XXX: Double render is needed here
         break;
       case 'R':
-        self->Options.toggle("render.raytracing.enable");
+        self->Options.render.raytracing.enable = !self->Options.render.raytracing.enable;
         render = true;
         break;
       case 'D':
-        self->Options.toggle("render.raytracing.denoise");
+        self->Options.render.raytracing.denoise = !self->Options.render.raytracing.denoise;
         render = true;
         break;
       case 'V':
-        self->Options.toggle("model.volume.enable");
+        self->Options.model.volume.enable = !self->Options.model.volume.enable;
         render = true;
         break;
       case 'I':
-        self->Options.toggle("model.volume.inverse");
+        self->Options.model.volume.inverse = !self->Options.model.volume.inverse;
         render = true;
         break;
       case 'O':
-        self->Options.toggle("model.point-sprites.enable");
+        self->Options.model.point_sprites.enable = !self->Options.model.point_sprites.enable;
         render = true;
         break;
       case 'U':
-        self->Options.toggle("render.background.blur");
+        self->Options.render.background.blur = !self->Options.render.background.blur;
         render = true;
         break;
       case 'K':
-        self->Options.toggle("interactor.trackball");
+        self->Options.interactor.trackball = !self->Options.interactor.trackball;
         render = true;
         break;
       case 'F':
-        self->Options.toggle("render.hdri.ambient");
+        self->Options.render.hdri.ambient = !self->Options.render.hdri.ambient;
         render = true;
         break;
       case 'J':
-        self->Options.toggle("render.background.skybox");
+        self->Options.render.background.skybox = !self->Options.render.background.skybox;
         render = true;
         break;
       case 'L':
       {
-        const double intensity = self->Options.getAsDouble("render.light.intensity");
+        const double intensity = self->Options.render.light.intensity;
         const bool down = rwi->GetShiftKey();
 
         /* `ref < x` is equivalent to:
@@ -305,12 +307,12 @@ class interactor_impl::internals
         /* new intensity in percents */
         const int newIntensityPct = std::lround(intensity * 100) + (down ? -offsetPp : +offsetPp);
 
-        self->Options.set("render.light.intensity", std::max(newIntensityPct, 0) / 100.0);
+        self->Options.render.light.intensity = std::max(newIntensityPct, 0) / 100.0;
         render = true;
         break;
       }
       case 'H':
-        self->Options.toggle("ui.cheatsheet");
+        self->Options.ui.cheatsheet = !self->Options.ui.cheatsheet;
         render = true;
         break;
       case '?':
@@ -326,7 +328,7 @@ class interactor_impl::internals
         render = true;
         break;
       case '5':
-        self->Options.toggle("scene.camera.orthographic");
+        self->Options.scene.camera.orthographic = !self->Options.scene.camera.orthographic;
         render = true;
         break;
       case '7':
@@ -358,9 +360,9 @@ class interactor_impl::internals
     if (checkColoring)
     {
       // Resynchronise renderer coloring status with options
-      self->Options.set("model.scivis.cells", renWithColor->GetColoringUseCell());
-      self->Options.set("model.scivis.array-name", renWithColor->GetColoringArrayName());
-      self->Options.set("model.scivis.component", renWithColor->GetColoringComponent());
+      self->Options.model.scivis.cells = renWithColor->GetColoringUseCell();
+      self->Options.model.scivis.array_name = renWithColor->GetColoringArrayName();
+      self->Options.model.scivis.component = renWithColor->GetColoringComponent();
     }
     if (render)
     {
diff --git a/library/src/loader_impl.cxx b/library/src/loader_impl.cxx
index ac65c40b79..8469acf8bf 100644
--- a/library/src/loader_impl.cxx
+++ b/library/src/loader_impl.cxx
@@ -124,7 +124,7 @@ class loader_impl::internals
     loader_impl::internals::ProgressDataStruct callbackData;
     callbackData.timer = timer;
     callbackData.widget = progressWidget;
-    if (this->Options.getAsBool("ui.loader-progress") && this->Interactor)
+    if (this->Options.ui.loader_progress && this->Interactor)
     {
       loader_impl::internals::CreateProgressRepresentationAndCallback(
         &callbackData, this->GenericImporter, this->Interactor);
@@ -151,7 +151,7 @@ class loader_impl::internals
     if (this->AnimationManager.Initialize(
           &this->Options, &this->Window, this->Interactor, this->GenericImporter))
     {
-      double animationTime = this->Options.getAsDouble("scene.animation.time");
+      double animationTime = this->Options.scene.animation.time;
       double timeRange[2];
       this->AnimationManager.GetTimeRange(timeRange);
 
@@ -285,7 +285,7 @@ loader& loader_impl::loadScene(const std::string& filePath)
   this->Internals->CurrentFullSceneImporter->SetRenderWindow(
     this->Internals->Window.GetRenderWindow());
 
-  int cameraIndex = this->Internals->Options.getAsInt("scene.camera.index");
+  int cameraIndex = this->Internals->Options.scene.camera.index;
   this->Internals->CurrentFullSceneImporter->SetCamera(cameraIndex);
 
   log::debug("Loading 3D scene: ", filePath, "\n");
@@ -296,7 +296,7 @@ loader& loader_impl::loadScene(const std::string& filePath)
   loader_impl::internals::ProgressDataStruct callbackData;
   callbackData.timer = timer;
   callbackData.widget = progressWidget;
-  if (this->Internals->Options.getAsBool("ui.loader-progress") && this->Internals->Interactor)
+  if (this->Internals->Options.ui.loader_progress && this->Internals->Interactor)
   {
     loader_impl::internals::CreateProgressRepresentationAndCallback(
       &callbackData, this->Internals->CurrentFullSceneImporter, this->Internals->Interactor);
@@ -321,7 +321,7 @@ loader& loader_impl::loadScene(const std::string& filePath)
         &this->Internals->Window, this->Internals->Interactor,
         this->Internals->CurrentFullSceneImporter))
   {
-    double animationTime = this->Internals->Options.getAsDouble("scene.animation.time");
+    double animationTime = this->Internals->Options.scene.animation.time;
     double timeRange[2];
     this->Internals->AnimationManager.GetTimeRange(timeRange);
 
diff --git a/library/src/options.cxx b/library/src/options.cxx
index b87a3a5dce..9eef17356a 100644
--- a/library/src/options.cxx
+++ b/library/src/options.cxx
@@ -1,4 +1,5 @@
 #include "options.h"
+#include "options_tools.h"
 
 #include "export.h"
 #include "init.h"
@@ -9,471 +10,90 @@
 
 #include <algorithm>
 #include <limits>
-#include <map>
-#include <type_traits>
-#include <variant>
+#include <string>
 
 namespace f3d
 {
-//----------------------------------------------------------------------------
-class options::internals
-{
-public:
-  using OptionVariant =
-    std::variant<bool, int, double, std::string, std::vector<int>, std::vector<double>>;
-
-  template<typename T, typename U>
-  struct IsTypeValid;
-
-  template<typename T, typename... Ts>
-  struct IsTypeValid<T, std::variant<Ts...>> : public std::disjunction<std::is_same<T, Ts>...>
-  {
-  };
-
-  template<typename T>
-  void init(const std::string& name, const T& value)
-  {
-    static_assert(IsTypeValid<T, OptionVariant>::value);
-    this->Options[name] = value;
-  }
-
-  template<typename T>
-  void set(const std::string& name, const T& value)
-  {
-    static_assert(!std::is_array_v<T> && !std::is_pointer_v<T>);
-    try
-    {
-      T& opt = std::get<T>(this->Options.at(name));
-      opt = value;
-    }
-    catch (const std::bad_variant_access&)
-    {
-      log::error("Trying to set option ", name, " with incompatible type");
-    }
-    catch (const std::out_of_range&)
-    {
-      log::error("Option ", name, " does not exist");
-    }
-  }
-
-  template<typename T>
-  void get(const std::string& name, T& value) const
-  {
-    try
-    {
-      value = std::get<T>(this->Options.at(name));
-    }
-    catch (const std::bad_variant_access&)
-    {
-      log::error("Trying to get option ", name, " with incompatible type");
-      return;
-    }
-    catch (const std::out_of_range&)
-    {
-      log::error("Option ", name, " does not exist");
-      return;
-    }
-  }
-
-  template<typename T>
-  T get(const std::string& name) const
-  {
-    T val = {};
-    this->get(name, val);
-    return val;
-  }
-
-  template<typename T>
-  T& getRef(const std::string& name)
-  {
-    try
-    {
-      return std::get<T>(this->Options.at(name));
-    }
-    catch (const std::bad_variant_access&)
-    {
-      throw options::incompatible_exception(
-        "Trying to get option reference " + name + " with incompatible type");
-    }
-    catch (const std::out_of_range&)
-    {
-      throw options::inexistent_exception("Option " + name + " does not exist");
-    }
-  }
-
-  std::map<std::string, OptionVariant> Options;
-};
-
 //----------------------------------------------------------------------------
 options::options()
-  : Internals(new options::internals)
 {
   detail::init::initialize();
-
-  // Scene
-  this->Internals->init("scene.animation.autoplay", false);
-  this->Internals->init("scene.animation.index", 0);
-  this->Internals->init("scene.animation.speed-factor", 1.0);
-  this->Internals->init("scene.animation.time", 0.0);
-  this->Internals->init("scene.animation.frame-rate", 60.0);
-  this->Internals->init("scene.camera.index", -1);
-  this->Internals->init("scene.up-direction", std::string("+Y"));
-
-  // Render
-  this->Internals->init("render.show-edges", false);
-  this->Internals->init("render.line-width", 1.0);
-  this->Internals->init("render.point-size", 10.0);
-  this->Internals->init("render.grid.enable", false);
-  this->Internals->init("render.grid.absolute", false);
-  this->Internals->init("render.grid.unit", 0.0);
-  this->Internals->init("render.grid.subdivisions", 10);
-  this->Internals->init("render.grid.color", std::vector<double>{ 0.0, 0.0, 0.0 });
-  this->Internals->init("render.backface-type", std::string("default"));
-
-  this->Internals->init("render.raytracing.enable", false);
-  this->Internals->init("render.raytracing.denoise", false);
-  this->Internals->init("render.raytracing.samples", 5);
-
-  this->Internals->init("render.effect.translucency-support", false);
-  this->Internals->init("render.effect.anti-aliasing", false);
-  this->Internals->init("render.effect.ambient-occlusion", false);
-  this->Internals->init("render.effect.tone-mapping", false);
-  this->Internals->init("render.effect.final-shader", std::string());
-
-  this->Internals->init("render.hdri.file", std::string());
-  this->Internals->init("render.hdri.ambient", false);
-  this->Internals->init("render.background.color", std::vector<double>{ 0.2, 0.2, 0.2 });
-  this->Internals->init("render.background.skybox", false);
-  this->Internals->init("render.background.blur", false);
-  this->Internals->init("render.background.blur.coc", 20.0);
-  this->Internals->init("render.light.intensity", 1.);
-
-  // UI
-  this->Internals->init("ui.bar", false);
-  this->Internals->init("ui.filename", false);
-  this->Internals->init("ui.filename-info", std::string());
-  this->Internals->init("ui.fps", false);
-  this->Internals->init("ui.cheatsheet", false);
-  this->Internals->init("ui.dropzone", false);
-  this->Internals->init("ui.dropzone-info", std::string());
-  this->Internals->init("ui.metadata", false);
-  this->Internals->init("ui.font-file", std::string());
-  this->Internals->init("ui.loader-progress", false);
-  this->Internals->init("ui.animation-progress", false);
-
-  // Model
-  this->Internals->init("model.matcap.texture", std::string());
-
-  this->Internals->init("model.color.opacity", 1.0);
-  // XXX: Not compatible with scivis: https://github.com/f3d-app/f3d/issues/347
-  this->Internals->init("model.color.rgb", std::vector<double>{ 1., 1., 1. });
-  // XXX: Artifacts when using with scivis: https://github.com/f3d-app/f3d/issues/348
-  this->Internals->init("model.color.texture", std::string());
-
-  this->Internals->init("model.emissive.factor", std::vector<double>{ 1., 1., 1. });
-  this->Internals->init("model.emissive.texture", std::string());
-
-  this->Internals->init("model.normal.texture", std::string());
-  this->Internals->init("model.normal.scale", 1.0);
-
-  this->Internals->init("model.material.metallic", 0.0);
-  this->Internals->init("model.material.roughness", 0.3);
-  this->Internals->init("model.material.texture", std::string());
-
-  this->Internals->init("model.scivis.cells", false);
-  this->Internals->init("model.scivis.array-name", F3D_RESERVED_STRING);
-  this->Internals->init("model.scivis.component", -1);
-  this->Internals->init("model.scivis.colormap",
-    std::vector<double>{
-      0.0, 0.0, 0.0, 0.0, 0.4, 0.9, 0.0, 0.0, 0.8, 0.9, 0.9, 0.0, 1.0, 1.0, 1.0, 1.0 });
-  this->Internals->init("model.scivis.range", std::vector<double>{ 0 });
-
-  // XXX: Rename into a "rendering-mode" option: https://github.com/f3d-app/f3d/issues/345
-  this->Internals->init("model.point-sprites.enable", false);
-  this->Internals->init("model.point-sprites.type", std::string("sphere"));
-  this->Internals->init("model.volume.enable", false);
-  this->Internals->init("model.volume.inverse", false);
-
-  // Camera projection
-  this->Internals->init("scene.camera.orthographic", false);
-
-  // Interactor
-  this->Internals->init("interactor.axis", false);
-  this->Internals->init("interactor.trackball", false);
-  this->Internals->init("interactor.invert-zoom", false);
 };
 
 //----------------------------------------------------------------------------
-options::~options()
-{
-  delete this->Internals;
-}
-
-//----------------------------------------------------------------------------
-options::options(const options& opt)
-  : Internals(new options::internals)
-{
-  this->Internals->Options = opt.Internals->Options;
-}
-
-//----------------------------------------------------------------------------
-options& options::operator=(const options& opt) noexcept
+options& options::set(const std::string& name, const option_variant_t& value)
 {
-  this->Internals->Options = opt.Internals->Options;
+  options_tools::set(*this, name, value);
   return *this;
 }
 
 //----------------------------------------------------------------------------
-options::options(options&& other) noexcept
+option_variant_t options::get(const std::string& name) const
 {
-  this->Internals = other.Internals;
-  other.Internals = nullptr;
+  return options_tools::get(*this, name);
 }
 
 //----------------------------------------------------------------------------
-options& options::operator=(options&& other) noexcept
+options& options::setAsString(const std::string& name, const std::string& str)
 {
-  if (this != &other)
-  {
-    delete this->Internals;
-    this->Internals = other.Internals;
-    other.Internals = nullptr;
-  }
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, bool value)
-{
-  this->Internals->set(name, value);
+  options_tools::setAsString(*this, name, str);
   return *this;
 }
 
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, int value)
-{
-  this->Internals->set(name, value);
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, double value)
-{
-  this->Internals->set(name, value);
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, const std::string& value)
-{
-  this->Internals->set(name, value);
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, const char* value)
-{
-  this->Internals->set(name, std::string(value));
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, const std::vector<int>& values)
-{
-  this->Internals->set(name, values);
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, const std::vector<double>& values)
-{
-  this->Internals->set(name, values);
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, std::initializer_list<int> values)
-{
-  this->Internals->set(name, std::vector<int>(values));
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-options& options::set(const std::string& name, std::initializer_list<double> values)
-{
-  this->Internals->set(name, std::vector<double>(values));
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-void options::get(const std::string& name, bool& value) const
-{
-  this->Internals->get(name, value);
-}
-
-//----------------------------------------------------------------------------
-void options::get(const std::string& name, int& value) const
-{
-  this->Internals->get(name, value);
-}
-
-//----------------------------------------------------------------------------
-void options::get(const std::string& name, double& value) const
-{
-  this->Internals->get(name, value);
-}
-
-//----------------------------------------------------------------------------
-void options::get(const std::string& name, std::string& value) const
-{
-  this->Internals->get(name, value);
-}
-
-//----------------------------------------------------------------------------
-void options::get(const std::string& name, std::vector<int>& value) const
-{
-  this->Internals->get(name, value);
-}
-
-//----------------------------------------------------------------------------
-void options::get(const std::string& name, std::vector<double>& value) const
-{
-  this->Internals->get(name, value);
-}
-
-//----------------------------------------------------------------------------
-bool options::getAsBool(const std::string& name) const
-{
-  return this->Internals->get<bool>(name);
-}
-
-//----------------------------------------------------------------------------
-int options::getAsInt(const std::string& name) const
-{
-  return this->Internals->get<int>(name);
-}
-
-//----------------------------------------------------------------------------
-double options::getAsDouble(const std::string& name) const
-{
-  return this->Internals->get<double>(name);
-}
-
 //----------------------------------------------------------------------------
 std::string options::getAsString(const std::string& name) const
 {
-  return this->Internals->get<std::string>(name);
-}
-
-//----------------------------------------------------------------------------
-std::vector<int> options::getAsIntVector(const std::string& name) const
-{
-  return this->Internals->get<std::vector<int>>(name);
-}
-
-//----------------------------------------------------------------------------
-std::vector<double> options::getAsDoubleVector(const std::string& name) const
-{
-  return this->Internals->get<std::vector<double>>(name);
-}
-
-//----------------------------------------------------------------------------
-bool& options::getAsBoolRef(const std::string& name)
-{
-  return this->Internals->getRef<bool>(name);
-}
-
-//----------------------------------------------------------------------------
-int& options::getAsIntRef(const std::string& name)
-{
-  return this->Internals->getRef<int>(name);
-}
-
-//----------------------------------------------------------------------------
-double& options::getAsDoubleRef(const std::string& name)
-{
-  return this->Internals->getRef<double>(name);
-}
-
-//----------------------------------------------------------------------------
-std::string& options::getAsStringRef(const std::string& name)
-{
-  return this->Internals->getRef<std::string>(name);
-}
-
-//----------------------------------------------------------------------------
-std::vector<int>& options::getAsIntVectorRef(const std::string& name)
-{
-  return this->Internals->getRef<std::vector<int>>(name);
-}
-
-//----------------------------------------------------------------------------
-std::vector<double>& options::getAsDoubleVectorRef(const std::string& name)
-{
-  return this->Internals->getRef<std::vector<double>>(name);
+  return options_tools::getAsString(*this, name);
 }
 
 //----------------------------------------------------------------------------
 options& options::toggle(const std::string& name)
-{
-  this->Internals->set<bool>(name, !this->Internals->get<bool>(name));
-  return *this;
-}
-
-//----------------------------------------------------------------------------
-bool options::isSame(const options& other, const std::string& name) const
 {
   try
   {
-    return this->Internals->Options.at(name) == other.Internals->Options.at(name);
+    option_variant_t val;
+    val = options_tools::get(*this, name);
+    options_tools::set(*this, name, !std::get<bool>(val));
+    return *this;
   }
-  catch (const std::out_of_range&)
+  catch (const std::bad_variant_access&)
   {
-    std::string error = "Options " + name + " does not exist";
-    log::error(error);
-    throw options::inexistent_exception(error + "\n");
+    throw options::incompatible_exception(
+      "Trying to get toggle " + name + " with incompatible type");
   }
 }
 
+//----------------------------------------------------------------------------
+bool options::isSame(const options& other, const std::string& name) const
+{
+  return options_tools::get(*this, name) == options_tools::get(other, name);
+}
+
 //----------------------------------------------------------------------------
 options& options::copy(const options& from, const std::string& name)
 {
-  try
-  {
-    this->Internals->Options.at(name) = from.Internals->Options.at(name);
-  }
-  catch (const std::out_of_range&)
-  {
-    std::string error = "Options " + name + " does not exist";
-    log::error(error);
-    throw options::inexistent_exception(error + "\n");
-  }
+  options_tools::set(*this, name, options_tools::get(from, name));
   return *this;
 }
 
 //----------------------------------------------------------------------------
-std::vector<std::string> options::getNames()
+std::vector<std::string> options::getNames() const
 {
-  std::vector<std::string> names;
-  names.reserve(this->Internals->Options.size());
-  for (const auto& [name, value] : this->Internals->Options)
-  {
-    names.emplace_back(name);
-  }
-  return names;
+  return options_tools::getNames();
 }
 
 //----------------------------------------------------------------------------
 std::pair<std::string, unsigned int> options::getClosestOption(const std::string& option) const
 {
-  if (this->Internals->Options.find(option) != this->Internals->Options.end())
+  std::vector<std::string> names = options_tools::getNames();
+  if (std::find(names.begin(), names.end(), option) != names.end())
   {
     return { option, 0 };
   }
 
   std::pair<std::string, int> ret = { "", std::numeric_limits<int>::max() };
 
-  for (const auto& [name, value] : this->Internals->Options)
+  for (const auto& name : names)
   {
     int distance = utils::textDistance(name, option);
     if (distance < ret.second)
@@ -485,6 +105,12 @@ std::pair<std::string, unsigned int> options::getClosestOption(const std::string
   return ret;
 }
 
+//----------------------------------------------------------------------------
+options::parsing_exception::parsing_exception(const std::string& what)
+  : exception(what)
+{
+}
+
 //----------------------------------------------------------------------------
 options::incompatible_exception::incompatible_exception(const std::string& what)
   : exception(what)
@@ -496,5 +122,4 @@ options::inexistent_exception::inexistent_exception(const std::string& what)
   : exception(what)
 {
 }
-
 }
diff --git a/library/src/window_impl.cxx b/library/src/window_impl.cxx
index 3205b35721..f8408e3a7a 100644
--- a/library/src/window_impl.cxx
+++ b/library/src/window_impl.cxx
@@ -311,7 +311,7 @@ window_impl::~window_impl()
 void window_impl::Initialize(bool withColoring)
 {
   this->Internals->WithColoring = withColoring;
-  this->Internals->Renderer->Initialize(this->Internals->Options.getAsString("scene.up-direction"));
+  this->Internals->Renderer->Initialize(this->Internals->Options.scene.up_direction);
   this->Internals->UpdateTheme();
   this->Internals->Initialized = true;
 }
@@ -325,147 +325,109 @@ void window_impl::UpdateDynamicOptions()
     this->Initialize(false);
   }
 
+  vtkF3DRendererWithColoring* renderer = this->Internals->Renderer;
+
   if (this->Internals->WindowType == Type::NONE)
   {
     // With a NONE window type, only update the actors to get accurate bounding box information
-    this->Internals->Renderer->UpdateActors();
+    renderer->UpdateActors();
     return;
   }
 
   // Set the cache path if not already
-  this->Internals->Renderer->SetCachePath(this->Internals->GetCachePath());
+  renderer->SetCachePath(this->Internals->GetCachePath());
 
   // Make sure lights are created before we take options into account
-  this->Internals->Renderer->UpdateLights();
+  renderer->UpdateLights();
 
-  this->Internals->Renderer->ShowAxis(this->Internals->Options.getAsBool("interactor.axis"));
-  this->Internals->Renderer->SetUseTrackball(
-    this->Internals->Options.getAsBool("interactor.trackball"));
-  this->Internals->Renderer->SetInvertZoom(
-    this->Internals->Options.getAsBool("interactor.invert-zoom"));
+  const options& opt = this->Internals->Options;
+  renderer->ShowAxis(opt.interactor.axis);
+  renderer->SetUseTrackball(opt.interactor.trackball);
+  renderer->SetInvertZoom(opt.interactor.invert_zoom);
 
-  // XXX: model.point-sprites.type only has an effect on geometry scene
+  // XXX: model.point_sprites.type only has an effect on geometry scene
   // but we set it here for practical reasons
-  std::string splatTypeStr = this->Internals->Options.getAsString("model.point-sprites.type");
-  int pointSize = this->Internals->Options.getAsDouble("render.point-size");
+  std::string splatTypeStr = opt.model.point_sprites.type;
+  int pointSize = opt.render.point_size;
   vtkF3DRendererWithColoring::SplatType splatType = vtkF3DRendererWithColoring::SplatType::SPHERE;
   if (splatTypeStr == "gaussian")
   {
     splatType = vtkF3DRendererWithColoring::SplatType::GAUSSIAN;
   }
 
-  this->Internals->Renderer->SetPointProperties(splatType, pointSize);
-
-  this->Internals->Renderer->SetLineWidth(
-    this->Internals->Options.getAsDouble("render.line-width"));
-  this->Internals->Renderer->ShowEdge(this->Internals->Options.getAsBool("render.show-edges"));
-  this->Internals->Renderer->ShowTimer(this->Internals->Options.getAsBool("ui.fps"));
-  this->Internals->Renderer->ShowFilename(this->Internals->Options.getAsBool("ui.filename"));
-  this->Internals->Renderer->SetFilenameInfo(
-    this->Internals->Options.getAsString("ui.filename-info"));
-  this->Internals->Renderer->ShowMetaData(this->Internals->Options.getAsBool("ui.metadata"));
-  this->Internals->Renderer->ShowCheatSheet(this->Internals->Options.getAsBool("ui.cheatsheet"));
-  this->Internals->Renderer->ShowDropZone(this->Internals->Options.getAsBool("ui.dropzone"));
-  this->Internals->Renderer->SetDropZoneInfo(
-    this->Internals->Options.getAsString("ui.dropzone-info"));
-
-  this->Internals->Renderer->SetUseRaytracing(
-    this->Internals->Options.getAsBool("render.raytracing.enable"));
-  this->Internals->Renderer->SetRaytracingSamples(
-    this->Internals->Options.getAsInt("render.raytracing.samples"));
-  this->Internals->Renderer->SetUseRaytracingDenoiser(
-    this->Internals->Options.getAsBool("render.raytracing.denoise"));
-
-  this->Internals->Renderer->SetUseSSAOPass(
-    this->Internals->Options.getAsBool("render.effect.ambient-occlusion"));
-  this->Internals->Renderer->SetUseFXAAPass(
-    this->Internals->Options.getAsBool("render.effect.anti-aliasing"));
-  this->Internals->Renderer->SetUseToneMappingPass(
-    this->Internals->Options.getAsBool("render.effect.tone-mapping"));
-  this->Internals->Renderer->SetUseDepthPeelingPass(
-    this->Internals->Options.getAsBool("render.effect.translucency-support"));
-  this->Internals->Renderer->SetBackfaceType(
-    this->Internals->Options.getAsString("render.backface-type"));
-  this->Internals->Renderer->SetFinalShader(
-    this->Internals->Options.getAsString("render.effect.final-shader"));
-
-  this->Internals->Renderer->SetBackground(
-    this->Internals->Options.getAsDoubleVector("render.background.color").data());
-  this->Internals->Renderer->SetUseBlurBackground(
-    this->Internals->Options.getAsBool("render.background.blur"));
-  this->Internals->Renderer->SetBlurCircleOfConfusionRadius(
-    this->Internals->Options.getAsDouble("render.background.blur.coc"));
-  this->Internals->Renderer->SetLightIntensity(
-    this->Internals->Options.getAsDouble("render.light.intensity"));
-
-  std::string hdriFile = this->Internals->Options.getAsString("render.hdri.file");
-  bool hdriAmbient = this->Internals->Options.getAsBool("render.hdri.ambient");
-  bool hdriSkybox = this->Internals->Options.getAsBool("render.background.skybox");
-  this->Internals->Renderer->SetHDRIFile(hdriFile);
-  this->Internals->Renderer->SetUseImageBasedLighting(hdriAmbient);
-  this->Internals->Renderer->ShowHDRISkybox(hdriSkybox);
-
-  this->Internals->Renderer->SetFontFile(this->Internals->Options.getAsString("ui.font-file"));
-
-  this->Internals->Renderer->SetGridUnitSquare(
-    this->Internals->Options.getAsDouble("render.grid.unit"));
-  this->Internals->Renderer->SetGridSubdivisions(
-    this->Internals->Options.getAsInt("render.grid.subdivisions"));
-  this->Internals->Renderer->SetGridAbsolute(
-    this->Internals->Options.getAsBool("render.grid.absolute"));
-  this->Internals->Renderer->ShowGrid(this->Internals->Options.getAsBool("render.grid.enable"));
-  this->Internals->Renderer->SetGridColor(
-    this->Internals->Options.getAsDoubleVector("render.grid.color"));
-
-  if (this->Internals->Options.getAsInt("scene.camera.index") == -1)
+  renderer->SetPointProperties(splatType, pointSize);
+
+  renderer->SetLineWidth(opt.render.line_width);
+  renderer->ShowEdge(opt.render.show_edges);
+  renderer->ShowTimer(opt.ui.fps);
+  renderer->ShowFilename(opt.ui.filename);
+  renderer->SetFilenameInfo(opt.ui.filename_info);
+  renderer->ShowMetaData(opt.ui.metadata);
+  renderer->ShowCheatSheet(opt.ui.cheatsheet);
+  renderer->ShowDropZone(opt.ui.dropzone);
+  renderer->SetDropZoneInfo(opt.ui.dropzone_info);
+
+  renderer->SetUseRaytracing(opt.render.raytracing.enable);
+  renderer->SetRaytracingSamples(opt.render.raytracing.samples);
+  renderer->SetUseRaytracingDenoiser(opt.render.raytracing.denoise);
+
+  renderer->SetUseSSAOPass(opt.render.effect.ambient_occlusion);
+  renderer->SetUseFXAAPass(opt.render.effect.anti_aliasing);
+  renderer->SetUseToneMappingPass(opt.render.effect.tone_mapping);
+  renderer->SetUseDepthPeelingPass(opt.render.effect.translucency_support);
+  renderer->SetBackfaceType(opt.render.backface_type);
+  renderer->SetFinalShader(opt.render.effect.final_shader);
+
+  renderer->SetBackground(opt.render.background.color.data());
+  renderer->SetUseBlurBackground(opt.render.background.blur);
+  renderer->SetBlurCircleOfConfusionRadius(opt.render.background.blur_coc);
+  renderer->SetLightIntensity(opt.render.light.intensity);
+
+  renderer->SetHDRIFile(opt.render.hdri.file);
+  renderer->SetUseImageBasedLighting(opt.render.hdri.ambient);
+  renderer->ShowHDRISkybox(opt.render.background.skybox);
+
+  renderer->SetFontFile(opt.ui.font_file);
+
+  renderer->SetGridUnitSquare(opt.render.grid.unit);
+  renderer->SetGridSubdivisions(opt.render.grid.subdivisions);
+  renderer->SetGridAbsolute(opt.render.grid.absolute);
+  renderer->ShowGrid(opt.render.grid.enable);
+  renderer->SetGridColor(opt.render.grid.color);
+
+  if (opt.scene.camera.index == -1)
   {
-    this->Internals->Renderer->SetUseOrthographicProjection(
-      this->Internals->Options.getAsBool("scene.camera.orthographic"));
+    renderer->SetUseOrthographicProjection(opt.scene.camera.orthographic);
   }
 
   if (this->Internals->WithColoring)
   {
-    this->Internals->Renderer->SetSurfaceColor(
-      this->Internals->Options.getAsDoubleVector("model.color.rgb").data());
-    this->Internals->Renderer->SetOpacity(
-      this->Internals->Options.getAsDouble("model.color.opacity"));
-    this->Internals->Renderer->SetTextureBaseColor(
-      this->Internals->Options.getAsString("model.color.texture"));
-    this->Internals->Renderer->SetRoughness(
-      this->Internals->Options.getAsDouble("model.material.roughness"));
-    this->Internals->Renderer->SetMetallic(
-      this->Internals->Options.getAsDouble("model.material.metallic"));
-    this->Internals->Renderer->SetTextureMaterial(
-      this->Internals->Options.getAsString("model.material.texture"));
-    this->Internals->Renderer->SetTextureEmissive(
-      this->Internals->Options.getAsString("model.emissive.texture"));
-    this->Internals->Renderer->SetEmissiveFactor(
-      this->Internals->Options.getAsDoubleVector("model.emissive.factor").data());
-    this->Internals->Renderer->SetTextureNormal(
-      this->Internals->Options.getAsString("model.normal.texture"));
-    this->Internals->Renderer->SetNormalScale(
-      this->Internals->Options.getAsDouble("model.normal.scale"));
-    this->Internals->Renderer->SetTextureMatCap(
-      this->Internals->Options.getAsString("model.matcap.texture"));
-
-    this->Internals->Renderer->SetColoring(this->Internals->Options.getAsBool("model.scivis.cells"),
-      this->Internals->Options.getAsString("model.scivis.array-name"),
-      this->Internals->Options.getAsInt("model.scivis.component"));
-    this->Internals->Renderer->SetScalarBarRange(
-      this->Internals->Options.getAsDoubleVector("model.scivis.range"));
-    this->Internals->Renderer->SetColormap(
-      this->Internals->Options.getAsDoubleVector("model.scivis.colormap"));
-    this->Internals->Renderer->ShowScalarBar(this->Internals->Options.getAsBool("ui.bar"));
-
-    this->Internals->Renderer->SetUsePointSprites(
-      this->Internals->Options.getAsBool("model.point-sprites.enable"));
-    this->Internals->Renderer->SetUseVolume(
-      this->Internals->Options.getAsBool("model.volume.enable"));
-    this->Internals->Renderer->SetUseInverseOpacityFunction(
-      this->Internals->Options.getAsBool("model.volume.inverse"));
+    std::vector<double> rgb = opt.model.color.rgb;
+    renderer->SetSurfaceColor(rgb.data());
+    renderer->SetOpacity(opt.model.color.opacity);
+    renderer->SetTextureBaseColor(opt.model.color.texture);
+    renderer->SetRoughness(opt.model.material.roughness);
+    renderer->SetMetallic(opt.model.material.metallic);
+    renderer->SetTextureMaterial(opt.model.material.texture);
+    renderer->SetTextureEmissive(opt.model.emissive.texture);
+    std::vector<double> factor = opt.model.emissive.factor;
+    renderer->SetEmissiveFactor(factor.data());
+    renderer->SetTextureNormal(opt.model.normal.texture);
+    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->SetScalarBarRange(opt.model.scivis.range);
+    renderer->SetColormap(opt.model.scivis.colormap);
+    renderer->ShowScalarBar(opt.ui.scalar_bar);
+
+    renderer->SetUsePointSprites(opt.model.point_sprites.enable);
+    renderer->SetUseVolume(opt.model.volume.enable);
+    renderer->SetUseInverseOpacityFunction(opt.model.volume.inverse);
   }
 
-  this->Internals->Renderer->UpdateActors();
+  renderer->UpdateActors();
 }
 
 //----------------------------------------------------------------------------
diff --git a/library/testing/CMakeLists.txt b/library/testing/CMakeLists.txt
index f1ac784fc4..410c0741dd 100644
--- a/library/testing/CMakeLists.txt
+++ b/library/testing/CMakeLists.txt
@@ -75,6 +75,7 @@ set_target_properties(libf3dSDKTests PROPERTIES
   )
 
 target_compile_definitions(libf3dSDKTests PRIVATE F3D_MODULE_EXR=$<BOOL:${F3D_MODULE_EXR}>)
+target_compile_definitions(libf3dSDKTests PRIVATE F3D_DISABLE_CXX17_API)
 
 # Remove this once VTK 9.3 support is removed
 if(VTK_VERSION VERSION_GREATER_EQUAL 9.3.20240729)
@@ -99,7 +100,6 @@ foreach (test ${libf3dSDKTests_list})
 endforeach ()
 
 # Specific test properties to check
-
 # CTest can't check colored output as it contains special chars
 set_tests_properties(libf3d::TestSDKLog PROPERTIES PASS_REGULAR_EXPRESSION
 "\
@@ -128,5 +128,31 @@ if(Qt5_FOUND)
   target_link_libraries(libf3dSDKTests Qt5::OpenGL)
 endif()
 
-# make sure the libf3d API is compatible with C++11
+# make sure the libf3d API is compatible with the right C++ standard
 set_target_properties(libf3dSDKTests PROPERTIES CXX_STANDARD 11)
+
+# Add Cxx17 tests
+list(APPEND libf3dSDKCxx17Tests_list
+     TestSDKOptionsCxx17.cxx
+)
+
+# create the testing file and list of tests
+create_test_sourcelist(_libf3dSDKCxx17Tests libf3dSDKCxx17Tests.cxx ${libf3dSDKCxx17Tests_list})
+
+# add the executable
+add_executable(libf3dSDKCxx17Tests ${_libf3dSDKCxx17Tests})
+set_target_properties(libf3dSDKCxx17Tests PROPERTIES
+  CXX_VISIBILITY_PRESET hidden
+  )
+
+# Add all the ADD_TEST for each test
+foreach (test ${libf3dSDKCxx17Tests_list})
+  get_filename_component (TName ${test} NAME_WE)
+  add_test (NAME libf3d::${TName} COMMAND libf3dSDKCxx17Tests ${TName}  "${F3D_SOURCE_DIR}/testing/" "${CMAKE_BINARY_DIR}/Testing/Temporary/" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+  set_tests_properties(libf3d::${TName} PROPERTIES TIMEOUT 30)
+endforeach ()
+
+target_link_libraries(libf3dSDKCxx17Tests libf3d)
+
+# make sure the libf3d API is compatible with the right C++ standard
+set_target_properties(libf3dSDKCxx17Tests PROPERTIES CXX_STANDARD 17)
diff --git a/library/testing/TestSDKDropZone.cxx b/library/testing/TestSDKDropZone.cxx
index fbe53c1519..4827131dc8 100644
--- a/library/testing/TestSDKDropZone.cxx
+++ b/library/testing/TestSDKDropZone.cxx
@@ -10,8 +10,8 @@ int TestSDKDropZone(int argc, char* argv[])
   f3d::window& win = eng.getWindow();
   f3d::options& opt = eng.getOptions();
   win.setSize(300, 300);
-  opt.set("ui.dropzone", true);
-  opt.set("ui.dropzone-info", "Drop a file to open it\nPress H to show cheatsheet");
+  opt.ui.dropzone = true;
+  opt.ui.dropzone_info = "Drop a file to open it\nPress H to show cheatsheet";
 
   win.render();
 
diff --git a/library/testing/TestSDKDynamicBackgroundColor.cxx b/library/testing/TestSDKDynamicBackgroundColor.cxx
index 028be4c39c..efafd3f7f1 100644
--- a/library/testing/TestSDKDynamicBackgroundColor.cxx
+++ b/library/testing/TestSDKDynamicBackgroundColor.cxx
@@ -12,15 +12,15 @@ int TestSDKDynamicBackgroundColor(int argc, char* argv[])
   f3d::window& win = eng.getWindow();
   f3d::options& opt = eng.getOptions();
   win.setSize(300, 300);
-  opt.set("ui.filename", true);
-  opt.set("ui.filename-info", "(1/1) cow.vtp");
+  opt.ui.filename = true;
+  opt.ui.filename_info = "(1/1) cow.vtp";
 
   load.loadGeometry(std::string(argv[1]) + "/data/cow.vtp");
 
   win.render();
 
   // Change the background color and make sure it is taken into account
-  opt.set("render.background.color", { 1.0, 1.0, 1.0 });
+  opt.render.background.color = { 1.0, 1.0, 1.0 };
 
   return TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
            std::string(argv[2]), "TestSDKDynamicBackgrounColor", 50)
diff --git a/library/testing/TestSDKDynamicFontFile.cxx b/library/testing/TestSDKDynamicFontFile.cxx
index 9ca7ef6220..cb8c18dd6e 100644
--- a/library/testing/TestSDKDynamicFontFile.cxx
+++ b/library/testing/TestSDKDynamicFontFile.cxx
@@ -12,15 +12,15 @@ int TestSDKDynamicFontFile(int argc, char* argv[])
   f3d::window& win = eng.getWindow();
   f3d::options& opt = eng.getOptions();
   win.setSize(300, 300);
-  opt.set("ui.filename", true);
-  opt.set("ui.filename-info", "(1/1) cow.vtp");
+  opt.ui.filename = true;
+  opt.ui.filename_info = "(1/1) cow.vtp";
 
   load.loadGeometry(std::string(argv[1]) + "/data/cow.vtp");
 
   win.render();
 
   // Change the font file and make sure it is taken into account
-  opt.set("ui.font-file", std::string(argv[1]) + "data/Crosterian.ttf");
+  opt.ui.font_file = std::string(argv[1]) + "data/Crosterian.ttf";
 
   return TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
            std::string(argv[2]), "TestSDKDynamicFontFile", 50)
diff --git a/library/testing/TestSDKDynamicHDRI.cxx b/library/testing/TestSDKDynamicHDRI.cxx
index 8ce055abe9..e75a43c490 100644
--- a/library/testing/TestSDKDynamicHDRI.cxx
+++ b/library/testing/TestSDKDynamicHDRI.cxx
@@ -19,8 +19,8 @@ int TestSDKDynamicHDRI(int argc, char* argv[])
   f3d::window& win = eng.getWindow();
   f3d::options& opt = eng.getOptions();
   win.setSize(300, 300);
-  opt.set("ui.filename", true);
-  opt.set("ui.filename-info", "(1/1) cow.vtp");
+  opt.ui.filename = true;
+  opt.ui.filename_info = "(1/1) cow.vtp";
 
   load.loadGeometry(std::string(argv[1]) + "/data/cow.vtp");
 
@@ -39,8 +39,8 @@ int TestSDKDynamicHDRI(int argc, char* argv[])
   eng.setCachePath(cachePath);
 
   // Enable HDRI ambient and skybox and check the default HDRI
-  opt.set("render.hdri.ambient", true);
-  opt.set("render.background.skybox", true);
+  opt.render.hdri.ambient = true;
+  opt.render.background.skybox = true;
   ret = TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
     std::string(argv[2]), "TestSDKDynamicHDRIDefault", 120);
   if (!ret)
@@ -50,7 +50,7 @@ int TestSDKDynamicHDRI(int argc, char* argv[])
   }
 
   // Change the hdri and make sure it is taken into account
-  opt.set("render.hdri.file", std::string(argv[1]) + "data/palermo_park_1k.hdr");
+  opt.render.hdri.file = std::string(argv[1]) + "data/palermo_park_1k.hdr";
   ret = TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
     std::string(argv[2]), "TestSDKDynamicHDRI", 50);
   if (!ret)
@@ -89,7 +89,7 @@ int TestSDKDynamicHDRI(int argc, char* argv[])
 
 #if F3D_MODULE_EXR
   // Change the hdri and make sure it is taken into account
-  opt.set("render.hdri.file", std::string(argv[1]) + "/data/kloofendal_43d_clear_1k.exr");
+  opt.render.hdri.file = std::string(argv[1]) + "/data/kloofendal_43d_clear_1k.exr";
   ret = TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
     std::string(argv[2]), "TestSDKDynamicHDRIExr", 50);
 
diff --git a/library/testing/TestSDKDynamicLightIntensity.cxx b/library/testing/TestSDKDynamicLightIntensity.cxx
index bcb006d511..bd9ac7e872 100644
--- a/library/testing/TestSDKDynamicLightIntensity.cxx
+++ b/library/testing/TestSDKDynamicLightIntensity.cxx
@@ -25,8 +25,8 @@ int TestSDKDynamicLightIntensity(int argc, char* argv[])
     return EXIT_FAILURE;
   }
 
-  // set light-intensity to 5x brighter
-  opt.set("render.light.intensity", 5.);
+  // set light intensity to 5x brighter
+  opt.render.light.intensity = 5.;
   if (!TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
         std::string(argv[2]), "TestSDKDynamicLightIntensity-5x-brighter", 50))
   {
@@ -34,8 +34,8 @@ int TestSDKDynamicLightIntensity(int argc, char* argv[])
     return EXIT_FAILURE;
   }
 
-  // set light-intensity to 5x darker
-  opt.set("render.light.intensity", .2);
+  // set light intensity to 5x darker
+  opt.render.light.intensity = .2;
   if (!TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
         std::string(argv[2]), "TestSDKDynamicLightIntensity-5x-darker", 50))
   {
diff --git a/library/testing/TestSDKDynamicProperties.cxx b/library/testing/TestSDKDynamicProperties.cxx
index b2405f0372..1759267d06 100644
--- a/library/testing/TestSDKDynamicProperties.cxx
+++ b/library/testing/TestSDKDynamicProperties.cxx
@@ -12,18 +12,18 @@ int TestSDKDynamicProperties(int argc, char* argv[])
   f3d::window& win = eng.getWindow();
   f3d::options& opt = eng.getOptions();
   win.setSize(300, 300);
-  opt.set("ui.filename", true);
-  opt.set("ui.filename-info", "(1/1) cow.vtp");
+  opt.ui.filename = true;
+  opt.ui.filename_info = "(1/1) cow.vtp";
 
   load.loadGeometry(std::string(argv[1]) + "/data/cow.vtp");
 
   win.render();
 
   // Change model properties and make sure it is taken into account
-  opt.set("model.material.roughness", 0.6);
-  opt.set("model.material.metallic", 0.5);
-  opt.set("model.color.rgb", { 0.6, 0.1, 0.2 });
-  opt.set("model.color.opacity", 0.6);
+  opt.model.material.roughness = 0.6;
+  opt.model.material.metallic = 0.5;
+  opt.model.color.rgb = { 0.6, 0.1, 0.2 };
+  opt.model.color.opacity = 0.6;
 
   return TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
            std::string(argv[2]), "TestSDKDynamicProperties", 50)
diff --git a/library/testing/TestSDKEngine.cxx b/library/testing/TestSDKEngine.cxx
index 6fe977162a..0df0aadcf8 100644
--- a/library/testing/TestSDKEngine.cxx
+++ b/library/testing/TestSDKEngine.cxx
@@ -37,19 +37,19 @@ int TestSDKEngine(int argc, char* argv[])
 
   // Test option setters
   f3d::options opt;
-  opt.set("model.scivis.cells", true);
+  opt.model.scivis.cells = true;
 
   eng0.setOptions(opt);
-  if (!eng0.getOptions().getAsBool("model.scivis.cells"))
+  if (!eng0.getOptions().model.scivis.cells)
   {
     std::cerr << "Unexpected options value using f3d::engine::setOptions(const options& opt)"
               << std::endl;
     return EXIT_FAILURE;
   }
 
-  opt.set("render.line-width", 1.7);
+  opt.render.line_width = 1.7;
   eng0.setOptions(std::move(opt));
-  if (eng0.getOptions().getAsDouble("render.line-width") != 1.7)
+  if (eng0.getOptions().render.line_width != 1.7)
   {
     std::cerr << "Unexpected options value using f3d::engine::setOptions(options&& opt)"
               << std::endl;
diff --git a/library/testing/TestSDKInteractorCallBack.cxx b/library/testing/TestSDKInteractorCallBack.cxx
index d1fe973610..bdca2d12e8 100644
--- a/library/testing/TestSDKInteractorCallBack.cxx
+++ b/library/testing/TestSDKInteractorCallBack.cxx
@@ -41,7 +41,7 @@ int TestSDKInteractorCallBack(int argc, char* argv[])
     {
       if (keySym == "S")
       {
-        options.set("interactor.axis", true);
+        options.interactor.axis = true;
         win.render();
         return true;
       }
diff --git a/library/testing/TestSDKLoadFromMemory.cxx b/library/testing/TestSDKLoadFromMemory.cxx
index aff9c624ec..04d55899da 100644
--- a/library/testing/TestSDKLoadFromMemory.cxx
+++ b/library/testing/TestSDKLoadFromMemory.cxx
@@ -14,7 +14,7 @@ int TestSDKLoadFromMemory(int argc, char* argv[])
   f3d::window& win = eng.getWindow().setSize(300, 300);
 
   std::string texturePath = std::string(argv[1]) + "data/world.png";
-  eng.getOptions().set("model.color.texture", texturePath);
+  eng.getOptions().model.color.texture = texturePath;
 
   // Load invalid number of points
   try
diff --git a/library/testing/TestSDKMultiColoring.cxx b/library/testing/TestSDKMultiColoring.cxx
index 5baf0dee57..921e35fbd2 100644
--- a/library/testing/TestSDKMultiColoring.cxx
+++ b/library/testing/TestSDKMultiColoring.cxx
@@ -26,7 +26,7 @@ int TestSDKMultiColoring(int argc, char* argv[])
   // Multiple geometries
   load.loadGeometry(cube).loadGeometry(left).loadGeometry(right);
 
-  opt.set("model.scivis.array-name", "Normals");
+  opt.model.scivis.array_name = "Normals";
 
   return TestSDKHelpers::RenderTest(eng.getWindow(), std::string(argv[1]) + "baselines/",
            std::string(argv[2]), "TestSDKMultiColoring", 50)
diff --git a/library/testing/TestSDKMultiOptions.cxx b/library/testing/TestSDKMultiOptions.cxx
index 8030b36772..e669866078 100644
--- a/library/testing/TestSDKMultiOptions.cxx
+++ b/library/testing/TestSDKMultiOptions.cxx
@@ -23,10 +23,10 @@ int TestSDKMultiOptions(int argc, char* argv[])
 
   // Render one geometry with a render option
   load.loadGeometry(left);
-  opt.set("render.show-edges", true);
-  opt.set("render.grid.enable", true);
-  opt.set("ui.metadata", true);
-  opt.set("model.material.roughness", 0.6);
+  opt.render.show_edges = true;
+  opt.render.grid.enable = true;
+  opt.ui.metadata = true;
+  opt.model.material.roughness = 0.6;
   win.render();
 
   // Add another geometry
diff --git a/library/testing/TestSDKOptions.cxx b/library/testing/TestSDKOptions.cxx
index 01741bcbfe..e8435bc80f 100644
--- a/library/testing/TestSDKOptions.cxx
+++ b/library/testing/TestSDKOptions.cxx
@@ -8,133 +8,102 @@ int TestSDKOptions(int argc, char* argv[])
   f3d::options opt;
 
   // Test bool
-  opt.set("model.scivis.cells", true);
-  if (opt.getAsBool("model.scivis.cells") != true)
+  opt.setAsString("model.scivis.cells", "false");
+  if (opt.getAsString("model.scivis.cells") != "false")
   {
-    std::cerr << "Options set/getAs bool is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString bool with boolalpha is not behaving as expected."
+              << std::endl;
     return EXIT_FAILURE;
   }
-  bool valBool;
-  opt.get("model.scivis.cells", valBool);
-  if (valBool != true)
+  opt.setAsString("model.scivis.cells", "1");
+  if (opt.getAsString("model.scivis.cells") != "true")
   {
-    std::cerr << "Options get bool is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString bool without boolalpha is not behaving as expected."
+              << std::endl;
     return EXIT_FAILURE;
   }
-  bool& refBool = opt.getAsBoolRef("model.scivis.cells");
-  refBool = false;
-  opt.get("model.scivis.cells", valBool);
-  if (valBool != false)
+  opt.model.scivis.cells = false;
+  if (opt.getAsString("model.scivis.cells") != "false")
   {
-    std::cerr << "Options getAsBoolRef is not behaving as expected." << std::endl;
+    std::cerr << "Options struct with getAsString bool is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-
-  // Test int
-  opt.set("scene.animation.index", 1);
-  if (opt.getAsInt("scene.animation.index") != 1)
+  opt.toggle("model.scivis.cells");
+  if (opt.getAsString("model.scivis.cells") != "true")
   {
-    std::cerr << "Options set/getAs int is not behaving as expected." << std::endl;
+    std::cerr << "Options toggle is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  int valInt;
-  opt.get("scene.animation.index", valInt);
-  if (valInt != 1)
+
+  // Test int
+  opt.setAsString("scene.animation.index", "2");
+  if (opt.getAsString("scene.animation.index") != "2")
   {
-    std::cerr << "Options get int is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString int is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  int& refInt = opt.getAsIntRef("scene.animation.index");
-  refInt = 2;
-  opt.get("scene.animation.index", valInt);
-  if (valInt != 2)
+  opt.scene.animation.index = 3;
+  if (opt.getAsString("scene.animation.index") != "3")
   {
-    std::cerr << "Options getAsIntRef is not behaving as expected." << std::endl;
+    std::cerr << "Options struct with getAsString int is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
 
   // Test double
-  opt.set("render.line-width", 1.7);
-  if (opt.getAsDouble("render.line-width") != 1.7)
+  opt.setAsString("render.line_width", "2.14");
+  if (opt.getAsString("render.line_width") != "2.14")
   {
-    std::cerr << "Options set/getAs double is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString double is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  double valDouble;
-  opt.get("render.line-width", valDouble);
-  if (valDouble != 1.7)
+  opt.render.line_width = 2.13;
+  if (opt.getAsString("render.line_width") != "2.13")
   {
-    std::cerr << "Options get double is not behaving as expected." << std::endl;
-    return EXIT_FAILURE;
-  }
-  double& refDouble = opt.getAsDoubleRef("render.line-width");
-  refDouble = 2.13;
-  opt.get("render.line-width", valDouble);
-  if (valDouble != 2.13)
-  {
-    std::cerr << "Options getAsDoubleRef is not behaving as expected." << std::endl;
+    std::cerr << "Options struct with getAsString double is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
 
-  // Test string
-  std::string inputString = "test";
-  opt.set("model.color.texture", inputString);
-  if (opt.getAsString("model.color.texture") != "test")
+  // Test ratio_t
+  opt.setAsString("scene.animation.speed_factor", "3.17");
+  if (opt.getAsString("scene.animation.speed_factor") != "3.17")
   {
-    std::cerr << "Options set/getAs string is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString ratio_t is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  std::string valString;
-  opt.get("model.color.texture", valString);
-  if (valString != "test")
+  opt.scene.animation.speed_factor = 3.18;
+  if (opt.getAsString("scene.animation.speed_factor") != "3.18")
   {
-    std::cerr << "Options get string is not behaving as expected." << std::endl;
+    std::cerr << "Options struct with getAsString ratio_t is not behaving as expected."
+              << std::endl;
     return EXIT_FAILURE;
   }
-  inputString = "testChar";
-  opt.set("model.color.texture", inputString.c_str());
-  if (opt.getAsString("model.color.texture") != "testChar")
+
+  // Test string
+  opt.setAsString("model.color.texture", "testAsString");
+  if (opt.getAsString("model.color.texture") != "testAsString")
   {
-    std::cerr << "Options set char* is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString string is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  std::string& refString = opt.getAsStringRef("model.color.texture");
-  refString = "dummy";
-  opt.get("model.color.texture", valString);
-  if (valString != "dummy")
+  opt.model.color.texture = "testInStruct";
+  if (opt.getAsString("model.color.texture") != "testInStruct")
   {
-    std::cerr << "Options getAsStringRef is not behaving as expected." << std::endl;
+    std::cerr << "Options struct with getAsString string is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
 
-  // XXX Test int vector is not done as their is currently no int vector option
-
   // Test double vector
-  opt.set("render.background.color", { 0.1, 0.2, 0.3 });
-  if (opt.getAsDoubleVector("render.background.color") != std::vector<double>{ 0.1, 0.2, 0.3 })
-  {
-    std::cerr << "Options getAsDoubleVector is not behaving as expected." << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::vector<double> valDoubleVec;
-  opt.get("render.background.color", valDoubleVec);
-  if (valDoubleVec != std::vector<double>{ 0.1, 0.2, 0.3 })
+  opt.setAsString("render.background.color", "0.1, 0.2, 0.4");
+  if (opt.getAsString("render.background.color") != "0.1, 0.2, 0.4")
   {
-    std::cerr << "Options get double vector is not behaving as expected." << std::endl;
+    std::cerr << "Options setAsString vector<double> is not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  opt.set("render.background.color", std::vector<double>{ 0.1, 0.2, 0.4 });
-  if (opt.getAsDoubleVectorRef("render.background.color") != std::vector<double>{ 0.1, 0.2, 0.4 })
+  opt.render.background.color = { 0.1, 0.2, 0.5 };
+  if (opt.getAsString("render.background.color") != "0.1, 0.2, 0.5")
   {
-    std::cerr << "Options set double vector is not behaving as expected." << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::vector<double>& refDoubleVec = opt.getAsDoubleVectorRef("render.background.color");
-  refDoubleVec = std::vector<double>{ 0.1, 0.2, 0.5 };
-  opt.get("render.background.color", valDoubleVec);
-  if (valDoubleVec != std::vector<double>{ 0.1, 0.2, 0.5 })
-  {
-    std::cerr << "Options getAsDoubleVectorRef is not behaving as expected." << std::endl;
+    std::cerr << "Options struct with getAsString vector<double> is not behaving as expected."
+              << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -154,46 +123,80 @@ int TestSDKOptions(int argc, char* argv[])
   }
 
   // Test chaining options
-  opt.set("model.scivis.cells", true).set("model.scivis.cells", false);
-  if (opt.getAsBool("model.scivis.cells") != false)
+  opt.setAsString("model.scivis.cells", "false").setAsString("model.scivis.cells", "true");
+  if (opt.getAsString("model.scivis.cells") != "true")
   {
-    std::cerr << "Chaining options is not working." << std::endl;
+    std::cerr << "Chaining options as string is not working." << std::endl;
     return EXIT_FAILURE;
   }
 
-  // Test error paths
-  double val;
-  opt.set("model.scivis.cells", 2.13);
-  opt.get("model.scivis.cells", val);
+  // Test toggle error paths
   try
   {
-    const double& refVal = opt.getAsDoubleRef("model.scivis.cells");
+    opt.toggle("render.line_width");
+    std::cerr << "Failing to get an expected exception when toggling non-boolean option."
+              << std::endl;
+    return EXIT_FAILURE;
   }
   catch (const f3d::options::incompatible_exception& ex)
   {
-    std::cout << "Expected exception:" << ex.what() << std::endl;
+    std::cout << "Expected exception: " << ex.what() << std::endl;
   }
 
-  opt.set("dummy", 2.13);
-  opt.get("dummy", val);
+  // Test parsing error path
   try
   {
-    const double& refVal = opt.getAsDoubleRef("dummy");
+    opt.setAsString("scene.animation.index", "invalid");
+    std::cerr << "Failing to get an expected exception when setting an invalid int." << std::endl;
+    return EXIT_FAILURE;
+  }
+  catch (const f3d::options::parsing_exception& ex)
+  {
+    std::cout << "Expected exception: " << ex.what() << std::endl;
   }
-  catch (const f3d::options::inexistent_exception& ex)
+  try
+  {
+    opt.setAsString("scene.animation.index", "2147483648");
+    std::cerr << "Failing to get an expected exception when setting an out of range int."
+              << std::endl;
+    std::cerr << "--" << opt.getAsString("scene.animation.index") << "--" << std::endl;
+    return EXIT_FAILURE;
+  }
+  catch (const f3d::options::parsing_exception& ex)
   {
-    std::cout << "Expected exception:" << ex.what() << std::endl;
+    std::cout << "Expected exception: " << ex.what() << std::endl;
   }
 
-  if (opt.getAsBool("model.scivis.cells") != false)
+  try
+  {
+    opt.setAsString("render.line_width", "invalid");
+    std::cerr << "Failing to get an expected exception when setting an invalid double."
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+  catch (const f3d::options::parsing_exception& ex)
   {
-    std::cerr << "Options error paths not behaving as expected." << std::endl;
+    std::cout << "Expected exception: " << ex.what() << std::endl;
+  }
+  try
+  {
+    opt.setAsString("render.line_width",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012"
+      "34567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234"
+      "56789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456"
+      "78901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678"
+      "90123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+      "1234567890123456789012345678901234567890");
     return EXIT_FAILURE;
   }
+  catch (const f3d::options::parsing_exception& ex)
+  {
+    std::cout << "Expected exception: " << ex.what() << std::endl;
+  }
 
   // Test copy operator and constructor
   f3d::options opt2 = opt;
-  if (opt2.getAsDouble("render.line-width") != 2.13)
+  if (opt2.render.line_width != 2.13)
   {
     std::cerr << "Options copy constructor not behaving as expected." << std::endl;
     return EXIT_FAILURE;
@@ -201,14 +204,14 @@ int TestSDKOptions(int argc, char* argv[])
 
   f3d::options opt3;
   opt3 = opt2;
-  if (opt3.getAsDouble("render.line-width") != 2.13)
+  if (opt3.render.line_width != 2.13)
   {
     std::cerr << "Options copy operator not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
 
   f3d::options opt4 = std::move(opt3);
-  if (opt4.getAsDouble("render.line-width") != 2.13)
+  if (opt4.render.line_width != 2.13)
   {
     std::cerr << "Options move constructor not behaving as expected." << std::endl;
     return EXIT_FAILURE;
@@ -216,35 +219,35 @@ int TestSDKOptions(int argc, char* argv[])
 
   f3d::options opt5;
   opt5 = std::move(opt4);
-  if (opt5.getAsDouble("render.line-width") != 2.13)
+  if (opt5.render.line_width != 2.13)
   {
     std::cerr << "Options move operator not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
 
   // Test getNames
-  auto names = opt.getNames();
-  if (names.size() == 0 || opt.getNames() != opt2.getNames())
+  std::vector<std::string> names = opt.getNames();
+  if (names.size() == 0 || names != opt2.getNames())
   {
     std::cerr << "Options getNames not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
 
   // Test isSame/copy
-  if (!opt.isSame(opt2, "render.line-width"))
+  if (!opt.isSame(opt2, "render.line_width"))
   {
     std::cerr << "Options isSame not behaving as expected." << std::endl;
     return EXIT_FAILURE;
   }
-  opt2.set("render.line-width", 3.12);
-  if (opt.isSame(opt2, "render.line-width"))
+  opt2.render.line_width = 3.12;
+  if (opt.isSame(opt2, "render.line_width"))
   {
     std::cerr << "Options isSame not behaving as expected when it should be different."
               << std::endl;
     return EXIT_FAILURE;
   }
-  opt2.copy(opt, "render.line-width");
-  if (opt2.getAsDouble("render.line-width") != 2.13)
+  opt2.copy(opt, "render.line_width");
+  if (opt2.render.line_width != 2.13)
   {
     std::cerr << "Options copy method not behaving as expected." << std::endl;
     return EXIT_FAILURE;
@@ -256,7 +259,7 @@ int TestSDKOptions(int argc, char* argv[])
     std::cerr << "Options isSame not behaving as expected with vectors." << std::endl;
     return EXIT_FAILURE;
   }
-  opt2.set("render.background.color", { 0.1, 0.2, 0.6 });
+  opt2.render.background.color = { 0.1, 0.2, 0.6 };
   if (opt.isSame(opt2, "render.background.color"))
   {
     std::cerr << "Options isSame not behaving as expected with vectors when it should be different."
@@ -264,7 +267,7 @@ int TestSDKOptions(int argc, char* argv[])
     return EXIT_FAILURE;
   }
   opt2.copy(opt, "render.background.color");
-  if (opt2.getAsDoubleVector("render.background.color") != std::vector<double>{ 0.1, 0.2, 0.5 })
+  if (opt2.render.background.color != std::vector<double>({ 0.1, 0.2, 0.5 }))
   {
     std::cerr << "Options copy method not behaving as expected with vectors." << std::endl;
     return EXIT_FAILURE;
@@ -277,7 +280,7 @@ int TestSDKOptions(int argc, char* argv[])
   }
   catch (const f3d::options::inexistent_exception& ex)
   {
-    std::cout << "Expected exception:" << ex.what() << std::endl;
+    std::cout << "Expected exception: " << ex.what() << std::endl;
   }
   try
   {
@@ -285,7 +288,7 @@ int TestSDKOptions(int argc, char* argv[])
   }
   catch (const f3d::options::inexistent_exception& ex)
   {
-    std::cout << "Expected exception:" << ex.what() << std::endl;
+    std::cout << "Expected exception: " << ex.what() << std::endl;
   }
 
   return EXIT_SUCCESS;
diff --git a/library/testing/TestSDKOptionsCxx17.cxx b/library/testing/TestSDKOptionsCxx17.cxx
new file mode 100644
index 0000000000..16997fe203
--- /dev/null
+++ b/library/testing/TestSDKOptionsCxx17.cxx
@@ -0,0 +1,106 @@
+#include <export.h>
+#include <options.h>
+
+#include <iostream>
+
+int TestSDKOptionsCxx17(int argc, char* argv[])
+{
+  f3d::options opt;
+
+  // Test bool
+  opt.set("model.scivis.cells", true);
+  if (std::get<bool>(opt.get("model.scivis.cells")) != true)
+  {
+    std::cerr << "Options set/get bool is not behaving as expected." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test int
+  opt.set("scene.animation.index", 1);
+  if (std::get<int>(opt.get("scene.animation.index")) != 1)
+  {
+    std::cerr << "Options set/get int is not behaving as expected." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test double
+  opt.set("render.line_width", 1.7);
+  if (std::get<double>(opt.get("render.line_width")) != 1.7)
+  {
+    std::cerr << "Options set/get double is not behaving as expected." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test ratio_t
+  opt.set("scene.animation.speed_factor", 3.17);
+  if (std::get<double>(opt.get("scene.animation.speed_factor")) != 3.17)
+  {
+    std::cerr << "Options set/get ratio_t is not behaving as expected." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test string
+  std::string inputString = "test";
+  opt.set("model.color.texture", inputString);
+  if (std::get<std::string>(opt.get("model.color.texture")) != "test")
+  {
+    std::cerr << "Options set/get string is not behaving as expected." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test double vector
+  opt.set("render.background.color", std::vector<double>{ 0.1, 0.2, 0.3 });
+  if (std::get<std::vector<double>>(opt.get("render.background.color")) !=
+    std::vector<double>{ 0.1, 0.2, 0.3 })
+  {
+    std::cerr << "Options set/get vector<double> is not behaving as expected." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test chaining options
+  opt.set("model.scivis.cells", true).set("model.scivis.cells", false);
+  if (std::get<bool>(opt.get("model.scivis.cells")) != false)
+  {
+    std::cerr << "Chaining options is not working." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Test error paths
+  try
+  {
+    opt.set("model.scivis.cells", 2.13);
+    std::cerr << "Failing to get an expected exception with setting an incompatible value."
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+  catch (const f3d::options::incompatible_exception& ex)
+  {
+    std::cout << "Expected exception: " << ex.what() << std::endl;
+  }
+
+  try
+  {
+    opt.set("dummy", 2.13);
+    std::cerr << "Failing to get an expected exception with setting an inexistent option."
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+  catch (const f3d::options::inexistent_exception& ex)
+  {
+    std::cout << "expected exception: " << ex.what() << std::endl;
+  }
+
+  try
+  {
+    opt.get("dummy");
+    std::cerr << "Failing to get an expected exception with getting an inexistent option."
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+  catch (const f3d::options::inexistent_exception& ex)
+  {
+    std::cout << "expected exception: " << ex.what() << std::endl;
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/library/testing/TestSDKRenderFinalShader.cxx b/library/testing/TestSDKRenderFinalShader.cxx
index 0db69dcb69..f767a3df67 100644
--- a/library/testing/TestSDKRenderFinalShader.cxx
+++ b/library/testing/TestSDKRenderFinalShader.cxx
@@ -34,7 +34,7 @@ int TestSDKRenderFinalShader(int argc, char* argv[])
   )=";
 
   f3d::options& options = eng.getOptions();
-  options.set("render.effect.final-shader", negativeShader);
+  options.render.effect.final_shader = negativeShader;
 
   if (!TestSDKHelpers::RenderTest(win, std::string(argv[1]) + "baselines/", std::string(argv[2]),
         "TestSDKRenderFinalShaderNegative", 50))
@@ -44,7 +44,7 @@ int TestSDKRenderFinalShader(int argc, char* argv[])
   }
 
   // change the shader to test the recompilation is triggered
-  options.set("render.effect.final-shader", vignetteShader);
+  options.render.effect.final_shader = vignetteShader;
 
   if (!TestSDKHelpers::RenderTest(win, std::string(argv[1]) + "baselines/", std::string(argv[2]),
         "TestSDKRenderFinalShaderVignette", 50))
diff --git a/library/testing/TestSDKWindowNative.cxx b/library/testing/TestSDKWindowNative.cxx
index 6edcde232e..704334f5a9 100644
--- a/library/testing/TestSDKWindowNative.cxx
+++ b/library/testing/TestSDKWindowNative.cxx
@@ -26,7 +26,7 @@ int TestSDKWindowNative(int argc, char* argv[])
   }
 
   f3d::options& options = eng.getOptions();
-  options.set("render.background.color", { 0.8, 0.2, 0.9 });
+  options.render.background.color = { 0.8, 0.2, 0.9 };
 
   // Use a higher threshold as background difference can be strong with mesa
   return TestSDKHelpers::RenderTest(win, std::string(argv[1]) + "baselines/", std::string(argv[2]),
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index a51b818742..96e31a07c7 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -28,7 +28,7 @@ get_property(F3D_MULTI_CONFIG_GENERATOR GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFI
 set(f3d_module_dir "${CMAKE_BINARY_DIR}$<${F3D_MULTI_CONFIG_GENERATOR}:/$<CONFIG>>/${f3d_python_package_name}")
 
 set_target_properties(pyf3d PROPERTIES
-  CXX_STANDARD 14
+  CXX_STANDARD 17
   CXX_VISIBILITY_PRESET hidden
   LIBRARY_OUTPUT_DIRECTORY "${f3d_module_dir}"
   )
diff --git a/python/F3DPythonBindings.cxx b/python/F3DPythonBindings.cxx
index 8d71681165..1307ed13ac 100644
--- a/python/F3DPythonBindings.cxx
+++ b/python/F3DPythonBindings.cxx
@@ -156,39 +156,33 @@ PYBIND11_MODULE(pyf3d, module)
 
   options //
     .def(py::init<>())
-    .def("__setitem__", py::overload_cast<const std::string&, bool>(&f3d::options::set))
-    .def("__setitem__", py::overload_cast<const std::string&, int>(&f3d::options::set))
-    .def("__setitem__", py::overload_cast<const std::string&, double>(&f3d::options::set))
-    .def(
-      "__setitem__", py::overload_cast<const std::string&, const std::string&>(&f3d::options::set))
-    .def("__setitem__",
-      py::overload_cast<const std::string&, const std::vector<int>&>(&f3d::options::set))
     .def("__setitem__",
-      py::overload_cast<const std::string&, const std::vector<double>&>(&f3d::options::set))
+      [](f3d::options& opts, const std::string& key, const f3d::option_variant_t& value)
+      {
+        try
+        {
+          opts.set(key, value);
+        }
+        catch (const f3d::options::inexistent_exception&)
+        {
+          throw py::key_error(key);
+        }
+        catch (const f3d::options::incompatible_exception&)
+        {
+          throw py::attribute_error(key);
+        }
+      })
     .def("__getitem__",
-      [](f3d::options& opts, const std::string key)
+      [](f3d::options& opts, const std::string& key)
       {
-#define TRY(getter)                                                                                \
-  try                                                                                              \
-  {                                                                                                \
-    auto v = getter(key);                                                                          \
-    return py::cast(v);                                                                            \
-  }                                                                                                \
-  catch (const f3d::options::inexistent_exception&)                                                \
-  {                                                                                                \
-    throw pybind11::key_error(key);                                                                \
-  }                                                                                                \
-  catch (const f3d::options::incompatible_exception&)                                              \
-  {                                                                                                \
-  }
-        TRY(opts.getAsBoolRef)
-        TRY(opts.getAsIntRef)
-        TRY(opts.getAsDoubleRef)
-        TRY(opts.getAsStringRef)
-        TRY(opts.getAsDoubleVectorRef)
-        TRY(opts.getAsIntVectorRef)
-        throw pybind11::key_error(key);
-#undef TRY
+        try
+        {
+          return opts.get(key);
+        }
+        catch (const f3d::options::inexistent_exception&)
+        {
+          throw py::key_error(key);
+        }
       })
     .def("__len__", [](f3d::options& opts) { return opts.getNames().size(); })
     .def(
diff --git a/python/testing/test_options.py b/python/testing/test_options.py
index e95f98e7f3..ea381848af 100644
--- a/python/testing/test_options.py
+++ b/python/testing/test_options.py
@@ -4,8 +4,8 @@
 
 
 def test_closest_option():
-    option, distance = f3d.Options().get_closest_option("scene-direction")
-    assert option == "scene.up-direction"
+    option, distance = f3d.Options().get_closest_option("scene_direction")
+    assert option == "scene.up_direction"
     assert distance == 3
 
 
@@ -13,9 +13,10 @@ def test_setitem():
     options = f3d.Options()
     options["interactor.axis"] = False
     options["model.material.roughness"] = 0.3
+    options["scene.animation.speed_factor"] = 3.3
     options["render.raytracing.samples"] = 5
     options["model.color.rgb"] = [1.0, 1.0, 1.0]
-    options["scene.up-direction"] = "+Y"
+    options["scene.up_direction"] = "+Y"
 
 
 def test_getitem():
@@ -24,9 +25,10 @@ def test_getitem():
 
     assert options["interactor.axis"] is False
     assert options["model.material.roughness"] == 0.3
+    assert options["scene.animation.speed_factor"] == 1.0
     assert options["render.raytracing.samples"] == 5
     assert options["model.color.rgb"] == [1.0, 1.0, 1.0]
-    assert options["scene.up-direction"] == "+Y"
+    assert options["scene.up_direction"] == "+Y"
 
 
 def test_get_non_existent_key():
@@ -35,13 +37,18 @@ def test_get_non_existent_key():
         assert options["hello"] == "world"
 
 
-@pytest.mark.xfail(reason="f3d::options::set does not throw, should it?")
 def test_set_non_existent_key():
     options = f3d.Options()
     with pytest.raises(KeyError):
         options["hello"] = "world"
 
 
+def test_set_incompatible_key():
+    options = f3d.Options()
+    with pytest.raises(AttributeError):
+        options["interactor.axis"] = "world"
+
+
 def test_len():
     options = f3d.Options()
     assert len(options) == len(options.keys())
@@ -62,17 +69,19 @@ def test_set_options():
     options = f3d.Options()
     options["interactor.axis"] = True
     options["model.material.roughness"] = 0.7
+    options["scene.animation.speed_factor"] = 3.7
     options["render.raytracing.samples"] = 2
     options["model.color.rgb"] = [0.0, 1.0, 1.0]
-    options["scene.up-direction"] = "-Z"
+    options["scene.up_direction"] = "-Z"
 
     engine = f3d.Engine(f3d.Window.NONE)
     engine.options = options
     assert engine.options["interactor.axis"] is True
     assert engine.options["model.material.roughness"] == 0.7
+    assert engine.options["scene.animation.speed_factor"] == 3.7
     assert engine.options["render.raytracing.samples"] == 2
     assert engine.options["model.color.rgb"] == [0.0, 1.0, 1.0]
-    assert engine.options["scene.up-direction"] == "-Z"
+    assert engine.options["scene.up_direction"] == "-Z"
 
 
 def test_to_dict():
@@ -91,9 +100,10 @@ def test_update_from_dict():
     d = {
         "interactor.axis": True,
         "model.material.roughness": 0.8,
+        "scene.animation.speed_factor": 3.8,
         "render.raytracing.samples": 8,
         "model.color.rgb": [0.1, 0.2, 1.3],
-        "scene.up-direction": "-X",
+        "scene.up_direction": "-X",
     }
     options.update(d)
     for k, v in d.items():
@@ -106,9 +116,10 @@ def test_update_from_kv_pairs():
     d = {
         "interactor.axis": True,
         "model.material.roughness": 0.8,
+        "scene.animation.speed_factor": 3.8,
         "render.raytracing.samples": 8,
         "model.color.rgb": [0.1, 0.2, 1.3],
-        "scene.up-direction": "-X",
+        "scene.up_direction": "-X",
     }
     options.update(d.items())
     for k, v in d.items():