diff --git a/algo/lib/CLI11.hpp b/algo/lib/CLI11.hpp
index 7f1a8dbe7df03d76c00b7cfceaa31fd2bed56c5d..1e3f0044c54ad5f7f3ff93793f5b1f1172c576b6 100644
--- a/algo/lib/CLI11.hpp
+++ b/algo/lib/CLI11.hpp
@@ -1,15 +1,15 @@
 #pragma once
 
-// CLI11: Version 1.5.4
+// CLI11: Version 1.7.1
 // Originally designed by Henry Schreiner
 // https://github.com/CLIUtils/CLI11
 //
 // This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts
-// from: v1.5.4
+// from: v1.7.1
 //
 // From LICENSE:
 //
-// CLI11 1.5 Copyright (c) 2017-2018 University of Cincinnati, developed by Henry
+// CLI11 1.7 Copyright (c) 2017-2019 University of Cincinnati, developed by Henry
 // Schreiner under NSF AWARD 1414736. All rights reserved.
 // 
 // Redistribution and use in source and binary forms of CLI11, with or without
@@ -48,6 +48,7 @@
 #include <istream>
 #include <iterator>
 #include <locale>
+#include <map>
 #include <memory>
 #include <numeric>
 #include <set>
@@ -66,9 +67,9 @@
 
 
 #define CLI11_VERSION_MAJOR 1
-#define CLI11_VERSION_MINOR 5
-#define CLI11_VERSION_PATCH 4
-#define CLI11_VERSION "1.5.4"
+#define CLI11_VERSION_MINOR 7
+#define CLI11_VERSION_PATCH 1
+#define CLI11_VERSION "1.7.1"
 
 
 
@@ -101,7 +102,7 @@
 #endif
 #endif
 
-#if defined(PYBIND11_CPP14)
+#if defined(CLI11_CPP14)
 #define CLI11_DEPRECATED(reason) [[deprecated(reason)]]
 #elif defined(_MSC_VER)
 #define CLI11_DEPRECATED(reason) __declspec(deprecated(reason))
@@ -116,14 +117,21 @@
 
 #ifdef __has_include
 
+// You can explicitly enable or disable support
+// by defining these to 1 or 0.
 #if defined(CLI11_CPP17) && __has_include(<optional>) && \
      !defined(CLI11_STD_OPTIONAL)
 #define CLI11_STD_OPTIONAL 1
+#elif !defined(CLI11_STD_OPTIONAL)
+#define CLI11_STD_OPTIONAL 0
 #endif
 
 #if defined(CLI11_CPP14) && __has_include(<experimental/optional>) && \
-    !defined(CLI11_EXPERIMENTAL_OPTIONAL)
+    !defined(CLI11_EXPERIMENTAL_OPTIONAL) \
+    && (!defined(CLI11_STD_OPTIONAL) || CLI11_STD_OPTIONAL == 0)
 #define CLI11_EXPERIMENTAL_OPTIONAL 1
+#elif !defined(CLI11_EXPERIMENTAL_OPTIONAL)
+#define CLI11_EXPERIMENTAL_OPTIONAL 0
 #endif
 
 #if __has_include(<boost/optional.hpp>) && !defined(CLI11_BOOST_OPTIONAL)
@@ -131,6 +139,8 @@
 #if BOOST_VERSION >= 105800
 #define CLI11_BOOST_OPTIONAL 1
 #endif
+#elif !defined(CLI11_BOOST_OPTIONAL)
+#define CLI11_BOOST_OPTIONAL 0
 #endif
 
 #endif
@@ -296,15 +306,16 @@ inline std::string trim_copy(const std::string &str, const std::string &filter)
     return trim(s, filter);
 }
 /// Print a two part "help" string
-inline void format_help(std::stringstream &out, std::string name, std::string description, size_t wid) {
+inline std::ostream &format_help(std::ostream &out, std::string name, std::string description, size_t wid) {
     name = "  " + name;
     out << std::setw(static_cast<int>(wid)) << std::left << name;
     if(!description.empty()) {
         if(name.length() >= wid)
-            out << std::endl << std::setw(static_cast<int>(wid)) << "";
+            out << "\n" << std::setw(static_cast<int>(wid)) << "";
         out << description;
     }
-    out << std::endl;
+    out << "\n";
+    return out;
 }
 
 /// Verify the first character of an option
@@ -333,27 +344,54 @@ inline std::string to_lower(std::string str) {
     return str;
 }
 
+/// remove underscores from a string
+inline std::string remove_underscore(std::string str) {
+    str.erase(std::remove(std::begin(str), std::end(str), '_'), std::end(str));
+    return str;
+}
+
+/// Find and replace a substring with another substring
+inline std::string find_and_replace(std::string str, std::string from, std::string to) {
+
+    size_t start_pos = 0;
+
+    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
+        str.replace(start_pos, from.length(), to);
+        start_pos += to.length();
+    }
+
+    return str;
+}
+
+/// Find a trigger string and call a modify callable function that takes the current string and starting position of the
+/// trigger and returns the position in the string to search for the next trigger string
+template <typename Callable> inline std::string find_and_modify(std::string str, std::string trigger, Callable modify) {
+    size_t start_pos = 0;
+    while((start_pos = str.find(trigger, start_pos)) != std::string::npos) {
+        start_pos = modify(str, start_pos);
+    }
+    return str;
+}
+
 /// Split a string '"one two" "three"' into 'one two', 'three'
+/// Quote characters can be ` ' or "
 inline std::vector<std::string> split_up(std::string str) {
 
-    std::vector<char> delims = {'\'', '\"'};
+    const std::string delims("\'\"`");
     auto find_ws = [](char ch) { return std::isspace<char>(ch, std::locale()); };
     trim(str);
 
     std::vector<std::string> output;
-
+    bool embeddedQuote = false;
+    char keyChar = ' ';
     while(!str.empty()) {
-        if(str[0] == '\'') {
-            auto end = str.find('\'', 1);
-            if(end != std::string::npos) {
-                output.push_back(str.substr(1, end - 1));
-                str = str.substr(end + 1);
-            } else {
-                output.push_back(str.substr(1));
-                str = "";
+        if(delims.find_first_of(str[0]) != std::string::npos) {
+            keyChar = str[0];
+            auto end = str.find_first_of(keyChar, 1);
+            while((end != std::string::npos) && (str[end - 1] == '\\')) { // deal with escaped quotes
+                end = str.find_first_of(keyChar, end + 1);
+                embeddedQuote = true;
             }
-        } else if(str[0] == '\"') {
-            auto end = str.find('\"', 1);
             if(end != std::string::npos) {
                 output.push_back(str.substr(1, end - 1));
                 str = str.substr(end + 1);
@@ -361,7 +399,6 @@ inline std::vector<std::string> split_up(std::string str) {
                 output.push_back(str.substr(1));
                 str = "";
             }
-
         } else {
             auto it = std::find_if(std::begin(str), std::end(str), find_ws);
             if(it != std::end(str)) {
@@ -373,9 +410,13 @@ inline std::vector<std::string> split_up(std::string str) {
                 str = "";
             }
         }
+        // transform any embedded quotes into the regular character
+        if(embeddedQuote) {
+            output.back() = find_and_replace(output.back(), std::string("\\") + keyChar, std::string(1, keyChar));
+            embeddedQuote = false;
+        }
         trim(str);
     }
-
     return output;
 }
 
@@ -395,6 +436,34 @@ inline std::string fix_newlines(std::string leader, std::string input) {
     return input;
 }
 
+/// This function detects an equal or colon followed by an escaped quote after an argument
+/// then modifies the string to replace the equality with a space.  This is needed
+/// to allow the split up function to work properly and is intended to be used with the find_and_modify function
+/// the return value is the offset+1 which is required by the find_and_modify function.
+inline size_t escape_detect(std::string &str, size_t offset) {
+    auto next = str[offset + 1];
+    if((next == '\"') || (next == '\'') || (next == '`')) {
+        auto astart = str.find_last_of("-/ \"\'`", offset - 1);
+        if(astart != std::string::npos) {
+            if(str[astart] == ((str[offset] == '=') ? '-' : '/'))
+                str[offset] = ' '; // interpret this as a space so the split_up works properly
+        }
+    }
+    return offset + 1;
+}
+
+/// Add quotes if the string contains spaces
+inline std::string &add_quotes_if_needed(std::string &str) {
+    if((str.front() != '"' && str.front() != '\'') || str.front() != str.back()) {
+        char quote = str.find('"') < str.find('\'') ? '\'' : '"';
+        if(str.find(' ') != std::string::npos) {
+            str.insert(0, 1, quote);
+            str.append(1, quote);
+        }
+    }
+    return str;
+}
+
 } // namespace detail
 } // namespace CLI
 
@@ -402,12 +471,13 @@ inline std::string fix_newlines(std::string leader, std::string input) {
 
 namespace CLI {
 
-// Use one of these on all error classes
+// Use one of these on all error classes.
+// These are temporary and are undef'd at the end of this file.
 #define CLI11_ERROR_DEF(parent, name)                                                                                  \
   protected:                                                                                                           \
-    name(std::string name, std::string msg, int exit_code) : parent(std::move(name), std::move(msg), exit_code) {}     \
-    name(std::string name, std::string msg, ExitCodes exit_code)                                                       \
-        : parent(std::move(name), std::move(msg), exit_code) {}                                                        \
+    name(std::string ename, std::string msg, int exit_code) : parent(std::move(ename), std::move(msg), exit_code) {}   \
+    name(std::string ename, std::string msg, ExitCodes exit_code)                                                      \
+        : parent(std::move(ename), std::move(msg), exit_code) {}                                                       \
                                                                                                                        \
   public:                                                                                                              \
     name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {}                           \
@@ -431,7 +501,7 @@ enum class ExitCodes {
     RequiresError,
     ExcludesError,
     ExtrasError,
-    INIError,
+    ConfigError,
     InvalidError,
     HorribleError,
     OptionNotFound,
@@ -449,16 +519,16 @@ enum class ExitCodes {
 
 /// All errors derive from this one
 class Error : public std::runtime_error {
-    int exit_code;
-    std::string name{"Error"};
+    int actual_exit_code;
+    std::string error_name{"Error"};
 
   public:
-    int get_exit_code() const { return exit_code; }
+    int get_exit_code() const { return actual_exit_code; }
 
-    std::string get_name() const { return name; }
+    std::string get_name() const { return error_name; }
 
     Error(std::string name, std::string msg, int exit_code = static_cast<int>(ExitCodes::BaseClass))
-        : runtime_error(msg), exit_code(exit_code), name(std::move(name)) {}
+        : runtime_error(msg), actual_exit_code(exit_code), error_name(std::move(name)) {}
 
     Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {}
 };
@@ -550,6 +620,13 @@ class CallForAdvancedHelp : public ParseError {
     CLI11_ERROR_DEF(ParseError, CallForAdvancedHelp)
     CallForAdvancedHelp() : CallForAdvancedHelp("This should be caught in your main function, see examples", ExitCodes::Success /* , 2 */ ) {}
 };
+
+/// Usually something like --help-all on command line
+class CallForAllHelp : public ParseError {
+    CLI11_ERROR_DEF(ParseError, CallForAllHelp)
+    CallForAllHelp()
+        : CallForAllHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
+};
   
 /// Does not output a diagnostic in CLI11_PARSE, but allows to return from main() with a specific error code.
 class RuntimeError : public ParseError {
@@ -644,12 +721,12 @@ class ExtrasError : public ParseError {
 };
 
 /// Thrown when extra values are found in an INI file
-class INIError : public ParseError {
-    CLI11_ERROR_DEF(ParseError, INIError)
-    CLI11_ERROR_SIMPLE(INIError)
-    static INIError Extras(std::string item) { return INIError("INI was not able to parse " + item); }
-    static INIError NotConfigurable(std::string item) {
-        return INIError(item + ": This option is not allowed in a configuration file");
+class ConfigError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ConfigError)
+    CLI11_ERROR_SIMPLE(ConfigError)
+    static ConfigError Extras(std::string item) { return ConfigError("INI was not able to parse " + item); }
+    static ConfigError NotConfigurable(std::string item) {
+        return ConfigError(item + ": This option is not allowed in a configuration file");
     }
 };
 
@@ -676,6 +753,9 @@ class OptionNotFound : public Error {
     explicit OptionNotFound(std::string name) : OptionNotFound(name + " not found", ExitCodes::OptionNotFound) {}
 };
 
+#undef CLI11_ERROR_DEF
+#undef CLI11_ERROR_SIMPLE
+
 /// @}
 
 } // namespace CLI
@@ -686,18 +766,24 @@ namespace CLI {
 
 // Type tools
 
-// We could check to see if C++14 is being used, but it does not hurt to redefine this
-// (even Google does this: https://github.com/google/skia/blob/master/include/private/SkTLogic.h)
-// It is not in the std namespace anyway, so no harm done.
+/// A copy of enable_if_t from C++14, compatible with C++11.
+///
+/// We could check to see if C++14 is being used, but it does not hurt to redefine this
+/// (even Google does this: https://github.com/google/skia/blob/master/include/private/SkTLogic.h)
+/// It is not in the std namespace anyway, so no harm done.
 
 template <bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;
 
+/// Check to see if something is a vector (fail check by default)
 template <typename T> struct is_vector { static const bool value = false; };
 
+/// Check to see if something is a vector (true if actually a vector)
 template <class T, class A> struct is_vector<std::vector<T, A>> { static bool const value = true; };
 
+/// Check to see if something is bool (fail check by default)
 template <typename T> struct is_bool { static const bool value = false; };
 
+/// Check to see if something is bool (true if actually a bool)
 template <> struct is_bool<bool> { static bool const value = true; };
 
 namespace detail {
@@ -839,7 +925,7 @@ inline bool split_short(const std::string &current, std::string &name, std::stri
 // Returns false if not a long option. Otherwise, sets opt name and other side of = and returns true
 inline bool split_long(const std::string &current, std::string &name, std::string &value) {
     if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
-        auto loc = current.find("=");
+        auto loc = current.find_first_of('=');
         if(loc != std::string::npos) {
             name = current.substr(2, loc - 2);
             value = current.substr(loc + 1);
@@ -852,6 +938,22 @@ inline bool split_long(const std::string &current, std::string &name, std::strin
         return false;
 }
 
+// Returns false if not a windows style option. Otherwise, sets opt name and value and returns true
+inline bool split_windows(const std::string &current, std::string &name, std::string &value) {
+    if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
+        auto loc = current.find_first_of(':');
+        if(loc != std::string::npos) {
+            name = current.substr(1, loc - 1);
+            value = current.substr(loc + 1);
+        } else {
+            name = current.substr(1);
+            value = "";
+        }
+        return true;
+    } else
+        return false;
+}
+
 // Splits a string into multiple long and short names
 inline std::vector<std::string> split_names(std::string current) {
     std::vector<std::string> output;
@@ -902,12 +1004,16 @@ get_names(const std::vector<std::string> &input) {
 } // namespace detail
 } // namespace CLI
 
-// From CLI/Ini.hpp:
+// From CLI/ConfigFwd.hpp:
 
 namespace CLI {
+
+class App;
+
 namespace detail {
 
-inline std::string inijoin(std::vector<std::string> args) {
+/// Comma separated join, adds quotes if needed
+inline std::string ini_join(std::vector<std::string> args) {
     std::ostringstream s;
     size_t start = 0;
     for(const auto &arg : args) {
@@ -926,86 +1032,126 @@ inline std::string inijoin(std::vector<std::string> args) {
     return s.str();
 }
 
-struct ini_ret_t {
-    /// This is the full name with dots
-    std::string fullname;
+} // namespace detail
 
-    /// Listing of inputs
-    std::vector<std::string> inputs;
+/// Holds values to load into Options
+struct ConfigItem {
+    /// This is the list of parents
+    std::vector<std::string> parents;
 
-    /// Current parent level
-    size_t level = 0;
+    /// This is the name
+    std::string name;
 
-    /// Return parent or empty string, based on level
-    ///
-    /// Level 0, a.b.c would return a
-    /// Level 1, a.b.c could return b
-    std::string parent() const {
-        std::vector<std::string> plist = detail::split(fullname, '.');
-        if(plist.size() > (level + 1))
-            return plist[level];
-        else
-            return "";
-    }
+    /// Listing of inputs
+    std::vector<std::string> inputs;
 
-    /// Return name
-    std::string name() const {
-        std::vector<std::string> plist = detail::split(fullname, '.');
-        return plist.at(plist.size() - 1);
+    /// The list of parents and name joined by "."
+    std::string fullname() const {
+        std::vector<std::string> tmp = parents;
+        tmp.emplace_back(name);
+        return detail::join(tmp, ".");
     }
 };
 
-/// Internal parsing function
-inline std::vector<ini_ret_t> parse_ini(std::istream &input) {
-    std::string name, line;
-    std::string section = "default";
-
-    std::vector<ini_ret_t> output;
-
-    while(getline(input, line)) {
-        std::vector<std::string> items;
-
-        detail::trim(line);
-        size_t len = line.length();
-        if(len > 1 && line[0] == '[' && line[len - 1] == ']') {
-            section = line.substr(1, len - 2);
-        } else if(len > 0 && line[0] != ';') {
-            output.emplace_back();
-            ini_ret_t &out = output.back();
-
-            // Find = in string, split and recombine
-            auto pos = line.find("=");
-            if(pos != std::string::npos) {
-                name = detail::trim_copy(line.substr(0, pos));
-                std::string item = detail::trim_copy(line.substr(pos + 1));
-                items = detail::split_up(item);
+/// This class provides a converter for configuration files.
+class Config {
+  protected:
+    std::vector<ConfigItem> items;
+
+  public:
+    /// Convert an app into a configuration
+    virtual std::string to_config(const App *, bool, bool, std::string) const = 0;
+
+    /// Convert a configuration into an app
+    virtual std::vector<ConfigItem> from_config(std::istream &) const = 0;
+
+    /// Convert a flag to a bool
+    virtual std::vector<std::string> to_flag(const ConfigItem &item) const {
+        if(item.inputs.size() == 1) {
+            std::string val = item.inputs.at(0);
+            val = detail::to_lower(val);
+
+            if(val == "true" || val == "on" || val == "yes") {
+                return std::vector<std::string>(1);
+            } else if(val == "false" || val == "off" || val == "no") {
+                return std::vector<std::string>();
             } else {
-                name = detail::trim_copy(line);
-                items = {"ON"};
+                try {
+                    size_t ui = std::stoul(val);
+                    return std::vector<std::string>(ui);
+                } catch(const std::invalid_argument &) {
+                    throw ConversionError::TrueFalse(item.fullname());
+                }
             }
+        } else {
+            throw ConversionError::TooManyInputsFlag(item.fullname());
+        }
+    }
 
-            if(detail::to_lower(section) == "default")
-                out.fullname = name;
-            else
-                out.fullname = section + "." + name;
+    /// Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure
+    std::vector<ConfigItem> from_file(const std::string &name) {
+        std::ifstream input{name};
+        if(!input.good())
+            throw FileError::Missing(name);
 
-            out.inputs.insert(std::end(out.inputs), std::begin(items), std::end(items));
-        }
+        return from_config(input);
     }
-    return output;
-}
 
-/// Parse an INI file, throw an error (ParseError:INIParseError or FileError) on failure
-inline std::vector<ini_ret_t> parse_ini(const std::string &name) {
+    /// virtual destructor
+    virtual ~Config() = default;
+};
+
+/// This converter works with INI files
+class ConfigINI : public Config {
+  public:
+    std::string to_config(const App *, bool default_also, bool write_description, std::string prefix) const override;
+
+    std::vector<ConfigItem> from_config(std::istream &input) const override {
+        std::string line;
+        std::string section = "default";
+
+        std::vector<ConfigItem> output;
+
+        while(getline(input, line)) {
+            std::vector<std::string> items_buffer;
+
+            detail::trim(line);
+            size_t len = line.length();
+            if(len > 1 && line[0] == '[' && line[len - 1] == ']') {
+                section = line.substr(1, len - 2);
+            } else if(len > 0 && line[0] != ';') {
+                output.emplace_back();
+                ConfigItem &out = output.back();
+
+                // Find = in string, split and recombine
+                auto pos = line.find('=');
+                if(pos != std::string::npos) {
+                    out.name = detail::trim_copy(line.substr(0, pos));
+                    std::string item = detail::trim_copy(line.substr(pos + 1));
+                    items_buffer = detail::split_up(item);
+                } else {
+                    out.name = detail::trim_copy(line);
+                    items_buffer = {"ON"};
+                }
 
-    std::ifstream input{name};
-    if(!input.good())
-        throw FileError::Missing(name);
+                if(detail::to_lower(section) != "default") {
+                    out.parents = {section};
+                }
 
-    return parse_ini(input);
-}
+                if(out.name.find('.') != std::string::npos) {
+                    std::vector<std::string> plist = detail::split(out.name, '.');
+                    out.name = plist.back();
+                    plist.pop_back();
+                    out.parents.insert(out.parents.end(), plist.begin(), plist.end());
+                }
+
+                out.inputs.insert(std::end(out.inputs), std::begin(items_buffer), std::end(items_buffer));
+            }
+        }
+        return output;
+    }
+};
 
-} // namespace detail
 } // namespace CLI
 
 // From CLI/Validators.hpp:
@@ -1013,79 +1159,373 @@ inline std::vector<ini_ret_t> parse_ini(const std::string &name) {
 namespace CLI {
 
 /// @defgroup validator_group Validators
+
 /// @brief Some validators that are provided
 ///
-/// These are simple `void(std::string&)` validators that are useful. They throw
-/// a ValidationError if they fail (or the normally expected error if the cast fails)
+/// These are simple `std::string(const std::string&)` validators that are useful. They return
+/// a string if the validation fails. A custom struct is provided, as well, with the same user
+/// semantics, but with the ability to provide a new type name.
 /// @{
 
-/// Check for an existing file
-inline std::string ExistingFile(const std::string &filename) {
-    struct stat buffer;
-    bool exist = stat(filename.c_str(), &buffer) == 0;
-    bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
-    if(!exist) {
-        return "File does not exist: " + filename;
-    } else if(is_dir) {
-        return "File is actually a directory: " + filename;
-    }
-    return std::string();
-}
+///
+struct Validator {
+    /// This is the type name, if empty the type name will not be changed
+    std::string tname;
+
+    /// This it the base function that is to be called.
+    /// Returns a string error message if validation fails.
+    std::function<std::string(const std::string &)> func;
+
+    /// This is the required operator for a validator - provided to help
+    /// users (CLI11 uses the member `func` directly)
+    std::string operator()(const std::string &str) const { return func(str); };
+
+    /// Combining validators is a new validator
+    Validator operator&(const Validator &other) const {
+        Validator newval;
+        newval.tname = (tname == other.tname ? tname : "");
+
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(const std::string &filename)> &f1 = func;
+        const std::function<std::string(const std::string &filename)> &f2 = other.func;
+
+        newval.func = [f1, f2](const std::string &filename) {
+            std::string s1 = f1(filename);
+            std::string s2 = f2(filename);
+            if(!s1.empty() && !s2.empty())
+                return s1 + " & " + s2;
+            else
+                return s1 + s2;
+        };
+        return newval;
+    }
 
-/// Check for an existing directory
-inline std::string ExistingDirectory(const std::string &filename) {
-    struct stat buffer;
-    bool exist = stat(filename.c_str(), &buffer) == 0;
-    bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
-    if(!exist) {
-        return "Directory does not exist: " + filename;
-    } else if(!is_dir) {
-        return "Directory is actually a file: " + filename;
-    }
-    return std::string();
-}
+    /// Combining validators is a new validator
+    Validator operator|(const Validator &other) const {
+        Validator newval;
+        newval.tname = (tname == other.tname ? tname : "");
+
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(const std::string &filename)> &f1 = func;
+        const std::function<std::string(const std::string &filename)> &f2 = other.func;
+
+        newval.func = [f1, f2](const std::string &filename) {
+            std::string s1 = f1(filename);
+            std::string s2 = f2(filename);
+            if(s1.empty() || s2.empty())
+                return std::string();
+            else
+                return s1 + " & " + s2;
+        };
+        return newval;
+    }
+};
+
+// The implementation of the built in validators is using the Validator class;
+// the user is only expected to use the const (static) versions (since there's no setup).
+// Therefore, this is in detail.
+namespace detail {
+
+/// Check for an existing file (returns error message if check fails)
+struct ExistingFileValidator : public Validator {
+    ExistingFileValidator() {
+        tname = "FILE";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool exist = stat(filename.c_str(), &buffer) == 0;
+            bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
+            if(!exist) {
+                return "File does not exist: " + filename;
+            } else if(is_dir) {
+                return "File is actually a directory: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an existing directory (returns error message if check fails)
+struct ExistingDirectoryValidator : public Validator {
+    ExistingDirectoryValidator() {
+        tname = "DIR";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool exist = stat(filename.c_str(), &buffer) == 0;
+            bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
+            if(!exist) {
+                return "Directory does not exist: " + filename;
+            } else if(!is_dir) {
+                return "Directory is actually a file: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
 
 /// Check for an existing path
-inline std::string ExistingPath(const std::string &filename) {
-    struct stat buffer;
-    bool const exist = stat(filename.c_str(), &buffer) == 0;
-    if(!exist) {
-        return "Path does not exist: " + filename;
+struct ExistingPathValidator : public Validator {
+    ExistingPathValidator() {
+        tname = "PATH";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool const exist = stat(filename.c_str(), &buffer) == 0;
+            if(!exist) {
+                return "Path does not exist: " + filename;
+            }
+            return std::string();
+        };
     }
-    return std::string();
-}
+};
 
-/// Check for a non-existing path
-inline std::string NonexistentPath(const std::string &filename) {
-    struct stat buffer;
-    bool exist = stat(filename.c_str(), &buffer) == 0;
-    if(exist) {
-        return "Path already exists: " + filename;
+/// Check for an non-existing path
+struct NonexistentPathValidator : public Validator {
+    NonexistentPathValidator() {
+        tname = "PATH";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool exist = stat(filename.c_str(), &buffer) == 0;
+            if(exist) {
+                return "Path already exists: " + filename;
+            }
+            return std::string();
+        };
     }
-    return std::string();
-}
+};
+} // namespace detail
 
-/// Produce a range validator function
-template <typename T> std::function<std::string(const std::string &)> Range(T min, T max) {
-    return [min, max](std::string input) {
-        T val;
-        detail::lexical_cast(input, val);
-        if(val < min || val > max)
-            return "Value " + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
+// Static is not needed here, because global const implies static.
 
-        return std::string();
-    };
-}
+/// Check for existing file (returns error message if check fails)
+const detail::ExistingFileValidator ExistingFile;
 
-/// Range of one value is 0 to value
-template <typename T> std::function<std::string(const std::string &)> Range(T max) {
-    return Range(static_cast<T>(0), max);
-}
+/// Check for an existing directory (returns error message if check fails)
+const detail::ExistingDirectoryValidator ExistingDirectory;
+
+/// Check for an existing path
+const detail::ExistingPathValidator ExistingPath;
+
+/// Check for an non-existing path
+const detail::NonexistentPathValidator NonexistentPath;
+
+///  Produce a range (factory). Min and max are inclusive.
+struct Range : public Validator {
+    /// This produces a range with min and max inclusive.
+    ///
+    /// Note that the constructor is templated, but the struct is not, so C++17 is not
+    /// needed to provide nice syntax for Range(a,b).
+    template <typename T> Range(T min, T max) {
+        std::stringstream out;
+        out << detail::type_name<T>() << " in [" << min << " - " << max << "]";
+
+        tname = out.str();
+        func = [min, max](std::string input) {
+            T val;
+            detail::lexical_cast(input, val);
+            if(val < min || val > max)
+                return "Value " + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
+
+            return std::string();
+        };
+    }
+
+    /// Range of one value is 0 to value
+    template <typename T> explicit Range(T max) : Range(static_cast<T>(0), max) {}
+};
 
+namespace detail {
+/// split a string into a program name and command line arguments
+/// the string is assumed to contain a file name followed by other arguments
+/// the return value contains is a pair with the first argument containing the program name and the second everything
+/// else
+inline std::pair<std::string, std::string> split_program_name(std::string commandline) {
+    // try to determine the programName
+    std::pair<std::string, std::string> vals;
+    trim(commandline);
+    auto esp = commandline.find_first_of(' ', 1);
+    while(!ExistingFile(commandline.substr(0, esp)).empty()) {
+        esp = commandline.find_first_of(' ', esp + 1);
+        if(esp == std::string::npos) {
+            // if we have reached the end and haven't found a valid file just assume the first argument is the
+            // program name
+            esp = commandline.find_first_of(' ', 1);
+            break;
+        }
+    }
+    vals.first = commandline.substr(0, esp);
+    rtrim(vals.first);
+    // strip the program name
+    vals.second = (esp != std::string::npos) ? commandline.substr(esp + 1) : std::string{};
+    ltrim(vals.second);
+    return vals;
+}
+} // namespace detail
 /// @}
 
 } // namespace CLI
 
+// From CLI/FormatterFwd.hpp:
+
+namespace CLI {
+
+class Option;
+class App;
+
+/// This enum signifies the type of help requested
+///
+/// This is passed in by App; all user classes must accept this as
+/// the second argument.
+
+enum class AppFormatMode {
+    Normal, //< The normal, detailed help
+    All,    //< A fully expanded help
+    Sub,    //< Used when printed as part of expanded subcommand
+};
+
+/// This is the minimum requirements to run a formatter.
+///
+/// A user can subclass this is if they do not care at all
+/// about the structure in CLI::Formatter.
+class FormatterBase {
+  protected:
+    /// @name Options
+    ///@{
+
+    /// The width of the first column
+    size_t column_width_{30};
+
+    /// @brief The required help printout labels (user changeable)
+    /// Values are Needs, Excludes, etc.
+    std::map<std::string, std::string> labels_;
+
+    ///@}
+    /// @name Basic
+    ///@{
+
+  public:
+    FormatterBase() = default;
+    FormatterBase(const FormatterBase &) = default;
+    FormatterBase(FormatterBase &&) = default;
+    virtual ~FormatterBase() = default;
+
+    /// This is the key method that puts together help
+    virtual std::string make_help(const App *, std::string, AppFormatMode) const = 0;
+
+    ///@}
+    /// @name Setters
+    ///@{
+
+    /// Set the "REQUIRED" label
+    void label(std::string key, std::string val) { labels_[key] = val; }
+
+    /// Set the column width
+    void column_width(size_t val) { column_width_ = val; }
+
+    ///@}
+    /// @name Getters
+    ///@{
+
+    /// Get the current value of a name (REQUIRED, etc.)
+    std::string get_label(std::string key) const {
+        if(labels_.find(key) == labels_.end())
+            return key;
+        else
+            return labels_.at(key);
+    }
+
+    /// Get the current column width
+    size_t get_column_width() const { return column_width_; }
+
+    ///@}
+};
+
+/// This is a specialty override for lambda functions
+class FormatterLambda final : public FormatterBase {
+    using funct_t = std::function<std::string(const App *, std::string, AppFormatMode)>;
+
+    /// The lambda to hold and run
+    funct_t lambda_;
+
+  public:
+    /// Create a FormatterLambda with a lambda function
+    explicit FormatterLambda(funct_t funct) : lambda_(std::move(funct)) {}
+
+    /// This will simply call the lambda function
+    std::string make_help(const App *app, std::string name, AppFormatMode mode) const override {
+        return lambda_(app, name, mode);
+    }
+};
+
+/// This is the default Formatter for CLI11. It pretty prints help output, and is broken into quite a few
+/// overridable methods, to be highly customizable with minimal effort.
+class Formatter : public FormatterBase {
+  public:
+    Formatter() = default;
+    Formatter(const Formatter &) = default;
+    Formatter(Formatter &&) = default;
+
+    /// @name Overridables
+    ///@{
+
+    /// This prints out a group of options with title
+    ///
+    virtual std::string make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const;
+
+    /// This prints out just the positionals "group"
+    virtual std::string make_positionals(const App *app) const;
+
+    /// This prints out all the groups of options
+    std::string make_groups(const App *app, AppFormatMode mode) const;
+
+    /// This prints out all the subcommands
+    virtual std::string make_subcommands(const App *app, AppFormatMode mode) const;
+
+    /// This prints out a subcommand
+    virtual std::string make_subcommand(const App *sub) const;
+
+    /// This prints out a subcommand in help-all
+    virtual std::string make_expanded(const App *sub) const;
+
+    /// This prints out all the groups of options
+    virtual std::string make_footer(const App *app) const;
+
+    /// This displays the description line
+    virtual std::string make_description(const App *app) const;
+
+    /// This displays the usage line
+    virtual std::string make_usage(const App *app, std::string name) const;
+
+    /// This puts everything together
+    std::string make_help(const App *, std::string, AppFormatMode) const override;
+
+    ///@}
+    /// @name Options
+    ///@{
+
+    /// This prints out an option help line, either positional or optional form
+    virtual std::string make_option(const Option *opt, bool is_positional) const {
+        std::stringstream out;
+        detail::format_help(
+            out, make_option_name(opt, is_positional) + make_option_opts(opt), make_option_desc(opt), column_width_);
+        return out.str();
+    }
+
+    /// @brief This is the name part of an option, Default: left column
+    virtual std::string make_option_name(const Option *, bool) const;
+
+    /// @brief This is the options part of the name, Default: combined into left column
+    virtual std::string make_option_opts(const Option *) const;
+
+    /// @brief This is the description. Default: Right column, on new line if left column too large
+    virtual std::string make_option_desc(const Option *) const;
+
+    /// @brief This is used to print the name on the USAGE line
+    virtual std::string make_option_usage(const Option *opt) const;
+
+    ///@}
+};
+
+} // namespace CLI
+
 // From CLI/Option.hpp:
 
 namespace CLI {
@@ -1100,6 +1540,8 @@ using Option_p = std::unique_ptr<Option>;
 
 enum class MultiOptionPolicy { Throw, TakeLast, TakeFirst, Join };
 
+/// This is the CRTP base class for Option and OptionDefaults. It was designed this way
+/// to share parts of the class; an OptionDefaults can copy to an Option.
 template <typename CRTP> class OptionBase {
     friend App;
 
@@ -1116,16 +1558,21 @@ template <typename CRTP> class OptionBase {
     /// Ignore the case when matching (option, not value)
     bool ignore_case_{false};
 
+    /// Ignore underscores when matching (option, not value)
+    bool ignore_underscore_{false};
+
     /// Allow this option to be given in a configuration file
     bool configurable_{true};
 
     /// Policy for multiple arguments when `expected_ == 1`  (can be set on bool flags, too)
     MultiOptionPolicy multi_option_policy_{MultiOptionPolicy::Throw};
 
+    /// Copy the contents to another similar class (one based on OptionBase)
     template <typename T> void copy_to(T *other) const {
         other->group(group_);
         other->required(required_);
         other->ignore_case(ignore_case_);
+        other->ignore_underscore(ignore_underscore_);
         other->configurable(configurable_);
         other->multi_option_policy(multi_option_policy_);
     }
@@ -1166,6 +1613,9 @@ template <typename CRTP> class OptionBase {
     /// The status of ignore case
     bool get_ignore_case() const { return ignore_case_; }
 
+    /// The status of ignore_underscore
+    bool get_ignore_underscore() const { return ignore_underscore_; }
+
     /// The status of configurable
     bool get_configurable() const { return configurable_; }
 
@@ -1202,6 +1652,8 @@ template <typename CRTP> class OptionBase {
     }
 };
 
+/// This is a version of OptionBase that only supports setting values,
+/// for defaults. It is stored as the default option in an App.
 class OptionDefaults : public OptionBase<OptionDefaults> {
   public:
     OptionDefaults() = default;
@@ -1219,6 +1671,12 @@ class OptionDefaults : public OptionBase<OptionDefaults> {
         ignore_case_ = value;
         return this;
     }
+
+    /// Ignore underscores in the option name
+    OptionDefaults *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        return this;
+    }
 };
 
 class Option : public OptionBase<Option> {
@@ -1251,7 +1709,9 @@ class Option : public OptionBase<Option> {
     std::string defaultval_;
 
     /// A human readable type value, set when App creates this
-    std::string typeval_;
+    ///
+    /// This is a lambda function so "types" can be dynamic, such as when a set prints its contents.
+    std::function<std::string()> type_name_{[]() { return std::string(); }};
 
     /// True if this option has a default
     bool default_{false};
@@ -1272,7 +1732,7 @@ class Option : public OptionBase<Option> {
     std::vector<std::function<std::string(std::string &)>> validators_;
 
     /// A list of options that are required with this option
-    std::set<Option *> requires_;
+    std::set<Option *> needs_;
 
     /// A list of options that are excluded with this option
     std::set<Option *> excludes_;
@@ -1300,13 +1760,14 @@ class Option : public OptionBase<Option> {
     ///@}
 
     /// Making an option by hand is not defined, it must be made by the App class
-    Option(std::string name,
-           std::string description = "",
-           std::function<bool(results_t)> callback = [](results_t) { return true; },
-           bool default_ = true,
-           App *parent = nullptr)
-        : description_(std::move(description)), default_(default_), parent_(parent), callback_(std::move(callback)) {
-        std::tie(snames_, lnames_, pname_) = detail::get_names(detail::split_names(name));
+    Option(std::string option_name,
+           std::string description,
+           std::function<bool(results_t)> callback,
+           bool defaulted,
+           App *parent)
+        : description_(std::move(description)), default_(defaulted), parent_(parent),
+          callback_(callback ? std::move(callback) : [](results_t) { return true; }) {
+        std::tie(snames_, lnames_, pname_) = detail::get_names(detail::split_names(option_name));
     }
 
   public:
@@ -1316,8 +1777,11 @@ class Option : public OptionBase<Option> {
     /// Count the total number of times an option was passed
     size_t count() const { return results_.size(); }
 
+    /// True if the option was not passed
+    size_t empty() const { return results_.empty(); }
+
     /// This class is true if option is passed.
-    operator bool() const { return count() > 0; }
+    operator bool() const { return !empty(); }
 
     /// Clear the parsed results (mostly for testing)
     void clear() { results_.clear(); }
@@ -1330,11 +1794,11 @@ class Option : public OptionBase<Option> {
     Option *expected(int value) {
         // Break if this is a flag
         if(type_size_ == 0)
-            throw IncorrectConstruction::SetFlag(single_name());
+            throw IncorrectConstruction::SetFlag(get_name(true, true));
 
         // Setting 0 is not allowed
         else if(value == 0)
-            throw IncorrectConstruction::Set0Opt(single_name());
+            throw IncorrectConstruction::Set0Opt(get_name());
 
         // No change is okay, quit now
         else if(expected_ == value)
@@ -1342,17 +1806,25 @@ class Option : public OptionBase<Option> {
 
         // Type must be a vector
         else if(type_size_ >= 0)
-            throw IncorrectConstruction::ChangeNotVector(single_name());
+            throw IncorrectConstruction::ChangeNotVector(get_name());
 
         // TODO: Can support multioption for non-1 values (except for join)
         else if(value != 1 && multi_option_policy_ != MultiOptionPolicy::Throw)
-            throw IncorrectConstruction::AfterMultiOpt(single_name());
+            throw IncorrectConstruction::AfterMultiOpt(get_name());
 
         expected_ = value;
         return this;
     }
 
-    /// Adds a validator
+    /// Adds a validator with a built in type name
+    Option *check(const Validator &validator) {
+        validators_.emplace_back(validator.func);
+        if(!validator.tname.empty())
+            type_name(validator.tname);
+        return this;
+    }
+
+    /// Adds a validator. Takes a const string& and returns an error message (empty if conversion/check is okay).
     Option *check(std::function<std::string(const std::string &)> validator) {
         validators_.emplace_back(validator);
         return this;
@@ -1371,11 +1843,20 @@ class Option : public OptionBase<Option> {
         return this;
     }
 
+    /// Adds a user supplied function to run on each item passed in (communicate though lambda capture)
+    Option *each(std::function<void(std::string)> func) {
+        validators_.emplace_back([func](std::string &inout) {
+            func(inout);
+            return std::string();
+        });
+        return this;
+    }
+
     /// Sets required options
     Option *needs(Option *opt) {
-        auto tup = requires_.insert(opt);
+        auto tup = needs_.insert(opt);
         if(!tup.second)
-            throw OptionAlreadyAdded::Requires(single_name(), opt->single_name());
+            throw OptionAlreadyAdded::Requires(get_name(), opt->get_name());
         return this;
     }
 
@@ -1393,25 +1874,17 @@ class Option : public OptionBase<Option> {
         return needs(opt1, args...);
     }
 
-#ifndef CLI11_CPP20
-    /// Sets required options \deprecated
-    CLI11_DEPRECATED("Use needs instead of requires (eventual keyword clash)")
-    Option *requires(Option *opt) { return needs(opt); }
-
-    /// Can find a string if needed \deprecated
-    template <typename T = App> Option *requires(std::string opt_name) {
-        for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
-            if(opt.get() != this && opt->check_name(opt_name))
-                return needs(opt.get());
-        throw IncorrectConstruction::MissingOption(opt_name);
-    }
+    /// Remove needs link from an option. Returns true if the option really was in the needs list.
+    bool remove_needs(Option *opt) {
+        auto iterator = std::find(std::begin(needs_), std::end(needs_), opt);
 
-    /// Any number supported, any mix of string and Opt \deprecated
-    template <typename A, typename B, typename... ARG> Option *requires(A opt, B opt1, ARG... args) {
-        requires(opt);
-        return requires(opt1, args...);
+        if(iterator != std::end(needs_)) {
+            needs_.erase(iterator);
+            return true;
+        } else {
+            return false;
+        }
     }
-#endif
 
     /// Sets excluded options
     Option *excludes(Option *opt) {
@@ -1440,10 +1913,22 @@ class Option : public OptionBase<Option> {
         return excludes(opt1, args...);
     }
 
-    /// Sets environment variable to read if no option given
-    Option *envname(std::string name) {
-        envname_ = name;
-        return this;
+    /// Remove needs link from an option. Returns true if the option really was in the needs list.
+    bool remove_excludes(Option *opt) {
+        auto iterator = std::find(std::begin(excludes_), std::end(excludes_), opt);
+
+        if(iterator != std::end(excludes_)) {
+            excludes_.erase(iterator);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /// Sets environment variable to read if no option given
+    Option *envname(std::string name) {
+        envname_ = name;
+        return this;
     }
 
     /// Ignore case
@@ -1456,7 +1941,21 @@ class Option : public OptionBase<Option> {
 
         for(const Option_p &opt : parent->options_)
             if(opt.get() != this && *opt == *this)
-                throw OptionAlreadyAdded(opt->get_name());
+                throw OptionAlreadyAdded(opt->get_name(true, true));
+
+        return this;
+    }
+
+    /// Ignore underscores in the option names
+    ///
+    /// The template hides the fact that we don't have the definition of App yet.
+    /// You are never expected to add an argument to the template here.
+    template <typename T = App> Option *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        auto *parent = dynamic_cast<T *>(parent_);
+        for(const Option_p &opt : parent->options_)
+            if(opt.get() != this && *opt == *this)
+                throw OptionAlreadyAdded(opt->get_name(true, true));
 
         return this;
     }
@@ -1465,7 +1964,7 @@ class Option : public OptionBase<Option> {
     Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
 
         if(get_items_expected() < 0)
-            throw IncorrectConstruction::MultiOptionPolicy(single_name());
+            throw IncorrectConstruction::MultiOptionPolicy(get_name());
         multi_option_policy_ = value;
         return this;
     }
@@ -1477,11 +1976,32 @@ class Option : public OptionBase<Option> {
     /// The number of arguments the option expects
     int get_type_size() const { return type_size_; }
 
+    /// The environment variable associated to this value
+    std::string get_envname() const { return envname_; }
+
+    /// The set of options needed
+    std::set<Option *> get_needs() const { return needs_; }
+
+    /// The set of options excluded
+    std::set<Option *> get_excludes() const { return excludes_; }
+
+    /// The default value (for help printing)
+    std::string get_defaultval() const { return defaultval_; }
+
+    /// Get the callback function
+    callback_t get_callback() const { return callback_; }
+
+    /// Get the long names
+    const std::vector<std::string> get_lnames() const { return lnames_; }
+
+    /// Get the short names
+    const std::vector<std::string> get_snames() const { return snames_; }
+
     /// The number of times the option expects to be included
     int get_expected() const { return expected_; }
 
-    /// \breif The total number of expected values (including the type)
-    /// This is positive if exactly this number is expected, and negitive for at least N values
+    /// \brief The total number of expected values (including the type)
+    /// This is positive if exactly this number is expected, and negative for at least N values
     ///
     /// v = fabs(size_type*expected)
     /// !MultiOptionPolicy::Throw
@@ -1516,89 +2036,58 @@ class Option : public OptionBase<Option> {
     /// Get the description
     const std::string &get_description() const { return description_; }
 
-    // Just the pname
-    std::string get_pname() const { return pname_; }
+    /// Set the description
+    Option *description(const std::string &description) {
+        description_ = description;
+        return this;
+    }
 
     ///@}
     /// @name Help tools
     ///@{
 
-    /// Gets a , sep list of names. Does not include the positional name if opt_only=true.
-    std::string get_name(bool opt_only = false) const {
-        std::vector<std::string> name_list;
-        if(!opt_only && pname_.length() > 0)
-            name_list.push_back(pname_);
-        for(const std::string &sname : snames_)
-            name_list.push_back("-" + sname);
-        for(const std::string &lname : lnames_)
-            name_list.push_back("--" + lname);
-        return detail::join(name_list);
-    }
-
-    /// The name and any extras needed for positionals
-    std::string help_positional() const {
-        std::string out = pname_;
-        if(get_expected() > 1)
-            out = out + "(" + std::to_string(get_expected()) + "x)";
-        else if(get_expected() == -1)
-            out = out + "...";
-        out = get_required() ? out : "[" + out + "]";
-        return out;
-    }
-
-    /// The most descriptive name available
-    std::string single_name() const {
-        if(!lnames_.empty())
-            return std::string("--") + lnames_[0];
-        else if(!snames_.empty())
-            return std::string("-") + snames_[0];
-        else
-            return pname_;
-    }
+    /// \brief Gets a comma separated list of names.
+    /// Will include / prefer the positional name if positional is true.
+    /// If all_options is false, pick just the most descriptive name to show.
+    /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
+    std::string get_name(bool positional = false, //<[input] Show the positional name
+                         bool all_options = false //<[input] Show every option
+                         ) const {
 
-    /// The first half of the help print, name plus default, etc. Setting opt_only to true avoids the positional name.
-    std::string help_name(bool opt_only = false) const {
-        std::stringstream out;
-        out << get_name(opt_only) << help_aftername();
-        return out.str();
-    }
+        if(all_options) {
 
-    /// pname with type info
-    std::string help_pname() const {
-        std::stringstream out;
-        out << get_pname() << help_aftername();
-        return out.str();
-    }
+            std::vector<std::string> name_list;
 
-    /// This is the part after the name is printed but before the description
-    std::string help_aftername() const {
-        std::stringstream out;
+            /// The all list will never include a positional unless asked or that's the only name.
+            if((positional && pname_.length()) || (snames_.empty() && lnames_.empty()))
+                name_list.push_back(pname_);
+
+            for(const std::string &sname : snames_)
+                name_list.push_back("-" + sname);
+
+            for(const std::string &lname : lnames_)
+                name_list.push_back("--" + lname);
+
+            return detail::join(name_list);
+
+        } else {
+
+            // This returns the positional name no matter what
+            if(positional)
+                return pname_;
+
+            // Prefer long name
+            else if(!lnames_.empty())
+                return std::string("--") + lnames_[0];
 
-        if(get_type_size() != 0) {
-            if(!typeval_.empty())
-                out << " " << typeval_;
-            if(!defaultval_.empty())
-                out << "=" << defaultval_;
-            if(get_expected() > 1)
-                out << " x " << get_expected();
-            if(get_expected() == -1)
-                out << " ...";
-            // if(get_required())
-            //    out << " (REQUIRED)";
-        }
-        if(!envname_.empty())
-            out << " (env:" << envname_ << ")";
-        if(!requires_.empty()) {
-            out << " Needs:";
-            for(const Option *opt : requires_)
-                out << " " << opt->single_name();
-        }
-        if(!excludes_.empty()) {
-            out << " Excludes:";
-            for(const Option *opt : excludes_)
-                out << " " << opt->single_name();
+            // Or short name if no long name
+            else if(!snames_.empty())
+                return std::string("-") + snames_[0];
+
+            // If positional is the only name, it's okay to use that
+            else
+                return pname_;
         }
-        return out.str();
     }
 
     ///@}
@@ -1608,13 +2097,15 @@ class Option : public OptionBase<Option> {
     /// Process the callback
     void run_callback() {
 
+        callback_run_ = true;
+
         // Run the validators (can change the string)
         if(!validators_.empty()) {
             for(std::string &result : results_)
                 for(const std::function<std::string(std::string &)> &vali : validators_) {
                     std::string err_msg = vali(result);
                     if(!err_msg.empty())
-                        throw ValidationError(single_name(), err_msg);
+                        throw ValidationError(get_name(), err_msg);
                 }
         }
 
@@ -1622,7 +2113,8 @@ class Option : public OptionBase<Option> {
 
         // Num items expected or length of vector, always at least 1
         // Only valid for a trimming policy
-        int trim_size = std::min(std::max(std::abs(get_items_expected()), 1), static_cast<int>(results_.size()));
+        int trim_size =
+            std::min<int>(std::max<int>(std::abs(get_items_expected()), 1), static_cast<int>(results_.size()));
 
         // Operation depends on the policy setting
         if(multi_option_policy_ == MultiOptionPolicy::TakeLast) {
@@ -1639,12 +2131,18 @@ class Option : public OptionBase<Option> {
             local_result = !callback_(partial_result);
 
         } else {
-            // For now, vector of non size 1 types are not supported but possibility included here
-            if((get_items_expected() > 0 && results_.size() != static_cast<size_t>(get_items_expected())) ||
-               (get_items_expected() < 0 && results_.size() < static_cast<size_t>(-get_items_expected())))
-                throw ArgumentMismatch(single_name(), get_items_expected(), results_.size());
-            else
-                local_result = !callback_(results_);
+            // Exact number required
+            if(get_items_expected() > 0) {
+                if(results_.size() != static_cast<size_t>(get_items_expected()))
+                    throw ArgumentMismatch(get_name(), get_items_expected(), results_.size());
+                // Variable length list
+            } else if(get_items_expected() < 0) {
+                // Require that this be a multiple of expected size and at least as many as expected
+                if(results_.size() < static_cast<size_t>(-get_items_expected()) ||
+                   results_.size() % static_cast<size_t>(std::abs(get_type_size())) != 0)
+                    throw ArgumentMismatch(get_name(), get_items_expected(), results_.size());
+            }
+            local_result = !callback_(results_);
         }
 
         if(local_result)
@@ -1659,7 +2157,7 @@ class Option : public OptionBase<Option> {
         for(const std::string &lname : lnames_)
             if(other.check_lname(lname))
                 return true;
-        // We need to do the inverse, just in case we are ignore_case
+        // We need to do the inverse, just in case we are ignore_case or ignore underscore
         for(const std::string &sname : other.snames_)
             if(check_sname(sname))
                 return true;
@@ -1682,13 +2180,17 @@ class Option : public OptionBase<Option> {
                 local_pname = detail::to_lower(local_pname);
                 name = detail::to_lower(name);
             }
+            if(ignore_underscore_) {
+                local_pname = detail::remove_underscore(local_pname);
+                name = detail::remove_underscore(name);
+            }
             return name == local_pname;
         }
     }
 
     /// Requires "-" to be removed from string
     bool check_sname(std::string name) const {
-        if(ignore_case_) {
+        if(ignore_case_) { // there can be no extra underscores in check_sname
             name = detail::to_lower(name);
             return std::find_if(std::begin(snames_), std::end(snames_), [&name](std::string local_sname) {
                        return detail::to_lower(local_sname) == name;
@@ -1700,18 +2202,39 @@ class Option : public OptionBase<Option> {
     /// Requires "--" to be removed from string
     bool check_lname(std::string name) const {
         if(ignore_case_) {
-            name = detail::to_lower(name);
+            if(ignore_underscore_) {
+                name = detail::to_lower(detail::remove_underscore(name));
+                return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
+                           return detail::to_lower(detail::remove_underscore(local_sname)) == name;
+                       }) != std::end(lnames_);
+            } else {
+                name = detail::to_lower(name);
+                return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
+                           return detail::to_lower(local_sname) == name;
+                       }) != std::end(lnames_);
+            }
+
+        } else if(ignore_underscore_) {
+            name = detail::remove_underscore(name);
             return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
-                       return detail::to_lower(local_sname) == name;
+                       return detail::remove_underscore(local_sname) == name;
                    }) != std::end(lnames_);
         } else
             return std::find(std::begin(lnames_), std::end(lnames_), name) != std::end(lnames_);
     }
 
-    /// Puts a result at the end, unless last_ is set, in which case it just keeps the last one
-    void add_result(std::string s) {
+    /// Puts a result at the end
+    Option *add_result(std::string s) {
         results_.push_back(s);
         callback_run_ = false;
+        return this;
+    }
+
+    /// Set the results vector all at once
+    Option *set_results(std::vector<std::string> result_vector) {
+        results_ = std::move(result_vector);
+        callback_run_ = false;
+        return this;
     }
 
     /// Get a copy of the results
@@ -1724,44 +2247,46 @@ class Option : public OptionBase<Option> {
     /// @name Custom options
     ///@{
 
-    /// Set a custom option, typestring, type_size
-    void set_custom_option(std::string typeval, int type_size = 1) {
-        typeval_ = typeval;
-        type_size_ = type_size;
+    /// Set the type function to run when displayed on this option
+    Option *type_name_fn(std::function<std::string()> typefun) {
+        type_name_ = typefun;
+        return this;
+    }
+
+    /// Set a custom option typestring
+    Option *type_name(std::string typeval) {
+        type_name_fn([typeval]() { return typeval; });
+        return this;
+    }
+
+    /// Set a custom option size
+    Option *type_size(int option_type_size) {
+        type_size_ = option_type_size;
         if(type_size_ == 0)
             required_ = false;
-        if(type_size < 0)
+        if(option_type_size < 0)
             expected_ = -1;
+        return this;
     }
 
     /// Set the default value string representation
-    void set_default_str(std::string val) { defaultval_ = val; }
+    Option *default_str(std::string val) {
+        defaultval_ = val;
+        return this;
+    }
 
     /// Set the default value string representation and evaluate
-    void set_default_val(std::string val) {
-        set_default_str(val);
+    Option *default_val(std::string val) {
+        default_str(val);
         auto old_results = results_;
         results_ = {val};
         run_callback();
         results_ = std::move(old_results);
+        return this;
     }
 
-    /// Set the type name displayed on this option
-    void set_type_name(std::string val) { typeval_ = val; }
-
     /// Get the typename for this option
-    std::string get_type_name() const { return typeval_; }
-
-    ///@}
-
-  protected:
-    /// @name App Helpers
-    ///@{
-    /// Can print positional name detailed option if true
-    bool _has_help_positional() const {
-        return get_positional() && (has_description() || !requires_.empty() || !excludes_.empty());
-    }
-    ///@}
+    std::string get_type_name() const { return type_name_(); }
 };
 
 } // namespace CLI
@@ -1780,7 +2305,7 @@ namespace CLI {
 #endif
 
 namespace detail {
-enum class Classifer { NONE, POSITIONAL_MARK, SHORT, LONG, SUBCOMMAND };
+enum class Classifier { NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS, SUBCOMMAND };
 struct AppFriend;
 } // namespace detail
 
@@ -1817,7 +2342,7 @@ class App {
     bool allow_extras_{false};
 
     /// If true, allow extra arguments in the ini file (ie, don't throw an error). INHERITABLE
-    bool allow_ini_extras_{false};
+    bool allow_config_extras_{false};
 
     ///  If true, return immediately on an unrecognised option (implies allow_extras) INHERITABLE
     bool prefix_command_{false};
@@ -1845,6 +2370,12 @@ class App {
     /// A pointer to the help flag if there is one INHERITABLE
     Option *help_ptr_{nullptr};
 
+    /// A pointer to the help all flag if there is one INHERITABLE
+    Option *help_all_ptr_{nullptr};
+
+    /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
+    std::shared_ptr<FormatterBase> formatter_{new Formatter()};
+
     /// The error message printing function INHERITABLE
     std::function<std::string(const App *, const Error &e)> failure_message_ = FailureMessage::simple;
 
@@ -1852,7 +2383,7 @@ class App {
     /// @name Parsing
     ///@{
 
-    using missing_t = std::vector<std::pair<detail::Classifer, std::string>>;
+    using missing_t = std::vector<std::pair<detail::Classifier, std::string>>;
 
     /// Pair of classifier, string for missing options. (extra detail is removed on returning from parse)
     ///
@@ -1875,16 +2406,28 @@ class App {
     /// If true, the program name is not case sensitive INHERITABLE
     bool ignore_case_{false};
 
+    /// If true, the program should ignore underscores INHERITABLE
+    bool ignore_underscore_{false};
+
     /// Allow subcommand fallthrough, so that parent commands can collect commands after subcommand.  INHERITABLE
     bool fallthrough_{false};
 
+    /// Allow '/' for options for Windows like options. Defaults to true on Windows, false otherwise. INHERITABLE
+    bool allow_windows_style_options_{
+#ifdef _WIN32
+        true
+#else
+        false
+#endif
+    };
+
     /// A pointer to the parent if this is a subcommand
     App *parent_{nullptr};
 
-    /// True if this command/subcommand was parsed
-    bool parsed_{false};
+    /// Counts the number of times this command/subcommand was parsed
+    size_t parsed_ = 0;
 
-    /// Minimum required subcommands
+    /// Minimum required subcommands (not inheritable!)
     size_t require_subcommand_min_ = 0;
 
     /// Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE
@@ -1906,15 +2449,21 @@ class App {
     /// Pointer to the config option
     Option *config_ptr_{nullptr};
 
+    /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
+    std::shared_ptr<Config> config_formatter_{new ConfigINI()};
+
     ///@}
 
     /// Special private constructor for subcommand
-    App(std::string description_, std::string name, App *parent)
-        : name_(std::move(name)), description_(std::move(description_)), parent_(parent) {
+    App(std::string description, std::string app_name, App *parent)
+        : name_(std::move(app_name)), description_(std::move(description)), parent_(parent) {
         // Inherit if not from a nullptr
         if(parent_ != nullptr) {
             if(parent_->help_ptr_ != nullptr)
-                set_help_flag(parent_->help_ptr_->get_name(), parent_->help_ptr_->get_description());
+                set_help_flag(parent_->help_ptr_->get_name(false, true), parent_->help_ptr_->get_description());
+            if(parent_->help_all_ptr_ != nullptr)
+                set_help_all_flag(parent_->help_all_ptr_->get_name(false, true),
+                                  parent_->help_all_ptr_->get_description());
 
             /// OptionDefaults
             option_defaults_ = parent_->option_defaults_;
@@ -1922,12 +2471,16 @@ class App {
             // INHERITABLE
             failure_message_ = parent_->failure_message_;
             allow_extras_ = parent_->allow_extras_;
-            allow_ini_extras_ = parent_->allow_ini_extras_;
+            allow_config_extras_ = parent_->allow_config_extras_;
             prefix_command_ = parent_->prefix_command_;
             ignore_case_ = parent_->ignore_case_;
+            ignore_underscore_ = parent_->ignore_underscore_;
             fallthrough_ = parent_->fallthrough_;
+            allow_windows_style_options_ = parent_->allow_windows_style_options_;
             group_ = parent_->group_;
             footer_ = parent_->footer_;
+            formatter_ = parent_->formatter_;
+            config_formatter_ = parent_->config_formatter_;
             require_subcommand_max_ = parent_->require_subcommand_max_;
         }
     }
@@ -1937,7 +2490,7 @@ class App {
     ///@{
 
     /// Create a new program. Pass in the same arguments as main(), along with a help string.
-    explicit App(std::string description_ = "", std::string name = "") : App(description_, name, nullptr) {
+    explicit App(std::string description = "", std::string app_name = "") : App(description, app_name, nullptr) {
         set_help_flag("-h,--help", "Print this help message and exit");
     }
 
@@ -1950,14 +2503,14 @@ class App {
     /// it is not possible to overload on std::function (fixed in c++14
     /// and backported to c++11 on newer compilers). Use capture by reference
     /// to get a pointer to App if needed.
-    App *set_callback(std::function<void()> callback) {
-        callback_ = callback;
+    App *callback(std::function<void()> app_callback) {
+        callback_ = std::move(app_callback);
         return this;
     }
 
     /// Set a name for the app (empty will use parser to set the name)
-    App *set_name(std::string name = "") {
-        name_ = name;
+    App *name(std::string app_name = "") {
+        name_ = app_name;
         return this;
     }
 
@@ -1969,19 +2522,19 @@ class App {
 
     /// Remove the error when extras are left over on the command line.
     /// Will also call App::allow_extras().
-    App *allow_ini_extras(bool allow = true) {
+    App *allow_config_extras(bool allow = true) {
         allow_extras(allow);
-        allow_ini_extras_ = allow;
+        allow_config_extras_ = allow;
         return this;
     }
 
-    /// Do not parse anything after the first unrecognised option and return
+    /// Do not parse anything after the first unrecognized option and return
     App *prefix_command(bool allow = true) {
         prefix_command_ = allow;
         return this;
     }
 
-    /// Ignore case. Subcommand inherit value.
+    /// Ignore case. Subcommands inherit value.
     App *ignore_case(bool value = true) {
         ignore_case_ = value;
         if(parent_ != nullptr) {
@@ -1993,8 +2546,44 @@ class App {
         return this;
     }
 
+    /// Allow windows style options, such as `/opt`. First matching short or long name used. Subcommands inherit value.
+    App *allow_windows_style_options(bool value = true) {
+        allow_windows_style_options_ = value;
+        return this;
+    }
+
+    /// Ignore underscore. Subcommands inherit value.
+    App *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        if(parent_ != nullptr) {
+            for(const auto &subc : parent_->subcommands_) {
+                if(subc.get() != this && (this->check_name(subc->name_) || subc->check_name(this->name_)))
+                    throw OptionAlreadyAdded(subc->name_);
+            }
+        }
+        return this;
+    }
+
+    /// Set the help formatter
+    App *formatter(std::shared_ptr<FormatterBase> fmt) {
+        formatter_ = fmt;
+        return this;
+    }
+
+    /// Set the help formatter
+    App *formatter_fn(std::function<std::string(const App *, std::string, AppFormatMode)> fmt) {
+        formatter_ = std::make_shared<FormatterLambda>(fmt);
+        return this;
+    }
+
+    /// Set the config formatter
+    App *config_formatter(std::shared_ptr<Config> fmt) {
+        config_formatter_ = fmt;
+        return this;
+    }
+
     /// Check to see if this subcommand was parsed, true only if received on command line.
-    bool parsed() const { return parsed_; }
+    bool parsed() const { return parsed_ > 0; }
 
     /// Get the OptionDefault object, to set option defaults
     OptionDefaults *option_defaults() { return &option_defaults_; }
@@ -2017,15 +2606,18 @@ class App {
     ///     std::string filename;
     ///     program.add_option("filename", filename, "description of filename");
     ///
-    Option *add_option(std::string name, callback_t callback, std::string description = "", bool defaulted = false) {
-        Option myopt{name, description, callback, defaulted, this};
+    Option *add_option(std::string option_name,
+                       callback_t option_callback,
+                       std::string description = "",
+                       bool defaulted = false) {
+        Option myopt{option_name, description, option_callback, defaulted, this};
 
         if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) {
                return *v == myopt;
            }) == std::end(options_)) {
             options_.emplace_back();
             Option_p &option = options_.back();
-            option.reset(new Option(name, description, callback, defaulted, this));
+            option.reset(new Option(option_name, description, option_callback, defaulted, this));
             option_defaults_.copy_to(option.get());
             return option.get();
         } else
@@ -2034,45 +2626,39 @@ class App {
 
     /// Add option for non-vectors (duplicate copy needed without defaulted to avoid `iostream << value`)
     template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
-    Option *add_option(std::string name,
+    Option *add_option(std::string option_name,
                        T &variable, ///< The variable to set
                        std::string description = "") {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
-        CLI::callback_t fun = [&variable, simple_name](CLI::results_t res) {
-            return detail::lexical_cast(res[0], variable);
-        };
+        CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };
 
-        Option *opt = add_option(name, fun, description, false);
-        opt->set_custom_option(detail::type_name<T>());
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name(detail::type_name<T>());
         return opt;
     }
 
     /// Add option for non-vectors with a default print
     template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
-    Option *add_option(std::string name,
+    Option *add_option(std::string option_name,
                        T &variable, ///< The variable to set
                        std::string description,
                        bool defaulted) {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
-        CLI::callback_t fun = [&variable, simple_name](CLI::results_t res) {
-            return detail::lexical_cast(res[0], variable);
-        };
+        CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };
 
-        Option *opt = add_option(name, fun, description, defaulted);
-        opt->set_custom_option(detail::type_name<T>());
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name(detail::type_name<T>());
         if(defaulted) {
             std::stringstream out;
             out << variable;
-            opt->set_default_str(out.str());
+            opt->default_str(out.str());
         }
         return opt;
     }
 
     /// Add option for vectors (no default)
     template <typename T>
-    Option *add_option(std::string name,
+    Option *add_option(std::string option_name,
                        std::vector<T> &variable, ///< The variable vector to set
                        std::string description = "") {
 
@@ -2086,14 +2672,14 @@ class App {
             return (!variable.empty()) && retval;
         };
 
-        Option *opt = add_option(name, fun, description, false);
-        opt->set_custom_option(detail::type_name<T>(), -1);
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name(detail::type_name<T>())->type_size(-1);
         return opt;
     }
 
     /// Add option for vectors
     template <typename T>
-    Option *add_option(std::string name,
+    Option *add_option(std::string option_name,
                        std::vector<T> &variable, ///< The variable vector to set
                        std::string description,
                        bool defaulted) {
@@ -2108,116 +2694,131 @@ class App {
             return (!variable.empty()) && retval;
         };
 
-        Option *opt = add_option(name, fun, description, defaulted);
-        opt->set_custom_option(detail::type_name<T>(), -1);
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name(detail::type_name<T>())->type_size(-1);
         if(defaulted)
-            opt->set_default_str("[" + detail::join(variable) + "]");
+            opt->default_str("[" + detail::join(variable) + "]");
         return opt;
     }
 
-    /// Set a help flag, replaced the existing one if present
-    Option *set_help_flag(std::string name = "", std::string description = "") {
+    /// Set a help flag, replace the existing one if present
+    Option *set_help_flag(std::string flag_name = "", std::string description = "") {
         if(help_ptr_ != nullptr) {
             remove_option(help_ptr_);
             help_ptr_ = nullptr;
         }
 
         // Empty name will simply remove the help flag
-        if(!name.empty()) {
-            help_ptr_ = add_flag(name, description);
+        if(!flag_name.empty()) {
+            help_ptr_ = add_flag(flag_name, description);
             help_ptr_->configurable(false);
         }
 
         return help_ptr_;
     }
 
+    /// Set a help all flag, replaced the existing one if present
+    Option *set_help_all_flag(std::string help_name = "", std::string description = "") {
+        if(help_all_ptr_ != nullptr) {
+            remove_option(help_all_ptr_);
+            help_all_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the help all flag
+        if(!help_name.empty()) {
+            help_all_ptr_ = add_flag(help_name, description);
+            help_all_ptr_->configurable(false);
+        }
+
+        return help_all_ptr_;
+    }
+
     /// Add option for flag
-    Option *add_flag(std::string name, std::string description = "") {
+    Option *add_flag(std::string flag_name, std::string description = "") {
         CLI::callback_t fun = [](CLI::results_t) { return true; };
 
-        Option *opt = add_option(name, fun, description, false);
+        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
-            throw IncorrectConstruction::PositionalFlag(name);
-        opt->set_custom_option("", 0);
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
         return opt;
     }
 
     /// Add option for flag integer
     template <typename T,
               enable_if_t<std::is_integral<T>::value && !is_bool<T>::value, detail::enabler> = detail::dummy>
-    Option *add_flag(std::string name,
-                     T &count, ///< A variable holding the count
+    Option *add_flag(std::string flag_name,
+                     T &flag_count, ///< A variable holding the count
                      std::string description = "") {
 
-        count = 0;
-        CLI::callback_t fun = [&count](CLI::results_t res) {
-            count = static_cast<T>(res.size());
+        flag_count = 0;
+        CLI::callback_t fun = [&flag_count](CLI::results_t res) {
+            flag_count = static_cast<T>(res.size());
             return true;
         };
 
-        Option *opt = add_option(name, fun, description, false);
+        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
-            throw IncorrectConstruction::PositionalFlag(name);
-        opt->set_custom_option("", 0);
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
         return opt;
     }
 
     /// Bool version - defaults to allowing multiple passings, but can be forced to one if
     /// `multi_option_policy(CLI::MultiOptionPolicy::Throw)` is used.
     template <typename T, enable_if_t<is_bool<T>::value, detail::enabler> = detail::dummy>
-    Option *add_flag(std::string name,
-                     T &count, ///< A variable holding true if passed
+    Option *add_flag(std::string flag_name,
+                     T &flag_count, ///< A variable holding true if passed
                      std::string description = "") {
 
-        count = false;
-        CLI::callback_t fun = [&count](CLI::results_t res) {
-            count = true;
+        flag_count = false;
+        CLI::callback_t fun = [&flag_count](CLI::results_t res) {
+            flag_count = true;
             return res.size() == 1;
         };
 
-        Option *opt = add_option(name, fun, description, false);
+        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
-            throw IncorrectConstruction::PositionalFlag(name);
-        opt->set_custom_option("", 0);
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
         opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
         return opt;
     }
 
     /// Add option for callback
-    Option *add_flag_function(std::string name,
+    Option *add_flag_function(std::string flag_name,
                               std::function<void(size_t)> function, ///< A function to call, void(size_t)
                               std::string description = "") {
 
         CLI::callback_t fun = [function](CLI::results_t res) {
-            auto count = static_cast<size_t>(res.size());
-            function(count);
+            function(res.size());
             return true;
         };
 
-        Option *opt = add_option(name, fun, description, false);
+        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
-            throw IncorrectConstruction::PositionalFlag(name);
-        opt->set_custom_option("", 0);
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
         return opt;
     }
 
 #ifdef CLI11_CPP14
     /// Add option for callback (C++14 or better only)
-    Option *add_flag(std::string name,
+    Option *add_flag(std::string flag_name,
                      std::function<void(size_t)> function, ///< A function to call, void(size_t)
                      std::string description = "") {
-        return add_flag_function(name, function, description);
+        return add_flag_function(flag_name, std::move(function), description);
     }
 #endif
 
-    /// Add set of options (No default)
+    /// Add set of options (No default, temp reference, such as an inline set)
     template <typename T>
-    Option *add_set(std::string name,
+    Option *add_set(std::string option_name,
                     T &member,           ///< The selected member of the set
                     std::set<T> options, ///< The set of possibilities
                     std::string description = "") {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
         CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
             bool retval = detail::lexical_cast(res[0], member);
             if(!retval)
@@ -2225,22 +2826,44 @@ class App {
             return std::find(std::begin(options), std::end(options), member) != std::end(options);
         };
 
-        Option *opt = add_option(name, fun, description, false);
+        Option *opt = add_option(option_name, fun, description, false);
         std::string typeval = detail::type_name<T>();
         typeval += " in {" + detail::join(options) + "}";
-        opt->set_custom_option(typeval);
+        opt->type_name(typeval);
+        return opt;
+    }
+
+    /// Add set of options (No default, set can be changed afterwords - do not destroy the set)
+    template <typename T>
+    Option *add_mutable_set(std::string option_name,
+                            T &member,                  ///< The selected member of the set
+                            const std::set<T> &options, ///< The set of possibilities
+                            std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            bool retval = detail::lexical_cast(res[0], member);
+            if(!retval)
+                throw ConversionError(res[0], simple_name);
+            return std::find(std::begin(options), std::end(options), member) != std::end(options);
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn(
+            [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
+
         return opt;
     }
 
-    /// Add set of options
+    /// Add set of options (with default, static set, such as an inline set)
     template <typename T>
-    Option *add_set(std::string name,
+    Option *add_set(std::string option_name,
                     T &member,           ///< The selected member of the set
-                    std::set<T> options, ///< The set of posibilities
+                    std::set<T> options, ///< The set of possibilities
                     std::string description,
                     bool defaulted) {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
         CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
             bool retval = detail::lexical_cast(res[0], member);
             if(!retval)
@@ -2248,25 +2871,52 @@ class App {
             return std::find(std::begin(options), std::end(options), member) != std::end(options);
         };
 
-        Option *opt = add_option(name, fun, description, defaulted);
+        Option *opt = add_option(option_name, fun, description, defaulted);
         std::string typeval = detail::type_name<T>();
         typeval += " in {" + detail::join(options) + "}";
-        opt->set_custom_option(typeval);
+        opt->type_name(typeval);
+        if(defaulted) {
+            std::stringstream out;
+            out << member;
+            opt->default_str(out.str());
+        }
+        return opt;
+    }
+
+    /// Add set of options (with default, set can be changed afterwards - do not destroy the set)
+    template <typename T>
+    Option *add_mutable_set(std::string option_name,
+                            T &member,                  ///< The selected member of the set
+                            const std::set<T> &options, ///< The set of possibilities
+                            std::string description,
+                            bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            bool retval = detail::lexical_cast(res[0], member);
+            if(!retval)
+                throw ConversionError(res[0], simple_name);
+            return std::find(std::begin(options), std::end(options), member) != std::end(options);
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn(
+            [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
         if(defaulted) {
             std::stringstream out;
             out << member;
-            opt->set_default_str(out.str());
+            opt->default_str(out.str());
         }
         return opt;
     }
 
-    /// Add set of options, string only, ignore case (no default)
-    Option *add_set_ignore_case(std::string name,
+    /// Add set of options, string only, ignore case (no default, static set)
+    Option *add_set_ignore_case(std::string option_name,
                                 std::string &member,           ///< The selected member of the set
                                 std::set<std::string> options, ///< The set of possibilities
                                 std::string description = "") {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
         CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
             member = detail::to_lower(res[0]);
             auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
@@ -2280,22 +2930,51 @@ class App {
             }
         };
 
-        Option *opt = add_option(name, fun, description, false);
+        Option *opt = add_option(option_name, fun, description, false);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
-        opt->set_custom_option(typeval);
+        opt->type_name(typeval);
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore case (no default, set can be changed afterwards - do not destroy the
+    /// set)
+    Option *add_mutable_set_ignore_case(std::string option_name,
+                                        std::string &member,                  ///< The selected member of the set
+                                        const std::set<std::string> &options, ///< The set of possibilities
+                                        std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
 
         return opt;
     }
 
-    /// Add set of options, string only, ignore case
-    Option *add_set_ignore_case(std::string name,
+    /// Add set of options, string only, ignore case (default, static set)
+    Option *add_set_ignore_case(std::string option_name,
                                 std::string &member,           ///< The selected member of the set
-                                std::set<std::string> options, ///< The set of posibilities
+                                std::set<std::string> options, ///< The set of possibilities
                                 std::string description,
                                 bool defaulted) {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
         CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
             member = detail::to_lower(res[0]);
             auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
@@ -2309,100 +2988,382 @@ class App {
             }
         };
 
-        Option *opt = add_option(name, fun, description, defaulted);
+        Option *opt = add_option(option_name, fun, description, defaulted);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
-        opt->set_custom_option(typeval);
+        opt->type_name(typeval);
         if(defaulted) {
-            opt->set_default_str(member);
+            opt->default_str(member);
         }
         return opt;
     }
 
-    /// Add a complex number
-    template <typename T>
-    Option *add_complex(std::string name,
-                        T &variable,
-                        std::string description = "",
-                        bool defaulted = false,
-                        std::string label = "COMPLEX") {
+    /// Add set of options, string only, ignore case (default, set can be changed afterwards - do not destroy the set)
+    Option *add_mutable_set_ignore_case(std::string option_name,
+                                        std::string &member,                  ///< The selected member of the set
+                                        const std::set<std::string> &options, ///< The set of possibilities
+                                        std::string description,
+                                        bool defaulted) {
 
-        std::string simple_name = CLI::detail::split(name, ',').at(0);
-        CLI::callback_t fun = [&variable, simple_name, label](results_t res) {
-            if(res[1].back() == 'i')
-                res[1].pop_back();
-            double x, y;
-            bool worked = detail::lexical_cast(res[0], x) && detail::lexical_cast(res[1], y);
-            if(worked)
-                variable = T(x, y);
-            return worked;
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
         };
 
-        CLI::Option *opt = add_option(name, fun, description, defaulted);
-        opt->set_custom_option(label, 2);
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
         if(defaulted) {
-            std::stringstream out;
-            out << variable;
-            opt->set_default_str(out.str());
+            opt->default_str(member);
         }
         return opt;
     }
 
-    /// Set a configuration ini file option, or clear it if no name passed
-    Option *set_config(std::string name = "",
-                       std::string default_filename = "",
-                       std::string help = "Read an ini file",
-                       bool required = false) {
+    /// Add set of options, string only, ignore underscore (no default, static set)
+    Option *add_set_ignore_underscore(std::string option_name,
+                                      std::string &member,           ///< The selected member of the set
+                                      std::set<std::string> options, ///< The set of possibilities
+                                      std::string description = "") {
 
-        // Remove existing config if present
-        if(config_ptr_ != nullptr)
-            remove_option(config_ptr_);
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
 
-        // Only add config if option passed
-        if(!name.empty()) {
-            config_name_ = default_filename;
-            config_required_ = required;
-            config_ptr_ = add_option(name, config_name_, help, !default_filename.empty());
-            config_ptr_->configurable(false);
-        }
+        Option *opt = add_option(option_name, fun, description, false);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
 
-        return config_ptr_;
+        return opt;
     }
 
-    /// Removes an option from the App. Takes an option pointer. Returns true if found and removed.
-    bool remove_option(Option *opt) {
-        auto iterator =
-            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
-        if(iterator != std::end(options_)) {
-            options_.erase(iterator);
-            return true;
-        }
-        return false;
-    }
+    /// Add set of options, string only, ignore underscore (no default, set can be changed afterwards - do not destroy
+    /// the set)
+    Option *add_mutable_set_ignore_underscore(std::string option_name,
+                                              std::string &member,                  ///< The selected member of the set
+                                              const std::set<std::string> &options, ///< The set of possibilities
+                                              std::string description = "") {
 
-    ///@}
-    /// @name Subcommmands
-    ///@{
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
 
-    /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
-    App *add_subcommand(std::string name, std::string description = "") {
-        subcommands_.emplace_back(new App(description, name, this));
-        for(const auto &subc : subcommands_)
-            if(subc.get() != subcommands_.back().get())
-                if(subc->check_name(subcommands_.back()->name_) || subcommands_.back()->check_name(subc->name_))
-                    throw OptionAlreadyAdded(subc->name_);
-        return subcommands_.back().get();
-    }
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
 
-    /// Check to see if a subcommand is part of this command (doesn't have to be in command line)
-    App *get_subcommand(App *subcom) const {
-        for(const App_p &subcomptr : subcommands_)
-            if(subcomptr.get() == subcom)
-                return subcom;
-        throw OptionNotFound(subcom->get_name());
+        return opt;
     }
 
-    /// Check to see if a subcommand is part of this command (text version)
+    /// Add set of options, string only, ignore underscore (default, static set)
+    Option *add_set_ignore_underscore(std::string option_name,
+                                      std::string &member,           ///< The selected member of the set
+                                      std::set<std::string> options, ///< The set of possibilities
+                                      std::string description,
+                                      bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore (default, set can be changed afterwards - do not destroy the
+    /// set)
+    Option *add_mutable_set_ignore_underscore(std::string option_name,
+                                              std::string &member,                  ///< The selected member of the set
+                                              const std::set<std::string> &options, ///< The set of possibilities
+                                              std::string description,
+                                              bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (no default, static set)
+    Option *add_set_ignore_case_underscore(std::string option_name,
+                                           std::string &member,           ///< The selected member of the set
+                                           std::set<std::string> options, ///< The set of possibilities
+                                           std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (no default, set can be changed afterwards - do not
+    /// destroy the set)
+    Option *add_mutable_set_ignore_case_underscore(std::string option_name,
+                                                   std::string &member, ///< The selected member of the set
+                                                   const std::set<std::string> &options, ///< The set of possibilities
+                                                   std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (default, static set)
+    Option *add_set_ignore_case_underscore(std::string option_name,
+                                           std::string &member,           ///< The selected member of the set
+                                           std::set<std::string> options, ///< The set of possibilities
+                                           std::string description,
+                                           bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (default, set can be changed afterwards - do not
+    /// destroy the set)
+    Option *add_mutable_set_ignore_case_underscore(std::string option_name,
+                                                   std::string &member, ///< The selected member of the set
+                                                   const std::set<std::string> &options, ///< The set of possibilities
+                                                   std::string description,
+                                                   bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add a complex number
+    template <typename T>
+    Option *add_complex(std::string option_name,
+                        T &variable,
+                        std::string description = "",
+                        bool defaulted = false,
+                        std::string label = "COMPLEX") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&variable, simple_name, label](results_t res) {
+            if(res[1].back() == 'i')
+                res[1].pop_back();
+            double x, y;
+            bool worked = detail::lexical_cast(res[0], x) && detail::lexical_cast(res[1], y);
+            if(worked)
+                variable = T(x, y);
+            return worked;
+        };
+
+        CLI::Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name(label)->type_size(2);
+        if(defaulted) {
+            std::stringstream out;
+            out << variable;
+            opt->default_str(out.str());
+        }
+        return opt;
+    }
+
+    /// Set a configuration ini file option, or clear it if no name passed
+    Option *set_config(std::string option_name = "",
+                       std::string default_filename = "",
+                       std::string help_message = "Read an ini file",
+                       bool required = false) {
+
+        // Remove existing config if present
+        if(config_ptr_ != nullptr)
+            remove_option(config_ptr_);
+
+        // Only add config if option passed
+        if(!option_name.empty()) {
+            config_name_ = default_filename;
+            config_required_ = required;
+            config_ptr_ = add_option(option_name, config_name_, help_message, !default_filename.empty());
+            config_ptr_->configurable(false);
+        }
+
+        return config_ptr_;
+    }
+
+    /// Removes an option from the App. Takes an option pointer. Returns true if found and removed.
+    bool remove_option(Option *opt) {
+        // Make sure no links exist
+        for(Option_p &op : options_) {
+            op->remove_needs(opt);
+            op->remove_excludes(opt);
+        }
+
+        if(help_ptr_ == opt)
+            help_ptr_ = nullptr;
+        if(help_all_ptr_ == opt)
+            help_all_ptr_ = nullptr;
+
+        auto iterator =
+            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
+        if(iterator != std::end(options_)) {
+            options_.erase(iterator);
+            return true;
+        }
+        return false;
+    }
+
+    ///@}
+    /// @name Subcommmands
+    ///@{
+
+    /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
+    App *add_subcommand(std::string subcommand_name, std::string description = "") {
+        CLI::App_p subcom(new App(description, subcommand_name, this));
+        for(const auto &subc : subcommands_)
+            if(subc->check_name(subcommand_name) || subcom->check_name(subc->name_))
+                throw OptionAlreadyAdded(subc->name_);
+        subcommands_.push_back(std::move(subcom));
+        return subcommands_.back().get();
+    }
+
+    /// Check to see if a subcommand is part of this command (doesn't have to be in command line)
+    App *get_subcommand(App *subcom) const {
+        for(const App_p &subcomptr : subcommands_)
+            if(subcomptr.get() == subcom)
+                return subcom;
+        throw OptionNotFound(subcom->get_name());
+    }
+
+    /// Check to see if a subcommand is part of this command (text version)
     App *get_subcommand(std::string subcom) const {
         for(const App_p &subcomptr : subcommands_)
             if(subcomptr->check_name(subcom))
@@ -2410,9 +3371,13 @@ class App {
         throw OptionNotFound(subcom);
     }
 
+    /// No argument version of count counts the number of times this subcommand was
+    /// passed in. The main app will return 1.
+    size_t count() const { return parsed_; }
+
     /// Changes the group membership
-    App *group(std::string name) {
-        group_ = name;
+    App *group(std::string group_name) {
+        group_ = group_name;
         return this;
     }
 
@@ -2454,7 +3419,7 @@ class App {
 
     /// Check to see if this subcommand was parsed, true only if received on command line.
     /// This allows the subcommand to be directly checked.
-    operator bool() const { return parsed_; }
+    operator bool() const { return parsed_ > 0; }
 
     ///@}
     /// @name Extras for subclassing
@@ -2468,10 +3433,25 @@ class App {
     ///@}
     /// @name Parsing
     ///@{
+    //
+    /// Reset the parsed data
+    void clear() {
 
-    /// Parses the command line - throws errors
+        parsed_ = false;
+        missing_.clear();
+        parsed_subcommands_.clear();
+
+        for(const Option_p &opt : options_) {
+            opt->clear();
+        }
+        for(const App_p &app : subcommands_) {
+            app->clear();
+        }
+    }
+
+    /// Parses the command line - throws errors.
     /// This must be called after the options are in but before the rest of the program.
-    void parse(int argc, char **argv) {
+    void parse(int argc, const char *const *argv) {
         // If the name is not set, read from command line
         if(name_.empty())
             name_ = argv[0];
@@ -2482,16 +3462,55 @@ class App {
         parse(args);
     }
 
+    /// Parse a single string as if it contained command line arguments.
+    /// This function splits the string into arguments then calls parse(std::vector<std::string> &)
+    /// the function takes an optional boolean argument specifying if the programName is included in the string to
+    /// process
+    void parse(std::string commandline, bool program_name_included = false) {
+
+        if(program_name_included) {
+            auto nstr = detail::split_program_name(commandline);
+            if(name_.empty()) {
+                name_ = nstr.first;
+            }
+            commandline = std::move(nstr.second);
+        } else
+            detail::trim(commandline);
+        // the next section of code is to deal with quoted arguments after an '=' or ':' for windows like operations
+        if(!commandline.empty()) {
+            commandline = detail::find_and_modify(commandline, "=", detail::escape_detect);
+            if(allow_windows_style_options_)
+                commandline = detail::find_and_modify(commandline, ":", detail::escape_detect);
+        }
+
+        auto args = detail::split_up(std::move(commandline));
+        // remove all empty strings
+        args.erase(std::remove(args.begin(), args.end(), std::string()), args.end());
+        std::reverse(args.begin(), args.end());
+
+        parse(args);
+    }
+
     /// The real work is done here. Expects a reversed vector.
     /// Changes the vector to the remaining options.
     void parse(std::vector<std::string> &args) {
+        // Clear if parsed
+        if(parsed_ > 0)
+            clear();
+
+        // _parse is incremented in commands/subcommands,
+        // but placed here to make sure this is cleared when
+        // running parse after an error is thrown, even by _validate.
+        parsed_ = 1;
         _validate();
+        parsed_ = 0;
+
         _parse(args);
         run_callback();
     }
 
     /// Provide a function to print a help message. The function gets access to the App pointer and error.
-    void set_failure_message(std::function<std::string(const App *, const Error &e)> function) {
+    void failure_message(std::function<std::string(const App *, const Error &e)> function) {
         failure_message_ = function;
     }
 
@@ -2507,8 +3526,8 @@ class App {
             return e.get_exit_code();
         }
 
-        if(dynamic_cast<const CLI::CallForAdvancedHelp *>(&e) != nullptr) {
-            out << help(30, "", 2);
+        if(dynamic_cast<const CLI::CallForAllHelp *>(&e) != nullptr) {
+            out << help("", AppFormatMode::All);
             return e.get_exit_code();
         }
 
@@ -2520,242 +3539,168 @@ class App {
         return e.get_exit_code();
     }
 
-    /// Reset the parsed data
-    void reset() {
-
-        parsed_ = false;
-        missing_.clear();
-        parsed_subcommands_.clear();
-
-        for(const Option_p &opt : options_) {
-            opt->clear();
-        }
-        for(const App_p &app : subcommands_) {
-            app->reset();
-        }
-    }
-
     ///@}
     /// @name Post parsing
     ///@{
 
     /// Counts the number of times the given option was passed.
-    size_t count(std::string name) const {
+    size_t count(std::string option_name) const {
         for(const Option_p &opt : options_) {
-            if(opt->check_name(name)) {
+            if(opt->check_name(option_name)) {
                 return opt->count();
             }
         }
-        throw OptionNotFound(name);
+        throw OptionNotFound(option_name);
     }
 
-    /// Get a subcommand pointer list to the currently selected subcommands (after parsing by default, in command line
-    /// order)
-    std::vector<App *> get_subcommands(bool parsed = true) const {
-        if(parsed) {
-            return parsed_subcommands_;
-        } else {
-            std::vector<App *> subcomms(subcommands_.size());
-            std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
-                return v.get();
-            });
-            return subcomms;
+    /// Get a subcommand pointer list to the currently selected subcommands (after parsing by by default, in command
+    /// line order; use parsed = false to get the original definition list.)
+    std::vector<App *> get_subcommands() const { return parsed_subcommands_; }
+
+    /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
+    /// subcommands (const)
+    std::vector<const App *> get_subcommands(const std::function<bool(const App *)> &filter) const {
+        std::vector<const App *> subcomms(subcommands_.size());
+        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
+            return v.get();
+        });
+
+        if(filter) {
+            subcomms.erase(std::remove_if(std::begin(subcomms),
+                                          std::end(subcomms),
+                                          [&filter](const App *app) { return !filter(app); }),
+                           std::end(subcomms));
+        }
+
+        return subcomms;
+    }
+
+    /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
+    /// subcommands
+    std::vector<App *> get_subcommands(const std::function<bool(App *)> &filter) {
+        std::vector<App *> subcomms(subcommands_.size());
+        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
+            return v.get();
+        });
+
+        if(filter) {
+            subcomms.erase(
+                std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](App *app) { return !filter(app); }),
+                std::end(subcomms));
         }
+
+        return subcomms;
     }
 
     /// Check to see if given subcommand was selected
     bool got_subcommand(App *subcom) const {
         // get subcom needed to verify that this was a real subcommand
-        return get_subcommand(subcom)->parsed_;
+        return get_subcommand(subcom)->parsed_ > 0;
     }
 
     /// Check with name instead of pointer to see if subcommand was selected
-    bool got_subcommand(std::string name) const { return get_subcommand(name)->parsed_; }
+    bool got_subcommand(std::string subcommand_name) const { return get_subcommand(subcommand_name)->parsed_ > 0; }
 
     ///@}
     /// @name Help
     ///@{
 
     /// Set footer.
-    App *set_footer(std::string footer) {
-        footer_ = footer;
+    App *footer(std::string footer_string) {
+        footer_ = std::move(footer_string);
         return this;
     }
 
-    /// Produce a string that could be read in as a config of the current values of the App. Set default_also to include
-    /// default arguments. Prefix will add a string to the beginning of each option.
-    std::string
-    config_to_str(bool default_also = false, std::string prefix = "", bool write_description = false) const {
-        std::stringstream out;
-        for(const Option_p &opt : options_) {
-
-            // Only process option with a long-name and configurable
-            if(!opt->lnames_.empty() && opt->get_configurable()) {
-                std::string name = prefix + opt->lnames_[0];
-                std::string value;
-
-                // Non-flags
-                if(opt->get_type_size() != 0) {
-
-                    // If the option was found on command line
-                    if(opt->count() > 0)
-                        value = detail::inijoin(opt->results());
-
-                    // If the option has a default and is requested by optional argument
-                    else if(default_also && !opt->defaultval_.empty())
-                        value = opt->defaultval_;
-                    // Flag, one passed
-                } else if(opt->count() == 1) {
-                    value = "true";
-
-                    // Flag, multiple passed
-                } else if(opt->count() > 1) {
-                    value = std::to_string(opt->count());
-
-                    // Flag, not present
-                } else if(opt->count() == 0 && default_also) {
-                    value = "false";
-                }
-
-                if(!value.empty()) {
-                    if(write_description && opt->has_description()) {
-                        if(static_cast<int>(out.tellp()) != 0) {
-                            out << std::endl;
-                        }
-                        out << "; " << detail::fix_newlines("; ", opt->get_description()) << std::endl;
-                    }
-                    out << name << "=" << value << std::endl;
-                }
-            }
-        }
-        for(const App_p &subcom : subcommands_)
-            out << subcom->config_to_str(default_also, prefix + subcom->name_ + ".");
-        return out.str();
+    /// Produce a string that could be read in as a config of the current values of the App. Set default_also to
+    /// include default arguments. Prefix will add a string to the beginning of each option.
+    std::string config_to_str(bool default_also = false, bool write_description = false) const {
+        return config_formatter_->to_config(this, default_also, write_description, "");
     }
 
-    /// Makes a help message, with a column wid for column 1
-    std::string help(size_t wid = 30, std::string prev = "", int help_level = 1) const {
-        // Delegate to subcommand if needed
+    /// Makes a help message, using the currently configured formatter
+    /// Will only do one subcommand at a time
+    std::string help(std::string prev = "", AppFormatMode mode = AppFormatMode::Normal) const {
         if(prev.empty())
-            prev = name_;
+            prev = get_name();
         else
-            prev += " " + name_;
+            prev += " " + get_name();
 
+        // Delegate to subcommand if needed
         auto selected_subcommands = get_subcommands();
         if(!selected_subcommands.empty())
-            return selected_subcommands.at(0)->help(wid, prev);
-
-        std::stringstream out;
-        out << description_ << std::endl;
-        out << "Usage:" << (prev.empty() ? "" : " ") << prev;
-
-        // Check for options_
-        bool npos = false;
-        std::vector<std::string> groups;
-        for(const Option_p &opt : options_) {
-            if(opt->nonpositional() && opt->help_level_ <= help_level) {
-                npos = true;
+            return selected_subcommands.at(0)->help(prev, mode);
+        else
+            return formatter_->make_help(this, prev, mode);
+    }
 
-                // Add group if it is not already in there
-                if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
-                    groups.push_back(opt->get_group());
-                }
-            }
-        }
+    ///@}
+    /// @name Getters
+    ///@{
 
-        if(npos)
-            out << " [OPTIONS]";
+    /// Access the formatter
+    std::shared_ptr<FormatterBase> get_formatter() const { return formatter_; }
 
-        // Positionals
-        bool pos = false;
-        for(const Option_p &opt : options_)
-            if(opt->get_positional()) {
-                // A hidden positional should still show up in the usage statement
-                // if(detail::to_lower(opt->get_group()).empty())
-                //    continue;
-                out << " " << opt->help_positional();
-                if(opt->_has_help_positional())
-                    pos = true;
-            }
+    /// Access the config formatter
+    std::shared_ptr<Config> get_config_formatter() const { return config_formatter_; }
 
-        if(!subcommands_.empty()) {
-            if(require_subcommand_min_ > 0)
-                out << " SUBCOMMAND";
-            else
-                out << " [SUBCOMMAND]";
-        }
+    /// Get the app or subcommand description
+    std::string get_description() const { return description_; }
 
-        out << std::endl;
+    /// Set the description
+    App *description(const std::string &description) {
+        description_ = description;
+        return this;
+    }
 
-        // Positional descriptions
-        if(pos) {
-            out << std::endl ;
-            for(const Option_p &opt : options_) {
-                if(detail::to_lower(opt->get_group()).empty())
-                    continue; // Hidden
-                if(opt->_has_help_positional())
-                    detail::format_help(out, opt->help_pname(), opt->get_description(), wid);
-            }
-        }
+    /// Get the list of options (user facing function, so returns raw pointers), has optional filter function
+    std::vector<const Option *> get_options(const std::function<bool(const Option *)> filter = {}) const {
+        std::vector<const Option *> options(options_.size());
+        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
+            return val.get();
+        });
 
-        // Options
-        if(npos) {
-            for(const std::string &group : groups) {
-                if(detail::to_lower(group).empty())
-                    continue; // Hidden
-                out << std::endl << group << std::endl;
-                for(const Option_p &opt : options_) {
-                    if(opt->nonpositional() && opt->get_group() == group && opt->help_level_ <= help_level)
-                        detail::format_help(out, opt->help_name(true), opt->get_description(), wid);
-                }
-            }
+        if(filter) {
+            options.erase(std::remove_if(std::begin(options),
+                                         std::end(options),
+                                         [&filter](const Option *opt) { return !filter(opt); }),
+                          std::end(options));
         }
 
-        // Subcommands
-        if(!subcommands_.empty()) {
-            std::set<std::string> subcmd_groups_seen;
-            for(const App_p &com : subcommands_) {
-                const std::string &group_key = detail::to_lower(com->get_group());
-                if(group_key.empty() || subcmd_groups_seen.count(group_key) != 0)
-                    continue; // Hidden or not in a group
+        return options;
+    }
 
-                subcmd_groups_seen.insert(group_key);
-                out << std::endl << com->get_group() << ":" << std::endl;
-                for(const App_p &new_com : subcommands_)
-                    if(detail::to_lower(new_com->get_group()) == group_key)
-                        detail::format_help(out, new_com->get_name(), new_com->description_, wid);
+    /// Get an option by name
+    const Option *get_option(std::string option_name) const {
+        for(const Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt.get();
             }
         }
-
-        if(!footer_.empty()) {
-            out << std::endl << footer_ << std::endl;
-        }
-
-        return out.str();
+        throw OptionNotFound(option_name);
     }
 
-    ///@}
-    /// @name Getters
-    ///@{
-
-    /// Get the app or subcommand description
-    std::string get_description() const { return description_; }
-
-    /// Get the list of options (user facing function, so returns raw pointers)
-    std::vector<Option *> get_options() const {
-        std::vector<Option *> options(options_.size());
-        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
-            return val.get();
-        });
-        return options;
+    /// Get an option by name (non-const version)
+    Option *get_option(std::string option_name) {
+        for(Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt.get();
+            }
+        }
+        throw OptionNotFound(option_name);
     }
 
     /// Check the status of ignore_case
     bool get_ignore_case() const { return ignore_case_; }
 
+    /// Check the status of ignore_underscore
+    bool get_ignore_underscore() const { return ignore_underscore_; }
+
     /// Check the status of fallthrough
     bool get_fallthrough() const { return fallthrough_; }
 
+    /// Check the status of the allow windows style options
+    bool get_allow_windows_style_options() const { return allow_windows_style_options_; }
+
     /// Get the group of this subcommand
     const std::string &get_group() const { return group_; }
 
@@ -2775,7 +3720,7 @@ class App {
     bool get_allow_extras() const { return allow_extras_; }
 
     /// Get the status of allow extras
-    bool get_allow_ini_extras() const { return allow_ini_extras_; }
+    bool get_allow_config_extras() const { return allow_config_extras_; }
 
     /// Get a pointer to the help flag.
     Option *get_help_ptr() { return help_ptr_; }
@@ -2783,21 +3728,31 @@ class App {
     /// Get a pointer to the help flag. (const)
     const Option *get_help_ptr() const { return help_ptr_; }
 
+    /// Get a pointer to the help all flag. (const)
+    const Option *get_help_all_ptr() const { return help_all_ptr_; }
+
     /// Get a pointer to the config option.
     Option *get_config_ptr() { return config_ptr_; }
 
+    /// Get a pointer to the config option. (const)
+    const Option *get_config_ptr() const { return config_ptr_; }
+
     /// Get the parent of this subcommand (or nullptr if master app)
     App *get_parent() { return parent_; }
 
-    /// Get a pointer to the config option. (const)
-    const Option *get_config_ptr() const { return config_ptr_; }
+    /// Get the parent of this subcommand (or nullptr if master app) (const version)
+    const App *get_parent() const { return parent_; }
 
     /// Get the name of the current app
     std::string get_name() const { return name_; }
 
-    /// Check the name, case insensitive if set
+    /// Check the name, case insensitive and underscore insensitive if set
     bool check_name(std::string name_to_check) const {
         std::string local_name = name_;
+        if(ignore_underscore_) {
+            local_name = detail::remove_underscore(name_);
+            name_to_check = detail::remove_underscore(name_to_check);
+        }
         if(ignore_case_) {
             local_name = detail::to_lower(name_);
             name_to_check = detail::to_lower(name_to_check);
@@ -2806,13 +3761,27 @@ class App {
         return local_name == name_to_check;
     }
 
+    /// Get the groups available directly from this option (in order)
+    std::vector<std::string> get_groups() const {
+        std::vector<std::string> groups;
+
+        for(const Option_p &opt : options_) {
+            // Add group if it is not already in there
+            if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
+                groups.push_back(opt->get_group());
+            }
+        }
+
+        return groups;
+    }
+
     /// This gets a vector of pointers with the original parse order
     const std::vector<Option *> &parse_order() const { return parse_order_; }
 
     /// This returns the missing options from the current subcommand
     std::vector<std::string> remaining(bool recurse = false) const {
         std::vector<std::string> miss_list;
-        for(const std::pair<detail::Classifer, std::string> &miss : missing_) {
+        for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
             miss_list.push_back(std::get<1>(miss));
         }
 
@@ -2826,18 +3795,18 @@ class App {
         return miss_list;
     }
 
-    /// This returns the number of remaining options, minus the -- seperator
+    /// This returns the number of remaining options, minus the -- separator
     size_t remaining_size(bool recurse = false) const {
-        size_t count = static_cast<size_t>(std::count_if(
-            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifer, std::string> &val) {
-                return val.first != detail::Classifer::POSITIONAL_MARK;
+        auto remaining_options = static_cast<size_t>(std::count_if(
+            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
+                return val.first != detail::Classifier::POSITIONAL_MARK;
             }));
         if(recurse) {
             for(const App_p &sub : subcommands_) {
-                count += sub->remaining_size(recurse);
+                remaining_options += sub->remaining_size(recurse);
             }
         }
-        return count;
+        return remaining_options;
     }
 
     ///@}
@@ -2847,10 +3816,10 @@ class App {
     ///
     /// Currently checks to see if multiple positionals exist with -1 args
     void _validate() const {
-        auto count = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
+        auto pcount = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
             return opt->get_items_expected() < 0 && opt->get_positional();
         });
-        if(count > 1)
+        if(pcount > 1)
             throw InvalidError(name_);
         for(const App_p &app : subcommands_)
             app->_validate();
@@ -2882,33 +3851,26 @@ class App {
     }
 
     /// Selects a Classifier enum based on the type of the current argument
-    detail::Classifer _recognize(const std::string &current) const {
+    detail::Classifier _recognize(const std::string &current) const {
         std::string dummy1, dummy2;
 
         if(current == "--")
-            return detail::Classifer::POSITIONAL_MARK;
+            return detail::Classifier::POSITIONAL_MARK;
         if(_valid_subcommand(current))
-            return detail::Classifer::SUBCOMMAND;
+            return detail::Classifier::SUBCOMMAND;
         if(detail::split_long(current, dummy1, dummy2))
-            return detail::Classifer::LONG;
+            return detail::Classifier::LONG;
         if(detail::split_short(current, dummy1, dummy2))
-            return detail::Classifer::SHORT;
-        return detail::Classifer::NONE;
+            return detail::Classifier::SHORT;
+        if((allow_windows_style_options_) && (detail::split_windows(current, dummy1, dummy2)))
+            return detail::Classifier::WINDOWS;
+        return detail::Classifier::NONE;
     }
 
-    /// Internal parse function
-    void _parse(std::vector<std::string> &args) {
-        parsed_ = true;
-        bool positional_only = false;
-
-        while(!args.empty()) {
-            _parse_single(args, positional_only);
-        }
-
-        if(help_ptr_ != nullptr && help_ptr_->count() > 0) {
-            throw CallForHelp();
-        }
+    // The parse function is now broken into several parts, and part of process
 
+    /// Read and process an ini file (main app only)
+    void _process_ini() {
         // Process an INI file
         if(config_ptr_ != nullptr) {
             if(*config_ptr_) {
@@ -2917,20 +3879,18 @@ class App {
             }
             if(!config_name_.empty()) {
                 try {
-                    std::vector<detail::ini_ret_t> values = detail::parse_ini(config_name_);
-                    while(!values.empty()) {
-                        if(!_parse_ini(values)) {
-                            throw INIError::Extras(values.back().fullname);
-                        }
-                    }
+                    std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
+                    _parse_config(values);
                 } catch(const FileError &) {
                     if(config_required_)
                         throw;
                 }
             }
         }
+    }
 
-        // Get envname options if not yet passed
+    /// Get envname options if not yet passed. Runs on *all* subcommands.
+    void _process_env() {
         for(const Option_p &opt : options_) {
             if(opt->count() == 0 && !opt->envname_.empty()) {
                 char *buffer = nullptr;
@@ -2956,140 +3916,202 @@ class App {
             }
         }
 
-        // Process callbacks
+        for(App_p &sub : subcommands_) {
+            sub->_process_env();
+        }
+    }
+
+    /// Process callbacks. Runs on *all* subcommands.
+    void _process_callbacks() {
         for(const Option_p &opt : options_) {
             if(opt->count() > 0 && !opt->get_callback_run()) {
                 opt->run_callback();
             }
         }
 
-        // Verify required options
+        for(App_p &sub : subcommands_) {
+            sub->_process_callbacks();
+        }
+    }
+
+    /// Run help flag processing if any are found.
+    ///
+    /// The flags allow recursive calls to remember if there was a help flag on a parent.
+    void _process_help_flags(bool trigger_help = false, bool trigger_all_help = false) const {
+        const Option *help_ptr = get_help_ptr();
+        const Option *help_all_ptr = get_help_all_ptr();
+
+        if(help_ptr != nullptr && help_ptr->count() > 0)
+            trigger_help = true;
+        if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
+            trigger_all_help = true;
+
+        // If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
+        if(!parsed_subcommands_.empty()) {
+            for(const App *sub : parsed_subcommands_)
+                sub->_process_help_flags(trigger_help, trigger_all_help);
+
+            // Only the final subcommand should call for help. All help wins over help.
+        } else if(trigger_all_help) {
+            throw CallForAllHelp();
+        } else if(trigger_help) {
+            throw CallForHelp();
+        }
+    }
+
+    /// Verify required options and cross requirements. Subcommands too (only if selected).
+    void _process_requirements() {
         for(const Option_p &opt : options_) {
+
             // Required or partially filled
             if(opt->get_required() || opt->count() != 0) {
                 // Make sure enough -N arguments parsed (+N is already handled in parsing function)
                 if(opt->get_items_expected() < 0 && opt->count() < static_cast<size_t>(-opt->get_items_expected()))
-                    throw ArgumentMismatch::AtLeast(opt->single_name(), -opt->get_items_expected());
+                    throw ArgumentMismatch::AtLeast(opt->get_name(), -opt->get_items_expected());
 
                 // Required but empty
                 if(opt->get_required() && opt->count() == 0)
-                    throw RequiredError(opt->single_name());
+                    throw RequiredError(opt->get_name());
             }
             // Requires
-            for(const Option *opt_req : opt->requires_)
+            for(const Option *opt_req : opt->needs_)
                 if(opt->count() > 0 && opt_req->count() == 0)
-                    throw RequiresError(opt->single_name(), opt_req->single_name());
+                    throw RequiresError(opt->get_name(), opt_req->get_name());
             // Excludes
             for(const Option *opt_ex : opt->excludes_)
                 if(opt->count() > 0 && opt_ex->count() != 0)
-                    throw ExcludesError(opt->single_name(), opt_ex->single_name());
+                    throw ExcludesError(opt->get_name(), opt_ex->get_name());
         }
 
         auto selected_subcommands = get_subcommands();
         if(require_subcommand_min_ > selected_subcommands.size())
             throw RequiredError::Subcommand(require_subcommand_min_);
 
-        // Convert missing (pairs) to extras (string only)
+        // Max error cannot occur, the extra subcommand will parse as an ExtrasError or a remaining item.
+
+        for(App_p &sub : subcommands_) {
+            if(sub->count() > 0)
+                sub->_process_requirements();
+        }
+    }
+
+    /// Process callbacks and such.
+    void _process() {
+        _process_ini();
+        _process_env();
+        _process_callbacks();
+        _process_help_flags();
+        _process_requirements();
+    }
+
+    /// Throw an error if anything is left over and should not be.
+    /// Modifies the args to fill in the missing items before throwing.
+    void _process_extras(std::vector<std::string> &args) {
         if(!(allow_extras_ || prefix_command_)) {
             size_t num_left_over = remaining_size();
             if(num_left_over > 0) {
                 args = remaining(false);
-                std::reverse(std::begin(args), std::end(args));
                 throw ExtrasError(args);
             }
         }
+
+        for(App_p &sub : subcommands_) {
+            if(sub->count() > 0)
+                sub->_process_extras(args);
+        }
     }
 
-    /// Parse one ini param, return false if not found in any subcommand, remove if it is
+    /// Internal parse function
+    void _parse(std::vector<std::string> &args) {
+        parsed_++;
+        bool positional_only = false;
+
+        while(!args.empty()) {
+            _parse_single(args, positional_only);
+        }
+
+        if(parent_ == nullptr) {
+            _process();
+
+            // Throw error if any items are left over (depending on settings)
+            _process_extras(args);
+
+            // Convert missing (pairs) to extras (string only)
+            args = remaining(false);
+        }
+    }
+
+    /// Parse one config param, return false if not found in any subcommand, remove if it is
     ///
     /// If this has more than one dot.separated.name, go into the subcommand matching it
     /// Returns true if it managed to find the option, if false you'll need to remove the arg manually.
-    bool _parse_ini(std::vector<detail::ini_ret_t> &args) {
-        detail::ini_ret_t &current = args.back();
-        std::string parent = current.parent(); // respects current.level
-        std::string name = current.name();
-
-        // If a parent is listed, go to a subcommand
-        if(!parent.empty()) {
-            current.level++;
-            for(const App_p &com : subcommands_)
-                if(com->check_name(parent))
-                    return com->_parse_ini(args);
-            return false;
+    void _parse_config(std::vector<ConfigItem> &args) {
+        for(ConfigItem item : args) {
+            if(!_parse_single_config(item) && !allow_config_extras_)
+                throw ConfigError::Extras(item.fullname());
         }
+    }
 
-        auto op_ptr = std::find_if(
-            std::begin(options_), std::end(options_), [name](const Option_p &v) { return v->check_lname(name); });
+    /// Fill in a single config option
+    bool _parse_single_config(const ConfigItem &item, size_t level = 0) {
+        if(level < item.parents.size()) {
+            App *subcom;
+            try {
+                subcom = get_subcommand(item.parents.at(level));
+            } catch(const OptionNotFound &) {
+                return false;
+            }
+            return subcom->_parse_single_config(item, level + 1);
+        }
 
-        if(op_ptr == std::end(options_)) {
-            if(allow_ini_extras_) {
+        Option *op;
+        try {
+            op = get_option("--" + item.name);
+        } catch(const OptionNotFound &) {
+            // If the option was not present
+            if(get_allow_config_extras())
                 // Should we worry about classifying the extras properly?
-                missing_.emplace_back(detail::Classifer::NONE, current.fullname);
-                args.pop_back();
-                return true;
-            }
+                missing_.emplace_back(detail::Classifier::NONE, item.fullname());
             return false;
         }
 
-        // Let's not go crazy with pointer syntax
-        Option_p &op = *op_ptr;
-
         if(!op->get_configurable())
-            throw INIError::NotConfigurable(current.fullname);
+            throw ConfigError::NotConfigurable(item.fullname());
 
-        if(op->results_.empty()) {
+        if(op->empty()) {
             // Flag parsing
             if(op->get_type_size() == 0) {
-                if(current.inputs.size() == 1) {
-                    std::string val = current.inputs.at(0);
-                    val = detail::to_lower(val);
-                    if(val == "true" || val == "on" || val == "yes")
-                        op->results_ = {""};
-                    else if(val == "false" || val == "off" || val == "no")
-                        ;
-                    else
-                        try {
-                            size_t ui = std::stoul(val);
-                            for(size_t i = 0; i < ui; i++)
-                                op->results_.emplace_back("");
-                        } catch(const std::invalid_argument &) {
-                            throw ConversionError::TrueFalse(current.fullname);
-                        }
-                } else
-                    throw ConversionError::TooManyInputsFlag(current.fullname);
+                op->set_results(config_formatter_->to_flag(item));
             } else {
-                op->results_ = current.inputs;
+                op->set_results(item.inputs);
                 op->run_callback();
             }
         }
 
-        args.pop_back();
         return true;
     }
 
-    /// Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing from
-    /// master
+    /// Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing
+    /// from master
     void _parse_single(std::vector<std::string> &args, bool &positional_only) {
 
-        detail::Classifer classifer = positional_only ? detail::Classifer::NONE : _recognize(args.back());
-        switch(classifer) {
-        case detail::Classifer::POSITIONAL_MARK:
-            missing_.emplace_back(classifer, args.back());
+        detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
+        switch(classifier) {
+        case detail::Classifier::POSITIONAL_MARK:
+            missing_.emplace_back(classifier, args.back());
             args.pop_back();
             positional_only = true;
             break;
-        case detail::Classifer::SUBCOMMAND:
+        case detail::Classifier::SUBCOMMAND:
             _parse_subcommand(args);
             break;
-        case detail::Classifer::LONG:
-            // If already parsed a subcommand, don't accept options_
-            _parse_arg(args, true);
-            break;
-        case detail::Classifer::SHORT:
+        case detail::Classifier::LONG:
+        case detail::Classifier::SHORT:
+        case detail::Classifier::WINDOWS:
             // If already parsed a subcommand, don't accept options_
-            _parse_arg(args, false);
+            _parse_arg(args, classifier);
             break;
-        case detail::Classifer::NONE:
+        case detail::Classifier::NONE:
             // Probably a positional or something for a parent (sub)command
             _parse_positional(args);
         }
@@ -3126,11 +4148,11 @@ class App {
             return parent_->_parse_positional(args);
         else {
             args.pop_back();
-            missing_.emplace_back(detail::Classifer::NONE, positional);
+            missing_.emplace_back(detail::Classifier::NONE, positional);
 
             if(prefix_command_) {
                 while(!args.empty()) {
-                    missing_.emplace_back(detail::Classifer::NONE, args.back());
+                    missing_.emplace_back(detail::Classifier::NONE, args.back());
                     args.pop_back();
                 }
             }
@@ -3160,33 +4182,46 @@ class App {
     }
 
     /// Parse a short (false) or long (true) argument, must be at the top of the list
-    void _parse_arg(std::vector<std::string> &args, bool second_dash) {
-
-        detail::Classifer current_type = second_dash ? detail::Classifer::LONG : detail::Classifer::SHORT;
+    void _parse_arg(std::vector<std::string> &args, detail::Classifier current_type) {
 
         std::string current = args.back();
 
-        std::string name;
+        std::string arg_name;
         std::string value;
         std::string rest;
 
-        if(second_dash) {
-            if(!detail::split_long(current, name, value))
+        switch(current_type) {
+        case detail::Classifier::LONG:
+            if(!detail::split_long(current, arg_name, value))
                 throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
-        } else {
-            if(!detail::split_short(current, name, rest))
+            break;
+        case detail::Classifier::SHORT:
+            if(!detail::split_short(current, arg_name, rest))
                 throw HorribleError("Short parsed but missing! You should not see this");
+            break;
+        case detail::Classifier::WINDOWS:
+            if(!detail::split_windows(current, arg_name, value))
+                throw HorribleError("windows option parsed but missing! You should not see this");
+            break;
+        default:
+            throw HorribleError("parsing got called with invalid option! You should not see this");
         }
 
-        auto op_ptr = std::find_if(std::begin(options_), std::end(options_), [name, second_dash](const Option_p &opt) {
-            return second_dash ? opt->check_lname(name) : opt->check_sname(name);
-        });
+        auto op_ptr =
+            std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](const Option_p &opt) {
+                if(current_type == detail::Classifier::LONG)
+                    return opt->check_lname(arg_name);
+                if(current_type == detail::Classifier::SHORT)
+                    return opt->check_sname(arg_name);
+                // this will only get called for detail::Classifier::WINDOWS
+                return opt->check_lname(arg_name) || opt->check_sname(arg_name);
+            });
 
         // Option not found
         if(op_ptr == std::end(options_)) {
             // If a subcommand, try the master command
             if(parent_ != nullptr && fallthrough_)
-                return parent_->_parse_arg(args, second_dash);
+                return parent_->_parse_arg(args, current_type);
             // Otherwise, add to missing
             else {
                 args.pop_back();
@@ -3228,7 +4263,7 @@ class App {
 
         // Unlimited vector parser
         if(num < 0) {
-            while(!args.empty() && _recognize(args.back()) == detail::Classifer::NONE) {
+            while(!args.empty() && _recognize(args.back()) == detail::Classifier::NONE) {
                 if(collected >= -num) {
                     // We could break here for allow extras, but we don't
 
@@ -3243,7 +4278,7 @@ class App {
             }
 
             // Allow -- to end an unlimited list and "eat" it
-            if(!args.empty() && _recognize(args.back()) == detail::Classifer::POSITIONAL_MARK)
+            if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
                 args.pop_back();
 
         } else {
@@ -3256,7 +4291,7 @@ class App {
             }
 
             if(num > 0) {
-                throw ArgumentMismatch::TypedAtLeast(op->single_name(), num, op->get_type_name());
+                throw ArgumentMismatch::TypedAtLeast(op->get_name(), num, op->get_type_name());
             }
         }
 
@@ -3269,13 +4304,26 @@ class App {
 
 namespace FailureMessage {
 
+/// Printout a clean, simple message on error (the default in CLI11 1.5+)
 inline std::string simple(const App *app, const Error &e) {
     std::string header = std::string(e.what()) + "\n";
+    std::vector<std::string> names;
+
+    // Collect names
     if(app->get_help_ptr() != nullptr)
-        header += "Run with " + app->get_help_ptr()->single_name() + " for more information.\n";
+        names.push_back(app->get_help_ptr()->get_name());
+
+    if(app->get_help_all_ptr() != nullptr)
+        names.push_back(app->get_help_all_ptr()->get_name());
+
+    // If any names found, suggest those
+    if(!names.empty())
+        header += "Run with " + detail::join(names, " or ") + " for more information.\n";
+
     return header;
 }
 
+/// Printout the full help string on error (if this fn is set, the old default for CLI11)
 inline std::string help(const App *app, const Error &e) {
     std::string header = std::string("ERROR: ") + e.get_name() + ": " + e.what() + "\n";
     header += app->help();
@@ -3306,3 +4354,302 @@ struct AppFriend {
 
 } // namespace CLI
 
+// From CLI/Config.hpp:
+
+namespace CLI {
+
+inline std::string
+ConfigINI::to_config(const App *app, bool default_also, bool write_description, std::string prefix) const {
+    std::stringstream out;
+    for(const Option *opt : app->get_options({})) {
+
+        // Only process option with a long-name and configurable
+        if(!opt->get_lnames().empty() && opt->get_configurable()) {
+            std::string name = prefix + opt->get_lnames()[0];
+            std::string value;
+
+            // Non-flags
+            if(opt->get_type_size() != 0) {
+
+                // If the option was found on command line
+                if(opt->count() > 0)
+                    value = detail::ini_join(opt->results());
+
+                // If the option has a default and is requested by optional argument
+                else if(default_also && !opt->get_defaultval().empty())
+                    value = opt->get_defaultval();
+                // Flag, one passed
+            } else if(opt->count() == 1) {
+                value = "true";
+
+                // Flag, multiple passed
+            } else if(opt->count() > 1) {
+                value = std::to_string(opt->count());
+
+                // Flag, not present
+            } else if(opt->count() == 0 && default_also) {
+                value = "false";
+            }
+
+            if(!value.empty()) {
+                if(write_description && opt->has_description()) {
+                    if(static_cast<int>(out.tellp()) != 0) {
+                        out << std::endl;
+                    }
+                    out << "; " << detail::fix_newlines("; ", opt->get_description()) << std::endl;
+                }
+
+                // Don't try to quote anything that is not size 1
+                if(opt->get_items_expected() != 1)
+                    out << name << "=" << value << std::endl;
+                else
+                    out << name << "=" << detail::add_quotes_if_needed(value) << std::endl;
+            }
+        }
+    }
+
+    for(const App *subcom : app->get_subcommands({}))
+        out << to_config(subcom, default_also, write_description, prefix + subcom->get_name() + ".");
+
+    return out.str();
+}
+
+} // namespace CLI
+
+// From CLI/Formatter.hpp:
+
+namespace CLI {
+
+inline std::string
+Formatter::make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const {
+    std::stringstream out;
+
+    out << "\n" << group << ":\n";
+    for(const Option *opt : opts) {
+        out << make_option(opt, is_positional);
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_positionals(const App *app) const {
+    std::vector<const Option *> opts =
+        app->get_options([](const Option *opt) { return !opt->get_group().empty() && opt->get_positional(); });
+
+    if(opts.empty())
+        return std::string();
+    else
+        return make_group(get_label("Positionals"), true, opts);
+}
+
+inline std::string Formatter::make_groups(const App *app, AppFormatMode mode) const {
+    std::stringstream out;
+    std::vector<std::string> groups = app->get_groups();
+
+    // Options
+    for(const std::string &group : groups) {
+        std::vector<const Option *> opts = app->get_options([app, mode, &group](const Option *opt) {
+            return opt->get_group() == group                    // Must be in the right group
+                   && opt->nonpositional()                      // Must not be a positional
+                   && (mode != AppFormatMode::Sub               // If mode is Sub, then
+                       || (app->get_help_ptr() != opt           // Ignore help pointer
+                           && app->get_help_all_ptr() != opt)); // Ignore help all pointer
+        });
+        if(!group.empty() && !opts.empty()) {
+            out << make_group(group, false, opts);
+
+            if(group != groups.back())
+                out << "\n";
+        }
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_description(const App *app) const {
+    std::string desc = app->get_description();
+
+    if(!desc.empty())
+        return desc + "\n";
+    else
+        return "";
+}
+
+inline std::string Formatter::make_usage(const App *app, std::string name) const {
+    std::stringstream out;
+
+    out << get_label("Usage") << ":" << (name.empty() ? "" : " ") << name;
+
+    std::vector<std::string> groups = app->get_groups();
+
+    // Print an Options badge if any options exist
+    std::vector<const Option *> non_pos_options =
+        app->get_options([](const Option *opt) { return opt->nonpositional(); });
+    if(!non_pos_options.empty())
+        out << " [" << get_label("OPTIONS") << "]";
+
+    // Positionals need to be listed here
+    std::vector<const Option *> positionals = app->get_options([](const Option *opt) { return opt->get_positional(); });
+
+    // Print out positionals if any are left
+    if(!positionals.empty()) {
+        // Convert to help names
+        std::vector<std::string> positional_names(positionals.size());
+        std::transform(positionals.begin(), positionals.end(), positional_names.begin(), [this](const Option *opt) {
+            return make_option_usage(opt);
+        });
+
+        out << " " << detail::join(positional_names, " ");
+    }
+
+    // Add a marker if subcommands are expected or optional
+    if(!app->get_subcommands({}).empty()) {
+        out << " " << (app->get_require_subcommand_min() == 0 ? "[" : "")
+            << get_label(app->get_require_subcommand_max() < 2 || app->get_require_subcommand_min() > 1 ? "SUBCOMMAND"
+                                                                                                        : "SUBCOMMANDS")
+            << (app->get_require_subcommand_min() == 0 ? "]" : "");
+    }
+
+    out << std::endl;
+
+    return out.str();
+}
+
+inline std::string Formatter::make_footer(const App *app) const {
+    std::string footer = app->get_footer();
+    if(!footer.empty())
+        return footer + "\n";
+    else
+        return "";
+}
+
+inline std::string Formatter::make_help(const App *app, std::string name, AppFormatMode mode) const {
+
+    // This immediately forwards to the make_expanded method. This is done this way so that subcommands can
+    // have overridden formatters
+    if(mode == AppFormatMode::Sub)
+        return make_expanded(app);
+
+    std::stringstream out;
+
+    out << make_description(app);
+    out << make_usage(app, name);
+    out << make_positionals(app);
+    out << make_groups(app, mode);
+    out << make_subcommands(app, mode);
+    out << make_footer(app);
+
+    return out.str();
+}
+
+inline std::string Formatter::make_subcommands(const App *app, AppFormatMode mode) const {
+    std::stringstream out;
+
+    std::vector<const App *> subcommands = app->get_subcommands({});
+
+    // Make a list in definition order of the groups seen
+    std::vector<std::string> subcmd_groups_seen;
+    for(const App *com : subcommands) {
+        std::string group_key = com->get_group();
+        if(!group_key.empty() &&
+           std::find_if(subcmd_groups_seen.begin(), subcmd_groups_seen.end(), [&group_key](std::string a) {
+               return detail::to_lower(a) == detail::to_lower(group_key);
+           }) == subcmd_groups_seen.end())
+            subcmd_groups_seen.push_back(group_key);
+    }
+
+    // For each group, filter out and print subcommands
+    for(const std::string &group : subcmd_groups_seen) {
+        out << "\n" << group << ":\n";
+        std::vector<const App *> subcommands_group = app->get_subcommands(
+            [&group](const App *sub_app) { return detail::to_lower(sub_app->get_group()) == detail::to_lower(group); });
+        for(const App *new_com : subcommands_group) {
+            if(mode != AppFormatMode::All) {
+                out << make_subcommand(new_com);
+            } else {
+                out << new_com->help(new_com->get_name(), AppFormatMode::Sub);
+                out << "\n";
+            }
+        }
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_subcommand(const App *sub) const {
+    std::stringstream out;
+    detail::format_help(out, sub->get_name(), sub->get_description(), column_width_);
+    return out.str();
+}
+
+inline std::string Formatter::make_expanded(const App *sub) const {
+    std::stringstream out;
+    out << sub->get_name() << "\n";
+
+    out << make_description(sub);
+    out << make_positionals(sub);
+    out << make_groups(sub, AppFormatMode::Sub);
+    out << make_subcommands(sub, AppFormatMode::Sub);
+
+    // Drop blank spaces
+    std::string tmp = detail::find_and_replace(out.str(), "\n\n", "\n");
+    tmp = tmp.substr(0, tmp.size() - 1); // Remove the final '\n'
+
+    // Indent all but the first line (the name)
+    return detail::find_and_replace(tmp, "\n", "\n  ") + "\n";
+}
+
+inline std::string Formatter::make_option_name(const Option *opt, bool is_positional) const {
+    if(is_positional)
+        return opt->get_name(true, false);
+    else
+        return opt->get_name(false, true);
+}
+
+inline std::string Formatter::make_option_opts(const Option *opt) const {
+    std::stringstream out;
+
+    if(opt->get_type_size() != 0) {
+        if(!opt->get_type_name().empty())
+            out << " " << get_label(opt->get_type_name());
+        if(!opt->get_defaultval().empty())
+            out << "=" << opt->get_defaultval();
+        if(opt->get_expected() > 1)
+            out << " x " << opt->get_expected();
+        if(opt->get_expected() == -1)
+            out << " ...";
+        if(opt->get_required())
+            out << " " << get_label("REQUIRED");
+    }
+    if(!opt->get_envname().empty())
+        out << " (" << get_label("Env") << ":" << opt->get_envname() << ")";
+    if(!opt->get_needs().empty()) {
+        out << " " << get_label("Needs") << ":";
+        for(const Option *op : opt->get_needs())
+            out << " " << op->get_name();
+    }
+    if(!opt->get_excludes().empty()) {
+        out << " " << get_label("Excludes") << ":";
+        for(const Option *op : opt->get_excludes())
+            out << " " << op->get_name();
+    }
+    return out.str();
+}
+
+inline std::string Formatter::make_option_desc(const Option *opt) const { return opt->get_description(); }
+
+inline std::string Formatter::make_option_usage(const Option *opt) const {
+    // Note that these are positionals usages
+    std::stringstream out;
+    out << make_option_name(opt, true);
+
+    if(opt->get_expected() > 1)
+        out << "(" << std::to_string(opt->get_expected()) << "x)";
+    else if(opt->get_expected() < 0)
+        out << "...";
+
+    return opt->get_required() ? out.str() : "[" + out.str() + "]";
+}
+
+} // namespace CLI
+