diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 868a581..d267897 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -144,6 +144,7 @@ else() # UNIX
     /guard:cf
     /Zi
     /W3
+    /utf-8
   )
 
   set(COMMON_LINKER_ARGS
@@ -213,6 +214,7 @@ add_link_options("$<$<COMPILE_LANGUAGE:CXX>:${XA_UTILS_CXX_LINKER_FLAGS}>")
 add_link_options("$<$<COMPILE_LANGUAGE:C>:${XA_UTILS_C_LINKER_FLAGS}>")
 
 if(WIN32)
+  add_compile_definitions(_UNICODE)
   include_directories(compat)
 endif()
 
diff --git a/src/compat/getopt.c b/src/compat/getopt.c
deleted file mode 100644
index ac7f9fe..0000000
--- a/src/compat/getopt.c
+++ /dev/null
@@ -1,562 +0,0 @@
-/*	$OpenBSD: getopt_long.c,v 1.23 2007/10/31 12:34:57 chl Exp $	*/
-/*	$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $	*/
-
-/*
- * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Sponsored in part by the Defense Advanced Research Projects
- * Agency (DARPA) and Air Force Research Laboratory, Air Force
- * Materiel Command, USAF, under agreement number F39502-99-1-0512.
- */
-/*-
- * Copyright (c) 2000 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Dieter Baron and Thomas Klausner.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <getopt.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <windows.h>
-
-#define	REPLACE_GETOPT		/* use this getopt as the system getopt(3) */
-
-#ifdef REPLACE_GETOPT
-int	opterr = 1;		/* if error message should be printed */
-int	optind = 1;		/* index into parent argv vector */
-int	optopt = '?';		/* character checked for validity */
-#undef	optreset		/* see getopt.h */
-#define	optreset		__mingw_optreset
-int	optreset;		/* reset getopt */
-char    *optarg;		/* argument associated with option */
-#endif
-
-#define PRINT_ERROR	((opterr) && (*options != ':'))
-
-#define FLAG_PERMUTE	0x01	/* permute non-options to the end of argv */
-#define FLAG_ALLARGS	0x02	/* treat non-options as args to option "-1" */
-#define FLAG_LONGONLY	0x04	/* operate as getopt_long_only */
-
-/* return values */
-#define	BADCH		(int)'?'
-#define	BADARG		((*options == ':') ? (int)':' : (int)'?')
-#define	INORDER 	(int)1
-
-#ifndef __CYGWIN__
-#define __progname __argv[0]
-#else
-extern char __declspec(dllimport) *__progname;
-#endif
-
-#ifdef __CYGWIN__
-static char EMSG[] = "";
-#else
-#define	EMSG		""
-#endif
-
-static int getopt_internal(int, char * const *, const char *,
-			   const struct option *, int *, int);
-static int parse_long_options(char * const *, const char *,
-			      const struct option *, int *, int);
-static int gcd(int, int);
-static void permute_args(int, int, int, char * const *);
-
-static char *place = EMSG; /* option letter processing */
-
-/* XXX: set optreset to 1 rather than these two */
-static int nonopt_start = -1; /* first non option argument (for permute) */
-static int nonopt_end = -1;   /* first option after non options (for permute) */
-
-/* Error messages */
-static const char recargchar[] = "option requires an argument -- %c";
-static const char recargstring[] = "option requires an argument -- %s";
-static const char ambig[] = "ambiguous option -- %.*s";
-static const char noarg[] = "option doesn't take an argument -- %.*s";
-static const char illoptchar[] = "unknown option -- %c";
-static const char illoptstring[] = "unknown option -- %s";
-
-static void
-_vwarnx(const char *fmt,va_list ap)
-{
-  (void)fprintf(stderr,"%s: ",__progname);
-  if (fmt != NULL)
-    (void)vfprintf(stderr,fmt,ap);
-  (void)fprintf(stderr,"\n");
-}
-
-static void
-warnx(const char *fmt,...)
-{
-  va_list ap;
-  va_start(ap,fmt);
-  _vwarnx(fmt,ap);
-  va_end(ap);
-}
-
-/*
- * Compute the greatest common divisor of a and b.
- */
-static int
-gcd(int a, int b)
-{
-	int c;
-
-	c = a % b;
-	while (c != 0) {
-		a = b;
-		b = c;
-		c = a % b;
-	}
-
-	return (b);
-}
-
-/*
- * Exchange the block from nonopt_start to nonopt_end with the block
- * from nonopt_end to opt_end (keeping the same order of arguments
- * in each block).
- */
-static void
-permute_args(int panonopt_start, int panonopt_end, int opt_end,
-	char * const *nargv)
-{
-	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
-	char *swap;
-
-	/*
-	 * compute lengths of blocks and number and size of cycles
-	 */
-	nnonopts = panonopt_end - panonopt_start;
-	nopts = opt_end - panonopt_end;
-	ncycle = gcd(nnonopts, nopts);
-	cyclelen = (opt_end - panonopt_start) / ncycle;
-
-	for (i = 0; i < ncycle; i++) {
-		cstart = panonopt_end+i;
-		pos = cstart;
-		for (j = 0; j < cyclelen; j++) {
-			if (pos >= panonopt_end)
-				pos -= nnonopts;
-			else
-				pos += nopts;
-			swap = nargv[pos];
-			/* LINTED const cast */
-			((char **) nargv)[pos] = nargv[cstart];
-			/* LINTED const cast */
-			((char **)nargv)[cstart] = swap;
-		}
-	}
-}
-
-/*
- * parse_long_options --
- *	Parse long options in argc/argv argument vector.
- * Returns -1 if short_too is set and the option does not match long_options.
- */
-static int
-parse_long_options(char * const *nargv, const char *options,
-	const struct option *long_options, int *idx, int short_too)
-{
-	char *current_argv, *has_equal;
-	size_t current_argv_len;
-	int i, ambiguous, match;
-
-#define IDENTICAL_INTERPRETATION(_x, _y)                                \
-	(long_options[(_x)].has_arg == long_options[(_y)].has_arg &&    \
-	 long_options[(_x)].flag == long_options[(_y)].flag &&          \
-	 long_options[(_x)].val == long_options[(_y)].val)
-
-	current_argv = place;
-	match = -1;
-	ambiguous = 0;
-
-	optind++;
-
-	if ((has_equal = strchr(current_argv, '=')) != NULL) {
-		/* argument found (--option=arg) */
-		current_argv_len = has_equal - current_argv;
-		has_equal++;
-	} else
-		current_argv_len = strlen(current_argv);
-
-	for (i = 0; long_options[i].name; i++) {
-		/* find matching long option */
-		if (strncmp(current_argv, long_options[i].name,
-		    current_argv_len))
-			continue;
-
-		if (strlen(long_options[i].name) == current_argv_len) {
-			/* exact match */
-			match = i;
-			ambiguous = 0;
-			break;
-		}
-		/*
-		 * If this is a known short option, don't allow
-		 * a partial match of a single character.
-		 */
-		if (short_too && current_argv_len == 1)
-			continue;
-
-		if (match == -1)	/* partial match */
-			match = i;
-		else if (!IDENTICAL_INTERPRETATION(i, match))
-			ambiguous = 1;
-	}
-	if (ambiguous) {
-		/* ambiguous abbreviation */
-		if (PRINT_ERROR)
-			warnx(ambig, (int)current_argv_len,
-			     current_argv);
-		optopt = 0;
-		return (BADCH);
-	}
-	if (match != -1) {		/* option found */
-		if (long_options[match].has_arg == no_argument
-		    && has_equal) {
-			if (PRINT_ERROR)
-				warnx(noarg, (int)current_argv_len,
-				     current_argv);
-			/*
-			 * XXX: GNU sets optopt to val regardless of flag
-			 */
-			if (long_options[match].flag == NULL)
-				optopt = long_options[match].val;
-			else
-				optopt = 0;
-			return (BADARG);
-		}
-		if (long_options[match].has_arg == required_argument ||
-		    long_options[match].has_arg == optional_argument) {
-			if (has_equal)
-				optarg = has_equal;
-			else if (long_options[match].has_arg ==
-			    required_argument) {
-				/*
-				 * optional argument doesn't use next nargv
-				 */
-				optarg = nargv[optind++];
-			}
-		}
-		if ((long_options[match].has_arg == required_argument)
-		    && (optarg == NULL)) {
-			/*
-			 * Missing argument; leading ':' indicates no error
-			 * should be generated.
-			 */
-			if (PRINT_ERROR)
-				warnx(recargstring,
-				    current_argv);
-			/*
-			 * XXX: GNU sets optopt to val regardless of flag
-			 */
-			if (long_options[match].flag == NULL)
-				optopt = long_options[match].val;
-			else
-				optopt = 0;
-			--optind;
-			return (BADARG);
-		}
-	} else {			/* unknown option */
-		if (short_too) {
-			--optind;
-			return (-1);
-		}
-		if (PRINT_ERROR)
-			warnx(illoptstring, current_argv);
-		optopt = 0;
-		return (BADCH);
-	}
-	if (idx)
-		*idx = match;
-	if (long_options[match].flag) {
-		*long_options[match].flag = long_options[match].val;
-		return (0);
-	} else
-		return (long_options[match].val);
-#undef IDENTICAL_INTERPRETATION
-}
-
-/*
- * getopt_internal --
- *	Parse argc/argv argument vector.  Called by user level routines.
- */
-static int
-getopt_internal(int nargc, char * const *nargv, const char *options,
-	const struct option *long_options, int *idx, int flags)
-{
-	char *oli;				/* option letter list index */
-	int optchar, short_too;
-	static int posixly_correct = -1;
-
-	if (options == NULL)
-		return (-1);
-
-	/*
-	 * XXX Some GNU programs (like cvs) set optind to 0 instead of
-	 * XXX using optreset.  Work around this braindamage.
-	 */
-	if (optind == 0)
-		optind = optreset = 1;
-
-	/*
-	 * Disable GNU extensions if POSIXLY_CORRECT is set or options
-	 * string begins with a '+'.
-	 *
-	 * CV, 2009-12-14: Check POSIXLY_CORRECT anew if optind == 0 or
-	 *                 optreset != 0 for GNU compatibility.
-	 */
-	if (posixly_correct == -1 || optreset != 0)
-		posixly_correct = (GetEnvironmentVariableW(L"POSIXLY_CORRECT", NULL, 0) != 0);
-	if (*options == '-')
-		flags |= FLAG_ALLARGS;
-	else if (posixly_correct || *options == '+')
-		flags &= ~FLAG_PERMUTE;
-	if (*options == '+' || *options == '-')
-		options++;
-
-	optarg = NULL;
-	if (optreset)
-		nonopt_start = nonopt_end = -1;
-start:
-	if (optreset || !*place) {		/* update scanning pointer */
-		optreset = 0;
-		if (optind >= nargc) {          /* end of argument vector */
-			place = EMSG;
-			if (nonopt_end != -1) {
-				/* do permutation, if we have to */
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				optind -= nonopt_end - nonopt_start;
-			}
-			else if (nonopt_start != -1) {
-				/*
-				 * If we skipped non-options, set optind
-				 * to the first of them.
-				 */
-				optind = nonopt_start;
-			}
-			nonopt_start = nonopt_end = -1;
-			return (-1);
-		}
-		if (*(place = nargv[optind]) != '-' ||
-		    (place[1] == '\0' && strchr(options, '-') == NULL)) {
-			place = EMSG;		/* found non-option */
-			if (flags & FLAG_ALLARGS) {
-				/*
-				 * GNU extension:
-				 * return non-option as argument to option 1
-				 */
-				optarg = nargv[optind++];
-				return (INORDER);
-			}
-			if (!(flags & FLAG_PERMUTE)) {
-				/*
-				 * If no permutation wanted, stop parsing
-				 * at first non-option.
-				 */
-				return (-1);
-			}
-			/* do permutation */
-			if (nonopt_start == -1)
-				nonopt_start = optind;
-			else if (nonopt_end != -1) {
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				nonopt_start = optind -
-				    (nonopt_end - nonopt_start);
-				nonopt_end = -1;
-			}
-			optind++;
-			/* process next argument */
-			goto start;
-		}
-		if (nonopt_start != -1 && nonopt_end == -1)
-			nonopt_end = optind;
-
-		/*
-		 * If we have "-" do nothing, if "--" we are done.
-		 */
-		if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
-			optind++;
-			place = EMSG;
-			/*
-			 * We found an option (--), so if we skipped
-			 * non-options, we have to permute.
-			 */
-			if (nonopt_end != -1) {
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				optind -= nonopt_end - nonopt_start;
-			}
-			nonopt_start = nonopt_end = -1;
-			return (-1);
-		}
-	}
-
-	/*
-	 * Check long options if:
-	 *  1) we were passed some
-	 *  2) the arg is not just "-"
-	 *  3) either the arg starts with -- we are getopt_long_only()
-	 */
-	if (long_options != NULL && place != nargv[optind] &&
-	    (*place == '-' || (flags & FLAG_LONGONLY))) {
-		short_too = 0;
-		if (*place == '-')
-			place++;		/* --foo long option */
-		else if (*place != ':' && strchr(options, *place) != NULL)
-			short_too = 1;		/* could be short option too */
-
-		optchar = parse_long_options(nargv, options, long_options,
-		    idx, short_too);
-		if (optchar != -1) {
-			place = EMSG;
-			return (optchar);
-		}
-	}
-
-	if ((optchar = (int)*place++) == (int)':' ||
-	    (optchar == (int)'-' && *place != '\0') ||
-	    (oli = strchr(options, optchar)) == NULL) {
-		/*
-		 * If the user specified "-" and  '-' isn't listed in
-		 * options, return -1 (non-option) as per POSIX.
-		 * Otherwise, it is an unknown option character (or ':').
-		 */
-		if (optchar == (int)'-' && *place == '\0')
-			return (-1);
-		if (!*place)
-			++optind;
-		if (PRINT_ERROR)
-			warnx(illoptchar, optchar);
-		optopt = optchar;
-		return (BADCH);
-	}
-	if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
-		/* -W long-option */
-		if (*place)			/* no space */
-			/* NOTHING */;
-		else if (++optind >= nargc) {	/* no arg */
-			place = EMSG;
-			if (PRINT_ERROR)
-				warnx(recargchar, optchar);
-			optopt = optchar;
-			return (BADARG);
-		} else				/* white space */
-			place = nargv[optind];
-		optchar = parse_long_options(nargv, options, long_options,
-		    idx, 0);
-		place = EMSG;
-		return (optchar);
-	}
-	if (*++oli != ':') {			/* doesn't take argument */
-		if (!*place)
-			++optind;
-	} else {				/* takes (optional) argument */
-		optarg = NULL;
-		if (*place)			/* no white space */
-			optarg = place;
-		else if (oli[1] != ':') {	/* arg not optional */
-			if (++optind >= nargc) {	/* no arg */
-				place = EMSG;
-				if (PRINT_ERROR)
-					warnx(recargchar, optchar);
-				optopt = optchar;
-				return (BADARG);
-			} else
-				optarg = nargv[optind];
-		}
-		place = EMSG;
-		++optind;
-	}
-	/* dump back option letter */
-	return (optchar);
-}
-
-#ifdef REPLACE_GETOPT
-/*
- * getopt --
- *	Parse argc/argv argument vector.
- *
- * [eventually this will replace the BSD getopt]
- */
-int
-getopt(int nargc, char * const *nargv, const char *options)
-{
-
-	/*
-	 * We don't pass FLAG_PERMUTE to getopt_internal() since
-	 * the BSD getopt(3) (unlike GNU) has never done this.
-	 *
-	 * Furthermore, since many privileged programs call getopt()
-	 * before dropping privileges it makes sense to keep things
-	 * as simple (and bug-free) as possible.
-	 */
-	return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
-}
-#endif /* REPLACE_GETOPT */
-
-/*
- * getopt_long --
- *	Parse argc/argv argument vector.
- */
-int
-getopt_long(int nargc, char * const *nargv, const char *options,
-    const struct option *long_options, int *idx)
-{
-
-	return (getopt_internal(nargc, nargv, options, long_options, idx,
-	    FLAG_PERMUTE));
-}
-
-/*
- * getopt_long_only --
- *	Parse argc/argv argument vector.
- */
-int
-getopt_long_only(int nargc, char * const *nargv, const char *options,
-    const struct option *long_options, int *idx)
-{
-
-	return (getopt_internal(nargc, nargv, options, long_options, idx,
-	    FLAG_PERMUTE|FLAG_LONGONLY));
-}
diff --git a/src/gas/CMakeLists.txt b/src/gas/CMakeLists.txt
index ced38a4..7cc7d3e 100644
--- a/src/gas/CMakeLists.txt
+++ b/src/gas/CMakeLists.txt
@@ -1,4 +1,5 @@
 set(GAS_DRIVER_SOURCES
+  command_line.cc
   gas.cc
   llvm_mc_runner.cc
   llvm_mc_runner_arm32.cc
@@ -18,7 +19,6 @@ set(ARCH_PREFIXES
 
 if(WIN32)
   list(APPEND GAS_DRIVER_SOURCES
-    ../compat/getopt.c
     gas.windows.cc
     process.windows.cc
     )
diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
new file mode 100644
index 0000000..bf59ebe
--- /dev/null
+++ b/src/gas/command_line.cc
@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+
+#include <algorithm>
+#include <optional>
+#include <vector>
+
+#include "command_line.hh"
+#include "exceptions.hh"
+#include "platform.hh"
+
+using namespace xamarin::android::gas;
+namespace ranges = std::ranges;
+
+bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector<platform::string> &args, OptionCallbackFn option_cb)
+{
+	uint32_t positional_count = 0;
+	bool next_arg_is_value = false;
+	std::optional<CommandLineOption> last_opt;
+
+	for (size_t i = 1; i < args.size (); i++) {
+		platform::string &option = args[i];
+		if (option.empty ()) {
+			continue;
+		}
+
+		platform::string::const_iterator iter = option.cbegin ();
+		while (iter != option.cend () && *iter == DASH) {
+			iter++;
+		}
+
+		if (next_arg_is_value) {
+			// getopt takes the next argument verbatim, if separated from the option requiring a value by a space.
+			// This is done regardless of whether or not the next argument is prefixed with `-` or is a known one.
+			if (last_opt.has_value ()) {
+				option_cb (last_opt.value (), option);
+			} else {
+				throw invalid_argument_error { "Option '" + option + "' requires an argument." };
+			}
+
+			next_arg_is_value = false;
+			last_opt.reset ();
+			continue;
+		}
+
+		if (iter == option.cbegin ()) { // positional
+			option_cb ({ positional_count++ }, { option });
+			continue;
+		}
+
+		platform::string::const_iterator name_start = iter;
+		while (iter != option.cend () && *iter != EQUALS) {
+			iter++;
+		}
+
+#if !defined (__APPLE__)
+		platform::string_view option_name { name_start, iter };
+#else
+		platform::string_view option_name (option.data () + (name_start - option.cbegin ()), iter - name_start);
+#endif
+		platform::string_view option_value;
+
+		if (iter != option.cend ()) { // has a value
+			iter++;
+#if !defined (__APPLE__)
+			option_value = { iter, option.cend () };
+#else
+			option_value = platform::string_view (option.data () + (iter - option.cbegin ()), option.cend () - iter);
+#endif
+		}
+
+		auto matching_option = [this, &option_name] (CommandLineOption const& o) -> bool {
+			if (o.name != option_name) {
+				return false;
+			}
+
+			return o.arch == TargetArchitecture::Any || o.arch == target_arch;
+		};
+
+#if !defined(__APPLE__)
+		auto match = ranges::find_if (options, matching_option);
+#else
+		// C++ standard library on mac CI doesn't have std::ranges::find_if
+		auto match = std::find_if (options.begin (), options.end (), matching_option);
+#endif
+		if (match == options.end ()) {
+			STDERR << "Uncrecognized option '" << option << "'\n";
+			continue;
+		}
+
+		CommandLineOption opt = *match;
+		if (opt.argument == ArgumentValue::Required && option_value.empty ()) {
+			next_arg_is_value = true;
+			last_opt = opt;
+			continue;
+		}
+
+		option_cb (opt, platform::string {option_value});
+	}
+
+	if (last_opt.has_value ()) {
+		platform::string message { "Option '" };
+		message
+			.append (last_opt.value ().name)
+			.append ("' requires an argument.");
+		throw invalid_operation_error {message};
+	}
+
+	return true;
+}
diff --git a/src/gas/command_line.hh b/src/gas/command_line.hh
new file mode 100644
index 0000000..a4f57e6
--- /dev/null
+++ b/src/gas/command_line.hh
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+#if !defined (GAS_COMMAND_LINE_HH)
+#define GAS_COMMAND_LINE_HH
+
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <span>
+#include <string>
+#include <variant>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+#include "constants.hh"
+#include "platform.hh"
+
+namespace xamarin::android::gas
+{
+	enum class ArgumentValue
+	{
+		Required,
+		NotRequired,
+	};
+
+	enum class OptionId : uint32_t
+	{
+		Ignore = 100,
+		O,
+		Warn,
+		G,
+		MFPU,
+		Version,
+		VersionExit,
+		Help,
+	};
+
+	struct CommandLineOption
+	{
+		platform::string_view name;
+		OptionId id;
+		ArgumentValue argument;
+		TargetArchitecture arch;
+
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id, ArgumentValue _argument, TargetArchitecture _arch)
+			: name (_name),
+			  id (_id),
+			  argument (_argument),
+			  arch (_arch)
+		{}
+
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id, TargetArchitecture _arch)
+			: CommandLineOption (_name, _id, ArgumentValue::NotRequired, _arch)
+		{}
+
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id, ArgumentValue _argument)
+			: CommandLineOption (_name, _id, _argument, TargetArchitecture::Any)
+		{}
+
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id)
+			: CommandLineOption (_name, _id, ArgumentValue::NotRequired, TargetArchitecture::Any)
+		{}
+	};
+
+	class CommandLine
+	{
+#if !defined(_WIN32)
+		static constexpr bool is_windows = false;
+#else
+		static constexpr bool is_windows = true;
+#endif
+
+	public:
+#if !defined(_WIN32)
+		using TArgType = char*;
+
+	private:
+		static inline constexpr char DASH = PCHAR('-');
+		static inline constexpr char EQUALS = PCHAR('=');
+#else
+		using TArgType = LPWSTR;
+
+	private:
+		static inline constexpr wchar_t DASH = PCHAR('-');
+		static inline constexpr wchar_t EQUALS = PCHAR('=');
+#endif
+
+	public:
+		using TOptionValue = std::variant<bool, platform::string>;
+		using TCallbackOption = std::variant<uint32_t, const CommandLineOption>;
+		using OptionCallbackFn = std::function<void(TCallbackOption option, TOptionValue val)>;
+
+	public:
+		explicit CommandLine (TargetArchitecture _target_arch) noexcept
+			: target_arch (_target_arch)
+		{}
+
+		template<size_t NElem>
+		bool parse (std::array<CommandLineOption, NElem> const& options, std::vector<platform::string> &args, OptionCallbackFn option_cb)
+		{
+			return parse (std::span (options.data(), options.size()), args, option_cb);
+		}
+
+	private:
+		bool parse (std::span<const CommandLineOption> options, std::vector<platform::string> &args, OptionCallbackFn option_cb);
+
+	private:
+		TargetArchitecture target_arch;
+	};
+}
+
+#define CLISTR(_str_lit_) PSTR((_str_lit_))
+
+#if !defined (_WIN32)
+#define CLIPARAM(_str_lit_) std::string_view { _str_lit_ }
+#else
+#define CLIPARAM(_str_lit_) std::string_view { _str_lit_ }
+#endif
+
+#endif // ndef GAS_COMMAND_LINE_HH
diff --git a/src/gas/constants.hh b/src/gas/constants.hh
index 6c28835..583ba5a 100644
--- a/src/gas/constants.hh
+++ b/src/gas/constants.hh
@@ -2,20 +2,22 @@
 #if !defined (__CONSTANTS_HH)
 #define __CONSTANTS_HH
 
+#include "platform.hh"
+
 namespace xamarin::android::gas
 {
 	class Constants final
 	{
 	public:
 #if defined (_WIN32)
-		static constexpr char newline[] = "\r\n";
-		static constexpr char llvm_mc_name[] = "llvm-mc.exe";
+		static constexpr platform::string_view newline { PSTR("\r\n") };
+		static constexpr platform::string_view llvm_mc_name { PSTR("llvm-mc.exe") };
 #else
-		static constexpr char newline[] = "\n";
-		static constexpr char llvm_mc_name[] = "llvm-mc";
+		static constexpr platform::string_view newline { "\n" };
+		static constexpr platform::string_view llvm_mc_name { "llvm-mc" };
 #endif
-		static constexpr char arch_hack_param[] = "@gas-arch=";
-		static constexpr char default_output_name[] = "a.out";
+		static constexpr platform::string_view arch_hack_param { PSTR("@gas-arch=") };
+		static constexpr platform::string_view default_output_name { PSTR("a.out") };
 		static constexpr int wrapper_general_error_code         = 100;
 		static constexpr int wrapper_llvm_mc_killed_error_code  = wrapper_general_error_code + 1;
 		static constexpr int wrapper_llvm_mc_stopped_error_code = wrapper_general_error_code + 2;
@@ -23,5 +25,14 @@ namespace xamarin::android::gas
 		static constexpr int wrapper_exec_failed_error_code     = wrapper_general_error_code + 4;
 		static constexpr int wrapper_wait_failed_error_code     = wrapper_general_error_code + 5;
 	};
+
+	enum class TargetArchitecture
+	{
+		Any,
+		ARM32,
+		ARM64,
+		X86,
+		X64,
+	};
 }
 #endif
diff --git a/src/gas/gas.cc b/src/gas/gas.cc
index 7efd933..2b0759a 100644
--- a/src/gas/gas.cc
+++ b/src/gas/gas.cc
@@ -3,23 +3,25 @@
 #include <unistd.h>
 #endif
 
+#include <array>
 #include <cstring>
 #include <iostream>
 #include <filesystem>
 
+#include "command_line.hh"
 #include "constants.hh"
 #include "gas.hh"
 #include "llvm_mc_runner.hh"
 
 using namespace xamarin::android::gas;
 
-int Gas::usage (bool is_error, std::string const message)
+int Gas::usage (bool is_error, platform::string const message)
 {
 	if (!message.empty ()) {
-		std::cerr << message << Constants::newline << Constants::newline;
+		STDERR << message << Constants::newline << Constants::newline;
 	}
 
-	std::cerr << "`" << program_name () << "` takes a subset of arguments accepted by the GNU Assembler (gas) program." << Constants::newline
+	STDERR << "`" << program_name () << "` takes a subset of arguments accepted by the GNU Assembler (gas) program." << Constants::newline
 	          << "Accepted options are limited to the ones used by Xamarin.Android and Mono/dotnet AOT, more can be added as-needed." << Constants::newline
 	          << "Some options are accepted but ignored, either because they are ignored by GAS as well or because they are used by" << Constants::newline
 	          << "Xamarin.Android or Mono/dotnet AOT, but not needed by `llvm-mc`.  All the unsupported options will cause the wrapper" << Constants::newline
@@ -56,29 +58,39 @@ int Gas::usage (bool is_error, std::string const message)
 	return is_error ? 1 : 0;
 }
 
-int Gas::run (int argc, char **argv)
+std::vector<platform::string> Gas::get_command_line (int &argc, char **&argv)
 {
-	determine_program_dir (argc, argv);
+	std::vector<platform::string> ret;
 
-	auto lowercase_string = [](std::string& s) {
+	for (int i = 0; i < argc; i++) {
+		ret.emplace_back (argv[i]);
+	}
+
+	return ret;
+}
+
+int Gas::run (std::vector<platform::string> args)
+{
+	determine_program_dir (args);
+	auto lowercase_string = [](platform::string& s) {
 		std::transform (
 			s.begin (),
 			s.end (),
 			s.begin (),
-			[](unsigned char c) { return std::tolower(c); }
+			[](platform::string::value_type c) { return std::tolower(c); }
 		);
 	};
 
-	std::string arch_name { generic_gas_name };
-	const char *first_param = argc > 1 ? argv[1] : nullptr;
-	if (first_param != nullptr && strlen (first_param) > sizeof(Constants::arch_hack_param) && strstr (first_param, Constants::arch_hack_param) == first_param) {
-		arch_name = first_param + (sizeof(Constants::arch_hack_param) - 1);
+	platform::string arch_name { generic_gas_name };
+	platform::string first_param { args.size () > 1 ? args[1] : PSTR("") };
+	if (!first_param.empty () && first_param.length () > Constants::arch_hack_param.size () && first_param.find (Constants::arch_hack_param) == 0) {
+		arch_name = first_param.substr (Constants::arch_hack_param.size ());
 		lowercase_string (arch_name);
 	}
 	_program_name = arch_name;
 
 	std::unique_ptr<LlvmMcRunner> mc_runner;
-	std::string ld_name;
+	platform::string ld_name;
 	if (arch_name.compare (arm64_gas_name.data ()) == 0) {
 		_target_arch = TargetArchitecture::ARM64;
 		mc_runner = std::make_unique<LlvmMcRunnerARM64> ();
@@ -96,34 +108,36 @@ int Gas::run (int argc, char **argv)
 		mc_runner = std::make_unique<LlvmMcRunnerX64> ();
 		ld_name = x64_ld_name.data ();
 	} else if (arch_name.compare (generic_gas_name) == 0) {
-		std::string message { "Program invoked via its generic name (" };
+		platform::string message { PSTR("Program invoked via its generic name (") };
 		message
 			.append (generic_gas_name)
-			.append ("), please use one of the ABI-prefixed names:")
+			.append (PSTR("), please use one of the ABI-prefixed names:"))
 			.append (Constants::newline)
-			.append ("  ").append (arm64_gas_name.data ()).append (Constants::newline)
-			.append ("  ").append (arm32_gas_name.data ()).append (Constants::newline)
-			.append ("  ").append (x86_gas_name.data ()).append (Constants::newline)
-			.append ("  ").append (x64_gas_name.data ()).append (Constants::newline);
+			.append (PSTR("  ")).append (arm64_gas_name.data ()).append (Constants::newline)
+			.append (PSTR("  ")).append (arm32_gas_name.data ()).append (Constants::newline)
+			.append (PSTR("  ")).append (x86_gas_name.data ()).append (Constants::newline)
+			.append (PSTR("  ")).append (x64_gas_name.data ()).append (Constants::newline);
 		return usage (true /* is_error */, message);
 	} else {
-		std::string message { "Unknown program name '" };
-		message.append (arch_name).append ("'").append (Constants::newline);
+		platform::string message { PSTR("Unknown program name '") };
+		message
+			.append (arch_name)
+			.append (PSTR("'"))
+			.append (Constants::newline);
 		return usage (true /* is_error */, message);
 	}
 
-	auto&& [terminate, is_error] = parse_arguments (argc, argv, mc_runner);
+	auto&& [terminate, is_error] = parse_arguments (args, mc_runner);
 	if (terminate || is_error) {
 		return is_error ? Constants::wrapper_general_error_code : 0;
 	}
 
 	fs::path llvm_mc = program_dir () / Constants::llvm_mc_name;
-
 	bool multiple_input_files = false;
 	bool derive_output_file_name = false;
 	switch (input_files.size ()) {
 		case 0:
-			return usage (true, "missing input files on command line");
+			return usage (true, PSTR("missing input files on command line"));
 
 		case 1:
 			// We should always have a value here since `a.out` is the default, but... :)
@@ -144,6 +158,7 @@ int Gas::run (int argc, char **argv)
 		mc_runner->set_input_file_path (input, derive_output_file_name);
 		int ret = mc_runner->run (llvm_mc);
 		if (ret != 0) {
+			STDERR << "  mc_runner failed with error code " << ret << Constants::newline;
 			return ret;
 		}
 	}
@@ -157,13 +172,11 @@ int Gas::run (int argc, char **argv)
 		fs::path ld_path { program_dir () };
 		ld_path /= ld_name;
 		auto ld = std::make_unique<Process> (ld_path);
-		ld->append_program_argument ("-o");
-		ld->append_program_argument (_gas_output_file.empty () ? Constants::default_output_name : _gas_output_file.string ());
-		ld->append_program_argument ("--relocatable");
+		ld->append_program_argument (PSTR("-o"));
+		ld->append_program_argument (_gas_output_file.empty () ? platform::string (Constants::default_output_name) : _gas_output_file.string ());
+		ld->append_program_argument (PSTR("--relocatable"));
 
-		std::cout << "Have multiple output files:" << Constants::newline;
 		for (fs::path const& output : output_files) {
-			std::cout << "  " << output << Constants::newline;
 			ld->append_program_argument (output.string ());
 		}
 
@@ -173,123 +186,110 @@ int Gas::run (int argc, char **argv)
 	return 0;
 }
 
-std::vector<option> Gas::common_options {
+constexpr std::array<CommandLineOption, 21> all_options {{
 	// Arguments ignored by GAS, we shall ignore them silently too
-	{ "divide",    no_argument,       nullptr, OPTION_IGNORE },
-	{ "k",         no_argument,       nullptr, OPTION_IGNORE },
-	{ "nocpp",     no_argument,       nullptr, OPTION_IGNORE },
-	{ "Qn",        no_argument,       nullptr, OPTION_IGNORE },
-	{ "Qy",        no_argument,       nullptr, OPTION_IGNORE },
-	{ "s",         no_argument,       nullptr, OPTION_IGNORE },
-	{ "w",         no_argument,       nullptr, OPTION_IGNORE },
-	{ "X",         no_argument,       nullptr, OPTION_IGNORE },
+	{ CLIPARAM("divide"),    OptionId::Ignore },
+	{ CLIPARAM("k"),         OptionId::Ignore },
+	{ CLIPARAM("nocpp"),     OptionId::Ignore },
+	{ CLIPARAM("Qn"),        OptionId::Ignore },
+	{ CLIPARAM("Qy"),        OptionId::Ignore },
+	{ CLIPARAM("s"),         OptionId::Ignore },
+	{ CLIPARAM("w"),         OptionId::Ignore },
+	{ CLIPARAM("X"),         OptionId::Ignore },
 
 	// Global GAS arguments we support
-	{ "o",         required_argument, nullptr, OPTION_O },
-	{ "warn",      no_argument,       nullptr, OPTION_WARN },
-	{ "g",         no_argument,       nullptr, OPTION_G },
-	{ "gen-debug", no_argument,       nullptr, OPTION_G },
+	{ CLIPARAM("o"),         OptionId::O,              ArgumentValue::Required },
+	{ CLIPARAM("warn"),      OptionId::Warn },
+	{ CLIPARAM("g"),         OptionId::G },
+	{ CLIPARAM("gen-debug"), OptionId::G },
 
 	// Arguments handled by us, not passed to llvm-mc
-	{ "h",         no_argument,       nullptr, OPTION_HELP },
-	{ "help",      no_argument,       nullptr, OPTION_HELP },
-	{ "V",         no_argument,       nullptr, OPTION_VERSION },
-	{ "version",   no_argument,       nullptr, OPTION_VERSION_EXIT },
-};
-
-std::vector<option> Gas::x86_options {
-	{ "32", no_argument, nullptr, OPTION_IGNORE }, // llvm-mc doesn't need this
-	{ "64", no_argument, nullptr, OPTION_IGNORE }, // llvm-mc doesn't need this
-};
-
-std::vector<option> Gas::arm32_options {
-	{ "mfpu", required_argument, nullptr, OPTION_MFPU },
-};
-
-Gas::ParseArgsResult Gas::parse_arguments (int argc, char **argv, std::unique_ptr<LlvmMcRunner>& mc_runner)
-{
-	std::vector<option> long_options { common_options };
-
-	switch (target_arch ()) {
-		case TargetArchitecture::ARM32:
-			long_options.insert (long_options.end (), arm32_options.begin (), arm32_options.end ());
-			break;
+	{ CLIPARAM("h"),         OptionId::Help },
+	{ CLIPARAM("help"),      OptionId::Help },
+	{ CLIPARAM("V"),         OptionId::Version },
+	{ CLIPARAM("version"),   OptionId::VersionExit },
 
-		case TargetArchitecture::X86:
-		case TargetArchitecture::X64:
-			long_options.insert (long_options.end (), x86_options.begin (), x86_options.end ());
-			break;
+	// x86 arguments
+	{ CLIPARAM("32"),        OptionId::Ignore,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
+	{ CLIPARAM("64"),        OptionId::Ignore,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
 
-		default:
-			break;
-	}
-	long_options.push_back ({ nullptr, 0, nullptr, 0 });
+	// x64 arguments
+	{ CLIPARAM("32"),        OptionId::Ignore,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
+	{ CLIPARAM("64"),        OptionId::Ignore,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
 
-	constexpr char PROGRAM_DESCRIPTION[] = "Xamarin.Android GAS adapter for llvm-mc";
+	// Arm32 arguments
+	{ CLIPARAM("mfpu"),      OptionId::MFPU,           ArgumentValue::Required, TargetArchitecture::ARM32 },
+}};
 
+Gas::ParseArgsResult Gas::parse_arguments (std::vector<platform::string> &args, std::unique_ptr<LlvmMcRunner>& mc_runner)
+{
 	bool terminate = false, is_error = false;
 	bool show_version = false, show_help = false;
 
-	while (true) {
-		int opt_index = 0;
-		int c = getopt_long_only (argc, argv, "-", long_options.data (), &opt_index);
+	auto handle_arg = [&](CommandLine::TCallbackOption option, CommandLine::TOptionValue val) {
+		if (std::holds_alternative<uint32_t> (option)) {
+			platform::string arg = std::get<platform::string> (val);
+			// Positional argument
+			if (arg.starts_with (Constants::arch_hack_param)) {
+				// Arch hack, ignore
+				return;
+			}
 
-		if (c == -1) {
-			break;
+			input_files.emplace_back (arg);
+			return;
 		}
 
-		switch (c) {
-			case '?':
-				terminate = true;
-				is_error = true;
-				break;
-
-			case 1: // non-option argument
-			{
-				// Ignore the arch hack parameter
-				const char *ret = strstr (optarg, Constants::arch_hack_param);
-				if (ret == nullptr || ret != optarg) {
-					// char8_t* cast treats path string as utf8
-					input_files.emplace_back (reinterpret_cast<char8_t*>(optarg));
-				}
-			}
-			break;
+		const auto opt = std::get<const CommandLineOption> (option);
+		if (opt.id == OptionId::Ignore) {
+			return;
+		}
 
-			case OPTION_VERSION:
+		switch (opt.id) {
+			case OptionId::Version:
 				show_version = true;
 				break;
 
-			case OPTION_VERSION_EXIT:
+			case OptionId::VersionExit:
 				show_version = true;
 				terminate = true;
 				break;
 
-			case OPTION_HELP:
+			case OptionId::Help:
 				show_help = true;
 				terminate = true;
 				break;
 
-			case OPTION_O:
-				_gas_output_file = reinterpret_cast<char8_t*>(optarg);
+			case OptionId::O:
+				_gas_output_file = std::get<platform::string> (val);
 				break;
 
-			case OPTION_MFPU:
-				mc_runner->map_option ("mfpu", optarg);
+			case OptionId::MFPU:
+				mc_runner->map_option (PSTR("mfpu"), std::get<platform::string> (val));
 				break;
 
-			case OPTION_G:
+			case OptionId::G:
 				mc_runner->generate_debug_info ();
 				break;
+
+			default:
+				break;
 		}
+	};
+
+	CommandLine cmdline { target_arch () };
+	if (!cmdline.parse (all_options, args, handle_arg)) {
+		terminate = true;
+		is_error = true;
 	}
 
+	constexpr platform::string_view PROGRAM_DESCRIPTION { PSTR("Xamarin.Android GAS adapter for llvm-mc") };
 	if (show_help) {
 		usage (false /* is_error */);
 		return {true, false};
 	} else if (show_version) {
-		std::cout << program_name () << " v" << XA_UTILS_VERSION << ", " << PROGRAM_DESCRIPTION << Constants::newline
-		          << "\tGAS version compatibility: " << BINUTILS_VERSION << Constants::newline
-		          << "\tllvm-mc version compatibility: " << LLVM_VERSION << Constants::newline << Constants::newline;
+		STDOUT << program_name () << " v" << XA_UTILS_VERSION << ", " << PROGRAM_DESCRIPTION << Constants::newline
+		       << "\tGAS version compatibility: " << BINUTILS_VERSION << Constants::newline
+		       << "\tllvm-mc version compatibility: " << LLVM_VERSION << Constants::newline << Constants::newline;
 		return {true, false};
 	}
 
diff --git a/src/gas/gas.hh b/src/gas/gas.hh
index ee5fa39..5c6c6d4 100644
--- a/src/gas/gas.hh
+++ b/src/gas/gas.hh
@@ -5,18 +5,15 @@
 #if !defined(_WIN32)
 #include <unistd.h>
 #endif
-#include <getopt.h>
 
 #include <array>
+#include <concepts>
 #include <filesystem>
-#include <iostream>
 #include <memory>
-#include <string>
 #include <vector>
 
-#if __has_include (<concepts>)
-#include <concepts>
-#endif // has <concepts>
+#include "constants.hh"
+#include "platform.hh"
 
 namespace xamarin::android::gas
 {
@@ -49,93 +46,37 @@ namespace xamarin::android::gas
 
 	class LlvmMcRunner;
 
-	enum class TargetArchitecture
-	{
-		ARM32,
-		ARM64,
-		X86,
-		X64,
-	};
-
-	enum OptionValues
-	{
-		OPTION_IGNORE = 100,
-		OPTION_O,
-		OPTION_WARN,
-		OPTION_G,
-		OPTION_MFPU,
-		OPTION_VERSION,
-		OPTION_VERSION_EXIT,
-		OPTION_HELP,
-	};
+	template<class T>
+	concept StringViewPart = std::is_same_v<T, platform::string_view>;
 
-	template<size_t Size>
-	struct helper_char_array final
+	template<size_t TotalLength, StringViewPart ...T>
+	consteval auto concat_string_views (T const&... parts)
 	{
-		constexpr char* data () noexcept
-		{
-			return _elems;
-		}
-
-		constexpr const char* data () const noexcept
-		{
-			return _elems;
-		}
-
-		constexpr char const& operator[] (size_t n) const noexcept
-		{
-			return _elems[n];
-		}
-
-		constexpr char& operator[] (size_t n) noexcept
-		{
-			return _elems[n];
-		}
-
-		char _elems[Size]{};
-	};
-
-	// MinGW 9 on the CI build bots has a bug in the gcc compiler which causes builds to fail with:
-	//
-	//  error G713F753E: ‘constexpr auto xamarin::android::concat_const(const char (&)[Length]...) [with long long unsigned int ...Length = {15, 7, 5}]’ called in a constant expression
-	//  ...
-	//  /usr/lib/gcc/x86_64-w64-mingw32/9.3-win32/include/c++/array:94:12: note: ‘struct std::array<char, 17>’ has no user-provided default constructor
-	// struct array
-	// ^~~~~
-	// /usr/lib/gcc/x86_64-w64-mingw32/9.3-win32/include/c++/array:110:56: note: and the implicitly-defined constructor does not initialize ‘char std::array<char, 17>::_M_elems [17]’
-	//  typename _AT_Type::_Type                         _M_elems;
-	//                                                   ^~~~~~~~
-	//
-	// thus we need to use this workaround here
-	//
-#if defined (__MINGW32__) && __GNUC__ < 10
-	template<size_t Size>
-	using char_array = helper_char_array<Size>;
-#else
-	template<size_t Size>
-	using char_array = std::array<char, Size>;
-#endif
-
-	template<size_t ...Length>
-	static constexpr auto concat_const (const char (&...parts)[Length])
-	{
-		// `parts` being constant string arrays, Length for each of them includes the trailing NUL byte, thus the
-		// `sizeof... (Length)` part which subtracts the number of template parameters - the amount of NUL bytes so that
-		// we don't waste space.
-		constexpr size_t total_length = (... + Length) - sizeof... (Length);
-		char_array<total_length + 1> ret;
-		ret[total_length] = 0;
+		std::array<platform::string_view::value_type, TotalLength + 1> ret; // lgtm [cpp/paddingbyteinformationdisclosure] the buffer is filled in the loop below
+		ret[TotalLength] = 0;
 
 		size_t i = 0;
-		for (char const* from : {parts...}) {
-			for (; *from != '\0'; i++) {
-				ret[i] = *from++;
+		for (auto const& sv : {parts...}) {
+			for (platform::string_view::value_type ch : sv) {
+				ret[i] = ch;
+				i++;
 			}
 		}
 
 		return ret;
 	}
 
+	consteval size_t calc_size (platform::string_view const& sv1) noexcept
+	{
+		return sv1.size ();
+	}
+
+	template<StringViewPart ...T>
+	consteval size_t calc_size (platform::string_view const& sv1, T const&... other_svs) noexcept
+	{
+		return sv1.size () + calc_size (other_svs...);
+	}
+
 	class Gas final
 	{
 		struct ParseArgsResult
@@ -149,29 +90,29 @@ namespace xamarin::android::gas
 			{}
 		};
 
-		static constexpr char generic_gas_name[] = "as";
-		static constexpr char generic_ld_name[] =
+		static constexpr platform::string_view generic_gas_name { PSTR("as") };
+		static constexpr platform::string_view generic_ld_name {
 #if defined (_WIN32)
-			"ld.exe"
+			PSTR("ld.exe")
 #else
-			"ld"
+			PSTR("ld")
 #endif
-			;
+		};
 
-		static constexpr char arm64_arch_prefix[] = "aarch64-linux-android-";
-		static constexpr char arm32_arch_prefix[] = "arm-linux-androideabi-";
-		static constexpr char x86_arch_prefix[] = "i686-linux-android-";
-		static constexpr char x64_arch_prefix[] = "x86_64-linux-android-";
+		static constexpr platform::string_view arm64_arch_prefix { PSTR("aarch64-linux-android-") };
+		static constexpr platform::string_view arm32_arch_prefix { PSTR("arm-linux-androideabi-") };
+		static constexpr platform::string_view x86_arch_prefix { PSTR("i686-linux-android-") };
+		static constexpr platform::string_view x64_arch_prefix { PSTR("x86_64-linux-android-") };
 
 	public:
 		~Gas ()
 		{}
 
-		void get_command_line (int &argc, char **&argv);
+		std::vector<platform::string> get_command_line (int &argc, char **&argv);
 
-		int run (int argc, char **argv);
+		int run (std::vector<platform::string> args);
 
-		const std::string& program_name () const noexcept
+		const platform::string& program_name () const noexcept
 		{
 			return _program_name;
 		}
@@ -187,35 +128,43 @@ namespace xamarin::android::gas
 		}
 
 	protected:
-		ParseArgsResult parse_arguments (int argc, char **argv, std::unique_ptr<LlvmMcRunner>& mc_runner);
+		ParseArgsResult parse_arguments (std::vector<platform::string> &args, std::unique_ptr<LlvmMcRunner>& mc_runner);
 
 	private:
-		void determine_program_dir (int argc, char **argv);
-		int usage (bool is_error, std::string const message = "");
+		void determine_program_dir (std::vector<platform::string> args);
+		int usage (bool is_error, platform::string const message = PSTR(""));
 
 	private:
-		static constexpr auto arm64_gas_name = concat_const (arm64_arch_prefix, generic_gas_name);
-		static constexpr auto arm32_gas_name = concat_const (arm32_arch_prefix, generic_gas_name);
-		static constexpr auto x86_gas_name   = concat_const (x86_arch_prefix, generic_gas_name);
-		static constexpr auto x64_gas_name   = concat_const (x64_arch_prefix, generic_gas_name);
+		static constexpr size_t arm64_gas_name_size = calc_size (arm64_arch_prefix, generic_gas_name);
+		static constexpr auto arm64_gas_name        = concat_string_views<arm64_gas_name_size> (arm64_arch_prefix, generic_gas_name);
+
+		static constexpr size_t arm32_gas_name_size = calc_size (arm32_arch_prefix, generic_gas_name);
+		static constexpr auto arm32_gas_name        = concat_string_views<arm32_gas_name_size> (arm32_arch_prefix, generic_gas_name);
+
+		static constexpr size_t x86_gas_name_size   = calc_size (x86_arch_prefix, generic_gas_name);
+		static constexpr auto x86_gas_name          = concat_string_views<x86_gas_name_size> (x86_arch_prefix, generic_gas_name);
 
-		static constexpr auto arm64_ld_name  = concat_const (arm64_arch_prefix, generic_ld_name);
-		static constexpr auto arm32_ld_name  = concat_const (arm32_arch_prefix, generic_ld_name);
-		static constexpr auto x86_ld_name    = concat_const (x86_arch_prefix, generic_ld_name);
-		static constexpr auto x64_ld_name    = concat_const (x64_arch_prefix, generic_ld_name);
+		static constexpr size_t x64_gas_name_size   = calc_size (x64_arch_prefix, generic_gas_name);
+		static constexpr auto x64_gas_name          = concat_string_views<x64_gas_name_size> (x64_arch_prefix, generic_gas_name);
 
-		static std::vector<option> common_options;
-		static std::vector<option> x86_options;
-		static std::vector<option> arm32_options;
+		static constexpr size_t arm64_ld_name_size  = calc_size (arm64_arch_prefix, generic_ld_name);
+		static constexpr auto arm64_ld_name         = concat_string_views<arm64_ld_name_size> (arm64_arch_prefix, generic_ld_name);
+
+		static constexpr size_t arm32_ld_name_size  = calc_size (arm32_arch_prefix, generic_ld_name);
+		static constexpr auto arm32_ld_name         = concat_string_views<arm32_ld_name_size> (arm32_arch_prefix, generic_ld_name);
+
+		static constexpr size_t x86_ld_name_size    = calc_size (x86_arch_prefix, generic_ld_name);
+		static constexpr auto x86_ld_name           = concat_string_views<x86_ld_name_size> (x86_arch_prefix, generic_ld_name);
+
+		static constexpr size_t x64_ld_name_size    = calc_size (x64_arch_prefix, generic_ld_name);
+		static constexpr auto x64_ld_name           = concat_string_views<x64_ld_name_size> (x64_arch_prefix, generic_ld_name);
 
 		std::vector<fs::path> input_files;
 
-		std::string         _program_name;
+		platform::string    _program_name;
 		fs::path            _gas_output_file;
 		fs::path            _program_dir;
 		TargetArchitecture  _target_arch;
 	};
 }
-
-extern xamarin::android::gas::Gas app;
 #endif // __GAS_HH
diff --git a/src/gas/gas.posix.cc b/src/gas/gas.posix.cc
index 5481bf6..84b5010 100644
--- a/src/gas/gas.posix.cc
+++ b/src/gas/gas.posix.cc
@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: MIT
-#include <libgen.h>
+
 #include <cstring>
+#include <vector>
+
+#include <libgen.h>
 
 #include "gas.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 
-void Gas::get_command_line ([[maybe_unused]] int &argc, [[maybe_unused]] char **&argv)
-{
-}
-
-void Gas::determine_program_dir ([[maybe_unused]] int argc, char **argv)
+void Gas::determine_program_dir (std::vector<platform::string> args)
 {
-	fs::path program_path { argv[0] };
+	fs::path program_path { args[0] };
 
 	_program_name = program_path.filename ();
 	if (program_path.is_absolute ()) {
diff --git a/src/gas/gas.windows.cc b/src/gas/gas.windows.cc
index cef3a3f..e421539 100644
--- a/src/gas/gas.windows.cc
+++ b/src/gas/gas.windows.cc
@@ -2,32 +2,17 @@
 #include <windows.h>
 #include <shlwapi.h>
 
-#include <algorithm>
 #include <cstring>
 #include <iostream>
-#include <string>
+#include <vector>
 
-#include "constants.hh"
 #include "exceptions.hh"
 #include "gas.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 
-void Gas::get_command_line (int &argc, char **&argv)
-{
-	LPWSTR *argvw = CommandLineToArgvW (GetCommandLineW (), &argc);
-	argv = new char*[argc + 1];
-
-	for (int i = 0; i < argc; i++) {
-		int size = WideCharToMultiByte (CP_UTF8, 0, argvw [i], -1, NULL, 0, NULL, NULL);
-		argv [i] = new char [size];
-		WideCharToMultiByte (CP_UTF8, 0, argvw [i], -1, argv [i], size, NULL, NULL);
-	}
-
-	argv [argc] = NULL;
-}
-
-void Gas::determine_program_dir ([[maybe_unused]] int argc, [[maybe_unused]] char **argv)
+void Gas::determine_program_dir (std::vector<platform::string> args)
 {
 	TCHAR buffer[MAX_PATH + 1]{};
 	constexpr DWORD bufSize = sizeof(buffer) / sizeof(*buffer);
diff --git a/src/gas/llvm_mc_runner.cc b/src/gas/llvm_mc_runner.cc
index caf1e13..965fc94 100644
--- a/src/gas/llvm_mc_runner.cc
+++ b/src/gas/llvm_mc_runner.cc
@@ -7,6 +7,7 @@
 
 #include "constants.hh"
 #include "llvm_mc_runner.hh"
+#include "platform.hh"
 #include "process.hh"
 
 using namespace xamarin::android::gas;
@@ -24,37 +25,41 @@ std::unordered_map<LlvmMcArgument, bool> LlvmMcRunner::known_options {
 
 int LlvmMcRunner::run (fs::path const& executable_path)
 {
-	auto process = std::make_unique<Process> (executable_path);
+	if (!fs::exists (executable_path)) {
+		STDERR << "Executable '" << executable_path.string () << "' does not exist." << Constants::newline;
+		return Constants::wrapper_exec_failed_error_code;
+	}
 
+	auto process = std::make_unique<Process> (executable_path);
 	auto opt = arguments.find (LlvmMcArgument::Arch);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("--arch", opt->second);
+		process->append_program_argument (PSTR("--arch"), opt->second);
 	}
 
-	process->append_program_argument ("--triple", triple);
-	process->append_program_argument ("--assemble");
+	process->append_program_argument (PSTR("--triple"), triple);
+	process->append_program_argument (PSTR("--assemble"));
 
 	opt = arguments.find (LlvmMcArgument::GenerateDebug);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("-g");
+		process->append_program_argument (PSTR("-g"));
 	}
 
 	opt = arguments.find (LlvmMcArgument::FileType);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("--filetype", opt->second);
+		process->append_program_argument (PSTR("--filetype"), opt->second);
 	}
 
 	opt = arguments.find (LlvmMcArgument::Mattr);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("--mattr", opt->second, true /* uses_comma_separated_list */);
+		process->append_program_argument (PSTR("--mattr"), opt->second, true /* uses_comma_separated_list */);
 	}
 
 	opt = arguments.find (LlvmMcArgument::Output);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("-o", opt->second);
+		process->append_program_argument (PSTR("-o"), opt->second);
 	}
 
-	std::string input_file { "\"" + input_file_path.make_preferred ().string () + "\"" };
+	platform::string input_file { PSTR("\"") + input_file_path.make_preferred ().string () + PSTR("\"") };
 	process->append_program_argument (input_file_path.make_preferred ().string ());
 
 	return process->run ();
diff --git a/src/gas/llvm_mc_runner.hh b/src/gas/llvm_mc_runner.hh
index b56edec..afb7cd5 100644
--- a/src/gas/llvm_mc_runner.hh
+++ b/src/gas/llvm_mc_runner.hh
@@ -3,13 +3,12 @@
 #define __LLVM_MC_RUNNER_HH
 
 #include <filesystem>
-#include <functional>
-#include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "exceptions.hh"
 #include "gas.hh"
+#include "platform.hh"
 #include "process.hh"
 
 namespace xamarin::android::gas
@@ -64,7 +63,7 @@ namespace xamarin::android::gas
 		fs::path make_output_file_path (fs::path const& input_file)
 		{
 			fs::path out_path = input_file;
-			return out_path.replace_extension (".o").make_preferred ();
+			return out_path.replace_extension (PSTR(".o")).make_preferred ();
 		}
 
 		void set_output_file_path (fs::path const& file_path)
@@ -86,50 +85,50 @@ namespace xamarin::android::gas
 			set_option (LlvmMcArgument::GenerateDebug);
 		}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") = 0;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) = 0;
 		int run (fs::path const& executable_path);
 
 	protected:
 		LlvmMcRunner (LlvmMcArchitecture arch)
 		{
-			set_option (LlvmMcArgument::FileType, "obj");
+			set_option (LlvmMcArgument::FileType, PSTR("obj"));
 
-			std::string architecture;
-			std::string triple_prefix;
+			platform::string architecture;
+			platform::string triple_prefix;
 			switch (arch) {
 				case LlvmMcArchitecture::ARM64:
-					triple_prefix = architecture = "aarch64";
+					triple_prefix = architecture = PSTR("aarch64");
 					break;
 
 				case LlvmMcArchitecture::ARM32:
-					triple_prefix = architecture = "arm";
+					triple_prefix = architecture = PSTR("arm");
 					break;
 
 				case LlvmMcArchitecture::X86:
-					triple_prefix = architecture = "x86";
+					triple_prefix = architecture = PSTR("x86");
 					break;
 
 				case LlvmMcArchitecture::X64:
-					architecture = "x86-64";
-					triple_prefix = "x86_64";
+					architecture = PSTR("x86-64");
+					triple_prefix = PSTR("x86_64");
 					break;
 			}
 
 			set_arch (architecture);
-			triple = triple_prefix + "-linux-gnu";
+			triple = triple_prefix + PSTR("-linux-gnu");
 		}
 
-		void set_arch (std::string const& arch)
+		void set_arch (platform::string const& arch)
 		{
 			set_option (LlvmMcArgument::Arch, arch);
 		}
 
-		void set_mcpu (std::string const& cpu)
+		void set_mcpu (platform::string const& cpu)
 		{
 			set_option (LlvmMcArgument::Mcpu, cpu);
 		}
 
-		void set_option (LlvmMcArgument argument, std::string const& value = "")
+		void set_option (LlvmMcArgument argument, platform::string const& value = PSTR(""))
 		{
 			if (argument == LlvmMcArgument::Arch) {
 				if (arguments.find (argument) != arguments.end ()) {
@@ -162,14 +161,14 @@ namespace xamarin::android::gas
 			return iter->second;
 		}
 
-		void append_attribute (std::string const& new_attr)
+		void append_attribute (platform::string const& new_attr)
 		{
 			set_option (LlvmMcArgument::Mattr, new_attr);
 		}
 
-		void append_attributes (std::vector<std::string> const& new_attrs)
+		void append_attributes (std::vector<platform::string> const& new_attrs)
 		{
-			for (std::string const& attr : new_attrs) {
+			for (platform::string const& attr : new_attrs) {
 				append_attribute (attr);
 			}
 		}
@@ -177,7 +176,7 @@ namespace xamarin::android::gas
 	private:
 		std::unordered_map<LlvmMcArgument, Process::process_argument> arguments;
 		fs::path input_file_path;
-		std::string triple;
+		platform::string triple;
 	};
 
 	class LlvmMcRunnerARM64 final : public LlvmMcRunner
@@ -190,7 +189,7 @@ namespace xamarin::android::gas
 		virtual ~LlvmMcRunnerARM64 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 	};
 
 	class LlvmMcRunnerARM32 final : public LlvmMcRunner
@@ -200,16 +199,16 @@ namespace xamarin::android::gas
 			: LlvmMcRunner (LlvmMcArchitecture::ARM32)
 		{
 			// We always target ARMv7-a
-			append_attribute ("+armv7-a");
+			append_attribute (PSTR("+armv7-a"));
 		}
 
 		virtual ~LlvmMcRunnerARM32 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 
 	private:
-		static std::unordered_map<std::string, std::vector<std::string>> fpu_type_map;
+		static std::unordered_map<platform::string, std::vector<platform::string>> fpu_type_map;
 	};
 
 	class LlvmMcRunnerX64 final : public LlvmMcRunner
@@ -222,7 +221,7 @@ namespace xamarin::android::gas
 		virtual ~LlvmMcRunnerX64 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 	};
 
 	class LlvmMcRunnerX86 final : public LlvmMcRunner
@@ -235,7 +234,7 @@ namespace xamarin::android::gas
 		virtual ~LlvmMcRunnerX86 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 	};
 }
 #endif // __LLVM_MC_RUNNER_HH
diff --git a/src/gas/llvm_mc_runner_arm32.cc b/src/gas/llvm_mc_runner_arm32.cc
index 3c67ed6..a28ba01 100644
--- a/src/gas/llvm_mc_runner_arm32.cc
+++ b/src/gas/llvm_mc_runner_arm32.cc
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
+
 #include "exceptions.hh"
 #include "llvm_mc_runner.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 
@@ -14,53 +16,53 @@ using namespace xamarin::android::gas;
 //
 //   llvm-mc --arch=arm --mattr=help < /dev/null
 //
-std::unordered_map<std::string, std::vector<std::string>> LlvmMcRunnerARM32::fpu_type_map {
-	{ "arm1020e",               {}},
-	{ "arm1020t",               {}},
-	{ "arm1136jf-s",            {}},
-	{ "arm7500fe",              {}},
-	{ "crypto-neon-fp-armv8",   {"+crypto", "+neon", "+armv8-a"}},
-	{ "crypto-neon-fp-armv8.1", {"+crypto", "+neon", "+armv8.1-a"}},
-	{ "fp-armv8",               {"+armv8-a"}},
-	{ "fpa",                    {}},
-	{ "fpa10",                  {}},
-	{ "fpa11",                  {}},
-	{ "fpe",                    {}},
-	{ "fpe2",                   {}},
-	{ "fpe3",                   {}},
-	{ "fpv4-sp-d16",            {}},
-	{ "fpv5-d16",               {}},
-	{ "fpv5-sp-d16",            {}},
-	{ "maverick",               {}},
-	{ "neon",                   {"+neon"}},
-	{ "neon-fp-armv8",          {"+neon", "+armv8-a", "+fp-armv8"}},
-	{ "neon-fp-armv8.1",        {"+neon", "+armv8.1-a", "+fp-armv8"}},
-	{ "neon-fp16",              {"+neon", "+fp16"}},
-	{ "neon-vfpv3",             {"+neon", "+vfp3"}},
-	{ "neon-vfpv4",             {"+neon", "+vfp4"}},
-	{ "softfpa",                {"+soft-float"}},
-	{ "softvfp",                {}}, // no llvm-mc equivalent?
-	{ "softvfp+vfp",            {}}, // no llvm-mc equivalent?
-	{ "vfp",                    {}}, // no llvm-mc equivalent?
-	{ "vfp10",                  {}}, // no llvm-mc equivalent?
-	{ "vfp10-r0",               {}}, // no llvm-mc equivalent?
-	{ "vfp9",                   {}}, // no llvm-mc equivalent?
-	{ "vfpv2",                  {"+vfp2"}},
-	{ "vfpv3",                  {"+vfp3"}},
-	{ "vfp3",                   {"+vfp3"}}, // undocumented GAS option, alias for vfpv3 above
-	{ "vfpv3-d16",              {"+vfp3d16"}},
-	{ "vfpv3-d16-fp16",         {"vfp3d16,+fp16"}},
-	{ "vfpv3-fp16",             {"+vfp3,+fp16"}},
-	{ "vfpv3xd",                {}}, // no llvm-mc equivalent?
-	{ "vfpv3xd-d16",            {}}, // no llvm-mc equivalent?
-	{ "vfpv4",                  {"+vfp4"}},
-	{ "vfpv4-d16",              {"+vfp4d16"}},
-	{ "vfpxd",                  {}}, // no llvm-mc equivalent?
+std::unordered_map<platform::string, std::vector<platform::string>> LlvmMcRunnerARM32::fpu_type_map {
+	{ PSTR("arm1020e"),               {}},
+	{ PSTR("arm1020t"),               {}},
+	{ PSTR("arm1136jf-s"),            {}},
+	{ PSTR("arm7500fe"),              {}},
+	{ PSTR("crypto-neon-fp-armv8"),   {PSTR("+crypto"), PSTR("+neon"), PSTR("+armv8-a")}},
+	{ PSTR("crypto-neon-fp-armv8.1"), {PSTR("+crypto"), PSTR("+neon"), PSTR("+armv8.1-a")}},
+	{ PSTR("fp-armv8"),               {PSTR("+armv8-a")}},
+	{ PSTR("fpa"),                    {}},
+	{ PSTR("fpa10"),                  {}},
+	{ PSTR("fpa11"),                  {}},
+	{ PSTR("fpe"),                    {}},
+	{ PSTR("fpe2"),                   {}},
+	{ PSTR("fpe3"),                   {}},
+	{ PSTR("fpv4-sp-d16"),            {}},
+	{ PSTR("fpv5-d16"),               {}},
+	{ PSTR("fpv5-sp-d16"),            {}},
+	{ PSTR("maverick"),               {}},
+	{ PSTR("neon"),                   {PSTR("+neon")}},
+	{ PSTR("neon-fp-armv8"),          {PSTR("+neon"), PSTR("+armv8-a"), PSTR("+fp-armv8")}},
+	{ PSTR("neon-fp-armv8.1"),        {PSTR("+neon"), PSTR("+armv8.1-a"), PSTR("+fp-armv8")}},
+	{ PSTR("neon-fp16"),              {PSTR("+neon"), PSTR("+fp16")}},
+	{ PSTR("neon-vfpv3"),             {PSTR("+neon"), PSTR("+vfp3")}},
+	{ PSTR("neon-vfpv4"),             {PSTR("+neon"), PSTR("+vfp4")}},
+	{ PSTR("softfpa"),                {PSTR("+soft-float")}},
+	{ PSTR("softvfp"),                {}}, // no llvm-mc equivalent?
+	{ PSTR("softvfp+vfp"),            {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp"),                    {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp10"),                  {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp10-r0"),               {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp9"),                   {}}, // no llvm-mc equivalent?
+	{ PSTR("vfpv2"),                  {PSTR("+vfp2")}},
+	{ PSTR("vfpv3"),                  {PSTR("+vfp3")}},
+	{ PSTR("vfp3"),                   {PSTR("+vfp3")}}, // undocumented GAS option, alias for vfpv3 above
+	{ PSTR("vfpv3-d16"),              {PSTR("+vfp3d16")}},
+	{ PSTR("vfpv3-d16-fp16"),         {PSTR("vfp3d16,+fp16")}},
+	{ PSTR("vfpv3-fp16"),             {PSTR("+vfp3,+fp16")}},
+	{ PSTR("vfpv3xd"),                {}}, // no llvm-mc equivalent?
+	{ PSTR("vfpv3xd-d16"),            {}}, // no llvm-mc equivalent?
+	{ PSTR("vfpv4"),                  {PSTR("+vfp4")}},
+	{ PSTR("vfpv4-d16"),              {PSTR("+vfp4d16")}},
+	{ PSTR("vfpxd"),                  {}}, // no llvm-mc equivalent?
 };
 
-void LlvmMcRunnerARM32::map_option (std::string const& gas_name, std::string const& value)
+void LlvmMcRunnerARM32::map_option (platform::string const& gas_name, platform::string const& value)
 {
-	if (gas_name != "mfpu") {
+	if (gas_name != PSTR("mfpu")) {
 		return;
 	}
 
@@ -68,13 +70,34 @@ void LlvmMcRunnerARM32::map_option (std::string const& gas_name, std::string con
 		throw invalid_argument_error { "The `-mfpu` option requires a value, argument `value` must not be empty" };
 	}
 
+	auto to_utf8 = [](platform::string const& s) -> std::string {
+#if !defined(_WIN32)
+		return s;
+#else
+		std::string ret (s.length (), 0);
+		std::transform (
+			s.begin (),
+			s.end (),
+			ret.begin (),
+			[](platform::string::value_type ch) {
+				return static_cast<std::string::value_type>(ch); }
+		);
+		return ret;
+#endif
+	};
+
 	auto mc_fpu = fpu_type_map.find (value);
 	if (mc_fpu == fpu_type_map.end ()) {
-		throw invalid_argument_error { "Unknown GAS FPU type: " + value };
+		std::string message { "Unknown GAS FPU type: " };
+		message.append (to_utf8 (value));
+		throw invalid_argument_error { message };
 	}
 
 	if (mc_fpu->second.empty ()) {
-		throw invalid_operation_error {"Unable to map known GAS FPU type '" + value + "' to llvm-mc value" };
+		std::string message { "Unable to map known GAS FPU type '" };
+		message.append (to_utf8 (value));
+		message.append ("' to llvm-mc value");
+		throw invalid_operation_error { message };
 	}
 
 	append_attributes (mc_fpu->second);
diff --git a/src/gas/llvm_mc_runner_arm64.cc b/src/gas/llvm_mc_runner_arm64.cc
index 793434e..5df5b00 100644
--- a/src/gas/llvm_mc_runner_arm64.cc
+++ b/src/gas/llvm_mc_runner_arm64.cc
@@ -3,5 +3,5 @@
 
 using namespace xamarin::android::gas;
 
-void LlvmMcRunnerARM64::map_option ([[maybe_unused]] std::string const& gas_name, [[maybe_unused]] std::string const& value)
+void LlvmMcRunnerARM64::map_option ([[maybe_unused]] platform::string const& gas_name, [[maybe_unused]] platform::string const& value)
 {}
diff --git a/src/gas/llvm_mc_runner_x64.cc b/src/gas/llvm_mc_runner_x64.cc
index e7d7293..58a415a 100644
--- a/src/gas/llvm_mc_runner_x64.cc
+++ b/src/gas/llvm_mc_runner_x64.cc
@@ -3,5 +3,5 @@
 
 using namespace xamarin::android::gas;
 
-void LlvmMcRunnerX64::map_option ([[maybe_unused]] std::string const& gas_name, [[maybe_unused]] std::string const& value)
+void LlvmMcRunnerX64::map_option ([[maybe_unused]] platform::string const& gas_name, [[maybe_unused]] platform::string const& value)
 {}
diff --git a/src/gas/llvm_mc_runner_x86.cc b/src/gas/llvm_mc_runner_x86.cc
index 1120b49..d406938 100644
--- a/src/gas/llvm_mc_runner_x86.cc
+++ b/src/gas/llvm_mc_runner_x86.cc
@@ -3,5 +3,5 @@
 
 using namespace xamarin::android::gas;
 
-void LlvmMcRunnerX86::map_option ([[maybe_unused]] std::string const& gas_name, [[maybe_unused]] std::string const& value)
+void LlvmMcRunnerX86::map_option ([[maybe_unused]] platform::string const& gas_name, [[maybe_unused]] platform::string const& value)
 {}
diff --git a/src/gas/main.cc b/src/gas/main.cc
index 9b77d0e..aca2ea8 100644
--- a/src/gas/main.cc
+++ b/src/gas/main.cc
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: MIT
-#include "gas.hh"
+#include <iostream>
+#include <vector>
 
-xamarin::android::gas::Gas app;
+#include "gas.hh"
+#include "platform.hh"
 
 int main (int argc, char **argv)
 {
-	// On windows this obtains the utf8 version of args
-	app.get_command_line (argc, argv);
+	xamarin::android::gas::Gas app;
+
+	std::vector<platform::string> args = app.get_command_line (argc, argv);
+
 	// TODO: handle exceptions here (use backward for stacktrace perhaps?)
-	return app.run (argc, argv);
+	return app.run (args);
 }
diff --git a/src/gas/platform.hh b/src/gas/platform.hh
new file mode 100644
index 0000000..80d241f
--- /dev/null
+++ b/src/gas/platform.hh
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+#if !defined(GAS_PLATFORM_HH)
+#define GAS_PLATFORM_HH
+
+#include <string>
+#include <iostream>
+
+#if defined(_WIN32)
+#define STDOUT std::cout
+#define STDERR std::cerr
+#define PSTR(_str_lit_) (_str_lit_)
+#define PCHAR(_ch_) (_ch_)
+#else
+#define STDOUT std::cout
+#define STDERR std::cerr
+#define PSTR(_str_lit_) (_str_lit_)
+#define PCHAR(_ch_) (_ch_)
+#endif
+
+namespace platform {
+#if !defined (_WIN32)
+	using string = std::string;
+	using string_view = std::string_view;
+#else
+	using string = std::string;
+	using string_view = std::string_view;
+#endif
+}
+
+#endif // ndef GAS_PLATFORM_HH
diff --git a/src/gas/process.cc b/src/gas/process.cc
index c57e952..90b3766 100644
--- a/src/gas/process.cc
+++ b/src/gas/process.cc
@@ -2,53 +2,35 @@
 #include <cstring>
 #include <iostream>
 
+#include "platform.hh"
 #include "process.hh"
 
 using namespace xamarin::android::gas;
 
 void Process::print_process_command_line ()
 {
-	std::cout << "Running: " << executable_path;
-	for (std::string const& arg : _args) {
-		std::cout << " " << arg;
+	STDOUT << "Running: " << executable_path;
+	for (platform::string const& arg : _args) {
+		STDOUT << " " << arg;
 	}
-	std::cout << "\n";
+	STDOUT << Constants::newline;
 }
 
-std::vector<std::string::const_pointer> Process::make_exec_args ()
-{
-	std::vector<std::string::const_pointer> exec_args;
-
-	const char *const epath = executable_path.string ().c_str ();
-	exec_args.push_back (
-#if defined(_WIN32)
-		_strdup (epath)
-#else
-		strdup (epath)
-#endif
-	);
-	for (std::string const& arg : _args) {
-		exec_args.push_back (arg.c_str ());
-	}
-
-	return exec_args;
-}
-
-void Process::append_program_argument (std::string const& option_name, std::string const& option_value)
+void Process::append_program_argument (platform::string const& option_name, platform::string const& option_value)
 {
 	if (option_value.empty ()) {
 		_args.push_back (option_name);
 		return;
 	}
 
-	std::string value_arg { option_name };
-	value_arg.append ("=");
+	platform::string value_arg { option_name };
+	value_arg.append (PSTR("="));
 	value_arg.append (option_value);
 
 	_args.push_back (value_arg);
 }
 
-void Process::append_program_argument (std::string const& option_name, string_list const& option_value, bool uses_comma_separated_list)
+void Process::append_program_argument (platform::string const& option_name, string_list const& option_value, bool uses_comma_separated_list)
 {
 	if (option_value.empty ()) {
 		append_program_argument (option_name);
@@ -56,19 +38,19 @@ void Process::append_program_argument (std::string const& option_name, string_li
 	}
 
 	if (!uses_comma_separated_list) {
-		for (std::string const& value : option_value) {
+		for (platform::string const& value : option_value) {
 			append_program_argument (option_name, value);
 		}
 		return;
 	}
 
-	std::string value_arg { option_name };
-	value_arg.append ("=");
+	platform::string value_arg { option_name };
+	value_arg.append (PSTR("="));
 
-	std::string value_list;
-	for (std::string const& value : option_value) {
+	platform::string value_list;
+	for (platform::string const& value : option_value) {
 		if (!value_list.empty ()) {
-			value_list.append (",");
+			value_list.append (PSTR(","));
 		}
 		value_list.append (value);
 	}
diff --git a/src/gas/process.hh b/src/gas/process.hh
index 6f57475..4520af9 100644
--- a/src/gas/process.hh
+++ b/src/gas/process.hh
@@ -6,15 +6,18 @@
 #include <string>
 #include <variant>
 #include <vector>
+
+#include "command_line.hh"
 #include "gas.hh"
+#include "platform.hh"
 
 namespace xamarin::android::gas
 {
 	class Process
 	{
 	public:
-		using string_list = std::vector<std::string>;
-		using process_argument = std::variant<std::string, string_list>;
+		using string_list = std::vector<platform::string>;
+		using process_argument = std::variant<platform::string, string_list>;
 
 	public:
 		explicit Process (fs::path const& executable_path)
@@ -22,14 +25,13 @@ namespace xamarin::android::gas
 		{}
 
 		int run (bool print_command_line = true);
-		void append_program_argument (std::string const& option_name, std::string const& option_value = "");
-		void append_program_argument (std::string const& option_name, string_list const& option_value, bool uses_comma_separated_list = false);
-
-		void append_program_argument (std::string const& option_name, process_argument const& option_value, bool uses_comma_separated_list = false)
+		void append_program_argument (platform::string const& option_name, platform::string const& option_value = PSTR(""));
+		void append_program_argument (platform::string const& option_name, string_list const& option_value, bool uses_comma_separated_list = false);
+		void append_program_argument (platform::string const& option_name, process_argument const& option_value, bool uses_comma_separated_list = false)
 		{
 			switch (option_value.index ()) {
 				case 0:
-					append_program_argument (option_name, std::get<std::string> (option_value));
+					append_program_argument (option_name, std::get<platform::string> (option_value));
 					break;
 
 				case 1:
@@ -38,17 +40,17 @@ namespace xamarin::android::gas
 			}
 		}
 
-		std::vector<std::string> const& args () const noexcept
+		std::vector<platform::string> const& args () const noexcept
 		{
 			return _args;
 		}
 
 	private:
 		void print_process_command_line ();
-		std::vector<std::string::const_pointer> make_exec_args ();
+		std::vector<platform::string::const_pointer> make_exec_args ();
 
 	private:
-		std::vector<std::string> _args;
+		std::vector<platform::string> _args;
 		fs::path const executable_path;
 	};
 }
diff --git a/src/gas/process.posix.cc b/src/gas/process.posix.cc
index b22c25c..27fd7c8 100644
--- a/src/gas/process.posix.cc
+++ b/src/gas/process.posix.cc
@@ -13,6 +13,24 @@
 
 using namespace xamarin::android::gas;
 
+std::vector<platform::string::const_pointer> Process::make_exec_args ()
+{
+	std::vector<platform::string::const_pointer> exec_args;
+
+	exec_args.push_back (
+#if defined(_WIN32)
+		_strdup (executable_path.string ().c_str ())
+#else
+		strdup (executable_path.string ().c_str ())
+#endif
+	);
+	for (platform::string const& arg : _args) {
+		exec_args.push_back (arg.c_str ());
+	}
+
+	return exec_args;
+}
+
 int Process::run (bool print_command_line)
 {
 	if (print_command_line) {
@@ -33,13 +51,13 @@ int Process::run (bool print_command_line)
 
 	pid_t llvm_mc_pid = fork ();
 	if (llvm_mc_pid == -1) {
-		std::cerr << "Fork failed. " << std::strerror (errno) << Constants::newline;
+		STDERR << "Fork failed. " << std::strerror (errno) << Constants::newline;
 		return Constants::wrapper_fork_failed_error_code;
 	}
 
 	if (llvm_mc_pid == 0) {
 		if (execv (executable_path.c_str (), const_cast<char* const*>(exec_args.data ())) == -1) {
-			std::cerr << "Failed to run " << Constants::llvm_mc_name << ". " << std::strerror (errno) << Constants::newline;
+			STDERR << "Failed to run " << Constants::llvm_mc_name << ". " << std::strerror (errno) << Constants::newline;
 		}
 		_exit (Constants::wrapper_exec_failed_error_code);
 	}
@@ -49,22 +67,22 @@ int Process::run (bool print_command_line)
 		pid_t result = waitpid (llvm_mc_pid,  &wstatus, WUNTRACED);
 
 		if (result == -1) {
-			std::cerr << "Failed to wait for " << Constants::llvm_mc_name << " to terminate. " << std::strerror (errno) << Constants::newline;
+			STDERR << "Failed to wait for " << Constants::llvm_mc_name << " to terminate. " << std::strerror (errno) << Constants::newline;
 			return Constants::wrapper_wait_failed_error_code;
 		}
 
 		if (WIFSIGNALED (wstatus)) {
-			std::cerr << Constants::llvm_mc_name << " was killed by signal " << WTERMSIG (wstatus) << Constants::newline;
+			STDERR << Constants::llvm_mc_name << " was killed by signal " << WTERMSIG (wstatus) << Constants::newline;
 			return Constants::wrapper_llvm_mc_killed_error_code;
 		} else if (WIFSTOPPED (wstatus)) {
-			std::cerr << Constants::llvm_mc_name << " was stopped by signal " << WSTOPSIG (wstatus) << Constants::newline;
+			STDERR << Constants::llvm_mc_name << " was stopped by signal " << WSTOPSIG (wstatus) << Constants::newline;
 			kill (llvm_mc_pid, SIGKILL); // Let's not risk hanging indifinitely...
 			return Constants::wrapper_llvm_mc_stopped_error_code;
 		}
 	} while (!WIFEXITED(wstatus) && !WIFSIGNALED(wstatus));
 
 	if (WEXITSTATUS (wstatus) != 0) {
-		std::cerr << Constants::llvm_mc_name << " exited with status " << WEXITSTATUS (wstatus) << Constants::newline;
+		STDERR << Constants::llvm_mc_name << " exited with status " << WEXITSTATUS (wstatus) << Constants::newline;
 	}
 	return WEXITSTATUS (wstatus);
 }
diff --git a/src/gas/process.windows.cc b/src/gas/process.windows.cc
index a381d0d..7edb57b 100644
--- a/src/gas/process.windows.cc
+++ b/src/gas/process.windows.cc
@@ -6,15 +6,16 @@
 #include <iostream>
 
 #include "constants.hh"
+#include "platform.hh"
 #include "process.hh"
 
 using namespace xamarin::android::gas;
 
-static std::string escape_argument (std::string arg)
+static platform::string escape_argument (platform::string arg)
 {
 	bool needs_quote = false;
 
-	for (std::string::value_type const& c : arg) {
+	for (platform::string::value_type const& c : arg) {
 		if (isalpha (c) || isdigit (c) ||
 		    c == '.' || c == '_' || c == '-' ||
 		    c == '+' || c == '/') {
@@ -29,16 +30,16 @@ static std::string escape_argument (std::string arg)
 		return arg;
 	}
 
-	std::string result = "\"";
-	for (std::string::const_reference c : arg) {
-		if (c == '\"' || c == '\\') {
-			result.append ("\\");
+	platform::string result = PSTR("\"");
+	for (platform::string::const_reference c : arg) {
+		if (c == PCHAR('\"') || c == PCHAR('\\')) {
+			result.append (PCHAR("\\"));
 		}
 
 		result += c;
 	}
 
-	result.append ("\"");
+	result.append (PSTR("\""));
 	return result;
 }
 
@@ -48,13 +49,13 @@ int Process::run (bool print_command_line)
 		print_process_command_line ();
 	}
 
-	std::string binary = executable_path.string ();
-	std::string args { escape_argument (binary) };
-	for (std::string const& a : _args) {
+	platform::string binary = executable_path.string ();
+	platform::string args { escape_argument (binary) };
+	for (platform::string const& a : _args) {
 		if (a.empty ()) {
 			continue;
 		}
-		args.append (" ");
+		args.append (PCHAR(" "));
 		args.append (escape_argument (a));
 	}