diff --git a/include/argparse.hpp b/include/argparse.hpp
new file mode 100644
index 0000000..333b5df
--- /dev/null
+++ b/include/argparse.hpp
@@ -0,0 +1,591 @@
+#pragma once
+//
+// @author : Morris Franken
+//  https://github.com/morrisfranken/argparse
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+//
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+#include <cctype>              // for isdigit, tolower
+#include <sstream>
+#include <cstdlib>             // for size_t, exit
+#include <algorithm>           // for max, transform, copy, min
+#include <iomanip>             // for operator<<, setw
+#include <iostream>            // for operator<<, basic_ostream, endl, ostream
+#include <iterator>            // for ostream_iterator
+#include <map>                 // for operator!=, map, _Rb_tree_iterator
+#include <memory>              // for allocator, shared_ptr, __shared_ptr_ac...
+#include <optional>            // for optional, nullopt
+#include <stdexcept>           // for runtime_error, invalid_argument
+#include <filesystem>          // for getting program_name from path
+#include <string>              // for string, operator+, basic_string, char_...
+#include <type_traits>         // for declval, false_type, true_type, is_enum
+#include <utility>             // for move, pair
+#include <vector>              // for vector
+
+#if __has_include(<magic_enum.hpp>)
+#include <magic_enum.hpp>      // for enum_entries
+#define HAS_MAGIC_ENUM
+#endif
+
+#define ARGPARSE_VERSION 4
+
+namespace argparse {
+    class Args;
+    using std::cout, std::cerr, std::endl, std::setw, std::size_t;
+
+    template<typename T> struct is_vector : public std::false_type {};
+    template<typename T, typename A> struct is_vector<std::vector<T, A>> : public std::true_type {};
+
+    template<typename T> struct is_optional : public std::false_type {};
+    template<typename T> struct is_optional<std::optional<T>> : public std::true_type {};
+
+    template<typename T> struct is_shared_ptr : public std::false_type {};
+    template<typename T> struct is_shared_ptr<std::shared_ptr<T>> : public std::true_type {};
+
+    template <typename, typename = void> struct has_ostream_operator : std::false_type {};
+    template <typename T> struct has_ostream_operator<T, decltype(void(std::declval<std::ostream&>() << std::declval<const T&>()))> : std::true_type {};
+
+    inline std::string bold(const std::string& input_str) {
+#ifdef _WIN32
+        return input_str; // no bold for windows
+#else
+        return "\033[1m" + input_str + "\033[0m";
+#endif
+    }
+
+    template<typename T> std::string toString(const T &v) {
+        if constexpr (has_ostream_operator<T>::value) {
+            return static_cast<std::ostringstream &&>((std::ostringstream() << std::boolalpha << v)).str();       // https://github.com/stan-dev/math/issues/590#issuecomment-550122627
+        } else {
+            return "unknown";
+        }
+    }
+
+    std::vector<std::string> inline split(const std::string &str) {
+        std::vector<std::string> splits;
+        std::stringstream ss(str);
+        std::string key;
+        while (std::getline(ss, key, ',')) {
+            if (!key.empty() && key.back() == '\0')
+                key.pop_back(); // last variables contain a '\0', which is unexpected when comparing to raw string, e.g. value == "test" will fail when the last character is '\0'. Therefore we can remove it
+            splits.emplace_back(std::move(key));
+        }
+        return splits;
+    }
+
+    template <typename T> std::string to_lower(const T &str_) { // both std::string and std::basic_string_view<char> (for magic_enum) are using to_lower
+        std::string str(str_.size(), '\0');
+        std::transform(str_.begin(), str_.end(), str.begin(), ::tolower);
+        return str;
+    }
+
+    template<typename T> inline T get(const std::string &v);
+    template<> inline std::string get(const std::string &v) { return v; }
+    template<> inline char get(const std::string &v) { return v.empty()? throw std::invalid_argument("empty string") : v.size() > 1?  v.substr(0,2) == "0x"? (char)std::stoul(v, nullptr, 16) : (char)std::stoi(v) : v[0]; }
+    template<> inline int get(const std::string &v) { return std::stoi(v); }
+    template<> inline short get(const std::string &v) { return std::stoi(v); }
+    template<> inline long get(const std::string &v) { return std::stol(v); }
+    template<> inline long long get(const std::string &v) { return std::stol(v); }
+    template<> inline bool get(const std::string &v) { return to_lower(v) == "true" || v == "1"; }
+    template<> inline float get(const std::string &v) { return std::stof(v); }
+    template<> inline double get(const std::string &v) { return std::stod(v); }
+    template<> inline unsigned char get(const std::string &v) { return get<char>(v); }
+    template<> inline unsigned int get(const std::string &v) { return std::stoul(v); }
+    template<> inline unsigned short get(const std::string &v) { return std::stoul(v); }
+    template<> inline unsigned long get(const std::string &v) { return std::stoul(v); }
+    template<> inline unsigned long long get(const std::string &v) { return std::stoul(v); }
+
+    template<typename T> inline T get(const std::string &v) { // remaining types
+        if constexpr (is_vector<T>::value) {
+            const std::vector<std::string> splitted = split(v);
+            T res(splitted.size());
+            if (!v.empty())
+                std::transform (splitted.begin(), splitted.end(), res.begin(), get<typename T::value_type>);
+            return res;
+        } else if constexpr (std::is_pointer<T>::value) {
+            return new typename std::remove_pointer<T>::type(get<typename std::remove_pointer<T>::type>(v));
+        } else if constexpr (is_shared_ptr<T>::value) {
+            return std::make_shared<typename T::element_type>(get<typename T::element_type>(v));
+        } else if constexpr (is_optional<T>::value) {
+            return get<typename T::value_type>(v);
+        } else if constexpr (std::is_enum<T>::value) {  // case-insensitive enum conversion
+#ifdef HAS_MAGIC_ENUM
+            constexpr auto& enum_entries = magic_enum::enum_entries<T>();
+            const std::string lower_str = to_lower(v);
+            for (const auto &[value, name] : enum_entries) {
+                if (to_lower(name) == lower_str)
+                    return value;
+            }
+            std::string error = "enum is only accepting [";
+            for (size_t i = 0; i < enum_entries.size(); i++)
+                error += (i==0? "" : ", ") + to_lower(enum_entries[i].second);
+            error += "]";
+            throw std::runtime_error(error);
+#else
+            throw std::runtime_error("Enum not supported, please install magic_enum (https://github.com/Neargye/magic_enum)");
+#endif
+        } else {
+            return T(v);
+        }
+    }
+
+    struct ConvertBase {
+        virtual ~ConvertBase() = default;
+        virtual void convert(const std::string &v) = 0;
+        virtual void set_default(const std::unique_ptr<ConvertBase> &default_value, const std::string &default_string) = 0;
+        [[nodiscard]] virtual size_t get_type_id() const = 0;
+        [[nodiscard]] virtual std::string get_allowed_entries() const = 0;
+    };
+
+    template <typename T> struct ConvertType : public ConvertBase {
+        T data;
+        ~ConvertType() override = default;
+        ConvertType() : ConvertBase() {};
+        explicit ConvertType(const T &value) : ConvertBase(), data(value) {};
+
+        void convert(const std::string &v) override {
+            data = get<T>(v);
+        }
+
+        void set_default(const std::unique_ptr<ConvertBase> &default_value, const std::string &default_string) override {
+            if (this->get_type_id() == default_value->get_type_id())    // When the types do not match exactly. resort to string conversion
+                data = ((ConvertType<T>*)(default_value.get()))->data;
+            else
+                data = get<T>(default_string);
+        }
+
+        [[nodiscard]] size_t get_type_id() const override {
+            return typeid(T).hash_code();
+        }
+
+        [[nodiscard]] std::string get_allowed_entries() const override {
+            std::stringstream ss;
+
+#ifdef HAS_MAGIC_ENUM
+            if constexpr (std::is_enum<T>::value) {
+                for (const auto &[value, name] : magic_enum::enum_entries<T>()) {
+                    ss << to_lower(name) << ", ";
+                }
+            }
+#endif
+
+            return ss.str();
+        }
+    };
+
+    struct Entry {
+        enum ARG_TYPE {ARG, KWARG, FLAG} type;
+
+        Entry(ARG_TYPE type, const std::string& key, std::string help, std::optional<std::string> implicit_value=std::nullopt) :
+                type(type),
+                keys_(split(key)),
+                help(std::move(help)),
+                implicit_value_(std::move(implicit_value)) {
+        }
+
+        // Allow both string inputs and direct-type inputs. Where a string-input will be converted like it would when using the commandline, and the direct approach is to simply use the value provided.
+        template <typename T> Entry &set_default(const T &default_value) {
+            this->default_str_ = toString(default_value);
+            if constexpr (!(std::is_array<T>::value || std::is_same<typename std::remove_all_extents<T>::type, char>::value)) {
+                data_default = std::make_unique<ConvertType<T>>(default_value);
+            }
+            return *this;
+        }
+
+        Entry &multi_argument() {
+            _is_multi_argument = true;
+            return *this;
+        }
+
+        // Magically convert the value string to the requested type
+        template <typename T> operator T&() {
+            // Automatically set the default to nullptr for pointer types and empty for optional types
+            if constexpr (is_optional<T>::value || std::is_pointer<T>::value || is_shared_ptr<T>::value) {
+                if (!default_str_.has_value()) {
+                    default_str_ = "none";
+                    if constexpr(is_optional<T>::value) {
+                        data_default = std::make_unique<ConvertType<T>> (T{std::nullopt});
+                    } else {
+                        data_default = std::make_unique<ConvertType<T>> ((T) nullptr);
+                    }
+                }
+            }
+
+            datap = std::make_unique<ConvertType<T>>();
+            return ((ConvertType<T>*)(datap.get()))->data;
+        }
+
+        // Force an ambiguous error when not using a reference.
+        template <typename T> operator T() {} // When you get here  because you received an error, make sure all parameters of argparse are references (e.g. with `&`)
+
+    private:
+        std::vector<std::string> keys_;
+        std::string help;
+        std::optional<std::string> value_;
+        std::optional<std::string> implicit_value_;
+        std::optional<std::string> default_str_;
+        std::string error;
+        std::unique_ptr<ConvertBase> datap;
+        std::unique_ptr<ConvertBase> data_default;
+        bool _is_multi_argument = false;
+        bool is_set_by_user = true;
+
+        [[nodiscard]] std::string _get_keys() const {
+            std::stringstream ss;
+            for (size_t i = 0; i < keys_.size(); i++)
+                ss << (i? "," : "") << (type == ARG? "" : (keys_[i].size() > 1 ? "--" : "-")) + keys_[i];
+            return ss.str();
+        }
+
+        void _convert(const std::string &value) {
+            try {
+                this->value_ = value;
+                datap->convert(value);
+            } catch (const std::invalid_argument &e) {
+                error = "Invalid argument, could not convert \"" + value + "\" for " + _get_keys() + " (" + help + ")";
+            } catch (const std::runtime_error &e) {
+                error = "Invalid argument \"" + value + "\" for " + _get_keys() + " (" + help + "). Error: " + e.what();
+            }
+        }
+
+        void _apply_default() {
+            is_set_by_user = false;
+            if (data_default != nullptr) {
+                value_ = *default_str_; // for printing
+                datap->set_default(data_default, *default_str_);
+            } else if (default_str_.has_value()) {   // in cases where a string is provided to the `set_default` function
+                _convert(default_str_.value());
+            } else {
+                error = "Argument missing: " + _get_keys() + " (" + help + ")";
+            }
+        }
+
+        [[nodiscard]] std::string info() const {
+            const std::string allowed_entries = datap->get_allowed_entries();
+            const std::string default_value = default_str_.has_value() ? "default: " + *default_str_ : "required";
+            const std::string implicit_value = implicit_value_.has_value() ? "implicit: \"" + *implicit_value_ + "\", ": "";
+            const std::string allowed_value = !allowed_entries.empty()? "allowed: <" + allowed_entries.substr(0, allowed_entries.size()-2) + ">, ": "";
+            return " [" + allowed_value + implicit_value + default_value + "]";
+        }
+
+        friend class Args;
+    };
+
+    struct SubcommandEntry {
+        std::shared_ptr<Args> subargs;
+        std::string subcommand_name;
+
+        explicit SubcommandEntry(std::string subcommand_name) : subcommand_name(std::move(subcommand_name)) {}
+
+        template<typename T> operator T &() {
+            static_assert(std::is_base_of_v<Args, T>, "Subcommand type must be a derivative of argparse::Args");
+
+            std::shared_ptr<T> res = std::make_shared<T>();
+            res->program_name = subcommand_name;
+            subargs = res;
+            return *(T*)(subargs.get());
+        }
+
+        // Force an ambiguous error when not using a reference.
+        template <typename T> operator T() {} // When you get here  because you received an error, make sure all parameters of argparse are references (e.g. with `&`)
+    };
+
+    class Args {
+    private:
+        size_t _arg_idx = 0;
+        std::vector<std::string> params;
+        std::vector<std::shared_ptr<Entry>> all_entries;
+        std::map<std::string, std::shared_ptr<Entry>> kwarg_entries;
+        std::vector<std::shared_ptr<Entry>> arg_entries;
+        std::map<std::string, std::shared_ptr<SubcommandEntry>> subcommand_entries;
+        bool has_options() {
+            return std::find_if(all_entries.begin(), all_entries.end(), [](auto e) { return e->type != Entry::ARG; }) != all_entries.end();
+        };
+
+    public:
+        std::string program_name;
+        bool is_valid = false;
+
+        virtual ~Args() = default;
+
+        /* Add a positional argument, the order in which it is defined equals the order in which they are being read.
+         * help : Description of the variable
+         *
+         * Returns a reference to the Entry, which will collapse into the requested type in `Entry::operator T()`
+         */
+        Entry &arg(const std::string &help) {
+            return arg("arg_" + std::to_string(_arg_idx), help);
+        }
+
+        /* Add a *named* positional argument, the order in which it is defined equals the order in which they are being read.
+         * key : The name of the argument, otherwise arg_<position> will be used
+         * help : Description of the variable
+         *
+         * Returns a reference to the Entry, which will collapse into the requested type in `Entry::operator T()`
+         */
+        Entry &arg(const std::string& key, const std::string &help) {
+            std::shared_ptr<Entry> entry = std::make_shared<Entry>(Entry::ARG, key, help);
+            // Increasing _arg_idx, so that arg2 will be arg_2, irregardless of whether it is preceded by other positional arguments
+            _arg_idx++;
+            arg_entries.emplace_back(entry);
+            all_entries.emplace_back(entry);
+            return *entry;
+        }
+
+        /* Add a Key-Worded argument that takes a variable.
+         * key : A comma-separated string, e.g. "k,key", which denotes the short (-k) and long(--key) keys_
+         * help : Description of the variable
+         * implicit_value : Implicit values are used when no value is provided.
+         *
+         * Returns a reference to the Entry, which will collapse into the requested type in `Entry::operator T()`
+         */
+        Entry &kwarg(const std::string &key, const std::string &help, const std::optional<std::string>& implicit_value=std::nullopt) {
+            std::shared_ptr<Entry> entry = std::make_shared<Entry>(Entry::KWARG, key, help, implicit_value);
+            all_entries.emplace_back(entry);
+            for (const std::string &k : entry->keys_) {
+                kwarg_entries[k] = entry;
+            }
+            return *entry;
+        }
+
+        /* Add a flag which will be false by default.
+         * key : A comma-separated string, e.g. "k,key", which denotes the short (-k) and long(--key) keys_
+         * help : Description of the variable
+         *
+         * Returns reference to Entry like kwarg
+         */
+        Entry &flag(const std::string &key, const std::string &help) {
+            return kwarg(key, help, "true").set_default<bool>(false);
+        }
+
+        /* Add a a subcommand
+         * command : name of the subcommand, e.g. 'commit', if you wish to implement a function like 'git commit'
+         *
+         * Returns a reference to the Entry, which will collapse into the requested type in `Entry::operator T()`
+         * Expected type *Must* be an std::shared_ptr of derivative of the argparse::Args class
+         */
+        SubcommandEntry &subcommand(const std::string &command) {
+            std::shared_ptr<SubcommandEntry> entry = std::make_shared<SubcommandEntry>(command);
+            subcommand_entries[command] = entry;
+            return *entry;
+        }
+
+        virtual void welcome() {}       // Allow to overwrite the `welcome` function to add a welcome-message to the help output
+        virtual void help() {
+            welcome();
+            cout << "Usage: " << program_name << " ";
+            for (const auto &entry : arg_entries)
+                cout << entry->keys_[0] << ' ';
+            if (has_options()) cout << " [options...]";
+            if (!subcommand_entries.empty()) {
+                cout << " [SUBCOMMAND: ";
+                for (const auto &[subcommand, subentry]: subcommand_entries) {
+                    cout << subcommand << ", ";
+                }
+                cout << "]";
+            }
+            cout << endl;
+            for (const auto &entry : arg_entries) {
+                cout << setw(17) << entry->keys_[0] << " : " << entry->help << entry->info() << endl;
+            }
+
+            if (has_options()) cout << endl << "Options:" << endl;
+            for (const auto &entry : all_entries) {
+                if (entry->type != Entry::ARG) {
+                    cout << setw(17) << entry->_get_keys() << " : " << entry->help << entry->info() << endl;
+                }
+            }
+
+            for (const auto &[subcommand, subentry] : subcommand_entries) {
+                cout << endl << endl << bold("Subcommand: ") << bold(subcommand) << endl;
+                subentry->subargs->help();
+            }
+        }
+
+        void validate(const bool &raise_on_error) {
+            for (const auto &entry : all_entries) {
+                if (!entry->error.empty()) {
+                    if (raise_on_error) {
+                        throw std::runtime_error(entry->error);
+                    } else {
+                        std::cerr << entry->error << std::endl;
+                        exit(-1);
+                    }
+                }
+            }
+        }
+
+        /* parse all parameters and also check for the help_flag which was set in this constructor
+         * Upon error, it will print the error and exit immediately if validation_action is ValidationAction::EXIT_ON_ERROR
+         */
+        void parse(int argc, const char* const *argv, const bool &raise_on_error) {
+            auto parse_subcommands = [&]() -> int {
+                for (int i = 1; i < argc; i++) {
+                    for (auto &[subcommand, subentry] : subcommand_entries) {
+                        if (subcommand == argv[i]) {
+                            subentry->subargs->parse(argc - i, argv + i, raise_on_error);
+                            return i;
+                        }
+                    }
+                }
+                return argc;
+            };
+            argc = parse_subcommands();   // argc_ is the number of arguments that should be parsed after the subcommand has finished parsing
+
+            program_name = std::filesystem::path(argv[0]).stem().string();
+            params = std::vector<std::string>(argv + 1, argv + argc);
+
+            bool& _help = flag("?,help", "print help");
+
+            auto is_value = [&](const size_t &i) -> bool {
+                return params.size() > i && (params[i][0] != '-' || (params[i].size() > 1 && std::isdigit(params[i][1])));  // check for number to not accidentally mark negative numbers as non-parameter
+            };
+            auto parse_param = [&](size_t &i, const std::string &key, const bool is_short, const std::optional<std::string> &equal_value=std::nullopt) {
+                auto itt = kwarg_entries.find(key);
+                if (itt != kwarg_entries.end()) {
+                    auto &entry = itt->second;
+                    if (equal_value.has_value()) {
+                        entry->_convert(equal_value.value());
+                    } else if (entry->implicit_value_.has_value()) {
+                        entry->_convert(*entry->implicit_value_);
+                    } else if (!is_short) { // short values are not allowed to look ahead for the next parameter
+                        if (is_value(i + 1)) {
+                            std::string value = params[++i];
+                            if (entry->_is_multi_argument) {
+                                while (is_value(i + 1))
+                                    value += "," + params[++i];
+                            }
+                            entry->_convert(value);
+                        } else if (entry->_is_multi_argument) {
+                            entry->_convert("");    // for multiargument parameters, return an empty vector when not passing any more values
+                        } else {
+                            entry->error = "No value provided for: " + key;
+                        }
+                    } else {
+                        entry->error = "No value provided for: " + key;
+                    }
+                } else {
+                    cerr << "unrecognised commandline argument: " << key << endl;
+                }
+            };
+            auto add_param = [&](size_t &i, const size_t &start) {
+                size_t eq_idx = params[i].find('=');  // check if value was passed using the '=' sign
+                if (eq_idx != std::string::npos) { // key/value from = notation
+                    std::string key = params[i].substr(start, eq_idx - start);
+                    std::string value = params[i].substr(eq_idx + 1);
+                    parse_param(i, key, false, value);
+                } else {
+                    std::string key = std::string(params[i].substr(start));
+                    parse_param(i, key, false);
+                }
+            };
+
+            std::vector<std::string> arguments_flat;
+            for (size_t i = 0; i < params.size(); i++) {
+                if (!is_value(i)) {
+                    if (params[i].size() > 1 && params[i][1] == '-') {  // long --
+                        add_param(i, 2);
+                    } else { // short -
+                        const size_t j_end = std::min(params[i].size(), params[i].find('=')) - 1;
+                        for (size_t j = 1; j < j_end; j++) { // add possible other flags
+                            const std::string key = std::string(1, params[i][j]);
+                            parse_param(i, key, true);
+                        }
+                        add_param(i, j_end);
+                    }
+                } else {
+                    arguments_flat.emplace_back(params[i]);
+                }
+            }
+
+            // Parse all the positional arguments, making sure multi_argument positional arguments are processed last to enable arguments afterwards
+            size_t arg_i = 0;
+            for (; arg_i < arg_entries.size() && !arg_entries[arg_i]->_is_multi_argument; arg_i++) { // iterate over positional arguments until a multi-argument is found
+                if (arg_i < arguments_flat.size())
+                    arg_entries[arg_i]->_convert(arguments_flat[arg_i]);
+            }
+            size_t arg_j = 1;
+            for (size_t j_end = arg_entries.size() - arg_i; arg_j <= j_end; arg_j++) { // iterate from back to front, to ensure non-multi-arguments in the front and back are given preference
+                size_t flat_idx = arguments_flat.size() - arg_j;
+                if (flat_idx < arguments_flat.size() && flat_idx >= arg_i) {
+                    if (arg_entries[arg_entries.size() - arg_j]->_is_multi_argument) {
+                        std::stringstream s;  // Combine multiple arguments into 1 comma-separated string for parsing
+                        copy(&arguments_flat[arg_i],&arguments_flat[flat_idx] + 1, std::ostream_iterator<std::string>(s,","));
+                        std::string value = s.str();
+                        value.back() = '\0'; // remove trailing ','
+                        arg_entries[arg_i]->_convert(value);
+                    } else {
+                        arg_entries[arg_entries.size() - arg_j]->_convert(arguments_flat[flat_idx]);
+                    }
+                }
+            }
+
+            // try to apply default values for arguments which have not been set
+            for (const auto &entry : all_entries) {
+                if (!entry->value_.has_value()) {
+                    entry->_apply_default();
+                }
+            }
+
+            if (_help) {
+                help();
+                exit(0);
+            }
+
+            validate(raise_on_error);
+            is_valid = true;
+        }
+
+        void print() const {
+            for (const auto &entry : all_entries) {
+                std::string snip = entry->type == Entry::ARG ? "(" + (entry->help.size() > 10 ? entry->help.substr(0, 7) + "..." : entry->help) + ")" : "";
+                cout << setw(21) << entry->_get_keys() + snip << " : " << (entry->is_set_by_user? bold(entry->value_.value_or("null")) : entry->value_.value_or("null")) << endl;
+            }
+
+            for (const auto &[subcommand, subentry] : subcommand_entries) {
+                if (subentry->subargs->is_valid) {
+                    cout << endl << "--- Subcommand: " << subcommand << endl;
+                    subentry->subargs->print();
+                }
+            }
+        }
+
+        virtual int run() {return 0;}       // For automatically running subcommands
+        int run_subcommands() {
+            for (const auto &[subcommand, subentry] : subcommand_entries) {
+                if (subentry->subargs->is_valid) {
+                    return subentry->subargs->run();
+                }
+            }
+
+            std::cerr << "No subcommand provided" << std::endl;
+            help();
+            return -1;
+        }
+    };
+
+    template <typename T> T parse(int argc, const char* const *argv, const bool &raise_on_error=false) {
+        T args = T();
+        args.parse(argc, argv, raise_on_error);
+        return args;
+    }
+}
\ No newline at end of file
diff --git a/makefile b/makefile
index bba04f8..6153994 100644
--- a/makefile
+++ b/makefile
@@ -8,11 +8,11 @@ clean:
 
 build_unix:
 	@echo "Building for unix..."
-	g++ -o build/owo src/main.cpp
+	g++ -o build/owo src/main.cpp -I include
 
 build_win:
 	@echo "Building for windows..."
-	x86_64-w64-mingw32-g++ -o build/owo.exe src/main.cpp
+	x86_64-w64-mingw32-g++ -o build/owo.exe src/main.cpp -I include
 
 make_deb:
 	mkdir build/owo_deb
@@ -38,4 +38,6 @@ make_arch:
 
 build_all: build_unix build_win make_deb make_arch
 
+dev: clean dirs build_unix
+
 .PHONY: all dirs clean build_all build_unix build_win
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 1e5fa36..91af22c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,8 +1,8 @@
 #include <iostream>
 #include <regex>
 #include <string>
-#include <fstream>
 #include <random>
+#include <argparse.hpp>
 using namespace std;
 
 string replacements[6][2] = {
@@ -87,111 +87,24 @@ string owo(string input, bool no_full_word = false, bool no_random_ending = fals
     return output;
 }
 
-int help() {
-    cout << "Usage: owo [-p] [-h] [-f file] [-o file] [text]" << endl;
-    cout << "       owo [text]" << endl;
-    cout << "       owo -f [file] -o [file]" << endl;
-    cout << "       echo [text] | owo -p" << endl << endl;
-    cout << "Options:" << endl;
-    cout << "  -p  Read from stdin" << endl;
-    cout << "  -h  Show this help message" << endl;
-    cout << "  -f  Read from file" << endl;
-    cout << "  -o  Write to file" << endl;
-    cout << "  -ne Stops extra stuff from being added to the end of sentences" << endl;
-    cout << "  -nf Stops full word replacements" << endl;
-    cout << "  text  Text to convert" << endl;
-    return 0;
-}
+struct Args : public argparse::Args {
+    bool &no_full_word      = flag("nfw", "Don't replace full words");
+    bool &no_random_ending  = flag("nre", "Don't add random ending");
+    bool &_stdin             = flag("p", "Read from stdin");
+    string &input           = arg("input", "Input string").set_default("");
+};
 
 int main(int argc, char *argv[]) {
+    auto args = argparse::parse<Args>(argc, argv);
     srand(time(nullptr));
-    string input, inputfile, outputfile;
-    bool _stdin = false, clipboard = false, no_full_word = false, no_random_ending = false;
 
-    if (argc < 2) {
-        cout << owo("No text provided") << endl << endl;
-        help();
-        return 1;
-    }
-
-    for (int i = 1; i < argc; i++) {
-        if (string(argv[i]) == "-f") {
-            inputfile = string(argv[i+1]);
-            i++;
-        } else if (string(argv[i]) == "-o") {
-            outputfile = string(argv[i+1]);
-            i++;
-        } else if (string(argv[i]) == "-p") {
-            _stdin = true;
-        } else if (string(argv[i]) == "-h") {
-            return help();
-        } else if (i == argc-1) {
-            input = string(argv[i]);
-        } else if (string(argv[i]) == "-ne") {
-            no_random_ending = true;
-        } else if (string(argv[i]) == "-nf") {
-            no_full_word = true;
-        } else {
-            cout << owo("Invalid argument: " + string(argv[i])) << endl << endl;
-            help();
-            return 1;
+    if (args._stdin) {
+        string line;
+        while (getline(cin, line)) {
+            cout << owo(line, args.no_full_word, args.no_random_ending) << endl;
         }
-    }
-    
-    if (_stdin && inputfile != "" || _stdin && input != "" || inputfile != "" && input != "") {
-        cout << owo("Cannot use multiple input methods at once") << endl << endl;
-        help();
-        return 1;
-    }
-
-    ostream *output;
-
-    if (outputfile != "") {
-        output = new ofstream(outputfile);
-        if (!output->good()) {
-            cout << owo("Failed to open output file") << endl;
-            return 1;
-        }
-    }
-
-    if (_stdin) {
-        while (getline(cin, input)) {
-            if (outputfile != "") {
-                *output << owo(input, no_full_word, no_random_ending) << endl;
-            } else {
-                cout << owo(input, no_full_word, no_random_ending) << endl;
-            }
-        }
-
-    } else if (inputfile != "") {
-        ifstream inputstream(inputfile);
-        if (!inputstream.good()) {
-            cout << owo("Failed to open input file") << endl;
-            if (outputfile != "") {
-                ((ofstream*)output)->close();
-            }
-            return 1;
-        }
-
-        while (getline(inputstream, input)) {
-            if (outputfile != "") {
-                *output << owo(input, no_full_word, no_random_ending) << endl;
-            } else {
-                cout << owo(input, no_full_word, no_random_ending) << endl;
-            }
-        }
-        inputstream.close();
-
-    } else if (input != "") {
-        if (outputfile != "") {
-            *output << owo(input, no_full_word, no_random_ending) << endl;
-        } else {
-            cout << owo(input, no_full_word, no_random_ending) << endl;
-        }
-    }
-
-    if (outputfile != "") {
-        ((ofstream*)output)->close();
+    } else {
+        cout << owo(args.input, args.no_full_word, args.no_random_ending) << endl;
     }
 
     return 0;