diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 9903963086..82ed616e46 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -63,6 +63,10 @@ repos:
               [.](cmake|cpp|cu|cuh|h|hpp|sh|pxd|py|pyx)$|
               CMakeLists[.]txt$|
               meta[.]yaml$
+        exclude: |
+          (?x)^(
+            ^cpp/tests/utilities/cxxopts.hpp
+          )
   - repo: https://github.com/pre-commit/mirrors-clang-format
     rev: v20.1.4
     hooks:
diff --git a/cpp/tests/utilities/base_fixture.hpp b/cpp/tests/utilities/base_fixture.hpp
index 41d9b40c45..00422d72f6 100644
--- a/cpp/tests/utilities/base_fixture.hpp
+++ b/cpp/tests/utilities/base_fixture.hpp
@@ -104,7 +104,7 @@ inline auto parse_test_options(int argc, char** argv)
       "rmm_mode", "RMM allocation mode", cxxopts::value<std::string>()->default_value("pool"));
 
     return options.parse(argc, argv);
-  } catch (const cxxopts::OptionException& e) {
+  } catch (const std::exception& e) {
     cuopt_assert(false, "Error parsing command line options");
   }
 
diff --git a/cpp/tests/utilities/cxxopts.hpp b/cpp/tests/utilities/cxxopts.hpp
index d42fd89b12..9c66cf58c0 100644
--- a/cpp/tests/utilities/cxxopts.hpp
+++ b/cpp/tests/utilities/cxxopts.hpp
@@ -1,44 +1,129 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION & AFFILIATES. All rights
- * reserved. SPDX-License-Identifier: Apache-2.0
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+
+Copyright (c) 2014-2022 Jarryd Beck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+// vim: ts=2:sw=2:expandtab
 
 #ifndef CXXOPTS_HPP_INCLUDED
 #define CXXOPTS_HPP_INCLUDED
 
-#include <cctype>
+#include <algorithm>
+#include <cstdint>
+#include <cstdlib>
 #include <cstring>
 #include <exception>
-#include <iostream>
+#include <initializer_list>
 #include <limits>
+#include <locale>
 #include <map>
 #include <memory>
-#include <regex>
 #include <sstream>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
+#ifdef CXXOPTS_NO_EXCEPTIONS
+#include <iostream>
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#if (__GNUC__ * 10 + __GNUC_MINOR__) < 49
+#define CXXOPTS_NO_REGEX true
+#endif
+#endif
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CXXOPTS_LINKONCE_CONST __declspec(selectany) extern
+#define CXXOPTS_LINKONCE       __declspec(selectany) extern
+#else
+#define CXXOPTS_LINKONCE_CONST
+#define CXXOPTS_LINKONCE
+#endif
+
+#ifndef CXXOPTS_NO_REGEX
+#include <regex>
+#endif  // CXXOPTS_NO_REGEX
+
+// Nonstandard before C++17, which is coincidentally what we also need for <optional>
+#ifdef __has_include
+#if __has_include(<optional>)
+#include <optional>
+#ifdef __cpp_lib_optional
+#define CXXOPTS_HAS_OPTIONAL
+#endif
+#endif
+#if __has_include(<filesystem>)
+#include <filesystem>
+#ifdef __cpp_lib_filesystem
+#define CXXOPTS_HAS_FILESYSTEM
+#endif
+#endif
+#endif
+
+#define CXXOPTS_FALLTHROUGH
+#ifdef __has_cpp_attribute
+#if __has_cpp_attribute(fallthrough)
+#undef CXXOPTS_FALLTHROUGH
+#define CXXOPTS_FALLTHROUGH [[fallthrough]]
+#endif
+#endif
+
+#if __cplusplus >= 201603L
+#define CXXOPTS_NODISCARD [[nodiscard]]
+#else
+#define CXXOPTS_NODISCARD
+#endif
+
 #ifndef CXXOPTS_VECTOR_DELIMITER
 #define CXXOPTS_VECTOR_DELIMITER ','
 #endif
 
-#define CXXOPTS__VERSION_MAJOR 2
-#define CXXOPTS__VERSION_MINOR 2
-#define CXXOPTS__VERSION_PATCH 0
+#define CXXOPTS__VERSION_MAJOR 3
+#define CXXOPTS__VERSION_MINOR 3
+#define CXXOPTS__VERSION_PATCH 1
+
+#if (__GNUC__ < 10 || (__GNUC__ == 10 && __GNUC_MINOR__ < 1)) && __GNUC__ >= 6
+#define CXXOPTS_NULL_DEREF_IGNORE
+#endif
+
+#if defined(__GNUC__)
+#define DO_PRAGMA(x)              _Pragma(#x)
+#define CXXOPTS_DIAGNOSTIC_PUSH   DO_PRAGMA(GCC diagnostic push)
+#define CXXOPTS_DIAGNOSTIC_POP    DO_PRAGMA(GCC diagnostic pop)
+#define CXXOPTS_IGNORE_WARNING(x) DO_PRAGMA(GCC diagnostic ignored x)
+#else
+// define other compilers here if needed
+#define CXXOPTS_DIAGNOSTIC_PUSH
+#define CXXOPTS_DIAGNOSTIC_POP
+#define CXXOPTS_IGNORE_WARNING(x)
+#endif
+
+#ifdef CXXOPTS_NO_RTTI
+#define CXXOPTS_RTTI_CAST static_cast
+#else
+#define CXXOPTS_RTTI_CAST dynamic_cast
+#endif
 
 namespace cxxopts {
 static constexpr struct {
@@ -56,12 +141,25 @@ static constexpr struct {
 #include <unicode/unistr.h>
 
 namespace cxxopts {
-typedef icu::UnicodeString String;
+
+using String = icu::UnicodeString;
 
 inline String toLocalString(std::string s) { return icu::UnicodeString::fromUTF8(std::move(s)); }
 
-class UnicodeStringIterator : public std::iterator<std::forward_iterator_tag, int32_t> {
+// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it:
+// warning: base class 'class std::enable_shared_from_this<cxxopts::Value>' has accessible
+// non-virtual destructor
+CXXOPTS_DIAGNOSTIC_PUSH
+CXXOPTS_IGNORE_WARNING("-Wnon-virtual-dtor")
+// This will be ignored under other compilers like LLVM clang.
+class UnicodeStringIterator {
  public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type        = int32_t;
+  using difference_type   = std::ptrdiff_t;
+  using pointer           = value_type*;
+  using reference         = value_type&;
+
   UnicodeStringIterator(const icu::UnicodeString* string, int32_t pos) : s(string), i(pos) {}
 
   value_type operator*() const { return s->char32At(i); }
@@ -82,12 +180,13 @@ class UnicodeStringIterator : public std::iterator<std::forward_iterator_tag, in
   const icu::UnicodeString* s;
   int32_t i;
 };
+CXXOPTS_DIAGNOSTIC_POP
 
 inline String& stringAppend(String& s, String a) { return s.append(std::move(a)); }
 
-inline String& stringAppend(String& s, int n, UChar32 c)
+inline String& stringAppend(String& s, std::size_t n, UChar32 c)
 {
-  for (int i = 0; i != n; ++i) {
+  for (std::size_t i = 0; i != n; ++i) {
     s.append(c);
   }
 
@@ -105,7 +204,7 @@ String& stringAppend(String& s, Iterator begin, Iterator end)
   return s;
 }
 
-inline size_t stringLength(const String& s) { return s.length(); }
+inline size_t stringLength(const String& s) { return static_cast<size_t>(s.length()); }
 
 inline std::string toUTF8String(const String& s)
 {
@@ -116,9 +215,11 @@ inline std::string toUTF8String(const String& s)
 }
 
 inline bool empty(const String& s) { return s.isEmpty(); }
+
 }  // namespace cxxopts
 
 namespace std {
+
 inline cxxopts::UnicodeStringIterator begin(const icu::UnicodeString& s)
 {
   return cxxopts::UnicodeStringIterator(&s, 0);
@@ -128,13 +229,15 @@ inline cxxopts::UnicodeStringIterator end(const icu::UnicodeString& s)
 {
   return cxxopts::UnicodeStringIterator(&s, s.length());
 }
+
 }  // namespace std
 
 // ifdef CXXOPTS_USE_UNICODE
 #else
 
 namespace cxxopts {
-typedef std::string String;
+
+using String = std::string;
 
 template <typename T>
 T toLocalString(T&& t)
@@ -142,11 +245,11 @@ T toLocalString(T&& t)
   return std::forward<T>(t);
 }
 
-inline size_t stringLength(const String& s) { return s.length(); }
+inline std::size_t stringLength(const String& s) { return s.length(); }
 
-inline String& stringAppend(String& s, String a) { return s.append(std::move(a)); }
+inline String& stringAppend(String& s, const String& a) { return s.append(a); }
 
-inline String& stringAppend(String& s, size_t n, char c) { return s.append(n, c); }
+inline String& stringAppend(String& s, std::size_t n, char c) { return s.append(n, c); }
 
 template <typename Iterator>
 String& stringAppend(String& s, Iterator begin, Iterator end)
@@ -161,28 +264,36 @@ std::string toUTF8String(T&& t)
 }
 
 inline bool empty(const std::string& s) { return s.empty(); }
+
 }  // namespace cxxopts
 
 // ifdef CXXOPTS_USE_UNICODE
 #endif
 
 namespace cxxopts {
+
 namespace {
-#ifdef _WIN32
-const std::string LQUOTE("\'");
-const std::string RQUOTE("\'");
-#else
-const std::string LQUOTE("‘");
-const std::string RQUOTE("’");
-#endif
+CXXOPTS_LINKONCE_CONST std::string LQUOTE("\'");
+CXXOPTS_LINKONCE_CONST std::string RQUOTE("\'");
 }  // namespace
 
+// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we
+// want to silence it: warning: base class 'class
+// std::enable_shared_from_this<cxxopts::Value>' has accessible non-virtual
+// destructor This will be ignored under other compilers like LLVM clang.
+CXXOPTS_DIAGNOSTIC_PUSH
+CXXOPTS_IGNORE_WARNING("-Wnon-virtual-dtor")
+
+// some older versions of GCC warn under this warning
+CXXOPTS_IGNORE_WARNING("-Weffc++")
 class Value : public std::enable_shared_from_this<Value> {
  public:
   virtual ~Value() = default;
 
   virtual std::shared_ptr<Value> clone() const = 0;
 
+  virtual void add(const std::string& text) const = 0;
+
   virtual void parse(const std::string& text) const = 0;
 
   virtual void parse() const = 0;
@@ -206,109 +317,115 @@ class Value : public std::enable_shared_from_this<Value> {
   virtual bool is_boolean() const = 0;
 };
 
-class OptionException : public std::exception {
+CXXOPTS_DIAGNOSTIC_POP
+
+namespace exceptions {
+
+class exception : public std::exception {
  public:
-  OptionException(const std::string& message) : m_message(message) {}
+  explicit exception(std::string message) : m_message(std::move(message)) {}
 
-  virtual const char* what() const noexcept { return m_message.c_str(); }
+  CXXOPTS_NODISCARD
+  const char* what() const noexcept override { return m_message.c_str(); }
 
  private:
   std::string m_message;
 };
 
-class OptionSpecException : public OptionException {
+class specification : public exception {
  public:
-  OptionSpecException(const std::string& message) : OptionException(message) {}
+  explicit specification(const std::string& message) : exception(message) {}
 };
 
-class OptionParseException : public OptionException {
+class parsing : public exception {
  public:
-  OptionParseException(const std::string& message) : OptionException(message) {}
+  explicit parsing(const std::string& message) : exception(message) {}
 };
 
-class option_exists_error : public OptionSpecException {
+class option_already_exists : public specification {
  public:
-  option_exists_error(const std::string& option)
-    : OptionSpecException("Option " + LQUOTE + option + RQUOTE + " already exists")
+  explicit option_already_exists(const std::string& option)
+    : specification("Option " + LQUOTE + option + RQUOTE + " already exists")
   {
   }
 };
 
-class invalid_option_format_error : public OptionSpecException {
+class invalid_option_format : public specification {
  public:
-  invalid_option_format_error(const std::string& format)
-    : OptionSpecException("Invalid option format " + LQUOTE + format + RQUOTE)
+  explicit invalid_option_format(const std::string& format)
+    : specification("Invalid option format " + LQUOTE + format + RQUOTE)
   {
   }
 };
 
-class option_syntax_exception : public OptionParseException {
+class invalid_option_syntax : public parsing {
  public:
-  option_syntax_exception(const std::string& text)
-    : OptionParseException("Argument " + LQUOTE + text + RQUOTE +
-                           " starts with a - but has incorrect syntax")
+  explicit invalid_option_syntax(const std::string& text)
+    : parsing("Argument " + LQUOTE + text + RQUOTE + " starts with a - but has incorrect syntax")
   {
   }
 };
 
-class option_not_exists_exception : public OptionParseException {
+class no_such_option : public parsing {
  public:
-  option_not_exists_exception(const std::string& option)
-    : OptionParseException("Option " + LQUOTE + option + RQUOTE + " does not exist")
+  explicit no_such_option(const std::string& option)
+    : parsing("Option " + LQUOTE + option + RQUOTE + " does not exist")
   {
   }
 };
 
-class missing_argument_exception : public OptionParseException {
+class missing_argument : public parsing {
  public:
-  missing_argument_exception(const std::string& option)
-    : OptionParseException("Option " + LQUOTE + option + RQUOTE + " is missing an argument")
+  explicit missing_argument(const std::string& option)
+    : parsing("Option " + LQUOTE + option + RQUOTE + " is missing an argument")
   {
   }
 };
 
-class option_requires_argument_exception : public OptionParseException {
+class option_requires_argument : public parsing {
  public:
-  option_requires_argument_exception(const std::string& option)
-    : OptionParseException("Option " + LQUOTE + option + RQUOTE + " requires an argument")
+  explicit option_requires_argument(const std::string& option)
+    : parsing("Option " + LQUOTE + option + RQUOTE + " requires an argument")
   {
   }
 };
 
-class option_not_has_argument_exception : public OptionParseException {
+class gratuitous_argument_for_option : public parsing {
  public:
-  option_not_has_argument_exception(const std::string& option, const std::string& arg)
-    : OptionParseException("Option " + LQUOTE + option + RQUOTE +
-                           " does not take an argument, but argument " + LQUOTE + arg + RQUOTE +
-                           " given")
+  gratuitous_argument_for_option(const std::string& option, const std::string& arg)
+    : parsing("Option " + LQUOTE + option + RQUOTE + " does not take an argument, but argument " +
+              LQUOTE + arg + RQUOTE + " given")
   {
   }
 };
 
-class option_not_present_exception : public OptionParseException {
+class requested_option_not_present : public parsing {
  public:
-  option_not_present_exception(const std::string& option)
-    : OptionParseException("Option " + LQUOTE + option + RQUOTE + " not present")
+  explicit requested_option_not_present(const std::string& option)
+    : parsing("Option " + LQUOTE + option + RQUOTE + " not present")
   {
   }
 };
 
-class argument_incorrect_type : public OptionParseException {
+class option_has_no_value : public exception {
  public:
-  argument_incorrect_type(const std::string& arg)
-    : OptionParseException("Argument " + LQUOTE + arg + RQUOTE + " failed to parse")
+  explicit option_has_no_value(const std::string& option)
+    : exception(!option.empty() ? ("Option " + LQUOTE + option + RQUOTE + " has no value")
+                                : "Option has no value")
   {
   }
 };
 
-class option_required_exception : public OptionParseException {
+class incorrect_argument_type : public parsing {
  public:
-  option_required_exception(const std::string& option)
-    : OptionParseException("Option " + LQUOTE + option + RQUOTE + " is required but not present")
+  explicit incorrect_argument_type(const std::string& arg)
+    : parsing("Argument " + LQUOTE + arg + RQUOTE + " failed to parse")
   {
   }
 };
 
+}  // namespace exceptions
+
 template <typename T>
 void throw_or_mimic(const std::string& text)
 {
@@ -321,22 +438,259 @@ void throw_or_mimic(const std::string& text)
   throw T{text};
 #else
   // Otherwise manually instantiate the exception, print what() to stderr,
-  // and abort
+  // and exit
   T exception{text};
   std::cerr << exception.what() << std::endl;
-  std::cerr << "Aborting (exceptions disabled)..." << std::endl;
-  std::abort();
+  std::exit(EXIT_FAILURE);
 #endif
 }
 
+using OptionNames = std::vector<std::string>;
+
 namespace values {
+
+namespace parser_tool {
+
+struct IntegerDesc {
+  std::string negative = "";
+  std::string base     = "";
+  std::string value    = "";
+};
+struct ArguDesc {
+  std::string arg_name = "";
+  bool grouping        = false;
+  bool set_value       = false;
+  std::string value    = "";
+};
+
+#ifdef CXXOPTS_NO_REGEX
+inline IntegerDesc SplitInteger(const std::string& text)
+{
+  if (text.empty()) { throw_or_mimic<exceptions::incorrect_argument_type>(text); }
+  IntegerDesc desc;
+  const char* pdata = text.c_str();
+  if (*pdata == '-') {
+    pdata += 1;
+    desc.negative = "-";
+  }
+  if (strncmp(pdata, "0x", 2) == 0) {
+    pdata += 2;
+    desc.base = "0x";
+  }
+  if (*pdata != '\0') {
+    desc.value = std::string(pdata);
+  } else {
+    throw_or_mimic<exceptions::incorrect_argument_type>(text);
+  }
+  return desc;
+}
+
+inline bool IsTrueText(const std::string& text)
+{
+  const char* pdata = text.c_str();
+  if (*pdata == 't' || *pdata == 'T') {
+    pdata += 1;
+    if (strncmp(pdata, "rue\0", 4) == 0) { return true; }
+  } else if (strncmp(pdata, "1\0", 2) == 0) {
+    return true;
+  }
+  return false;
+}
+
+inline bool IsFalseText(const std::string& text)
+{
+  const char* pdata = text.c_str();
+  if (*pdata == 'f' || *pdata == 'F') {
+    pdata += 1;
+    if (strncmp(pdata, "alse\0", 5) == 0) { return true; }
+  } else if (strncmp(pdata, "0\0", 2) == 0) {
+    return true;
+  }
+  return false;
+}
+
+inline OptionNames split_option_names(const std::string& text)
+{
+  OptionNames split_names;
+
+  std::string::size_type token_start_pos = 0;
+  auto length                            = text.length();
+
+  if (length == 0) { throw_or_mimic<exceptions::invalid_option_format>(text); }
+
+  while (token_start_pos < length) {
+    const auto& npos        = std::string::npos;
+    auto next_non_space_pos = text.find_first_not_of(' ', token_start_pos);
+    if (next_non_space_pos == npos) { throw_or_mimic<exceptions::invalid_option_format>(text); }
+    token_start_pos         = next_non_space_pos;
+    auto next_delimiter_pos = text.find(',', token_start_pos);
+    if (next_delimiter_pos == token_start_pos) {
+      throw_or_mimic<exceptions::invalid_option_format>(text);
+    }
+    if (next_delimiter_pos == npos) { next_delimiter_pos = length; }
+    auto token_length = next_delimiter_pos - token_start_pos;
+    // validate the token itself matches the regex /([:alnum:][-_[:alnum:]]*/
+    {
+      const char* option_name_valid_chars =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz"
+        "0123456789"
+        "_-.?";
+
+      if (!std::isalnum(text[token_start_pos], std::locale::classic()) ||
+          text.find_first_not_of(option_name_valid_chars, token_start_pos) < next_delimiter_pos) {
+        throw_or_mimic<exceptions::invalid_option_format>(text);
+      }
+    }
+    split_names.emplace_back(text.substr(token_start_pos, token_length));
+    token_start_pos = next_delimiter_pos + 1;
+  }
+  return split_names;
+}
+
+inline ArguDesc ParseArgument(const char* arg, bool& matched)
+{
+  ArguDesc argu_desc;
+  const char* pdata = arg;
+  matched           = false;
+  if (strncmp(pdata, "--", 2) == 0) {
+    pdata += 2;
+    if (isalnum(*pdata, std::locale::classic())) {
+      argu_desc.arg_name.push_back(*pdata);
+      pdata += 1;
+      while (isalnum(*pdata, std::locale::classic()) || *pdata == '-' || *pdata == '_') {
+        argu_desc.arg_name.push_back(*pdata);
+        pdata += 1;
+      }
+      if (argu_desc.arg_name.length() > 1) {
+        if (*pdata == '=') {
+          argu_desc.set_value = true;
+          pdata += 1;
+          if (*pdata != '\0') { argu_desc.value = std::string(pdata); }
+          matched = true;
+        } else if (*pdata == '\0') {
+          matched = true;
+        }
+      }
+    }
+  } else if (strncmp(pdata, "-", 1) == 0) {
+    pdata += 1;
+    argu_desc.grouping = true;
+    while (isalnum(*pdata, std::locale::classic())) {
+      argu_desc.arg_name.push_back(*pdata);
+      pdata += 1;
+    }
+    matched = !argu_desc.arg_name.empty() && *pdata == '\0';
+  }
+  return argu_desc;
+}
+
+#else  // CXXOPTS_NO_REGEX
+
 namespace {
-std::basic_regex<char> integer_pattern("(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)");
-std::basic_regex<char> truthy_pattern("(t|T)(rue)?|1");
-std::basic_regex<char> falsy_pattern("(f|F)(alse)?|0");
+CXXOPTS_LINKONCE
+const char* const integer_pattern = "(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)";
+CXXOPTS_LINKONCE
+const char* const truthy_pattern = "(t|T)(rue)?|1";
+CXXOPTS_LINKONCE
+const char* const falsy_pattern = "(f|F)(alse)?|0";
+CXXOPTS_LINKONCE
+const char* const option_pattern = "--([[:alnum:]][-_[:alnum:]\\.]+)(=(.*))?|-([[:alnum:]].*)";
+CXXOPTS_LINKONCE
+const char* const option_specifier_pattern =
+  "([[:alnum:]][-_[:alnum:]\\.]*)(,[ ]*[[:alnum:]][-_[:alnum:]]*)*";
+CXXOPTS_LINKONCE
+const char* const option_specifier_separator_pattern = ", *";
+
 }  // namespace
 
+inline IntegerDesc SplitInteger(const std::string& text)
+{
+  static const std::basic_regex<char> integer_matcher(integer_pattern);
+
+  std::smatch match;
+  std::regex_match(text, match, integer_matcher);
+
+  if (match.length() == 0) { throw_or_mimic<exceptions::incorrect_argument_type>(text); }
+
+  IntegerDesc desc;
+  desc.negative = match[1];
+  desc.base     = match[2];
+  desc.value    = match[3];
+
+  if (match.length(4) > 0) {
+    desc.base  = match[5];
+    desc.value = "0";
+    return desc;
+  }
+
+  return desc;
+}
+
+inline bool IsTrueText(const std::string& text)
+{
+  static const std::basic_regex<char> truthy_matcher(truthy_pattern);
+  std::smatch result;
+  std::regex_match(text, result, truthy_matcher);
+  return !result.empty();
+}
+
+inline bool IsFalseText(const std::string& text)
+{
+  static const std::basic_regex<char> falsy_matcher(falsy_pattern);
+  std::smatch result;
+  std::regex_match(text, result, falsy_matcher);
+  return !result.empty();
+}
+
+// Gets the option names specified via a single, comma-separated string,
+// and returns the separate, space-discarded, non-empty names
+// (without considering which or how many are single-character)
+inline OptionNames split_option_names(const std::string& text)
+{
+  static const std::basic_regex<char> option_specifier_matcher(option_specifier_pattern);
+  if (!std::regex_match(text.c_str(), option_specifier_matcher)) {
+    throw_or_mimic<exceptions::invalid_option_format>(text);
+  }
+
+  OptionNames split_names;
+
+  static const std::basic_regex<char> option_specifier_separator_matcher(
+    option_specifier_separator_pattern);
+  constexpr int use_non_matches{-1};
+  auto token_iterator = std::sregex_token_iterator(
+    text.begin(), text.end(), option_specifier_separator_matcher, use_non_matches);
+  std::copy(token_iterator, std::sregex_token_iterator(), std::back_inserter(split_names));
+  return split_names;
+}
+
+inline ArguDesc ParseArgument(const char* arg, bool& matched)
+{
+  static const std::basic_regex<char> option_matcher(option_pattern);
+  std::match_results<const char*> result;
+  std::regex_match(arg, result, option_matcher);
+  matched = !result.empty();
+
+  ArguDesc argu_desc;
+  if (matched) {
+    argu_desc.arg_name  = result[1].str();
+    argu_desc.set_value = result[2].length() > 0;
+    argu_desc.value     = result[3].str();
+    if (result[4].length() > 0) {
+      argu_desc.grouping = true;
+      argu_desc.arg_name = result[4].str();
+    }
+  }
+
+  return argu_desc;
+}
+
+#endif  // CXXOPTS_NO_REGEX
+#undef CXXOPTS_NO_REGEX
+}  // namespace parser_tool
+
 namespace detail {
+
 template <typename T, bool B>
 struct SignedCheck;
 
@@ -347,11 +701,11 @@ struct SignedCheck<T, true> {
   {
     if (negative) {
       if (u > static_cast<U>((std::numeric_limits<T>::min)())) {
-        throw_or_mimic<argument_incorrect_type>(text);
+        throw_or_mimic<exceptions::incorrect_argument_type>(text);
       }
     } else {
       if (u > static_cast<U>((std::numeric_limits<T>::max)())) {
-        throw_or_mimic<argument_incorrect_type>(text);
+        throw_or_mimic<exceptions::incorrect_argument_type>(text);
       }
     }
   }
@@ -360,7 +714,7 @@ struct SignedCheck<T, true> {
 template <typename T>
 struct SignedCheck<T, false> {
   template <typename U>
-  void operator()(bool, U, const std::string&)
+  void operator()(bool, U, const std::string&) const
   {
   }
 };
@@ -370,70 +724,72 @@ void check_signed_range(bool negative, U value, const std::string& text)
 {
   SignedCheck<T, std::numeric_limits<T>::is_signed>()(negative, value, text);
 }
+
 }  // namespace detail
 
 template <typename R, typename T>
-R checked_negate(T&& t, const std::string&, std::true_type)
+void checked_negate(R& r, T&& t, const std::string&, std::true_type)
 {
   // if we got to here, then `t` is a positive number that fits into
   // `R`. So to avoid MSVC C4146, we first cast it to `R`.
   // See https://github.com/jarro2783/cxxopts/issues/62 for more details.
-  return static_cast<R>(-static_cast<R>(t - 1) - 1);
+  r = static_cast<R>(-static_cast<R>(t - 1) - 1);
 }
 
 template <typename R, typename T>
-T checked_negate(T&& t, const std::string& text, std::false_type)
+void checked_negate(R&, T&&, const std::string& text, std::false_type)
 {
-  throw_or_mimic<argument_incorrect_type>(text);
-  return t;
+  throw_or_mimic<exceptions::incorrect_argument_type>(text);
 }
 
 template <typename T>
 void integer_parser(const std::string& text, T& value)
 {
-  std::smatch match;
-  std::regex_match(text, match, integer_pattern);
-
-  if (match.length() == 0) { throw_or_mimic<argument_incorrect_type>(text); }
-
-  if (match.length(4) > 0) {
-    value = 0;
-    return;
-  }
-
-  using US = typename std::make_unsigned<T>::type;
+  parser_tool::IntegerDesc int_desc = parser_tool::SplitInteger(text);
 
+  using US                 = typename std::make_unsigned<T>::type;
   constexpr bool is_signed = std::numeric_limits<T>::is_signed;
-  const bool negative      = match.length(1) > 0;
-  const uint8_t base       = match.length(2) > 0 ? 16 : 10;
 
-  auto value_match = match[3];
+  const bool negative            = int_desc.negative.length() > 0;
+  const uint8_t base             = int_desc.base.length() > 0 ? 16 : 10;
+  const std::string& value_match = int_desc.value;
 
   US result = 0;
 
-  for (auto iter = value_match.first; iter != value_match.second; ++iter) {
+  for (char ch : value_match) {
     US digit = 0;
 
-    if (*iter >= '0' && *iter <= '9') {
-      digit = static_cast<US>(*iter - '0');
-    } else if (base == 16 && *iter >= 'a' && *iter <= 'f') {
-      digit = static_cast<US>(*iter - 'a' + 10);
-    } else if (base == 16 && *iter >= 'A' && *iter <= 'F') {
-      digit = static_cast<US>(*iter - 'A' + 10);
+    if (ch >= '0' && ch <= '9') {
+      digit = static_cast<US>(ch - '0');
+    } else if (base == 16 && ch >= 'a' && ch <= 'f') {
+      digit = static_cast<US>(ch - 'a' + 10);
+    } else if (base == 16 && ch >= 'A' && ch <= 'F') {
+      digit = static_cast<US>(ch - 'A' + 10);
     } else {
-      throw_or_mimic<argument_incorrect_type>(text);
+      throw_or_mimic<exceptions::incorrect_argument_type>(text);
     }
 
-    const US next = static_cast<US>(result * base + digit);
-    if (result > next) { throw_or_mimic<argument_incorrect_type>(text); }
+    US limit = 0;
+    if (negative) {
+      limit = static_cast<US>(std::abs(static_cast<intmax_t>((std::numeric_limits<T>::min)())));
+    } else {
+      limit = (std::numeric_limits<T>::max)();
+    }
+
+    if (base != 0 && result > limit / base) {
+      throw_or_mimic<exceptions::incorrect_argument_type>(text);
+    }
+    if (result * base > limit - digit) {
+      throw_or_mimic<exceptions::incorrect_argument_type>(text);
+    }
 
-    result = next;
+    result = static_cast<US>(result * base + digit);
   }
 
   detail::check_signed_range<T>(negative, result, text);
 
   if (negative) {
-    value = checked_negate<T>(result, text, std::integral_constant<bool, is_signed>());
+    checked_negate<T>(value, result, text, std::integral_constant<bool, is_signed>());
   } else {
     value = static_cast<T>(result);
   }
@@ -444,42 +800,28 @@ void stringstream_parser(const std::string& text, T& value)
 {
   std::stringstream in(text);
   in >> value;
-  if (!in) { throw_or_mimic<argument_incorrect_type>(text); }
+  if (!in) { throw_or_mimic<exceptions::incorrect_argument_type>(text); }
 }
 
-inline void parse_value(const std::string& text, uint8_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, int8_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, uint16_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, int16_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, uint32_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, int32_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, uint64_t& value) { integer_parser(text, value); }
-
-inline void parse_value(const std::string& text, int64_t& value) { integer_parser(text, value); }
+template <typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+void parse_value(const std::string& text, T& value)
+{
+  integer_parser(text, value);
+}
 
 inline void parse_value(const std::string& text, bool& value)
 {
-  std::smatch result;
-  std::regex_match(text, result, truthy_pattern);
-
-  if (!result.empty()) {
+  if (parser_tool::IsTrueText(text)) {
     value = true;
     return;
   }
 
-  std::regex_match(text, result, falsy_pattern);
-  if (!result.empty()) {
+  if (parser_tool::IsFalseText(text)) {
     value = false;
     return;
   }
 
-  throw_or_mimic<argument_incorrect_type>(text);
+  throw_or_mimic<exceptions::incorrect_argument_type>(text);
 }
 
 inline void parse_value(const std::string& text, std::string& value) { value = text; }
@@ -487,29 +829,66 @@ inline void parse_value(const std::string& text, std::string& value) { value = t
 // The fallback parser. It uses the stringstream parser to parse all types
 // that have not been overloaded explicitly.  It has to be placed in the
 // source code before all other more specialized templates.
-template <typename T>
+template <typename T, typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr>
 void parse_value(const std::string& text, T& value)
 {
   stringstream_parser(text, value);
 }
 
+#ifdef CXXOPTS_HAS_OPTIONAL
+template <typename T>
+void parse_value(const std::string& text, std::optional<T>& value)
+{
+  T result;
+  parse_value(text, result);
+  value = std::move(result);
+}
+#endif
+
+#ifdef CXXOPTS_HAS_FILESYSTEM
+inline void parse_value(const std::string& text, std::filesystem::path& value)
+{
+  value.assign(text);
+}
+#endif
+
+inline void parse_value(const std::string& text, char& c)
+{
+  if (text.length() != 1) { throw_or_mimic<exceptions::incorrect_argument_type>(text); }
+
+  c = text[0];
+}
+
 template <typename T>
 void parse_value(const std::string& text, std::vector<T>& value)
 {
+  if (text.empty()) {
+    T v;
+    parse_value(text, v);
+    value.emplace_back(std::move(v));
+    return;
+  }
   std::stringstream in(text);
   std::string token;
-  while (in.eof() == false && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) {
+  while (!in.eof() && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) {
     T v;
     parse_value(token, v);
     value.emplace_back(std::move(v));
   }
 }
 
-inline void parse_value(const std::string& text, char& c)
+template <typename T>
+void add_value(const std::string& text, T& value)
 {
-  if (text.length() != 1) { throw_or_mimic<argument_incorrect_type>(text); }
+  parse_value(text, value);
+}
 
-  c = text[0];
+template <typename T>
+void add_value(const std::string& text, std::vector<T>& value)
+{
+  T v;
+  add_value(text, v);
+  value.emplace_back(std::move(v));
 }
 
 template <typename T>
@@ -529,9 +908,11 @@ class abstract_value : public Value {
  public:
   abstract_value() : m_result(std::make_shared<T>()), m_store(m_result.get()) {}
 
-  abstract_value(T* t) : m_store(t) {}
+  explicit abstract_value(T* t) : m_store(t) {}
+
+  ~abstract_value() override = default;
 
-  virtual ~abstract_value() = default;
+  abstract_value& operator=(const abstract_value&) = default;
 
   abstract_value(const abstract_value& rhs)
   {
@@ -548,60 +929,59 @@ class abstract_value : public Value {
     m_implicit_value = rhs.m_implicit_value;
   }
 
-  void parse(const std::string& text) const { parse_value(text, *m_store); }
+  void add(const std::string& text) const override { add_value(text, *m_store); }
 
-  bool is_container() const { return type_is_container<T>::value; }
+  void parse(const std::string& text) const override { parse_value(text, *m_store); }
 
-  void parse() const { parse_value(m_default_value, *m_store); }
+  bool is_container() const override { return type_is_container<T>::value; }
 
-  bool has_default() const { return m_default; }
+  void parse() const override { parse_value(m_default_value, *m_store); }
 
-  bool has_implicit() const { return m_implicit; }
+  bool has_default() const override { return m_default; }
 
-  std::shared_ptr<Value> default_value(const std::string& value)
+  bool has_implicit() const override { return m_implicit; }
+
+  std::shared_ptr<Value> default_value(const std::string& value) override
   {
     m_default       = true;
     m_default_value = value;
     return shared_from_this();
   }
 
-  std::shared_ptr<Value> implicit_value(const std::string& value)
+  std::shared_ptr<Value> implicit_value(const std::string& value) override
   {
     m_implicit       = true;
     m_implicit_value = value;
     return shared_from_this();
   }
 
-  std::shared_ptr<Value> no_implicit_value()
+  std::shared_ptr<Value> no_implicit_value() override
   {
     m_implicit = false;
     return shared_from_this();
   }
 
-  std::string get_default_value() const { return m_default_value; }
+  std::string get_default_value() const override { return m_default_value; }
 
-  std::string get_implicit_value() const { return m_implicit_value; }
+  std::string get_implicit_value() const override { return m_implicit_value; }
 
-  bool is_boolean() const { return std::is_same<T, bool>::value; }
+  bool is_boolean() const override { return std::is_same<T, bool>::value; }
 
   const T& get() const
   {
-    if (m_store == nullptr) {
-      return *m_result;
-    } else {
-      return *m_store;
-    }
+    if (m_store == nullptr) { return *m_result; }
+    return *m_store;
   }
 
  protected:
-  std::shared_ptr<T> m_result;
-  T* m_store;
+  std::shared_ptr<T> m_result{};
+  T* m_store{};
 
   bool m_default  = false;
   bool m_implicit = false;
 
-  std::string m_default_value;
-  std::string m_implicit_value;
+  std::string m_default_value{};
+  std::string m_implicit_value{};
 };
 
 template <typename T>
@@ -609,19 +989,30 @@ class standard_value : public abstract_value<T> {
  public:
   using abstract_value<T>::abstract_value;
 
-  std::shared_ptr<Value> clone() const { return std::make_shared<standard_value<T>>(*this); }
+  CXXOPTS_NODISCARD
+  std::shared_ptr<Value> clone() const override
+  {
+    return std::make_shared<standard_value<T>>(*this);
+  }
 };
 
 template <>
 class standard_value<bool> : public abstract_value<bool> {
  public:
-  ~standard_value() = default;
+  ~standard_value() override = default;
 
   standard_value() { set_default_and_implicit(); }
 
-  standard_value(bool* b) : abstract_value(b) { set_default_and_implicit(); }
+  explicit standard_value(bool* b) : abstract_value(b)
+  {
+    m_implicit       = true;
+    m_implicit_value = "true";
+  }
 
-  std::shared_ptr<Value> clone() const { return std::make_shared<standard_value<bool>>(*this); }
+  std::shared_ptr<Value> clone() const override
+  {
+    return std::make_shared<standard_value<bool>>(*this);
+  }
 
  private:
   void set_default_and_implicit()
@@ -632,6 +1023,7 @@ class standard_value<bool> : public abstract_value<bool> {
     m_implicit_value = "true";
   }
 };
+
 }  // namespace values
 
 template <typename T>
@@ -648,44 +1040,71 @@ std::shared_ptr<Value> value(T& t)
 
 class OptionAdder;
 
+CXXOPTS_NODISCARD
+inline const std::string& first_or_empty(const OptionNames& long_names)
+{
+  static const std::string empty{""};
+  return long_names.empty() ? empty : long_names.front();
+}
+
 class OptionDetails {
  public:
-  OptionDetails(const std::string& short_,
-                const std::string& long_,
-                const String& desc,
+  OptionDetails(std::string short_,
+                OptionNames long_,
+                String desc,
                 std::shared_ptr<const Value> val)
-    : m_short(short_), m_long(long_), m_desc(desc), m_value(val), m_count(0)
+    : m_short(std::move(short_)),
+      m_long(std::move(long_)),
+      m_desc(std::move(desc)),
+      m_value(std::move(val)),
+      m_count(0)
   {
+    m_hash = std::hash<std::string>{}(first_long_name() + m_short);
   }
 
-  OptionDetails(const OptionDetails& rhs) : m_desc(rhs.m_desc), m_count(rhs.m_count)
+  OptionDetails(const OptionDetails& rhs)
+    : m_desc(rhs.m_desc), m_value(rhs.m_value->clone()), m_count(rhs.m_count)
   {
-    m_value = rhs.m_value->clone();
   }
 
   OptionDetails(OptionDetails&& rhs) = default;
 
+  CXXOPTS_NODISCARD
   const String& description() const { return m_desc; }
 
+  CXXOPTS_NODISCARD
   const Value& value() const { return *m_value; }
 
+  CXXOPTS_NODISCARD
   std::shared_ptr<Value> make_storage() const { return m_value->clone(); }
 
+  CXXOPTS_NODISCARD
   const std::string& short_name() const { return m_short; }
 
-  const std::string& long_name() const { return m_long; }
+  CXXOPTS_NODISCARD
+  const std::string& first_long_name() const { return first_or_empty(m_long); }
+
+  CXXOPTS_NODISCARD
+  const std::string& essential_name() const { return m_long.empty() ? m_short : m_long.front(); }
+
+  CXXOPTS_NODISCARD
+  const OptionNames& long_names() const { return m_long; }
+
+  std::size_t hash() const { return m_hash; }
 
  private:
-  std::string m_short;
-  std::string m_long;
-  String m_desc;
-  std::shared_ptr<const Value> m_value;
+  std::string m_short{};
+  OptionNames m_long{};
+  String m_desc{};
+  std::shared_ptr<const Value> m_value{};
   int m_count;
+
+  std::size_t m_hash{};
 };
 
 struct HelpOptionDetails {
   std::string s;
-  std::string l;
+  OptionNames l;
   String desc;
   bool has_default;
   std::string default_value;
@@ -697,64 +1116,103 @@ struct HelpOptionDetails {
 };
 
 struct HelpGroupDetails {
-  std::string name;
-  std::string description;
-  std::vector<HelpOptionDetails> options;
+  std::string name{};
+  std::string description{};
+  std::vector<HelpOptionDetails> options{};
 };
 
 class OptionValue {
  public:
-  void parse(std::shared_ptr<const OptionDetails> details, const std::string& text)
+  void add(const std::shared_ptr<const OptionDetails>& details, const std::string& text)
+  {
+    ensure_value(details);
+    ++m_count;
+    m_value->add(text);
+    m_long_names = &details->long_names();
+  }
+
+  void parse(const std::shared_ptr<const OptionDetails>& details, const std::string& text)
   {
     ensure_value(details);
     ++m_count;
     m_value->parse(text);
+    m_long_names = &details->long_names();
   }
 
-  void parse_default(std::shared_ptr<const OptionDetails> details)
+  void parse_default(const std::shared_ptr<const OptionDetails>& details)
   {
     ensure_value(details);
-    m_default = true;
+    m_default    = true;
+    m_long_names = &details->long_names();
     m_value->parse();
   }
 
-  size_t count() const noexcept { return m_count; }
+  void parse_no_value(const std::shared_ptr<const OptionDetails>& details)
+  {
+    m_long_names = &details->long_names();
+  }
+
+#if defined(CXXOPTS_NULL_DEREF_IGNORE)
+  CXXOPTS_DIAGNOSTIC_PUSH
+  CXXOPTS_IGNORE_WARNING("-Wnull-dereference")
+#endif
+
+  CXXOPTS_NODISCARD
+  std::size_t count() const noexcept { return m_count; }
+
+#if defined(CXXOPTS_NULL_DEREF_IGNORE)
+  CXXOPTS_DIAGNOSTIC_POP
+#endif
 
   // TODO: maybe default options should count towards the number of arguments
+  CXXOPTS_NODISCARD
   bool has_default() const noexcept { return m_default; }
 
   template <typename T>
   const T& as() const
   {
-    if (m_value == nullptr) { throw_or_mimic<std::domain_error>("No value"); }
+    if (m_value == nullptr) {
+      throw_or_mimic<exceptions::option_has_no_value>(
+        m_long_names == nullptr ? "" : first_or_empty(*m_long_names));
+    }
 
-#ifdef CXXOPTS_NO_RTTI
-    return static_cast<const values::standard_value<T>&>(*m_value).get();
-#else
-    return dynamic_cast<const values::standard_value<T>&>(*m_value).get();
-#endif
+    return CXXOPTS_RTTI_CAST<const values::standard_value<T>&>(*m_value).get();
+  }
+
+#ifdef CXXOPTS_HAS_OPTIONAL
+  template <typename T>
+  std::optional<T> as_optional() const
+  {
+    if (m_value == nullptr) { return std::nullopt; }
+    return as<T>();
   }
+#endif
 
  private:
-  void ensure_value(std::shared_ptr<const OptionDetails> details)
+  void ensure_value(const std::shared_ptr<const OptionDetails>& details)
   {
     if (m_value == nullptr) { m_value = details->make_storage(); }
   }
 
-  std::shared_ptr<Value> m_value;
-  size_t m_count = 0;
-  bool m_default = false;
+  const OptionNames* m_long_names = nullptr;
+  // Holding this pointer is safe, since OptionValue's only exist in key-value pairs,
+  // where the key has the string we point to.
+  std::shared_ptr<Value> m_value{};
+  std::size_t m_count = 0;
+  bool m_default      = false;
 };
 
 class KeyValue {
  public:
-  KeyValue(std::string key_, std::string value_)
+  KeyValue(std::string key_, std::string value_) noexcept
     : m_key(std::move(key_)), m_value(std::move(value_))
   {
   }
 
+  CXXOPTS_NODISCARD
   const std::string& key() const { return m_key; }
 
+  CXXOPTS_NODISCARD
   const std::string& value() const { return m_value; }
 
   template <typename T>
@@ -770,74 +1228,178 @@ class KeyValue {
   std::string m_value;
 };
 
+using ParsedHashMap = std::unordered_map<std::size_t, OptionValue>;
+using NameHashMap   = std::unordered_map<std::string, std::size_t>;
+
 class ParseResult {
  public:
-  ParseResult(
-    const std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<OptionDetails>>>,
-    std::vector<std::string>,
-    bool allow_unrecognised,
-    int&,
-    char**&);
-
-  size_t count(const std::string& o) const
-  {
-    auto iter = m_options->find(o);
-    if (iter == m_options->end()) { return 0; }
+  class Iterator {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type        = KeyValue;
+    using difference_type   = void;
+    using pointer           = const KeyValue*;
+    using reference         = const KeyValue&;
+
+    Iterator()                = default;
+    Iterator(const Iterator&) = default;
+
+    // GCC complains about m_iter not being initialised in the member
+    // initializer list
+    CXXOPTS_DIAGNOSTIC_PUSH
+    CXXOPTS_IGNORE_WARNING("-Weffc++")
+    Iterator(const ParseResult* pr, bool end = false) : m_pr(pr)
+    {
+      if (end) {
+        m_sequential = false;
+        m_iter       = m_pr->m_defaults.end();
+      } else {
+        m_sequential = true;
+        m_iter       = m_pr->m_sequential.begin();
+
+        if (m_iter == m_pr->m_sequential.end()) {
+          m_sequential = false;
+          m_iter       = m_pr->m_defaults.begin();
+        }
+      }
+    }
+    CXXOPTS_DIAGNOSTIC_POP
+
+    Iterator& operator++()
+    {
+      ++m_iter;
+      if (m_sequential && m_iter == m_pr->m_sequential.end()) {
+        m_sequential = false;
+        m_iter       = m_pr->m_defaults.begin();
+        return *this;
+      }
+      return *this;
+    }
+
+    Iterator operator++(int)
+    {
+      Iterator retval = *this;
+      ++(*this);
+      return retval;
+    }
+
+    bool operator==(const Iterator& other) const
+    {
+      return (m_sequential == other.m_sequential) && (m_iter == other.m_iter);
+    }
+
+    bool operator!=(const Iterator& other) const { return !(*this == other); }
+
+    const KeyValue& operator*() { return *m_iter; }
 
-    auto riter = m_results.find(iter->second);
+    const KeyValue* operator->() { return m_iter.operator->(); }
 
-    return riter->second.count();
+   private:
+    const ParseResult* m_pr;
+    std::vector<KeyValue>::const_iterator m_iter;
+    bool m_sequential = true;
+  };
+
+  ParseResult()                   = default;
+  ParseResult(const ParseResult&) = default;
+
+  ParseResult(NameHashMap&& keys,
+              ParsedHashMap&& values,
+              std::vector<KeyValue> sequential,
+              std::vector<KeyValue> default_opts,
+              std::vector<std::string>&& unmatched_args)
+    : m_keys(std::move(keys)),
+      m_values(std::move(values)),
+      m_sequential(std::move(sequential)),
+      m_defaults(std::move(default_opts)),
+      m_unmatched(std::move(unmatched_args))
+  {
   }
 
-  const OptionValue& operator[](const std::string& option) const
+  ParseResult& operator=(ParseResult&&)      = default;
+  ParseResult& operator=(const ParseResult&) = default;
+
+  Iterator begin() const { return Iterator(this); }
+
+  Iterator end() const { return Iterator(this, true); }
+
+  std::size_t count(const std::string& o) const
   {
-    auto iter = m_options->find(option);
+    auto iter = m_keys.find(o);
+    if (iter == m_keys.end()) { return 0; }
 
-    if (iter == m_options->end()) { throw_or_mimic<option_not_present_exception>(option); }
+    auto viter = m_values.find(iter->second);
 
-    auto riter = m_results.find(iter->second);
+    if (viter == m_values.end()) { return 0; }
 
-    return riter->second;
+    return viter->second.count();
   }
 
-  const std::vector<KeyValue>& arguments() const { return m_sequential; }
+  bool contains(const std::string& o) const { return static_cast<bool>(count(o)); }
 
- private:
-  void parse(int& argc, char**& argv);
+  const OptionValue& operator[](const std::string& option) const
+  {
+    auto iter = m_keys.find(option);
 
-  void add_to_option(const std::string& option, const std::string& arg);
+    if (iter == m_keys.end()) { throw_or_mimic<exceptions::requested_option_not_present>(option); }
 
-  bool consume_positional(std::string a);
+    auto viter = m_values.find(iter->second);
 
-  void parse_option(std::shared_ptr<OptionDetails> value,
-                    const std::string& name,
-                    const std::string& arg = "");
+    if (viter == m_values.end()) {
+      throw_or_mimic<exceptions::requested_option_not_present>(option);
+    }
+
+    return viter->second;
+  }
+
+#ifdef CXXOPTS_HAS_OPTIONAL
+  template <typename T>
+  std::optional<T> as_optional(const std::string& option) const
+  {
+    auto iter = m_keys.find(option);
+    if (iter != m_keys.end()) {
+      auto viter = m_values.find(iter->second);
+      if (viter != m_values.end()) { return viter->second.as_optional<T>(); }
+    }
+    return std::nullopt;
+  }
+#endif
 
-  void parse_default(std::shared_ptr<OptionDetails> details);
+  const std::vector<KeyValue>& arguments() const { return m_sequential; }
 
-  void checked_parse_arg(int argc,
-                         char* argv[],
-                         int& current,
-                         std::shared_ptr<OptionDetails> value,
-                         const std::string& name);
+  const std::vector<std::string>& unmatched() const { return m_unmatched; }
 
-  const std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<OptionDetails>>> m_options;
-  std::vector<std::string> m_positional;
-  std::vector<std::string>::iterator m_next_positional;
-  std::unordered_set<std::string> m_positional_set;
-  std::unordered_map<std::shared_ptr<OptionDetails>, OptionValue> m_results;
+  const std::vector<KeyValue>& defaults() const { return m_defaults; }
 
-  bool m_allow_unrecognised;
+  const std::string arguments_string() const
+  {
+    std::string result;
+    for (const auto& kv : m_sequential) {
+      result += kv.key() + " = " + kv.value() + "\n";
+    }
+    for (const auto& kv : m_defaults) {
+      result += kv.key() + " = " + kv.value() + " " + "(default)" + "\n";
+    }
+    return result;
+  }
 
-  std::vector<KeyValue> m_sequential;
+ private:
+  NameHashMap m_keys{};
+  ParsedHashMap m_values{};
+  std::vector<KeyValue> m_sequential{};
+  std::vector<KeyValue> m_defaults{};
+  std::vector<std::string> m_unmatched{};
 };
 
 struct Option {
-  Option(const std::string& opts,
-         const std::string& desc,
-         const std::shared_ptr<const Value>& value = ::cxxopts::value<bool>(),
-         const std::string& arg_help               = "")
-    : opts_(opts), desc_(desc), value_(value), arg_help_(arg_help)
+  Option(std::string opts,
+         std::string desc,
+         std::shared_ptr<const Value> value = ::cxxopts::value<bool>(),
+         std::string arg_help               = "")
+    : opts_(std::move(opts)),
+      desc_(std::move(desc)),
+      value_(std::move(value)),
+      arg_help_(std::move(arg_help))
   {
   }
 
@@ -847,19 +1409,63 @@ struct Option {
   std::string arg_help_;
 };
 
-class Options {
-  typedef std::unordered_map<std::string, std::shared_ptr<OptionDetails>> OptionMap;
+using OptionMap              = std::unordered_map<std::string, std::shared_ptr<OptionDetails>>;
+using PositionalList         = std::vector<std::string>;
+using PositionalListIterator = PositionalList::const_iterator;
 
+class OptionParser {
  public:
-  Options(std::string program, std::string help_string = "")
-    : m_program(std::move(program)),
+  OptionParser(const OptionMap& options, const PositionalList& positional, bool allow_unrecognised)
+    : m_options(options), m_positional(positional), m_allow_unrecognised(allow_unrecognised)
+  {
+  }
+
+  ParseResult parse(int argc, const char* const* argv);
+
+  bool consume_positional(const std::string& a, PositionalListIterator& next);
+
+  void checked_parse_arg(int argc,
+                         const char* const* argv,
+                         int& current,
+                         const std::shared_ptr<OptionDetails>& value,
+                         const std::string& name);
+
+  void add_to_option(const std::shared_ptr<OptionDetails>& value, const std::string& arg);
+
+  void parse_option(const std::shared_ptr<OptionDetails>& value,
+                    const std::string& name,
+                    const std::string& arg = "");
+
+  void parse_default(const std::shared_ptr<OptionDetails>& details);
+
+  void parse_no_value(const std::shared_ptr<OptionDetails>& details);
+
+ private:
+  void finalise_aliases();
+
+  const OptionMap& m_options;
+  const PositionalList& m_positional;
+
+  std::vector<KeyValue> m_sequential{};
+  std::vector<KeyValue> m_defaults{};
+  bool m_allow_unrecognised;
+
+  ParsedHashMap m_parsed{};
+  NameHashMap m_keys{};
+};
+
+class Options {
+ public:
+  explicit Options(std::string program_name, std::string help_string = "")
+    : m_program(std::move(program_name)),
       m_help_string(toLocalString(std::move(help_string))),
       m_custom_help("[OPTION...]"),
       m_positional_help("positional parameters"),
       m_show_positional(false),
       m_allow_unrecognised(false),
-      m_options(std::make_shared<OptionMap>()),
-      m_next_positional(m_positional.end())
+      m_width(76),
+      m_tab_expansion(false),
+      m_options(std::make_shared<OptionMap>())
   {
   }
 
@@ -887,7 +1493,19 @@ class Options {
     return *this;
   }
 
-  ParseResult parse(int& argc, char**& argv);
+  Options& set_width(std::size_t width)
+  {
+    m_width = width;
+    return *this;
+  }
+
+  Options& set_tab_expansion(bool expansion = true)
+  {
+    m_tab_expansion = expansion;
+    return *this;
+  }
+
+  ParseResult parse(int argc, const char* const* argv);
 
   OptionAdder add_options(std::string group = "");
 
@@ -897,11 +1515,23 @@ class Options {
 
   void add_option(const std::string& group,
                   const std::string& s,
-                  const std::string& l,
+                  const OptionNames& l,
                   std::string desc,
-                  std::shared_ptr<const Value> value,
+                  const std::shared_ptr<const Value>& value,
                   std::string arg_help);
 
+  void add_option(const std::string& group,
+                  const std::string& short_name,
+                  const std::string& single_long_name,
+                  std::string desc,
+                  const std::shared_ptr<const Value>& value,
+                  std::string arg_help)
+  {
+    OptionNames long_names;
+    long_names.emplace_back(single_long_name);
+    add_option(group, short_name, long_names, desc, value, arg_help);
+  }
+
   // parse positional arguments into the given option
   void parse_positional(std::string option);
 
@@ -915,14 +1545,16 @@ class Options {
     parse_positional(std::vector<std::string>{begin, end});
   }
 
-  std::string help(const std::vector<std::string>& groups = {}) const;
+  std::string help(const std::vector<std::string>& groups = {}, bool print_usage = true) const;
 
-  const std::vector<std::string> groups() const;
+  std::vector<std::string> groups() const;
 
   const HelpGroupDetails& group_help(const std::string& group) const;
 
+  const std::string& program() const { return m_program; }
+
  private:
-  void add_one_option(const std::string& option, std::shared_ptr<OptionDetails> details);
+  void add_one_option(const std::string& option, const std::shared_ptr<OptionDetails>& details);
 
   String help_one_group(const std::string& group) const;
 
@@ -930,20 +1562,22 @@ class Options {
 
   void generate_all_groups_help(String& result) const;
 
-  std::string m_program;
-  String m_help_string;
-  std::string m_custom_help;
-  std::string m_positional_help;
+  std::string m_program{};
+  String m_help_string{};
+  std::string m_custom_help{};
+  std::string m_positional_help{};
   bool m_show_positional;
   bool m_allow_unrecognised;
+  std::size_t m_width;
+  bool m_tab_expansion;
 
   std::shared_ptr<OptionMap> m_options;
-  std::vector<std::string> m_positional;
-  std::vector<std::string>::iterator m_next_positional;
-  std::unordered_set<std::string> m_positional_set;
+  std::vector<std::string> m_positional{};
+  std::unordered_set<std::string> m_positional_set{};
 
   // mapping from groups to help options
-  std::map<std::string, HelpGroupDetails> m_help;
+  std::vector<std::string> m_group{};
+  std::map<std::string, HelpGroupDetails> m_help{};
 };
 
 class OptionAdder {
@@ -954,8 +1588,8 @@ class OptionAdder {
 
   OptionAdder& operator()(const std::string& opts,
                           const std::string& desc,
-                          std::shared_ptr<const Value> value = ::cxxopts::value<bool>(),
-                          std::string arg_help               = "");
+                          const std::shared_ptr<const Value>& value = ::cxxopts::value<bool>(),
+                          std::string arg_help                      = "");
 
  private:
   Options& m_options;
@@ -963,29 +1597,26 @@ class OptionAdder {
 };
 
 namespace {
-constexpr int OPTION_LONGEST  = 30;
-constexpr int OPTION_DESC_GAP = 2;
-
-std::basic_regex<char> option_matcher("--([[:alnum:]][-_[:alnum:]]+)(=(.*))?|-([[:alnum:]]+)");
-
-std::basic_regex<char> option_specifier("(([[:alnum:]]),)?[ ]*([[:alnum:]][-_[:alnum:]]*)?");
+constexpr std::size_t OPTION_LONGEST  = 30;
+constexpr std::size_t OPTION_DESC_GAP = 2;
 
 String format_option(const HelpOptionDetails& o)
 {
-  auto& s = o.s;
-  auto& l = o.l;
+  const auto& s = o.s;
+  const auto& l = first_or_empty(o.l);
 
   String result = "  ";
 
-  if (s.size() > 0) {
-    result += "-" + toLocalString(s) + ",";
+  if (!s.empty()) {
+    result += "-" + toLocalString(s);
+    if (!l.empty()) { result += ","; }
   } else {
     result += "   ";
   }
 
-  if (l.size() > 0) { result += " --" + toLocalString(l); }
+  if (!l.empty()) { result += " --" + toLocalString(l); }
 
-  auto arg = o.arg_help.size() > 0 ? toLocalString(o.arg_help) : "arg";
+  auto arg = !o.arg_help.empty() ? toLocalString(o.arg_help) : "arg";
 
   if (!o.is_boolean) {
     if (o.has_implicit) {
@@ -998,12 +1629,15 @@ String format_option(const HelpOptionDetails& o)
   return result;
 }
 
-String format_description(const HelpOptionDetails& o, size_t start, size_t width)
+String format_description(const HelpOptionDetails& o,
+                          std::size_t start,
+                          std::size_t allowed,
+                          bool tab_expansion)
 {
   auto desc = o.desc;
 
   if (o.has_default && (!o.is_boolean || o.default_value != "false")) {
-    if (o.default_value != "") {
+    if (!o.default_value.empty()) {
       desc += toLocalString(" (default: " + o.default_value + ")");
     } else {
       desc += toLocalString(" (default: \"\")");
@@ -1012,60 +1646,83 @@ String format_description(const HelpOptionDetails& o, size_t start, size_t width
 
   String result;
 
+  if (tab_expansion) {
+    String desc2;
+    auto size = std::size_t{0};
+    for (auto c = std::begin(desc); c != std::end(desc); ++c) {
+      if (*c == '\n') {
+        desc2 += *c;
+        size = 0;
+      } else if (*c == '\t') {
+        auto skip = 8 - size % 8;
+        stringAppend(desc2, skip, ' ');
+        size += skip;
+      } else {
+        desc2 += *c;
+        ++size;
+      }
+    }
+    desc = desc2;
+  }
+
+  desc += " ";
+
   auto current   = std::begin(desc);
+  auto previous  = current;
   auto startLine = current;
   auto lastSpace = current;
 
-  auto size = size_t{};
+  auto size = std::size_t{};
+
+  bool appendNewLine;
+  bool onlyWhiteSpace = true;
 
   while (current != std::end(desc)) {
-    if (*current == ' ') { lastSpace = current; }
-
-    if (*current == '\n') {
-      startLine = current + 1;
-      lastSpace = startLine;
-    } else if (size > width) {
-      if (lastSpace == startLine) {
-        stringAppend(result, startLine, current + 1);
-        stringAppend(result, "\n");
-        stringAppend(result, start, ' ');
-        startLine = current + 1;
-        lastSpace = startLine;
-      } else {
-        stringAppend(result, startLine, lastSpace);
-        stringAppend(result, "\n");
-        stringAppend(result, start, ' ');
-        startLine = lastSpace + 1;
-        lastSpace = startLine;
+    appendNewLine = false;
+    if (*previous == ' ' || *previous == '\t') { lastSpace = current; }
+    if (*current != ' ' && *current != '\t') { onlyWhiteSpace = false; }
+
+    while (*current == '\n') {
+      previous = current;
+      ++current;
+      appendNewLine = true;
+    }
+
+    if (!appendNewLine && size >= allowed) {
+      if (lastSpace != startLine) {
+        current  = lastSpace;
+        previous = current;
       }
-      size = 0;
-    } else {
-      ++size;
+      appendNewLine = true;
     }
 
+    if (appendNewLine) {
+      stringAppend(result, startLine, current);
+      startLine = current;
+      lastSpace = current;
+
+      if (*previous != '\n') { stringAppend(result, "\n"); }
+
+      stringAppend(result, start, ' ');
+
+      if (*previous != '\n') { stringAppend(result, lastSpace, current); }
+
+      onlyWhiteSpace = true;
+      size           = 0;
+    }
+
+    previous = current;
     ++current;
+    ++size;
   }
 
-  // append whatever is left
-  stringAppend(result, startLine, current);
+  // append whatever is left but ignore whitespace
+  if (!onlyWhiteSpace) { stringAppend(result, startLine, previous); }
 
   return result;
 }
-}  // namespace
 
-inline ParseResult::ParseResult(
-  const std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<OptionDetails>>> options,
-  std::vector<std::string> positional,
-  bool allow_unrecognised,
-  int& argc,
-  char**& argv)
-  : m_options(options),
-    m_positional(std::move(positional)),
-    m_next_positional(m_positional.begin()),
-    m_allow_unrecognised(allow_unrecognised)
-{
-  parse(argc, argv);
-}
+}  // namespace
 
 inline void Options::add_options(const std::string& group, std::initializer_list<Option> options)
 {
@@ -1082,68 +1739,68 @@ inline OptionAdder Options::add_options(std::string group)
 
 inline OptionAdder& OptionAdder::operator()(const std::string& opts,
                                             const std::string& desc,
-                                            std::shared_ptr<const Value> value,
+                                            const std::shared_ptr<const Value>& value,
                                             std::string arg_help)
 {
-  std::match_results<const char*> result;
-  std::regex_match(opts.c_str(), result, option_specifier);
-
-  if (result.empty()) { throw_or_mimic<invalid_option_format_error>(opts); }
-
-  const auto& short_match = result[2];
-  const auto& long_match  = result[3];
-
-  if (!short_match.length() && !long_match.length()) {
-    throw_or_mimic<invalid_option_format_error>(opts);
-  } else if (long_match.length() == 1 && short_match.length()) {
-    throw_or_mimic<invalid_option_format_error>(opts);
-  }
-
-  auto option_names = [](const std::sub_match<const char*>& short_,
-                         const std::sub_match<const char*>& long_) {
-    if (long_.length() == 1) {
-      return std::make_tuple(long_.str(), short_.str());
-    } else {
-      return std::make_tuple(short_.str(), long_.str());
-    }
-  }(short_match, long_match);
-
-  m_options.add_option(m_group,
-                       std::get<0>(option_names),
-                       std::get<1>(option_names),
-                       desc,
-                       value,
-                       std::move(arg_help));
+  OptionNames option_names = values::parser_tool::split_option_names(opts);
+  // Note: All names will be non-empty; but we must separate the short
+  // (length-1) and longer names
+  std::string short_name{""};
+  auto first_short_name_iter =
+    std::partition(option_names.begin(), option_names.end(), [&](const std::string& name) {
+      return name.length() > 1;
+    });
+  auto num_length_1_names = (option_names.end() - first_short_name_iter);
+  switch (num_length_1_names) {
+    case 1:
+      short_name = *first_short_name_iter;
+      option_names.erase(first_short_name_iter);
+      CXXOPTS_FALLTHROUGH;
+    case 0: break;
+    default: throw_or_mimic<exceptions::invalid_option_format>(opts);
+  };
+
+  m_options.add_option(m_group, short_name, option_names, desc, value, std::move(arg_help));
 
   return *this;
 }
 
-inline void ParseResult::parse_default(std::shared_ptr<OptionDetails> details)
+inline void OptionParser::parse_default(const std::shared_ptr<OptionDetails>& details)
+{
+  // TODO: remove the duplicate code here
+  auto& store = m_parsed[details->hash()];
+  store.parse_default(details);
+  m_defaults.emplace_back(details->essential_name(), details->value().get_default_value());
+}
+
+inline void OptionParser::parse_no_value(const std::shared_ptr<OptionDetails>& details)
 {
-  m_results[details].parse_default(details);
+  auto& store = m_parsed[details->hash()];
+  store.parse_no_value(details);
 }
 
-inline void ParseResult::parse_option(std::shared_ptr<OptionDetails> value,
-                                      const std::string& /*name*/,
-                                      const std::string& arg)
+inline void OptionParser::parse_option(const std::shared_ptr<OptionDetails>& value,
+                                       const std::string& /*name*/,
+                                       const std::string& arg)
 {
-  auto& result = m_results[value];
+  auto hash    = value->hash();
+  auto& result = m_parsed[hash];
   result.parse(value, arg);
 
-  m_sequential.emplace_back(value->long_name(), arg);
+  m_sequential.emplace_back(value->essential_name(), arg);
 }
 
-inline void ParseResult::checked_parse_arg(int argc,
-                                           char* argv[],
-                                           int& current,
-                                           std::shared_ptr<OptionDetails> value,
-                                           const std::string& name)
+inline void OptionParser::checked_parse_arg(int argc,
+                                            const char* const* argv,
+                                            int& current,
+                                            const std::shared_ptr<OptionDetails>& value,
+                                            const std::string& name)
 {
   if (current + 1 >= argc) {
     if (value->value().has_implicit()) {
       parse_option(value, name, value->value().get_implicit_value());
     } else {
-      throw_or_mimic<missing_argument_exception>(name);
+      throw_or_mimic<exceptions::missing_argument>(name);
     }
   } else {
     if (value->value().has_implicit()) {
@@ -1155,37 +1812,35 @@ inline void ParseResult::checked_parse_arg(int argc,
   }
 }
 
-inline void ParseResult::add_to_option(const std::string& option, const std::string& arg)
+inline void OptionParser::add_to_option(const std::shared_ptr<OptionDetails>& value,
+                                        const std::string& arg)
 {
-  auto iter = m_options->find(option);
-
-  if (iter == m_options->end()) { throw_or_mimic<option_not_exists_exception>(option); }
+  auto hash    = value->hash();
+  auto& result = m_parsed[hash];
+  result.add(value, arg);
 
-  parse_option(iter->second, option, arg);
+  m_sequential.emplace_back(value->essential_name(), arg);
 }
 
-inline bool ParseResult::consume_positional(std::string a)
+inline bool OptionParser::consume_positional(const std::string& a, PositionalListIterator& next)
 {
-  while (m_next_positional != m_positional.end()) {
-    auto iter = m_options->find(*m_next_positional);
-    if (iter != m_options->end()) {
-      auto& result = m_results[iter->second];
+  while (next != m_positional.end()) {
+    auto iter = m_options.find(*next);
+    if (iter != m_options.end()) {
       if (!iter->second->value().is_container()) {
+        auto& result = m_parsed[iter->second->hash()];
         if (result.count() == 0) {
-          add_to_option(*m_next_positional, a);
-          ++m_next_positional;
+          add_to_option(iter->second, a);
+          ++next;
           return true;
-        } else {
-          ++m_next_positional;
-          continue;
         }
-      } else {
-        add_to_option(*m_next_positional, a);
-        return true;
+        ++next;
+        continue;
       }
-    } else {
-      throw_or_mimic<option_not_exists_exception>(*m_next_positional);
+      add_to_option(iter->second, a);
+      return true;
     }
+    throw_or_mimic<exceptions::no_such_option>(*next);
   }
 
   return false;
@@ -1198,30 +1853,30 @@ inline void Options::parse_positional(std::string option)
 
 inline void Options::parse_positional(std::vector<std::string> options)
 {
-  m_positional      = std::move(options);
-  m_next_positional = m_positional.begin();
+  m_positional = std::move(options);
 
   m_positional_set.insert(m_positional.begin(), m_positional.end());
 }
 
 inline void Options::parse_positional(std::initializer_list<std::string> options)
 {
-  parse_positional(std::vector<std::string>(std::move(options)));
+  parse_positional(std::vector<std::string>(options));
 }
 
-inline ParseResult Options::parse(int& argc, char**& argv)
+inline ParseResult Options::parse(int argc, const char* const* argv)
 {
-  ParseResult result(m_options, m_positional, m_allow_unrecognised, argc, argv);
-  return result;
+  OptionParser parser(*m_options, m_positional, m_allow_unrecognised);
+
+  return parser.parse(argc, argv);
 }
 
-inline void ParseResult::parse(int& argc, char**& argv)
+inline ParseResult OptionParser::parse(int argc, const char* const* argv)
 {
-  int current = 1;
-
-  int nextKeep = 1;
-
+  int current            = 1;
   bool consume_remaining = false;
+  auto next_positional   = m_positional.begin();
+
+  std::vector<std::string> unmatched;
 
   while (current != argc) {
     if (strcmp(argv[current], "--") == 0) {
@@ -1229,42 +1884,43 @@ inline void ParseResult::parse(int& argc, char**& argv)
       ++current;
       break;
     }
+    bool matched = false;
+    values::parser_tool::ArguDesc argu_desc =
+      values::parser_tool::ParseArgument(argv[current], matched);
 
-    std::match_results<const char*> result;
-    std::regex_match(argv[current], result, option_matcher);
-
-    if (result.empty()) {
+    if (!matched) {
       // not a flag
 
       // but if it starts with a `-`, then it's an error
       if (argv[current][0] == '-' && argv[current][1] != '\0') {
-        if (!m_allow_unrecognised) { throw_or_mimic<option_syntax_exception>(argv[current]); }
+        if (!m_allow_unrecognised) {
+          throw_or_mimic<exceptions::invalid_option_syntax>(argv[current]);
+        }
       }
 
       // if true is returned here then it was consumed, otherwise it is
       // ignored
-      if (consume_positional(argv[current])) {
+      if (consume_positional(argv[current], next_positional)) {
       } else {
-        argv[nextKeep] = argv[current];
-        ++nextKeep;
+        unmatched.emplace_back(argv[current]);
       }
       // if we return from here then it was parsed successfully, so continue
     } else {
       // short or long option?
-      if (result[4].length() != 0) {
-        const std::string& s = result[4];
+      if (argu_desc.grouping) {
+        const std::string& s = argu_desc.arg_name;
 
         for (std::size_t i = 0; i != s.size(); ++i) {
           std::string name(1, s[i]);
-          auto iter = m_options->find(name);
+          auto iter = m_options.find(name);
 
-          if (iter == m_options->end()) {
+          if (iter == m_options.end()) {
             if (m_allow_unrecognised) {
+              unmatched.push_back(std::string("-") + s[i]);
               continue;
-            } else {
-              // error
-              throw_or_mimic<option_not_exists_exception>(name);
             }
+            // error
+            throw_or_mimic<exceptions::no_such_option>(name);
           }
 
           auto value = iter->second;
@@ -1274,36 +1930,38 @@ inline void ParseResult::parse(int& argc, char**& argv)
             checked_parse_arg(argc, argv, current, value, name);
           } else if (value->value().has_implicit()) {
             parse_option(value, name, value->value().get_implicit_value());
+          } else if (i + 1 < s.size()) {
+            std::string arg_value = s.substr(i + 1);
+            parse_option(value, name, arg_value);
+            break;
           } else {
             // error
-            throw_or_mimic<option_requires_argument_exception>(name);
+            throw_or_mimic<exceptions::option_requires_argument>(name);
           }
         }
-      } else if (result[1].length() != 0) {
-        const std::string& name = result[1];
+      } else if (argu_desc.arg_name.length() != 0) {
+        const std::string& name = argu_desc.arg_name;
 
-        auto iter = m_options->find(name);
+        auto iter = m_options.find(name);
 
-        if (iter == m_options->end()) {
+        if (iter == m_options.end()) {
           if (m_allow_unrecognised) {
             // keep unrecognised options in argument list, skip to next argument
-            argv[nextKeep] = argv[current];
-            ++nextKeep;
+            unmatched.emplace_back(argv[current]);
             ++current;
             continue;
-          } else {
-            // error
-            throw_or_mimic<option_not_exists_exception>(name);
           }
+          // error
+          throw_or_mimic<exceptions::no_such_option>(name);
         }
 
         auto opt = iter->second;
 
         // equals provided for long option?
-        if (result[2].length() != 0) {
+        if (argu_desc.set_value) {
           // parse the option given
 
-          parse_option(opt, name, result[3]);
+          parse_option(opt, name, argu_desc.value);
         } else {
           // parse the next argument
           checked_parse_arg(argc, argv, current, opt, name);
@@ -1314,30 +1972,54 @@ inline void ParseResult::parse(int& argc, char**& argv)
     ++current;
   }
 
-  for (auto& opt : *m_options) {
-    auto& detail = opt.second;
-    auto& value  = detail->value();
+  for (auto& opt : m_options) {
+    auto& detail      = opt.second;
+    const auto& value = detail->value();
 
-    auto& store = m_results[detail];
+    auto& store = m_parsed[detail->hash()];
 
-    if (value.has_default() && !store.count() && !store.has_default()) { parse_default(detail); }
+    if (value.has_default()) {
+      if (!store.count() && !store.has_default()) { parse_default(detail); }
+    } else {
+      parse_no_value(detail);
+    }
   }
 
   if (consume_remaining) {
     while (current < argc) {
-      if (!consume_positional(argv[current])) { break; }
+      if (!consume_positional(argv[current], next_positional)) { break; }
       ++current;
     }
 
     // adjust argv for any that couldn't be swallowed
     while (current != argc) {
-      argv[nextKeep] = argv[current];
-      ++nextKeep;
+      unmatched.emplace_back(argv[current]);
       ++current;
     }
   }
 
-  argc = nextKeep;
+  finalise_aliases();
+
+  ParseResult parsed(std::move(m_keys),
+                     std::move(m_parsed),
+                     std::move(m_sequential),
+                     std::move(m_defaults),
+                     std::move(unmatched));
+  return parsed;
+}
+
+inline void OptionParser::finalise_aliases()
+{
+  for (auto& option : m_options) {
+    auto& detail                = *option.second;
+    auto hash                   = detail.hash();
+    m_keys[detail.short_name()] = hash;
+    for (const auto& long_name : detail.long_names()) {
+      m_keys[long_name] = hash;
+    }
+
+    m_parsed.emplace(hash, OptionValue());
+  }
 }
 
 inline void Options::add_option(const std::string& group, const Option& option)
@@ -1347,19 +2029,24 @@ inline void Options::add_option(const std::string& group, const Option& option)
 
 inline void Options::add_option(const std::string& group,
                                 const std::string& s,
-                                const std::string& l,
+                                const OptionNames& l,
                                 std::string desc,
-                                std::shared_ptr<const Value> value,
+                                const std::shared_ptr<const Value>& value,
                                 std::string arg_help)
 {
   auto stringDesc = toLocalString(std::move(desc));
   auto option     = std::make_shared<OptionDetails>(s, l, stringDesc, value);
 
-  if (s.size() > 0) { add_one_option(s, option); }
+  if (!s.empty()) { add_one_option(s, option); }
 
-  if (l.size() > 0) { add_one_option(l, option); }
+  for (const auto& long_name : l) {
+    add_one_option(long_name, option);
+  }
 
   // add the help details
+
+  if (m_help.find(group) == m_help.end()) { m_group.push_back(group); }
+
   auto& options = m_help[group];
 
   options.options.emplace_back(HelpOptionDetails{s,
@@ -1375,46 +2062,54 @@ inline void Options::add_option(const std::string& group,
 }
 
 inline void Options::add_one_option(const std::string& option,
-                                    std::shared_ptr<OptionDetails> details)
+                                    const std::shared_ptr<OptionDetails>& details)
 {
   auto in = m_options->emplace(option, details);
 
-  if (!in.second) { throw_or_mimic<option_exists_error>(option); }
+  if (!in.second) { throw_or_mimic<exceptions::option_already_exists>(option); }
 }
 
 inline String Options::help_one_group(const std::string& g) const
 {
-  typedef std::vector<std::pair<String, String>> OptionHelp;
+  using OptionHelp = std::vector<std::pair<String, String>>;
 
   auto group = m_help.find(g);
   if (group == m_help.end()) { return ""; }
 
   OptionHelp format;
 
-  size_t longest = 0;
+  std::size_t longest = 0;
 
   String result;
 
   if (!g.empty()) { result += toLocalString(" " + g + " options:\n"); }
 
   for (const auto& o : group->second.options) {
-    if (m_positional_set.find(o.l) != m_positional_set.end() && !m_show_positional) { continue; }
+    if (o.l.size() && m_positional_set.find(o.l.front()) != m_positional_set.end() &&
+        !m_show_positional) {
+      continue;
+    }
 
     auto s  = format_option(o);
     longest = (std::max)(longest, stringLength(s));
     format.push_back(std::make_pair(s, String()));
   }
+  longest = (std::min)(longest, OPTION_LONGEST);
 
-  longest = (std::min)(longest, static_cast<size_t>(OPTION_LONGEST));
-
-  // widest allowed description
-  auto allowed = size_t{76} - longest - OPTION_DESC_GAP;
+  // widest allowed description -- min 10 chars for helptext/line
+  std::size_t allowed = 10;
+  if (m_width > allowed + longest + OPTION_DESC_GAP) {
+    allowed = m_width - longest - OPTION_DESC_GAP;
+  }
 
   auto fiter = format.begin();
   for (const auto& o : group->second.options) {
-    if (m_positional_set.find(o.l) != m_positional_set.end() && !m_show_positional) { continue; }
+    if (o.l.size() && m_positional_set.find(o.l.front()) != m_positional_set.end() &&
+        !m_show_positional) {
+      continue;
+    }
 
-    auto d = format_description(o, longest + OPTION_DESC_GAP, allowed);
+    auto d = format_description(o, longest + OPTION_DESC_GAP, allowed, m_tab_expansion);
 
     result += fiter->first;
     if (stringLength(fiter->first) > longest) {
@@ -1436,7 +2131,7 @@ inline String Options::help_one_group(const std::string& g) const
 inline void Options::generate_group_help(String& result,
                                          const std::vector<std::string>& print_groups) const
 {
-  for (size_t i = 0; i != print_groups.size(); ++i) {
+  for (std::size_t i = 0; i != print_groups.size(); ++i) {
     const String& group_help_text = help_one_group(print_groups[i]);
     if (empty(group_help_text)) { continue; }
     result += group_help_text;
@@ -1446,28 +2141,24 @@ inline void Options::generate_group_help(String& result,
 
 inline void Options::generate_all_groups_help(String& result) const
 {
-  std::vector<std::string> all_groups;
-  all_groups.reserve(m_help.size());
-
-  for (auto& group : m_help) {
-    all_groups.push_back(group.first);
-  }
-
-  generate_group_help(result, all_groups);
+  generate_group_help(result, m_group);
 }
 
-inline std::string Options::help(const std::vector<std::string>& help_groups) const
+inline std::string Options::help(const std::vector<std::string>& help_groups,
+                                 bool print_usage) const
 {
-  String result =
-    m_help_string + "\nUsage:\n  " + toLocalString(m_program) + " " + toLocalString(m_custom_help);
+  String result = m_help_string;
+  if (print_usage) { result += "\nUsage:\n  " + toLocalString(m_program); }
+
+  if (!m_custom_help.empty()) { result += " " + toLocalString(m_custom_help); }
 
-  if (m_positional.size() > 0 && m_positional_help.size() > 0) {
+  if (!m_positional.empty() && !m_positional_help.empty()) {
     result += " " + toLocalString(m_positional_help);
   }
 
   result += "\n\n";
 
-  if (help_groups.size() == 0) {
+  if (help_groups.empty()) {
     generate_all_groups_help(result);
   } else {
     generate_group_help(result, help_groups);
@@ -1476,18 +2167,7 @@ inline std::string Options::help(const std::vector<std::string>& help_groups) co
   return toUTF8String(result);
 }
 
-inline const std::vector<std::string> Options::groups() const
-{
-  std::vector<std::string> g;
-
-  std::transform(
-    m_help.begin(),
-    m_help.end(),
-    std::back_inserter(g),
-    [](const std::map<std::string, HelpGroupDetails>::value_type& pair) { return pair.first; });
-
-  return g;
-}
+inline std::vector<std::string> Options::groups() const { return m_group; }
 
 inline const HelpGroupDetails& Options::group_help(const std::string& group) const
 {
diff --git a/cpp/tests/utilities/cxxopts_license.txt b/cpp/tests/utilities/cxxopts_license.txt
index 4ee833a76a..324a203585 100644
--- a/cpp/tests/utilities/cxxopts_license.txt
+++ b/cpp/tests/utilities/cxxopts_license.txt
@@ -1,19 +1,19 @@
-/*
- * Copyright (c) 2014, 2015, 2016, 2017 Jarryd Beck
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- *
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
+Copyright (c) 2014 Jarryd Beck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/thirdparty/THIRD_PARTY_LICENSES b/thirdparty/THIRD_PARTY_LICENSES
index 290f9c35cb..665324e106 100644
--- a/thirdparty/THIRD_PARTY_LICENSES
+++ b/thirdparty/THIRD_PARTY_LICENSES
@@ -1,3 +1,27 @@
 ==================================================
 Third Party Licenses
 ==================================================
+
+-----------------------------------------------------------------------------------------
+== cxxopts
+
+Files: cpp/tests/utilities/cxxopts.hpp
+Copyright (c) 2014 Jarryd Beck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.