diff --git a/src/CommandLine/Core/GetoptTokenizer.cs b/src/CommandLine/Core/GetoptTokenizer.cs
new file mode 100644
index 00000000..d9fe63fc
--- /dev/null
+++ b/src/CommandLine/Core/GetoptTokenizer.cs
@@ -0,0 +1,219 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CommandLine.Infrastructure;
+using CSharpx;
+using RailwaySharp.ErrorHandling;
+using System.Text.RegularExpressions;
+
+namespace CommandLine.Core
+{
+    static class GetoptTokenizer
+    {
+        public static Result<IEnumerable<Token>, Error> Tokenize(
+            IEnumerable<string> arguments,
+            Func<string, NameLookupResult> nameLookup)
+        {
+            return GetoptTokenizer.Tokenize(arguments, nameLookup, ignoreUnknownArguments:false, allowDashDash:true, posixlyCorrect:false);
+        }
+
+        public static Result<IEnumerable<Token>, Error> Tokenize(
+            IEnumerable<string> arguments,
+            Func<string, NameLookupResult> nameLookup,
+            bool ignoreUnknownArguments,
+            bool allowDashDash,
+            bool posixlyCorrect)
+        {
+            var errors = new List<Error>();
+            Action<string> onBadFormatToken = arg => errors.Add(new BadFormatTokenError(arg));
+            Action<string> unknownOptionError = name => errors.Add(new UnknownOptionError(name));
+            Action<string> doNothing = name => {};
+            Action<string> onUnknownOption = ignoreUnknownArguments ? doNothing : unknownOptionError;
+
+            int consumeNext = 0;
+            Action<int> onConsumeNext = (n => consumeNext = consumeNext + n);
+            bool forceValues = false;
+
+            var tokens = new List<Token>();
+
+            var enumerator = arguments.GetEnumerator();
+            while (enumerator.MoveNext())
+            {
+                switch (enumerator.Current) {
+                    case null:
+                        break;
+
+                    case string arg when forceValues:
+                        tokens.Add(Token.ValueForced(arg));
+                        break;
+
+                    case string arg when consumeNext > 0:
+                        tokens.Add(Token.Value(arg));
+                        consumeNext = consumeNext - 1;
+                        break;
+
+                    case "--" when allowDashDash:
+                        forceValues = true;
+                        break;
+
+                    case "--":
+                        tokens.Add(Token.Value("--"));
+                        if (posixlyCorrect) forceValues = true;
+                        break;
+
+                    case "-":
+                        // A single hyphen is always a value (it usually means "read from stdin" or "write to stdout")
+                        tokens.Add(Token.Value("-"));
+                        if (posixlyCorrect) forceValues = true;
+                        break;
+
+                    case string arg when arg.StartsWith("--"):
+                        tokens.AddRange(TokenizeLongName(arg, nameLookup, onBadFormatToken, onUnknownOption, onConsumeNext));
+                        break;
+
+                    case string arg when arg.StartsWith("-"):
+                        tokens.AddRange(TokenizeShortName(arg, nameLookup, onUnknownOption, onConsumeNext));
+                        break;
+
+                    case string arg:
+                        // If we get this far, it's a plain value
+                        tokens.Add(Token.Value(arg));
+                        if (posixlyCorrect) forceValues = true;
+                        break;
+                }
+            }
+
+            return Result.Succeed<IEnumerable<Token>, Error>(tokens.AsEnumerable(), errors.AsEnumerable());
+        }
+
+        public static Result<IEnumerable<Token>, Error> ExplodeOptionList(
+            Result<IEnumerable<Token>, Error> tokenizerResult,
+            Func<string, Maybe<char>> optionSequenceWithSeparatorLookup)
+        {
+            var tokens = tokenizerResult.SucceededWith().Memoize();
+
+            var replaces = tokens.Select((t, i) =>
+                optionSequenceWithSeparatorLookup(t.Text)
+                    .MapValueOrDefault(sep => Tuple.Create(i + 1, sep),
+                        Tuple.Create(-1, '\0'))).SkipWhile(x => x.Item1 < 0).Memoize();
+
+            var exploded = tokens.Select((t, i) =>
+                        replaces.FirstOrDefault(x => x.Item1 == i).ToMaybe()
+                            .MapValueOrDefault(r => t.Text.Split(r.Item2).Select(Token.Value),
+                                Enumerable.Empty<Token>().Concat(new[] { t })));
+
+            var flattened = exploded.SelectMany(x => x);
+
+            return Result.Succeed(flattened, tokenizerResult.SuccessMessages());
+        }
+
+        public static Func<
+                    IEnumerable<string>,
+                    IEnumerable<OptionSpecification>,
+                    Result<IEnumerable<Token>, Error>>
+            ConfigureTokenizer(
+                    StringComparer nameComparer,
+                    bool ignoreUnknownArguments,
+                    bool enableDashDash,
+                    bool posixlyCorrect)
+        {
+            return (arguments, optionSpecs) =>
+                {
+                    var tokens = GetoptTokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, nameComparer), ignoreUnknownArguments, enableDashDash, posixlyCorrect);
+                    var explodedTokens = GetoptTokenizer.ExplodeOptionList(tokens, name => NameLookup.HavingSeparator(name, optionSpecs, nameComparer));
+                    return explodedTokens;
+                };
+        }
+
+        private static IEnumerable<Token> TokenizeShortName(
+            string arg,
+            Func<string, NameLookupResult> nameLookup,
+            Action<string> onUnknownOption,
+            Action<int> onConsumeNext)
+        {
+
+            // First option char that requires a value means we swallow the rest of the string as the value
+            // But if there is no rest of the string, then instead we swallow the next argument
+            string chars = arg.Substring(1);
+            int len = chars.Length;
+            if (len > 0 && Char.IsDigit(chars[0]))
+            {
+                // Assume it's a negative number
+                yield return Token.Value(arg);
+                yield break;
+            }
+            for (int i = 0; i < len; i++)
+            {
+                var s = new String(chars[i], 1);
+                switch(nameLookup(s))
+                {
+                    case NameLookupResult.OtherOptionFound:
+                        yield return Token.Name(s);
+
+                        if (i+1 < len)
+                        {
+                            // Rest of this is the value (e.g. "-sfoo" where "-s" is a string-consuming arg)
+                            yield return Token.Value(chars.Substring(i+1));
+                            yield break;
+                        }
+                        else
+                        {
+                            // Value is in next param (e.g., "-s foo")
+                            onConsumeNext(1);
+                        }
+                        break;
+
+                    case NameLookupResult.NoOptionFound:
+                        onUnknownOption(s);
+                        break;
+
+                    default:
+                        yield return Token.Name(s);
+                        break;
+                }
+            }
+        }
+
+        private static IEnumerable<Token> TokenizeLongName(
+            string arg,
+            Func<string, NameLookupResult> nameLookup,
+            Action<string> onBadFormatToken,
+            Action<string> onUnknownOption,
+            Action<int> onConsumeNext)
+        {
+            string[] parts = arg.Substring(2).Split(new char[] { '=' }, 2);
+            string name = parts[0];
+            string value = (parts.Length > 1) ? parts[1] : null;
+            // A parameter like "--stringvalue=" is acceptable, and makes stringvalue be the empty string
+            if (String.IsNullOrWhiteSpace(name) || name.Contains(" "))
+            {
+                onBadFormatToken(arg);
+                yield break;
+            }
+            switch(nameLookup(name))
+            {
+                case NameLookupResult.NoOptionFound:
+                    onUnknownOption(name);
+                    yield break;
+
+                case NameLookupResult.OtherOptionFound:
+                    yield return Token.Name(name);
+                    if (value == null) // NOT String.IsNullOrEmpty
+                    {
+                        onConsumeNext(1);
+                    }
+                    else
+                    {
+                        yield return Token.Value(value);
+                    }
+                    break;
+
+                default:
+                    yield return Token.Name(name);
+                    break;
+            }
+        }
+    }
+}
diff --git a/src/CommandLine/Infrastructure/StringExtensions.cs b/src/CommandLine/Infrastructure/StringExtensions.cs
index 7bfab66a..db8aa0bd 100644
--- a/src/CommandLine/Infrastructure/StringExtensions.cs
+++ b/src/CommandLine/Infrastructure/StringExtensions.cs
@@ -73,5 +73,23 @@ public static bool ToBoolean(this string value)
         {
             return value.Equals("true", StringComparison.OrdinalIgnoreCase);
         }
+
+        public static bool ToBooleanLoose(this string value)
+        {
+            if ((string.IsNullOrEmpty(value)) ||
+                (value == "0") ||
+                (value.Equals("f", StringComparison.OrdinalIgnoreCase)) ||
+                (value.Equals("n", StringComparison.OrdinalIgnoreCase)) ||
+                (value.Equals("no", StringComparison.OrdinalIgnoreCase)) ||
+                (value.Equals("off", StringComparison.OrdinalIgnoreCase)) ||
+                (value.Equals("false", StringComparison.OrdinalIgnoreCase)))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/src/CommandLine/Parser.cs b/src/CommandLine/Parser.cs
index 10c9b4e1..4301aa52 100644
--- a/src/CommandLine/Parser.cs
+++ b/src/CommandLine/Parser.cs
@@ -185,8 +185,13 @@ private static Result<IEnumerable<Token>, Error> Tokenize(
                 IEnumerable<OptionSpecification> optionSpecs,
                 ParserSettings settings)
         {
-            return
-                Tokenizer.ConfigureTokenizer(
+            return settings.GetoptMode
+                ? GetoptTokenizer.ConfigureTokenizer(
+                    settings.NameComparer,
+                    settings.IgnoreUnknownArguments,
+                    settings.EnableDashDash,
+                    settings.PosixlyCorrect)(arguments, optionSpecs)
+                : Tokenizer.ConfigureTokenizer(
                     settings.NameComparer,
                     settings.IgnoreUnknownArguments,
                     settings.EnableDashDash)(arguments, optionSpecs);
diff --git a/src/CommandLine/ParserSettings.cs b/src/CommandLine/ParserSettings.cs
index 95a4cd81..5ed73f30 100644
--- a/src/CommandLine/ParserSettings.cs
+++ b/src/CommandLine/ParserSettings.cs
@@ -5,6 +5,7 @@
 using System.IO;
 
 using CommandLine.Infrastructure;
+using CSharpx;
 
 namespace CommandLine
 {
@@ -23,9 +24,11 @@ public class ParserSettings : IDisposable
         private bool autoHelp;
         private bool autoVersion;
         private CultureInfo parsingCulture;
-        private bool enableDashDash;
+        private Maybe<bool> enableDashDash;
         private int maximumDisplayWidth;
-        private bool allowMultiInstance;
+        private Maybe<bool> allowMultiInstance;
+        private bool getoptMode;
+        private Maybe<bool> posixlyCorrect;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ParserSettings"/> class.
@@ -38,6 +41,10 @@ public ParserSettings()
             autoVersion = true;
             parsingCulture = CultureInfo.InvariantCulture;
             maximumDisplayWidth = GetWindowWidth();
+            getoptMode = false;
+            enableDashDash = Maybe.Nothing<bool>();
+            allowMultiInstance = Maybe.Nothing<bool>();
+            posixlyCorrect = Maybe.Nothing<bool>();
         }
 
         private int GetWindowWidth()
@@ -159,11 +166,12 @@ public bool AutoVersion
         /// <summary>
         /// Gets or sets a value indicating whether enable double dash '--' syntax,
         /// that forces parsing of all subsequent tokens as values.
+        /// If GetoptMode is true, this defaults to true, but can be turned off by explicitly specifying EnableDashDash = false.
         /// </summary>
         public bool EnableDashDash
         {
-            get { return enableDashDash; }
-            set { PopsicleSetter.Set(Consumed, ref enableDashDash, value); }
+            get => enableDashDash.MatchJust(out bool value) ? value : getoptMode;
+            set => PopsicleSetter.Set(Consumed, ref enableDashDash, Maybe.Just(value));
         }
 
         /// <summary>
@@ -177,11 +185,31 @@ public int MaximumDisplayWidth
 
         /// <summary>
         /// Gets or sets a value indicating whether options are allowed to be specified multiple times.
+        /// If GetoptMode is true, this defaults to true, but can be turned off by explicitly specifying AllowMultiInstance = false.
         /// </summary>
         public bool AllowMultiInstance
         {
-            get => allowMultiInstance;
-            set => PopsicleSetter.Set(Consumed, ref allowMultiInstance, value);
+            get => allowMultiInstance.MatchJust(out bool value) ? value : getoptMode;
+            set => PopsicleSetter.Set(Consumed, ref allowMultiInstance, Maybe.Just(value));
+        }
+
+        /// <summary>
+        /// Whether strict getopt-like processing is applied to option values; if true, AllowMultiInstance and EnableDashDash will default to true as well.
+        /// </summary>
+        public bool GetoptMode
+        {
+            get => getoptMode;
+            set => PopsicleSetter.Set(Consumed, ref getoptMode, value);
+        }
+
+        /// <summary>
+        /// Whether getopt-like processing should follow the POSIX rules (the equivalent of using the "+" prefix in the C getopt() call).
+        /// If not explicitly set, will default to false unless the POSIXLY_CORRECT environment variable is set, in which case it will default to true.
+        /// </summary>
+        public bool PosixlyCorrect
+        {
+            get => posixlyCorrect.MapValueOrDefault(val => val, () => Environment.GetEnvironmentVariable("POSIXLY_CORRECT").ToBooleanLoose());
+            set => PopsicleSetter.Set(Consumed, ref posixlyCorrect, Maybe.Just(value));
         }
 
         internal StringComparer NameComparer
diff --git a/tests/CommandLine.Tests/Fakes/Simple_Options_With_ExtraArgs.cs b/tests/CommandLine.Tests/Fakes/Simple_Options_With_ExtraArgs.cs
new file mode 100644
index 00000000..bb276fa5
--- /dev/null
+++ b/tests/CommandLine.Tests/Fakes/Simple_Options_With_ExtraArgs.cs
@@ -0,0 +1,27 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+using System.Collections.Generic;
+
+namespace CommandLine.Tests.Fakes
+{
+    public class Simple_Options_WithExtraArgs
+    {
+        [Option(HelpText = "Define a string value here.")]
+        public string StringValue { get; set; }
+
+        [Option('s', "shortandlong", HelpText = "Example with both short and long name.")]
+        public string ShortAndLong { get; set; }
+
+        [Option('i', Min = 3, Max = 4, Separator = ',', HelpText = "Define a int sequence here.")]
+        public IEnumerable<int> IntSequence { get; set; }
+
+        [Option('x', HelpText = "Define a boolean or switch value here.")]
+        public bool BoolValue { get; set; }
+
+        [Value(0, HelpText = "Define a long value here.")]
+        public long LongValue { get; set; }
+
+        [Value(1, HelpText = "Extra args get collected here.")]
+        public IEnumerable<string> ExtraArgs { get; set; }
+    }
+}
diff --git a/tests/CommandLine.Tests/Unit/Core/GetoptTokenizerTests.cs b/tests/CommandLine.Tests/Unit/Core/GetoptTokenizerTests.cs
new file mode 100644
index 00000000..337a9a3f
--- /dev/null
+++ b/tests/CommandLine.Tests/Unit/Core/GetoptTokenizerTests.cs
@@ -0,0 +1,126 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+using FluentAssertions;
+using CSharpx;
+using RailwaySharp.ErrorHandling;
+using CommandLine.Core;
+
+namespace CommandLine.Tests.Unit.Core
+{
+    public class GetoptTokenizerTests
+    {
+        [Fact]
+        public void Explode_scalar_with_separator_in_odd_args_input_returns_sequence()
+        {
+            // Fixture setup
+            var expectedTokens = new[] { Token.Name("i"), Token.Value("10"), Token.Name("string-seq"),
+                Token.Value("aaa"), Token.Value("bb"),  Token.Value("cccc"), Token.Name("switch") };
+            var specs = new[] { new OptionSpecification(string.Empty, "string-seq",
+                false, string.Empty, Maybe.Nothing<int>(), Maybe.Nothing<int>(), ',', null, string.Empty, string.Empty, new List<string>(), typeof(IEnumerable<string>), TargetType.Sequence, string.Empty)};
+
+            // Exercize system
+            var result =
+                GetoptTokenizer.ExplodeOptionList(
+                    Result.Succeed(
+                        Enumerable.Empty<Token>().Concat(new[] { Token.Name("i"), Token.Value("10"),
+                            Token.Name("string-seq"), Token.Value("aaa,bb,cccc"), Token.Name("switch") }),
+                        Enumerable.Empty<Error>()),
+                        optionName => NameLookup.HavingSeparator(optionName, specs, StringComparer.Ordinal));
+            // Verify outcome
+            ((Ok<IEnumerable<Token>, Error>)result).Success.Should().BeEquivalentTo(expectedTokens);
+
+            // Teardown
+        }
+
+        [Fact]
+        public void Explode_scalar_with_separator_in_even_args_input_returns_sequence()
+        {
+            // Fixture setup
+            var expectedTokens = new[] { Token.Name("x"), Token.Name("string-seq"),
+                Token.Value("aaa"), Token.Value("bb"),  Token.Value("cccc"), Token.Name("switch") };
+            var specs = new[] { new OptionSpecification(string.Empty, "string-seq",
+                false, string.Empty, Maybe.Nothing<int>(), Maybe.Nothing<int>(), ',', null, string.Empty, string.Empty, new List<string>(), typeof(IEnumerable<string>), TargetType.Sequence, string.Empty)};
+
+            // Exercize system
+            var result =
+                GetoptTokenizer.ExplodeOptionList(
+                    Result.Succeed(
+                        Enumerable.Empty<Token>().Concat(new[] { Token.Name("x"),
+                            Token.Name("string-seq"), Token.Value("aaa,bb,cccc"), Token.Name("switch") }),
+                        Enumerable.Empty<Error>()),
+                        optionName => NameLookup.HavingSeparator(optionName, specs, StringComparer.Ordinal));
+
+            // Verify outcome
+            ((Ok<IEnumerable<Token>, Error>)result).Success.Should().BeEquivalentTo(expectedTokens);
+
+            // Teardown
+        }
+
+        [Fact]
+        public void Should_properly_parse_option_with_equals_in_value()
+        {
+            /**
+             * This is how the arg. would look in `static void Main(string[] args)`
+             * if passed from the command-line and the option-value wrapped in quotes.
+             * Ex.) ./app --connectionString="Server=localhost;Data Source..."
+             */
+            var args = new[] { "--connectionString=Server=localhost;Data Source=(LocalDB)\v12.0;Initial Catalog=temp;" };
+
+            var result = GetoptTokenizer.Tokenize(args, name => NameLookupResult.OtherOptionFound);
+
+            var tokens = result.SucceededWith();
+
+            Assert.NotNull(tokens);
+            Assert.Equal(2, tokens.Count());
+            Assert.Equal("connectionString", tokens.First().Text);
+            Assert.Equal("Server=localhost;Data Source=(LocalDB)\v12.0;Initial Catalog=temp;", tokens.Last().Text);
+        }
+
+        [Fact]
+        public void Should_return_error_if_option_format_with_equals_is_not_correct()
+        {
+            var args = new[] { "--option1 = fail", "--option2= succeed" };
+
+            var result = GetoptTokenizer.Tokenize(args, name => NameLookupResult.OtherOptionFound);
+
+            var errors = result.SuccessMessages();
+
+            Assert.NotNull(errors);
+            Assert.Equal(1, errors.Count());
+            Assert.Equal(ErrorType.BadFormatTokenError, errors.First().Tag);
+
+            var tokens = result.SucceededWith();
+            Assert.NotNull(tokens);
+            Assert.Equal(2, tokens.Count());
+            Assert.Equal(TokenType.Name, tokens.First().Tag);
+            Assert.Equal(TokenType.Value, tokens.Last().Tag);
+            Assert.Equal("option2", tokens.First().Text);
+            Assert.Equal(" succeed", tokens.Last().Text);
+        }
+
+
+        [Theory]
+        [InlineData(new[] { "-a", "-" }, 2,"a","-")]
+        [InlineData(new[] { "--file", "-" }, 2,"file","-")]
+        [InlineData(new[] { "-f-" }, 2,"f", "-")]
+        [InlineData(new[] { "--file=-" }, 2, "file", "-")]
+        [InlineData(new[] { "-a", "--" }, 2, "a", "--")]
+        public void Single_dash_as_a_value(string[] args, int countExcepted,string first,string last)
+        {
+            //Arrange
+            //Act
+            var result = GetoptTokenizer.Tokenize(args, name => NameLookupResult.OtherOptionFound);
+            var tokens = result.SucceededWith().ToList();
+            //Assert
+            tokens.Should().NotBeNull();
+            tokens.Count.Should().Be(countExcepted);
+            tokens.First().Text.Should().Be(first);
+            tokens.Last().Text.Should().Be(last);
+        }
+    }
+
+}
diff --git a/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs b/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs
index f14eea51..a489b741 100644
--- a/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs
+++ b/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs
@@ -124,14 +124,13 @@ public void Should_return_error_if_option_format_with_equals_is_not_correct()
             Assert.Equal(ErrorType.BadFormatTokenError, tokens.Last().Tag);
         }
 
-
         [Theory]
         [InlineData(new[] { "-a", "-" }, 2,"a","-")]
         [InlineData(new[] { "--file", "-" }, 2,"file","-")]
         [InlineData(new[] { "-f-" }, 2,"f", "-")]
         [InlineData(new[] { "--file=-" }, 2, "file", "-")]
         [InlineData(new[] { "-a", "--" }, 1, "a", "a")]
-        public void single_dash_as_a_value(string[] args, int countExcepted,string first,string last)
+        public void Single_dash_as_a_value(string[] args, int countExcepted,string first,string last)
         {
             //Arrange
             //Act
diff --git a/tests/CommandLine.Tests/Unit/GetoptParserTests.cs b/tests/CommandLine.Tests/Unit/GetoptParserTests.cs
new file mode 100644
index 00000000..cd2a1577
--- /dev/null
+++ b/tests/CommandLine.Tests/Unit/GetoptParserTests.cs
@@ -0,0 +1,284 @@
+using System;
+using Xunit;
+using FluentAssertions;
+using CommandLine.Core;
+using CommandLine.Tests.Fakes;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace CommandLine.Tests.Unit
+{
+    public class GetoptParserTests
+    {
+        public GetoptParserTests()
+        {
+        }
+
+        public class SimpleArgsData : TheoryData<string[], Simple_Options_WithExtraArgs>
+        {
+            public SimpleArgsData()
+            {
+                // Options and values can be mixed by default
+                Add(new string [] { "--stringvalue=foo", "-x", "256" },
+                    new Simple_Options_WithExtraArgs {
+                        IntSequence = Enumerable.Empty<int>(),
+                        ShortAndLong = null,
+                        StringValue = "foo",
+                        BoolValue = true,
+                        LongValue = 256,
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                Add(new string [] { "256", "--stringvalue=foo", "-x" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        IntSequence = Enumerable.Empty<int>(),
+                        BoolValue = true,
+                        LongValue = 256,
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                Add(new string [] {"--stringvalue=foo", "256", "-x" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        IntSequence = Enumerable.Empty<int>(),
+                        BoolValue = true,
+                        LongValue = 256,
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+
+                // Sequences end at first non-value arg even if they haven't yet consumed their max
+                Add(new string [] {"--stringvalue=foo", "-i1", "2", "3", "-x", "256" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        IntSequence = new[] { 1, 2, 3 },
+                        BoolValue = true,
+                        LongValue = 256,
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                // Sequences also end after consuming their max even if there would be more parameters
+                Add(new string [] {"--stringvalue=foo", "-i1", "2", "3", "4", "256", "-x" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        IntSequence = new[] { 1, 2, 3, 4 },
+                        BoolValue = true,
+                        LongValue = 256,
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+
+                // The special -- option, if not consumed, turns off further option processing
+                Add(new string [] {"--stringvalue", "foo", "256", "-x", "-sbar" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = "bar",
+                        BoolValue = true,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                Add(new string [] {"--stringvalue", "foo", "--", "256", "-x", "-sbar" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        BoolValue = false,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = new [] { "-x", "-sbar" },
+                    });
+
+                // But if -- is specified as a value following an equal sign, it has no special meaning
+                Add(new string [] {"--stringvalue=--", "256", "-x", "-sbar" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "--",
+                        ShortAndLong = "bar",
+                        BoolValue = true,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+
+                // Options that take values will take the next arg whatever it looks like
+                Add(new string [] {"--stringvalue", "-x", "256" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "-x",
+                        BoolValue = false,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                Add(new string [] {"--stringvalue", "-x", "-x", "256" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "-x",
+                        BoolValue = true,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+
+                // That applies even if the next arg is -- which would normally stop option processing: if it's after an option that takes a value, it's consumed as the value
+                Add(new string [] {"--stringvalue", "--", "256", "-x", "-sbar" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "--",
+                        ShortAndLong = "bar",
+                        BoolValue = true,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+
+                // Options that take values will not swallow the next arg if a value was specified with =
+                Add(new string [] {"--stringvalue=-x", "256" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "-x",
+                        BoolValue = false,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                Add(new string [] {"--stringvalue=-x", "-x", "256" },
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "-x",
+                        BoolValue = true,
+                        LongValue = 256,
+                        IntSequence = Enumerable.Empty<int>(),
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+            }
+        }
+
+        [Theory]
+        [ClassData(typeof(SimpleArgsData))]
+        public void Getopt_parser_without_posixly_correct_allows_mixed_options_and_nonoptions(string[] args, Simple_Options_WithExtraArgs expected)
+        {
+            // Arrange
+            var sut = new Parser(config => {
+                config.GetoptMode = true;
+                config.PosixlyCorrect = false;
+            });
+
+            // Act
+            var result = sut.ParseArguments<Simple_Options_WithExtraArgs>(args);
+
+            // Assert
+            if (result is Parsed<Simple_Options_WithExtraArgs> parsed) {
+                parsed.Value.Should().BeEquivalentTo(expected);
+            } else if (result is NotParsed<Simple_Options_WithExtraArgs> notParsed) {
+                Console.WriteLine(String.Join(", ", notParsed.Errors.Select(err => err.Tag.ToString())));
+            }
+            result.Should().BeOfType<Parsed<Simple_Options_WithExtraArgs>>();
+            result.As<Parsed<Simple_Options_WithExtraArgs>>().Value.Should().BeEquivalentTo(expected);
+        }
+
+        public class SimpleArgsDataWithPosixlyCorrect : TheoryData<string[], Simple_Options_WithExtraArgs>
+        {
+            public SimpleArgsDataWithPosixlyCorrect()
+            {
+                Add(new string [] { "--stringvalue=foo", "-x", "256" },
+                    // Parses all options
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        IntSequence = Enumerable.Empty<int>(),
+                        BoolValue = true,
+                        LongValue = 256,
+                        ExtraArgs = Enumerable.Empty<string>(),
+                    });
+                Add(new string [] { "256", "--stringvalue=foo", "-x" },
+                    // Stops parsing after "256", so StringValue and BoolValue not set
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = null,
+                        ShortAndLong = null,
+                        IntSequence = Enumerable.Empty<int>(),
+                        BoolValue = false,
+                        LongValue = 256,
+                        ExtraArgs = new string[] { "--stringvalue=foo", "-x" },
+                    });
+                Add(new string [] {"--stringvalue=foo", "256", "-x" },
+                    // Stops parsing after "256", so StringValue is set but BoolValue is not
+                    new Simple_Options_WithExtraArgs {
+                        StringValue = "foo",
+                        ShortAndLong = null,
+                        IntSequence = Enumerable.Empty<int>(),
+                        BoolValue = false,
+                        LongValue = 256,
+                        ExtraArgs = new string[] { "-x" },
+                    });
+            }
+        }
+
+        [Theory]
+        [ClassData(typeof(SimpleArgsDataWithPosixlyCorrect))]
+        public void Getopt_parser_with_posixly_correct_stops_parsing_at_first_nonoption(string[] args, Simple_Options_WithExtraArgs expected)
+        {
+            // Arrange
+            var sut = new Parser(config => {
+                config.GetoptMode = true;
+                config.PosixlyCorrect = true;
+                config.EnableDashDash = true;
+            });
+
+            // Act
+            var result = sut.ParseArguments<Simple_Options_WithExtraArgs>(args);
+
+            // Assert
+            result.Should().BeOfType<Parsed<Simple_Options_WithExtraArgs>>();
+            result.As<Parsed<Simple_Options_WithExtraArgs>>().Value.Should().BeEquivalentTo(expected);
+        }
+
+        [Fact]
+        public void Getopt_mode_defaults_to_EnableDashDash_being_true()
+        {
+            // Arrange
+            var sut = new Parser(config => {
+                config.GetoptMode = true;
+                config.PosixlyCorrect = false;
+            });
+            var args = new string [] {"--stringvalue", "foo", "256", "--", "-x", "-sbar" };
+            var expected = new Simple_Options_WithExtraArgs {
+                    StringValue = "foo",
+                    ShortAndLong = null,
+                    BoolValue = false,
+                    LongValue = 256,
+                    IntSequence = Enumerable.Empty<int>(),
+                    ExtraArgs = new [] { "-x", "-sbar" },
+                };
+
+            // Act
+            var result = sut.ParseArguments<Simple_Options_WithExtraArgs>(args);
+
+            // Assert
+            result.Should().BeOfType<Parsed<Simple_Options_WithExtraArgs>>();
+            result.As<Parsed<Simple_Options_WithExtraArgs>>().Value.Should().BeEquivalentTo(expected);
+        }
+
+        [Fact]
+        public void Getopt_mode_can_have_EnableDashDash_expicitly_disabled()
+        {
+            // Arrange
+            var sut = new Parser(config => {
+                config.GetoptMode = true;
+                config.PosixlyCorrect = false;
+                config.EnableDashDash = false;
+            });
+            var args = new string [] {"--stringvalue", "foo", "256", "--", "-x", "-sbar" };
+            var expected = new Simple_Options_WithExtraArgs {
+                    StringValue = "foo",
+                    ShortAndLong = "bar",
+                    BoolValue = true,
+                    LongValue = 256,
+                    IntSequence = Enumerable.Empty<int>(),
+                    ExtraArgs = new [] { "--" },
+                };
+
+            // Act
+            var result = sut.ParseArguments<Simple_Options_WithExtraArgs>(args);
+
+            // Assert
+            result.Should().BeOfType<Parsed<Simple_Options_WithExtraArgs>>();
+            result.As<Parsed<Simple_Options_WithExtraArgs>>().Value.Should().BeEquivalentTo(expected);
+        }
+    }
+}
diff --git a/tests/CommandLine.Tests/Unit/ParserTests.cs b/tests/CommandLine.Tests/Unit/ParserTests.cs
index f8593cf3..b079ce0f 100644
--- a/tests/CommandLine.Tests/Unit/ParserTests.cs
+++ b/tests/CommandLine.Tests/Unit/ParserTests.cs
@@ -136,6 +136,7 @@ public void Parse_repeated_options_with_default_parser()
 
             // Verify outcome
             Assert.IsType<NotParsed<Options_With_Switches>>(result);
+            // NOTE: Once GetoptMode becomes the default, it will imply MultiInstance and the above check will fail because it will be Parsed.
             // Teardown
         }
 
@@ -298,6 +299,7 @@ public void Parse_repeated_options_with_default_parser_in_verbs_scenario()
 
             // Verify outcome
             Assert.IsType<NotParsed<object>>(result);
+            // NOTE: Once GetoptMode becomes the default, it will imply MultiInstance and the above check will fail because it will be Parsed.
             // Teardown
         }
 
@@ -973,6 +975,7 @@ public void Parse_repeated_options_in_verbs_scenario_with_multi_instance()
         [Fact]
         public void Parse_repeated_options_in_verbs_scenario_without_multi_instance()
         {
+            // NOTE: Once GetoptMode becomes the default, it will imply MultiInstance and this test will fail because the parser result will be Parsed.
             using (var sut = new Parser(settings => settings.AllowMultiInstance = false))
             {
                 var longVal1 = 100;