diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8766c4b80..64d4a8fe5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -55,6 +55,7 @@
 - Added 200 Bus Synthetic Illinois Case
 - Added node objects to `PowerElectronics` module & updated all examples to make use of them.
 - Separated internal and external residuals of `PowerElectronics` models.
+- Added `CliArgs` class for better management of command-line options.
 
 ## v0.1
 
diff --git a/GridKit/Utilities/CMakeLists.txt b/GridKit/Utilities/CMakeLists.txt
index afc0badf2..d9f52f088 100644
--- a/GridKit/Utilities/CMakeLists.txt
+++ b/GridKit/Utilities/CMakeLists.txt
@@ -6,6 +6,7 @@ target_include_directories(Utilities INTERFACE
 add_library(GridKit::Utilities ALIAS Utilities)
 
 add_subdirectory(Logger)
+add_subdirectory(CliArgs)
 add_subdirectory(CliOptions)
 
 install(TARGETS Utilities EXPORT gridkit-targets)
diff --git a/GridKit/Utilities/CliArgs/ArgValue.hpp b/GridKit/Utilities/CliArgs/ArgValue.hpp
new file mode 100644
index 000000000..cd3274e3c
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/ArgValue.hpp
@@ -0,0 +1,127 @@
+/**
+ * @file ArgValue.hpp
+ * @author Philip Fackler (facklerpw@ornl.gov)
+ */
+
+#pragma once
+
+#include <any>
+#include <sstream>
+#include <string>
+
+#include <GridKit/Utilities/String.hpp>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+
+    /**
+     * @brief Represents a single value of arbitrary type
+     *
+     * The value is internally represented as a std::string that is parsed when
+     * requested as a specific type
+     */
+    class ArgValue
+    {
+      /**
+       * @brief Check that T != ArgValue
+       *
+       */
+      template <typename T>
+      static constexpr bool notAnArgValue =
+          !std::is_same_v<std::remove_reference_t<T>, ArgValue>;
+
+      /**
+       * @brief Check that T != std::initializer_list<ArgValue>
+       */
+      template <typename T>
+      static constexpr bool notAnArgValueList =
+          !std::is_same_v<std::remove_reference_t<T>, std::initializer_list<ArgValue>>;
+
+      /**
+       * @brief Check that T is not an ArgValue or list of ArgValues
+       */
+      template <typename T>
+      static constexpr bool notArgValue = notAnArgValue<T> && notAnArgValueList<T>;
+
+    public:
+      /**
+       * @brief Default construction results in empty value
+       *
+       * @note the SFINAE parameter is used to work around an issue with libc++
+       */
+      ArgValue() = default;
+
+      /**
+       * @brief Copy constructor
+       */
+      ArgValue(const ArgValue&) = default;
+
+      /**
+       * @brief Move constructor
+       */
+      ArgValue(ArgValue&&) = default;
+
+      /**
+       * @brief Construct from any value
+       */
+      template <typename T>
+      ArgValue(T&& val, std::enable_if_t<notArgValue<T>, int> = 0)
+        : value_((std::stringstream() << val).str())
+      {
+      }
+
+      ArgValue& operator=(const ArgValue&) = default;
+      ArgValue& operator=(ArgValue&&)      = default;
+
+      /**
+       * @brief Assign any value
+       */
+      template <typename T>
+      ArgValue& operator=(T&& val)
+      {
+        value_ = (std::stringstream() << val).str();
+        return *this;
+      }
+
+      /**
+       * @brief Check if no value is contained
+       */
+      bool empty() const
+      {
+        return value_.empty();
+      }
+
+      /**
+       * @brief Get string representation
+       */
+      const std::string& get() const
+      {
+        return value_;
+      }
+
+      /**
+       * @brief Get string representation
+       */
+      const std::string& operator()() const
+      {
+        return get();
+      }
+
+      /**
+       * @brief Get value of specific expected type
+       */
+      template <typename T>
+      T as() const
+      {
+        return GridKit::Utilities::parse<T>(value_);
+      }
+
+    private:
+      /// Internal representation
+      std::string value_{};
+    };
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/CliArgs/ArgVector.hpp b/GridKit/Utilities/CliArgs/ArgVector.hpp
new file mode 100644
index 000000000..ef2617c81
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/ArgVector.hpp
@@ -0,0 +1,135 @@
+/**
+ * @file ArgVector.hpp
+ * @author Philip Fackler (facklerpw@ornl.gov)
+ */
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <vector>
+
+#include <GridKit/Utilities/CliArgs/ArgValue.hpp>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+
+    // Forward declaration
+    struct CliArgsImpl;
+
+    /**
+     * @brief Represents a set of 0 or more values associated with a given
+     * command-line option
+     *
+     * This class allows the internal data to be interpreted as a discrete set
+     * of values (std::array) of a given type or as a single value, hopefully
+     * making it more intuitive for users. For example...
+     *
+     * If an ArgVector v is expected to hold one value of type `double`, that
+     * value can be extracted with `auto r = v.as<double>();`. This means `r`
+     * will be a `double` value assigned with the contents of the first element
+     * of `v`.
+     *
+     * If an ArgVector v is expected to hold two values of type `int`, on the
+     * other hand, the values can be extracted as a `std::array<int, 2>` using
+     * `as<int, 2>()`. Using `std::array` allows structured bindings for the
+     * user: `auto [a, b] = v.as<int, 2>();`
+     */
+    class ArgVector
+    {
+    public:
+      /**
+       * @brief Default is empty (no values)
+       */
+      ArgVector() = default;
+
+      /**
+       * @brief Construct with a single value
+       */
+      template <typename T>
+      ArgVector(T&& val)
+        : vec_{val}
+      {
+      }
+
+      ArgVector(std::initializer_list<ArgValue> vals)
+        : vec_{vals}
+      {
+      }
+
+      /**
+       * @brief Interpret as `N` values of type `T`
+       */
+      template <typename T, std::size_t N>
+      std::array<T, N> as() const
+      {
+        assert(vec_.size() == N);
+        std::array<T, N> ret;
+        for (std::size_t i = 0; i < N; ++i)
+        {
+          ret[i] = vec_[i].as<T>();
+        }
+        return ret;
+      }
+
+      /**
+       * @brief Interpret as `N` values of type `std::string`
+       */
+      template <std::size_t N>
+      decltype(auto) as() const
+      {
+        return as<std::string, N>();
+      }
+
+      /**
+       * @brief Interpret as single value of type `T`
+       */
+      template <typename T>
+      decltype(auto) as() const
+      {
+        return vec_[0].as<T>();
+      }
+
+      /**
+       * @brief Interpret as single `std::string` value
+       */
+      const std::string& operator()() const
+      {
+        return vec_[0].get();
+      }
+
+      /**
+       * @brief Get one of the contained `ArgValue` objects
+       */
+      const ArgValue& operator[](std::size_t i) const
+      {
+        return vec_[i];
+      }
+
+      /**
+       * @brief Check for existence of values
+       */
+      bool empty() const
+      {
+        return vec_.empty();
+      }
+
+      /**
+       * @brief Get number of `ArgValue` objects
+       */
+      std::size_t size() const
+      {
+        return vec_.size();
+      }
+
+    private:
+      /// Internal set of values
+      std::vector<ArgValue> vec_;
+
+      friend struct CliArgsImpl;
+    };
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/CliArgs/CMakeLists.txt b/GridKit/Utilities/CliArgs/CMakeLists.txt
new file mode 100644
index 000000000..5e4d70d49
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/CMakeLists.txt
@@ -0,0 +1,13 @@
+gridkit_add_library(utilities_cli_args
+  SOURCES
+    CliArgs.cpp
+  HEADERS
+    CliArgs.hpp
+    ArgValue.hpp
+    ArgVector.hpp
+    Option.hpp
+  LINK_LIBRARIES
+    PUBLIC GridKit::utilities_logger
+  )
+
+target_link_libraries(Utilities INTERFACE GridKit::utilities_cli_args)
diff --git a/GridKit/Utilities/CliArgs/CliArgs.cpp b/GridKit/Utilities/CliArgs/CliArgs.cpp
new file mode 100644
index 000000000..77a109e8f
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/CliArgs.cpp
@@ -0,0 +1,60 @@
+#include <algorithm>
+#include <cassert>
+#include <filesystem>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+#include <GridKit/Utilities/CliArgs/CliArgs.hpp>
+#include <GridKit/Utilities/Logger/Logger.hpp>
+
+#include "CliArgsImpl.hpp"
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+    CliArgs::CliArgs(std::initializer_list<Option> opts)
+      : pImpl_(std::make_unique<CliArgsImpl>(opts))
+    {
+    }
+
+    CliArgs::~CliArgs()
+    {
+    }
+
+    std::ostream& operator<<(std::ostream& os, const CliArgs& args)
+    {
+      os << *(args.pImpl_);
+      return os;
+    }
+
+    void CliArgs::parseArgs(int argc, const char* argv[])
+    {
+      pImpl_->parseArgs(argc, argv);
+    }
+
+    void CliArgs::printUsage(std::ostream& os) const
+    {
+      pImpl_->printUsage(os);
+    }
+
+    void CliArgs::printHelp(std::ostream& os) const
+    {
+      pImpl_->printHelp(os);
+    }
+
+    const std::string& CliArgs::getAppName() const
+    {
+      return pImpl_->app_name_;
+    }
+
+    const ArgVector& CliArgs::operator[](const std::string& name) const
+    {
+      return (*pImpl_)[name];
+    }
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/CliArgs/CliArgs.hpp b/GridKit/Utilities/CliArgs/CliArgs.hpp
new file mode 100644
index 000000000..58a40b01b
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/CliArgs.hpp
@@ -0,0 +1,137 @@
+/**
+ * @file CliArgs.hpp
+ * @author Philip Fackler (facklerpw@ornl.gov)
+ *
+ * @brief Define and parse expected command-line arguments
+ */
+
+#pragma once
+
+#include <initializer_list>
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <GridKit/Utilities/CliArgs/ArgVector.hpp>
+#include <GridKit/Utilities/CliArgs/Option.hpp>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+
+    /**
+     * @brief Table with which to specify and parse command-line arguments
+     *
+     * An application developer can specify expected options using a terse
+     * syntax (using the keyword aggregate construction for each Option):
+     *
+     * ```
+     * CliArgs args{{.name     = {"--opt1"},
+     *               .help     = "an option with an argument"},
+     *
+     *              {.name     = {"--opt2", "-o"},
+     *               .help     = "An option with an argument (and a short-hand)",
+     *               .type     = ArgType::Integer,
+     *               .defaults = 0},
+     *
+     *              {.name     = {"--flag1", "-f"},
+     *               .help     = "A flag option (no argument)",
+     *               .flag     = true}};
+     * ```
+     *
+     * @note The `{"--help", "-h"}` argument is added automatically. When it is
+     * parsed from the command line. The help description will be printed and
+     * the application will exit.
+     *
+     * @note The usage syntax is intended to be similar to
+     * [ArgParse.jl](https://carlobaldassi.github.io/ArgParse.jl/stable/).
+     *
+     * @todo Allow option grouping for a more expressive help description.
+     */
+    class CliArgs
+    {
+    public:
+      /**
+       * @brief Construct with braced list (see class description)
+       */
+      explicit CliArgs(std::initializer_list<Option> args);
+
+      /// Destructor
+      ~CliArgs();
+
+      /**
+       * @brief Parse command-line arguments using existing specification
+       */
+      void parseArgs(int argc, const char* argv[]);
+
+      /**
+       * @brief Print one-line application usage expression
+       */
+      void printUsage(std::ostream& os = std::cout) const;
+
+      /**
+       * @brief Print help description. Includes one-line usage expression and a
+       * list of all expected options.
+       */
+      void printHelp(std::ostream& os = std::cout) const;
+
+      /**
+       * @brief Executable name (known only after calling parseArgs())
+       */
+      const std::string& getAppName() const;
+
+      /**
+       * @brief Get the parsed values (or defaults) for the given argument.
+       *
+       * Arguments may be looked up with either their long-hand or their
+       * short-hand forms, but without the hyphens (e.g., args["arg1"] using the
+       * example from the class description).
+       */
+      const ArgVector& operator[](const std::string& name) const;
+
+      ///@{
+      /**
+       * @brief Alternative syntax (see ArgVector::as)
+       */
+      template <typename T, std::size_t N>
+      std::array<T, N> get(const std::string& name) const
+      {
+        return (*this)[name].as<T, N>();
+      }
+
+      template <std::size_t N>
+      decltype(auto) get(const std::string& name) const
+      {
+        return (*this)[name].as<N>();
+      }
+
+      template <typename T>
+      decltype(auto) get(const std::string& name) const
+      {
+        return (*this)[name].as<T>();
+      }
+
+      const std::string& get(const std::string& name) const
+      {
+        return (*this)[name]();
+      }
+
+      ///@}
+
+    private:
+      /**
+       * @brief Stream insertion operator for printing the argument table
+       *
+       * @note This is useful mainly for debugging purposes. It prints both the
+       * list of options and the option name map, so the same Option will be
+       * shown multiple times. Each Option is printed with its associated parsed
+       * argument values.
+       */
+      friend std::ostream& operator<<(std::ostream& os, const CliArgs& args);
+
+      std::unique_ptr<CliArgsImpl> pImpl_;
+    };
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/CliArgs/CliArgsImpl.hpp b/GridKit/Utilities/CliArgs/CliArgsImpl.hpp
new file mode 100644
index 000000000..000238b20
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/CliArgsImpl.hpp
@@ -0,0 +1,604 @@
+#include <GridKit/Utilities/Stream.hpp>
+#include <GridKit/Utilities/String.hpp>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+    using Log = ::GridKit::Utilities::Logger;
+
+    /**
+     * @brief Associate an Option with its parsed arguments
+     */
+    struct OptionArgumentPair
+    {
+      /**
+       * @brief Construct with an Option spec and an empty set of values
+       */
+      explicit OptionArgumentPair(Option opt)
+        : option(std::move(opt))
+      {
+      }
+
+      // OptionArgumentPair(OptionArgumentPair
+
+      /// Reference to existing option
+      Option    option;
+      /// Parsed values
+      ArgVector values{};
+    };
+
+    /**
+     * @brief Implementation of CliArgs
+     */
+    struct CliArgsImpl
+    {
+      ///@{
+      /// @brief Implmentation of CliArgs
+      CliArgsImpl(std::initializer_list<Option> args);
+
+      void parseArgs(int argc, const char* argv[]);
+      void printUsage(std::ostream& os = std::cout) const;
+      void printHelp(std::ostream& os = std::cout) const;
+
+      const ArgVector& operator[](const std::string& name) const;
+      ///@}
+
+      /// Map a name to an Option (fail if duplicate name)
+      void mapName(const std::string& name, OptionArgumentPair* opt);
+      /// Perform sanity assertions and add Option to name_map_
+      void setupArg(OptionArgumentPair& opt);
+
+      /// Option lookup via (hyphenless) name
+      const OptionArgumentPair* findByName(const std::string& name) const;
+
+      /// Option lookup via (hyphenless) name
+      OptionArgumentPair* findByName(const std::string& name)
+      {
+        return const_cast<OptionArgumentPair*>(
+            const_cast<const CliArgsImpl*>(this)->findByName(name));
+      }
+
+      /// Option lookup via raw (hyphened) name
+      OptionArgumentPair* findByRawName(const std::string& raw);
+
+      /// Store application name ("app" placeholder is changed in parseArgs())
+      std::string                                          app_name_{"app"};
+      /// Collection of options
+      std::vector<OptionArgumentPair>                      table_;
+      /// Map of names to options
+      std::unordered_map<std::string, OptionArgumentPair*> name_map_;
+    };
+
+    /**
+     * @brief Print all the values in an ArgVector to a string
+     *
+     * @note This is useful mainly for debugging purposes
+     */
+    std::string format(const ArgVector& av)
+    {
+      std::stringstream os;
+      os << "[";
+      if (av.empty())
+      {
+        os << "]";
+      }
+      else
+      {
+        os << av[0]();
+        for (std::size_t i = 1; i < av.size(); ++i)
+        {
+          os << ", " << av[i]();
+        }
+        os << "]";
+      }
+      return os.str();
+    }
+
+    /**
+     * @brief Map ArgType from Option to string used as part of help description
+     * for an Option
+     */
+    inline const std::string& typeString(const Option& opt)
+    {
+      static const std::string labels[] =
+          {"STRING", "REAL", "INT", "BOOL", "UNSPECIFIED"};
+      return labels[static_cast<int>(opt.type)];
+    }
+
+    /**
+     * @brief Stream insertion operator to print an Option specification and
+     * parsed argument(s)
+     *
+     * @note This is useful mainly for debugging purposes
+     */
+    std::ostream& operator<<(std::ostream&             os,
+                             const OptionArgumentPair& arg)
+    {
+      os << "  name     : " << arg.option.name[0];
+      if (!arg.option.name[1].empty())
+      {
+        os << ", " << arg.option.name[1];
+      }
+      os << '\n';
+      os << "  help     : " << arg.option.help << '\n';
+      os << "  required : " << std::boolalpha << arg.option.required << '\n';
+      os << "  type     : " << typeString(arg.option) << '\n';
+      os << "  flag     : " << std::boolalpha << arg.option.flag << '\n';
+      os << "  defaults : " << format(arg.option.defaults) << '\n';
+      os << "  nargs    : " << arg.option.nargs << '\n';
+      os << "  values   : " << format(arg.values);
+      return os;
+    }
+
+    /// Implementation of CliArgs
+    std::ostream& operator<<(std::ostream& os, const CliArgsImpl& args)
+    {
+      for (auto&& arg : args.table_)
+      {
+        os << arg << "\n\n";
+      }
+      for (auto&& [key, arg] : args.name_map_)
+      {
+        os << key << " =>\n"
+           << *arg << "\n\n";
+      }
+      return os;
+    }
+
+    void CliArgsImpl::mapName(const std::string& name, OptionArgumentPair* arg)
+    {
+      if (!name_map_.try_emplace(name, arg).second)
+      {
+        auto msg = "CliArgs: attempt to add duplicate option name: \""
+                   + name + "\".";
+        Log::error() << msg << std::endl;
+        throw std::runtime_error(msg);
+      }
+    }
+
+    bool notANumber(const std::string& raw)
+    {
+      double v;
+      return (std::stringstream(raw) >> v).fail();
+    }
+
+    void CliArgsImpl::setupArg(OptionArgumentPair& arg)
+    {
+      const auto& name = arg.option.name;
+      assert(name[0].starts_with("--"));
+      mapName(name[0].substr(2), &arg);
+      if (!name[1].empty())
+      {
+        assert(name[1].starts_with("-"));
+        assert(!name[1].starts_with("--"));
+        if (!notANumber(name[1]))
+        {
+          auto msg = "CliArgs: Cannot use number as option name: \""
+                     + name[1] + "\".";
+          Log::error() << msg << std::endl;
+          throw std::runtime_error(msg);
+        }
+        mapName(name[1].substr(1), &arg);
+      }
+
+      if (arg.option.flag)
+      {
+        arg.option.defaults = false;
+        arg.option.nargs    = 0;
+      }
+    }
+
+    CliArgsImpl::CliArgsImpl(std::initializer_list<Option> opts)
+    {
+      // Store and map options
+      table_.reserve(opts.size() + 1);
+      for (auto& opt : opts)
+      {
+        auto& arg = table_.emplace_back(opt);
+        setupArg(arg);
+      }
+
+      // add "help" entry on behalf of the user
+      if (!name_map_.count("help") && !name_map_.count("h"))
+      {
+        auto& help = table_.emplace_back(
+            Option{.name = {"--help", "-h"},
+                   .help = "Print this help message",
+                   .flag = true});
+        setupArg(help);
+      }
+    }
+
+    const OptionArgumentPair* CliArgsImpl::findByName(const std::string& name)
+        const
+    {
+      auto ret = name_map_.find(name);
+      if (ret == name_map_.end())
+      {
+        return nullptr;
+      }
+      return ret->second;
+    }
+
+    bool looksLikeAnOption(const std::string& raw)
+    {
+      return raw.starts_with("-") && notANumber(raw);
+    }
+
+    OptionArgumentPair* CliArgsImpl::findByRawName(const std::string& raw)
+    {
+      if (raw.starts_with("--"))
+      {
+        return findByName(raw.substr(2));
+      }
+      else if (raw.starts_with("-"))
+      {
+        return findByName(raw.substr(1));
+      }
+      return nullptr;
+    }
+
+    void CliArgsImpl::parseArgs(int argc, const char* argv[])
+    {
+      app_name_   = std::filesystem::path(argv[0]).filename();
+      bool status = true;
+
+      // Current argument (may involve multiple tokens)
+      OptionArgumentPair* arg{nullptr};
+      for (int i = 1; i < argc; ++i)
+      {
+        auto token = std::string(argv[i]);
+        if (looksLikeAnOption(token))
+        {
+          auto* new_arg = findByRawName(token);
+          if (!new_arg)
+          {
+            Log::error() << "CliArgs: unrecognized option \"" << token
+                         << "\"\n";
+            status = false;
+            arg    = nullptr;
+            continue;
+          }
+          if (arg && arg->values.size() != arg->option.nargs)
+          {
+            // option not given correct number of values
+            Log::error() << "CliArgs: option \"" << arg->option.name[0]
+                         << "\" requires " << arg->option.nargs
+                         << " arguments; " << arg->values.size()
+                         << " given.\n";
+            status = false;
+          }
+          arg = new_arg;
+          if (arg->option.flag)
+          {
+            // handle current arg as flag and move on
+            arg->values = true;
+          }
+        }
+        else if (arg)
+        {
+          if (arg->option.flag)
+          {
+            Log::error() << "CliArgs: flag option \"" << arg->option.name[0]
+                         << "\" was given an argument (\"" << token << "\")\n";
+            status = false;
+          }
+          // set value from current token
+          arg->values.vec_.emplace_back(token);
+        }
+        else
+        {
+          // TODO: positional arguments
+          Log::error() << "CliArgs: unrecognized option \"" << token
+                       << "\"\n";
+          status = false;
+          arg    = nullptr;
+        }
+      }
+
+      // Check for final flag argument
+      if (arg)
+      {
+        // If we still have an active arg, it's either a flag (which is OK) or
+        // an option which expects a value that hasn't been given
+        if (!arg->option.flag && arg->values.size() != arg->option.nargs)
+        {
+          // option not given correct number of values
+          Log::error() << "CliArgs: option \"" << arg->option.name[0]
+                       << "\" requires " << arg->option.nargs << " arguments; "
+                       << arg->values.size() << " given.\n";
+          status = false;
+        }
+      }
+
+      // check for help request
+      if ((*this)["help"].as<bool>())
+      {
+        printHelp();
+        exit(EXIT_SUCCESS);
+      }
+
+      // check that all required options have values
+      for (const auto& arg : table_)
+      {
+        if (arg.option.required && arg.values.size() != arg.option.nargs)
+        {
+          Log::error() << "CliArgs: no input given for required option \""
+                       << arg.option.name[0] << "\"\n";
+          status = false;
+        }
+      }
+
+      // print help and quit if errors have occurred
+      if (!status)
+      {
+        printHelp();
+        throw std::runtime_error("CliArgs: requirements not met");
+      }
+    }
+
+    namespace
+    {
+      // Items in this anonymous namespace were stolen (and simplified) from
+      // Boost.ProgramOptions
+
+      /// A help line can't be longer than 80 characters
+      inline constexpr unsigned maxLineLength = 80;
+
+      /// Column for help descriptions will be half the total line length
+      inline constexpr unsigned minHelpLength = maxLineLength / 2;
+
+      /**
+       * @brief Format string with option name(s) and type (if specified)
+       */
+      std::string formatFirstColumn(const Option& opt)
+      {
+        std::stringstream ss;
+        ss << "  ";
+        if (!opt.name[1].empty())
+        {
+          ss << opt.name[1] << ", ";
+        }
+        ss << opt.name[0];
+        if (opt.type != ArgType::Unspecified)
+        {
+          ss << " (" << typeString(opt) << ")";
+        }
+        return ss.str();
+      }
+
+      /**
+       * @brief Determine how much width the first column needs
+       *
+       * The width of the help column takes priority, and in cases where the
+       * first column option string exceeds the arg column width, the help
+       * description will simply be moved down a line.
+       */
+      unsigned getArgColumnWidth(const std::vector<OptionArgumentPair>& args)
+      {
+        const unsigned startOfHelpColumn = maxLineLength - minHelpLength;
+
+        // Find the maximum width of the option column
+        unsigned width{23};
+        for (auto&& arg : args)
+        {
+          auto c1 = formatFirstColumn(arg.option);
+          width   = std::max(width, static_cast<unsigned>(c1.size()));
+        }
+
+        // If first column is longer than the start of the help column,
+        // we'll go to a new line
+        width = std::min(width, startOfHelpColumn - 1);
+
+        // add an additional space to improve readability
+        ++width;
+        return width;
+      }
+
+      /**
+       * @brief Format a paragraph to the output stream
+       *
+       * This function attempts to take care of line breaks well
+       */
+      void printParagraph(std::ostream&    os,
+                          std::string_view par,
+                          unsigned         indent,
+                          unsigned         lineLength)
+      {
+        // Through remainder of this function, 'lineLength' will be the length
+        // available for characters, not including indent.
+        assert(indent < lineLength);
+        lineLength -= indent;
+
+        if (par.size() < lineLength)
+        {
+          os << par;
+        }
+        else
+        {
+          const auto parEnd = par.cend();
+          for (auto lineBegin = par.cbegin(); lineBegin != parEnd;)
+          {
+            // If line starts with space, but second character
+            // is not space, remove the leading space.
+            // We don't remove double spaces because those
+            // might be intentianal.
+            if ((*lineBegin == ' ') && ((lineBegin + 1 < parEnd) && (*(lineBegin + 1) != ' ')))
+            {
+              ++lineBegin;
+            }
+
+            unsigned remaining =
+                static_cast<unsigned>(std::distance(lineBegin, parEnd));
+            auto lineEnd =
+                lineBegin + ((remaining < lineLength) ? remaining : lineLength);
+
+            // prevent chopped words
+            // Is lineEnd between two non-space characters?
+            if ((*(lineEnd - 1) != ' ') && ((lineEnd < parEnd) && (*lineEnd != ' ')))
+            {
+              // find last ' ' in the second half of the current paragraph
+              // line
+              auto line      = std::string_view(lineBegin, lineEnd);
+              auto lastSpace = line.find_last_of(' ');
+
+              if (lastSpace != std::string_view::npos)
+              {
+                // is lastSpace within the second half of the current line
+                if ((line.size() - lastSpace) < (lineLength / 2))
+                {
+                  lineEnd = lineBegin + lastSpace;
+                }
+              }
+            }
+
+            // write line to stream
+            os << std::string_view(lineBegin, lineEnd);
+
+            // more lines to follow?
+            if (lineEnd != parEnd)
+            {
+              os << '\n';
+              leftPad(os, indent);
+            }
+
+            lineBegin = lineEnd;
+          }
+        }
+      }
+
+      /**
+       * @brief Print the help description of an option as a paragraph
+       */
+      void printOptionHelp(std::ostream&      os,
+                           const std::string& desc,
+                           unsigned           firstColWidth,
+                           unsigned           lineLength)
+      {
+        // we need to use one char less per line to work correctly if actual
+        // console has longer lines
+        assert(lineLength > 1);
+        if (lineLength > 1)
+        {
+          --lineLength;
+        }
+
+        // lineLength must be larger than firstColWidth
+        // this assert may fail due to user error or environment conditions!
+        assert(lineLength > firstColWidth);
+
+        unsigned          padSize = 0;
+        std::stringstream ss(desc);
+        for (std::string par; std::getline(ss, par);)
+        {
+          leftPad(os, padSize);
+          printParagraph(os, par, firstColWidth, lineLength);
+          os << '\n';
+          padSize = firstColWidth;
+        }
+      }
+
+      /**
+       * @brief Print the option name(s) [and type] followed by the help
+       * description [and defaults]
+       */
+      void printOption(std::ostream& os,
+                       const Option& opt,
+                       unsigned      firstColWidth)
+      {
+        auto c1 = formatFirstColumn(opt);
+        os << c1;
+
+        if (!opt.help.empty())
+        {
+          unsigned padSize = firstColWidth - static_cast<unsigned>(c1.size());
+          if (c1.size() >= firstColWidth)
+          {
+            os.put('\n'); // first column is too long, new line for help
+            padSize = firstColWidth;
+          }
+          leftPad(os, padSize);
+
+          auto desc = opt.help;
+          if (!opt.flag && !opt.defaults.empty())
+          {
+            desc += "\ndefault: " + format(opt.defaults);
+          }
+          printOptionHelp(os, desc, firstColWidth, maxLineLength);
+        }
+      }
+    } // namespace
+
+    /**
+     * @brief Format the portion of the usage expression for a single Option
+     */
+    std::string formatOptionUsage(const Option& opt)
+    {
+      std::stringstream ss;
+      if (!opt.required)
+      {
+        ss << "[";
+      }
+      if (!opt.name[1].empty())
+      {
+        ss << opt.name[1];
+      }
+      else
+      {
+        ss << opt.name[0];
+      }
+
+      auto placeholder = toUpper(opt.name[0].substr(2));
+      for (std::size_t i = 0; i < opt.nargs; ++i)
+      {
+        ss << " " << placeholder;
+      }
+
+      if (!opt.required)
+      {
+        ss << "]";
+      }
+      return ss.str();
+    }
+
+    void CliArgsImpl::printUsage(std::ostream& os) const
+    {
+      os << "Usage: " << app_name_;
+      for (auto&& arg : table_)
+      {
+        os << " " << formatOptionUsage(arg.option);
+      }
+      os << "\n\n";
+    }
+
+    void CliArgsImpl::printHelp(std::ostream& os) const
+    {
+      printUsage(os);
+
+      auto width = getArgColumnWidth(table_);
+
+      for (auto&& arg : table_)
+      {
+        printOption(os, arg.option, width);
+        os << "\n";
+      }
+    }
+
+    const ArgVector& CliArgsImpl::operator[](const std::string& name) const
+    {
+      auto arg = findByName(name);
+      if (!arg)
+      {
+        auto msg = "CliArgs: unrecognized option requested: \"" + name + "\"";
+        Log::error() << msg << '\n';
+        throw std::runtime_error(msg);
+      }
+      if (arg->values.empty() && !arg->option.defaults.empty())
+      {
+        return arg->option.defaults;
+      }
+      return arg->values;
+    }
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/CliArgs/Option.hpp b/GridKit/Utilities/CliArgs/Option.hpp
new file mode 100644
index 000000000..23a5ed327
--- /dev/null
+++ b/GridKit/Utilities/CliArgs/Option.hpp
@@ -0,0 +1,78 @@
+/**
+ * @file Option.hpp
+ * @author Philip Fackler (facklerpw@ornl.gov)
+ */
+
+#pragma once
+
+#include <array>
+#include <string>
+
+#include <GridKit/Utilities/CliArgs/ArgVector.hpp>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+
+    /**
+     * @brief Specify expected type to which an argument should parse
+     *
+     * @note Currently this is only used for the "help" output to let users
+     * know what type of value to provide.
+     */
+    enum class ArgType
+    {
+      String,     ///< Expect string value
+      Real,       ///< Expect floating-point value
+      Integer,    ///< Expect integer value
+      Boolean,    ///< Expect bool value
+      Unspecified ///< Since the `type` member is optional
+    };
+
+    /**
+     * @brief Specifies a command-line option's parameters
+     *
+     * @note An open struct is used for this to enable keyword construction
+     * (e.g.,
+     * `Option opt{.name = {"--arg", "-a"}, .help = "Option description"};`
+     * ). See CliArgs.
+     *
+     * @todo
+     * - Allow positional arguments
+     * - Allow `nargs` to be "arbitrary"
+     */
+    struct Option
+    {
+      /**
+       * @brief Key(s) by which to refer to this Option
+       *
+       * This is the only field that must be explicitly initialized. It expects
+       * 1 or 2 elements.  The first element must exist and must be the
+       * long-hand form, `--name` (must have exactly two hyphens).  The second
+       * element is optional but must be the short-hand form, `-n` (that is,
+       * only one `-`).
+       */
+      std::array<std::string, 2> name;
+      /// Help description to be printed on request. Can be multiple lines.
+      std::string                help{};
+      /// Arguments are optional be default. This makes an argument required
+      bool                       required{false};
+      /// The expected type to which a value should parse
+      ArgType                    type{ArgType::Unspecified};
+      /**
+       * @brief This indicates that the option is a flag, and not followed by a
+       * value
+       *
+       * Flag options are automatically configured to be false by default and
+       * flip to true if parsed.
+       */
+      bool                       flag{false};
+      /// The number of values that can be provided with an option
+      std::size_t                nargs{1};
+      /// Default value(s)
+      ArgVector                  defaults{};
+    };
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/CliOptions/CMakeLists.txt b/GridKit/Utilities/CliOptions/CMakeLists.txt
index cfd854a59..5322cb913 100644
--- a/GridKit/Utilities/CliOptions/CMakeLists.txt
+++ b/GridKit/Utilities/CliOptions/CMakeLists.txt
@@ -2,6 +2,9 @@ gridkit_add_library(utilities_cli_options
   SOURCES
     CliOptions.cpp
   HEADERS
-    CliOptions.hpp)
+    CliOptions.hpp
+  LINK_LIBRARIES
+    PUBLIC GridKit::utilities_logger
+  )
 
 target_link_libraries(Utilities INTERFACE GridKit::utilities_cli_options)
diff --git a/GridKit/Utilities/Stream.hpp b/GridKit/Utilities/Stream.hpp
new file mode 100644
index 000000000..69338cddc
--- /dev/null
+++ b/GridKit/Utilities/Stream.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <iomanip>
+#include <iostream>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+    /**
+     * @brief Print `width` number of spaces
+     */
+    void leftPad(std::ostream& os, unsigned width)
+    {
+      os << std::setfill(' ') << std::setw(static_cast<int>(width)) << "";
+    }
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/GridKit/Utilities/String.hpp b/GridKit/Utilities/String.hpp
new file mode 100644
index 000000000..26e0d39e0
--- /dev/null
+++ b/GridKit/Utilities/String.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <sstream>
+#include <string>
+
+namespace GridKit
+{
+  namespace Utilities
+  {
+    /**
+     * @brief Convert a string to all uppercase
+     */
+    std::string toUpper(std::string str)
+    {
+      std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c)
+                     { return std::toupper(c); });
+      return str;
+    }
+
+    /**
+     * @brief Attempt to parse a string to the given type
+     *
+     * @return parsed value of type T
+     */
+    template <typename T>
+    T parse(const std::string& str)
+    {
+      using namespace std::string_literals;
+
+      T ret;
+
+      auto ss = std::stringstream(str);
+      ss >> ret;
+
+      if (ss.fail() || !ss.eof())
+      {
+        throw std::runtime_error(
+            "Failed to parse \""s + str + "\" as value of type \'" + typeid(T).name() + "\'");
+      }
+      return ret;
+    }
+
+  } // namespace Utilities
+} // namespace GridKit
diff --git a/examples/PhasorDynamics/Tiny/ThreeBus/Basic/CMakeLists.txt b/examples/PhasorDynamics/Tiny/ThreeBus/Basic/CMakeLists.txt
index 81266df9d..5f97c09d6 100644
--- a/examples/PhasorDynamics/Tiny/ThreeBus/Basic/CMakeLists.txt
+++ b/examples/PhasorDynamics/Tiny/ThreeBus/Basic/CMakeLists.txt
@@ -2,14 +2,15 @@ gridkit_example_current_install_path(_install_path)
 
 add_executable(ThreeBusBasic ThreeBusBasic.cpp)
 target_link_libraries(ThreeBusBasic
-	GridKit::phasor_dynamics_components
-	GridKit::solvers_dyn)
+    GridKit::phasor_dynamics_components
+    GridKit::solvers_dyn)
 install(TARGETS ThreeBusBasic RUNTIME DESTINATION ${_install_path})
 
 add_executable(ThreeBusBasicJson ThreeBusBasicJson.cpp)
 target_link_libraries(ThreeBusBasicJson
 	GridKit::phasor_dynamics_components
 	GridKit::solvers_dyn
+    GridKit::utilities_cli_args
     GridKit::testing)
 install(TARGETS ThreeBusBasicJson RUNTIME DESTINATION ${_install_path})
 gridkit_example_add_file(ThreeBusBasic.case.json)
@@ -17,12 +18,11 @@ gridkit_example_add_file(ThreeBusBasic.ref.csv)
 
 add_test(NAME ThreeBusBasic COMMAND ThreeBusBasic)
 add_test(NAME ThreeBusBasicJson
-    COMMAND ThreeBusBasicJson ${CMAKE_CURRENT_BINARY_DIR}/ThreeBusBasic.case.json)
-add_test(NAME ThreeBusBasicJson_no_arg
     COMMAND ThreeBusBasicJson
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+        --case ThreeBusBasic.case.json
+        --compare mon.csv ThreeBusBasic.ref.csv)
 
 gridkit_example_add_file(ThreeBusBasic.solver.json)
-add_test(NAME ThreeBusBasic_using_app
+add_test(NAME ThreeBusBasic_pdsim
     COMMAND PDSim ThreeBusBasic.solver.json
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/examples/PhasorDynamics/Tiny/ThreeBus/Basic/ThreeBusBasicJson.cpp b/examples/PhasorDynamics/Tiny/ThreeBus/Basic/ThreeBusBasicJson.cpp
index f31f47ec1..d302d6e23 100644
--- a/examples/PhasorDynamics/Tiny/ThreeBus/Basic/ThreeBusBasicJson.cpp
+++ b/examples/PhasorDynamics/Tiny/ThreeBus/Basic/ThreeBusBasicJson.cpp
@@ -10,9 +10,7 @@
  */
 #include <cmath>
 #include <ctime>
-#include <filesystem>
-#include <fstream>
-#include <vector>
+#include <iostream>
 
 #include <GridKit/Model/PhasorDynamics/ComponentLibrary.hpp>
 #include <GridKit/Model/PhasorDynamics/SystemModel.hpp>
@@ -20,7 +18,7 @@
 #include <GridKit/Solver/Dynamic/Ida.hpp>
 #include <GridKit/Testing/TestHelpers.hpp>
 #include <GridKit/Testing/Testing.hpp>
-#include <GridKit/Utilities/CliOptions/CliOptions.hpp>
+#include <GridKit/Utilities/CliArgs/CliArgs.hpp>
 
 #define ERROR_TOL 1.0e-4
 
@@ -28,64 +26,47 @@ using scalar_type = double;
 using real_type   = double;
 using index_type  = size_t;
 
-// NOTES:
-// Write function to compare to CSV files
-//  compare number of lines and number of items per line
-
 int main(int argc, const char* argv[])
 {
   using namespace GridKit::PhasorDynamics;
   using namespace AnalysisManager::Sundials;
   using namespace GridKit::Utilities;
+  using namespace GridKit::Testing;
+
+  CliArgs args{
+      {
+          .name     = {"--case", "-c"},
+          .help     = "JSON file describing the system configuration",
+          .required = false,
+          .defaults = "ThreeBusBasic.case.json",
+      },
+
+      {
+          .name     = {"--compare", "-r"},
+          .help     = "Two CSV files to compare:\n"
+                      "<expected-output-file> <reference-file>",
+          .nargs    = 2,
+          .defaults = {"mon.csv", "ThreeBusBasic.ref.csv"},
+      },
+
+      {
+          .name     = {"--tolerance", "-t"},
+          .help     = "Allowable maximum error between compared files",
+          .type     = ArgType::Real,
+          .defaults = 1.0e-4,
+      }};
+
+  args.parseArgs(argc, argv);
 
-  auto error_allowed = static_cast<real_type>(1e-4);
-
-  //
   // Input file
-  //
-
-  std::filesystem::path input_file;
-  if (argc < 2)
-  {
-    if (std::filesystem::exists("ThreeBusBasic.case.json"))
-    {
-      input_file = std::filesystem::current_path() / "ThreeBusBasic.case.json";
-    }
-    else
-    {
-      std::cout << "\n"
-                   "ERROR: No input file found or provided.\n"
-                   "\n"
-                   "Usage:\n"
-                   "       ThreeBusBasicJson <json-input-file>\n"
-                   "\n"
-                   "Please provide a JSON input file as a positional command-line \n"
-                   "argument.\n"
-                   "\n"
-                   "By default this example will look for \"ThreeBusBasic.json\" in the \n"
-                   "current working directory and use that if found.\n"
-                   "\n";
-      exit(1);
-    }
-  }
-  else
-  {
-    input_file = argv[1];
-  }
-
+  auto input_file = args["case"]();
   std::cout << "Example: ThreeBusBasicJson\n";
   std::cout << "Input file: " << input_file << '\n';
 
-  //
   // Create model data
-  //
-
   auto data = parseSystemModelData(input_file);
 
-  //
   // Instantiate system
-  //
-
   SystemModel<scalar_type, index_type> sys(data);
   sys.allocate();
 
@@ -123,13 +104,24 @@ int main(int argc, const char* argv[])
   sys.stopMonitor();
 
   // Generate aggregate errors comparing variable output to reference solution
-  auto errorSet =
-      GridKit::Testing::compareCSV("mon.csv", "ThreeBusBasic.ref.csv");
+  TestStatus status{__func__};
+  if (!args["compare"].empty())
+  {
+    const auto& [out_file, ref_file] = args["compare"].as<2>();
+
+    auto errorSet = GridKit::Testing::compareCSV(out_file, ref_file);
 
-  // Print the errors
-  errorSet.display();
+    // Print the errors
+    errorSet.display();
+
+    auto error_allowed = args["tolerance"].as<real_type>();
+
+    status *= errorSet.total.max_error < error_allowed;
+
+    status.report();
+  }
 
   std::cout << "\n\nComplete in " << (stop - start) / CLOCKS_PER_SEC << " seconds\n";
 
-  return errorSet.total.max_error < error_allowed ? 0 : 1;
+  return status.get();
 }
diff --git a/tests/UnitTests/Utilities/CMakeLists.txt b/tests/UnitTests/Utilities/CMakeLists.txt
index 67ad95578..142d7b0de 100644
--- a/tests/UnitTests/Utilities/CMakeLists.txt
+++ b/tests/UnitTests/Utilities/CMakeLists.txt
@@ -15,11 +15,18 @@ add_executable(test_cli_options runCliOptionsTests.cpp)
 target_link_libraries(test_cli_options PRIVATE
     GridKit::utilities_cli_options
     GridKit::testing)
+add_executable(test_cli_args runCliArgsTests.cpp)
+target_link_libraries(test_cli_args PRIVATE
+    GridKit::utilities_cli_args
+    GridKit::utilities_logger
+    GridKit::testing)
 
 add_test(NAME UtilitiesCaseFormatTest COMMAND test_case_format)
 add_test(NAME UtilitiesLoggerTest COMMAND test_logger)
 add_test(NAME UtilitiesCliOptionsTest COMMAND test_cli_options)
+add_test(NAME UtilitiesCliArgsTest COMMAND test_cli_args)
 
 install(TARGETS test_case_format)
 install(TARGETS test_logger)
 install(TARGETS test_cli_options)
+install(TARGETS test_cli_args)
diff --git a/tests/UnitTests/Utilities/CliArgsTests.hpp b/tests/UnitTests/Utilities/CliArgsTests.hpp
new file mode 100644
index 000000000..770acfa27
--- /dev/null
+++ b/tests/UnitTests/Utilities/CliArgsTests.hpp
@@ -0,0 +1,216 @@
+/**
+ * @file CliArgsTests.hpp
+ */
+
+#pragma once
+
+#include <string>
+
+#include <GridKit/Testing/TestHelpers.hpp>
+#include <GridKit/Testing/Testing.hpp>
+#include <GridKit/Utilities/CliArgs/CliArgs.hpp>
+#include <GridKit/Utilities/Logger/Logger.hpp>
+
+namespace GridKit
+{
+  namespace Testing
+  {
+    using Log = ::GridKit::Utilities::Logger;
+    using namespace std::string_literals;
+
+    class CliArgsTests
+    {
+    public:
+      CliArgsTests()
+      {
+      }
+
+      virtual ~CliArgsTests()
+      {
+      }
+
+      /**
+       * @brief Test (good and bad) construction before parsing
+       */
+      TestOutcome construction()
+      {
+        using namespace GridKit::Utilities;
+
+        TestStatus status{true};
+
+        CliArgs args{{.name = {"--opt1"},
+                      .help = "an option with an argument"},
+
+                     {.name     = {"--opt2", "-o"},
+                      .help     = "An option with an argument and a short-hand",
+                      .type     = ArgType::Integer,
+                      .defaults = 0},
+
+                     {.name  = {"--opt3"},
+                      .help  = "An option with two arguments",
+                      .nargs = 2},
+
+                     {.name = {"--flag1", "-f"},
+                      .help = "A flag option (no argument)",
+                      .flag = true}};
+
+        status *= args["opt1"].empty();
+        status *= !args["opt2"].empty();
+        status *= args["opt2"].as<int>() == 0;
+        status *= args["opt3"].empty();
+        status *= (&args["o"]) == (&args["opt2"]);
+        status *= args["flag1"].as<bool>() == false;
+
+        // bad: duplicate name
+        status *= throws<std::runtime_error>(
+            [&]()
+            {
+              CliArgs args{
+                  {.name = {"--opt1"}},
+                  {.name = {"--opt1", "-o"}}};
+            });
+        status *= throws<std::runtime_error>(
+            [&]()
+            {
+              CliArgs args{
+                  {.name = {"--opt1", "-o"}},
+                  {.name = {"--opt2", "-o"}}};
+            });
+
+        return status.report(__func__);
+      }
+
+      /**
+       * @brief Test for values after parsing
+       */
+      TestOutcome simpleParse()
+      {
+        using namespace GridKit::Utilities;
+
+        CliArgs args{{.name     = {"--file"},
+                      .required = true},
+
+                     {.name  = {"--twoargs"},
+                      .nargs = 2},
+
+                     {.name = {"--size", "-N"},
+                      .type = ArgType::Integer},
+
+                     {.name = {"--tol", "-t"},
+                      .type = ArgType::Real},
+
+                     {.name     = {"--params", "-p"},
+                      .type     = ArgType::Real,
+                      .nargs    = 3,
+                      .defaults = {0, 0, 0}}};
+
+        CommandLine cl{
+            "phony",
+            "--file",
+            "fake.txt",
+            "--twoargs",
+            "arg1",
+            "arg2",
+            "-N",
+            "16",
+            "-t",
+            "0.01",
+            "--params",
+            "0.025",
+            "-1.14",
+            "-21"};
+
+        args.parseArgs(cl.argc, cl.argv);
+
+        TestStatus status{true};
+
+        status *= args.getAppName() == "phony";
+        status *= args["file"]() == "fake.txt";
+        status *= args["twoargs"].as<2>() == std::array{"arg1"s, "arg2"s};
+
+        auto [arg1, arg2] = args["twoargs"].as<2>();
+
+        status *= arg1 == "arg1"s;
+        status *= arg2 == "arg2"s;
+        status *= args["N"].as<int>() == 16;
+
+        auto [N] = args["N"].as<int, 1>();
+
+        status *= N == 16;
+        status *= args.get<int>("N") == 16;
+        status *= args.get<double>("tol") == 0.01;
+
+        auto [x, y, z] = args["params"].as<double, 3>();
+
+        status *= isEqual(x, 0.025);
+        status *= isEqual(y, -1.14);
+        status *= isEqual(z, -21.0);
+        status *=
+            args.get<double, 3>("params") == args["params"].as<double, 3>();
+
+        status *= throws<std::runtime_error>(
+            [&]()
+            { args.get("bad"); });
+
+        return status.report(__func__);
+      }
+
+      /**
+       * @brief Test for errors with bad command-line arguments
+       */
+      TestOutcome parsingErrors()
+      {
+        using namespace GridKit::Utilities;
+
+        TestStatus status{true};
+
+        auto argsAreBad = [&](auto&& cl)
+        {
+          CliArgs args{{.name     = {"--opt1"},
+                        .required = true},
+
+                       {.name  = {"--opt2", "-o"},
+                        .nargs = 2},
+
+                       {.name = {"--flag1", "-f"},
+                        .flag = true}};
+
+          return throws<std::runtime_error>(
+              [&]()
+              { args.parseArgs(cl.argc, cl.argv); });
+        };
+
+        Log::setVerbosity(Log::Verbosity::EVERYTHING);
+
+        // not providing required option
+        Log::misc() << "Expect error for not providing required option\n";
+        status *= argsAreBad(CommandLine{"app"});
+
+        // giving an unexpected option
+        Log::misc() << "Expect error about unexpected option\n";
+        status *= argsAreBad(CommandLine{"app", "--opt1", "val", "-N", "16"});
+
+        // incorrect number of values for an option
+        Log::misc() << "Expect error because 1 < 2\n";
+        status *= argsAreBad(
+            CommandLine{"app", "--opt1", "val", "--opt2", "6"});
+        Log::misc() << "Expect error because 3 > 2\n";
+        status *= argsAreBad(
+            CommandLine{"app", "--opt1", "val", "--opt2", "6", "7", "8"});
+
+        // passing a value to a flag option
+        Log::misc() << "Expect error because flag options don't take args\n";
+        status *= argsAreBad(CommandLine{"app", "--opt1", "val", "-f", "bad"});
+
+        Log::misc() << "Expect error because option name can't be a number\n";
+        status *= throws<std::runtime_error>(
+            []
+            { CliArgs args{{.name = {"--one", "-1"}}}; });
+
+        return status.report(__func__);
+      }
+
+    }; // class CliArgsTests
+
+  } // namespace Testing
+} // namespace GridKit
diff --git a/tests/UnitTests/Utilities/runCliArgsTests.cpp b/tests/UnitTests/Utilities/runCliArgsTests.cpp
new file mode 100644
index 000000000..c2d87724e
--- /dev/null
+++ b/tests/UnitTests/Utilities/runCliArgsTests.cpp
@@ -0,0 +1,13 @@
+#include "CliArgsTests.hpp"
+
+int main()
+{
+  GridKit::Testing::TestingResults result;
+  GridKit::Testing::CliArgsTests   test;
+
+  result += test.construction();
+  result += test.simpleParse();
+  result += test.parsingErrors();
+
+  return result.summary();
+}