diff --git a/Directory.Packages.props b/Directory.Packages.props
index da1e624248..cf42c3fd4d 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -9,12 +9,12 @@
 
   <ItemGroup>
     <!-- Roslyn dependencies -->
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.0.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.14.0" />
     <!-- Runtime dependencies -->
     <PackageVersion Include="Microsoft.Bcl.Memory" Version="9.0.6" />
     <!-- external dependencies -->
     <PackageVersion Include="ApprovalTests" Version="7.0.0" />
-    <PackageVersion Include="BenchmarkDotNet" Version="0.13.1" />
+    <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageVersion Include="AwesomeAssertions" Version="8.1.0" />
     <PackageVersion Include="Microsoft.DotNet.PlatformAbstractions" Version="3.1.6" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
index f19908599f..d9c2d7f7d8 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -104,6 +104,14 @@
     public static Option<System.IO.DirectoryInfo> AcceptExistingOnly(this Option<System.IO.DirectoryInfo> option)
     public static Option<System.IO.FileSystemInfo> AcceptExistingOnly(this Option<System.IO.FileSystemInfo> option)
     public static Option<T> AcceptExistingOnly<T>(this Option<T> option)
+  public class ParsableArgument<T> : Argument<T>
+    .ctor(System.String name)
+  public class ParsableListArgument<T> : Argument<List<T>>
+    .ctor(System.String name)
+  public class ParsableListOption<T> : Option<List<T>>
+    .ctor(System.String name, System.String[] aliases)
+  public class ParsableOption<T> : Option<T>
+    .ctor(System.String name, System.String[] aliases)
   public class ParserConfiguration
     .ctor()
     public System.Boolean EnablePosixBundling { get; set; }
@@ -140,6 +148,10 @@
     .ctor(System.String description = )
     public System.Collections.Generic.IList<Directive> Directives { get; }
     public System.Void Add(Directive directive)
+  public class SpanParsableArgument<T> : Argument<T>
+    .ctor(System.String name)
+  public class SpanParsableOption<T> : Option<T>
+    .ctor(System.String name, System.String[] aliases)
   public abstract class Symbol
     public System.String Description { get; set; }
     public System.Boolean Hidden { get; set; }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
index 0aa02b9eb9..37030de962 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
@@ -13,24 +13,22 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_CustomScenarios
     {
         private string _testSymbolsAsString;
-        private CliCommand _rootCommand;
-        private CliConfiguration _configuration;
-
+        private Command _rootCommand;
+        
         [GlobalSetup(Target = nameof(OneOptWithNestedCommand_Parse))]
         public void SetupOneOptWithNestedCommand()
         {
-            _rootCommand = new CliCommand("root_command");
-            var nestedCommand = new CliCommand("nested_command");
-            var option = new CliOption<int>("-opt1") { DefaultValueFactory = (_) => 123 };
+            _rootCommand = new Command("root_command");
+            var nestedCommand = new Command("nested_command");
+            var option = new Option<int>("-opt1") { DefaultValueFactory = (_) => 123 };
             nestedCommand.Options.Add(option);
             _rootCommand.Subcommands.Add(nestedCommand);
 
             _testSymbolsAsString = "root_command nested_command -opt1 321";
-            _configuration = new CliConfiguration(_rootCommand);
         }
 
         [Benchmark]
         public ParseResult OneOptWithNestedCommand_Parse() 
-            => _rootCommand.Parse(_testSymbolsAsString, _configuration);
+            => _rootCommand.Parse(_testSymbolsAsString);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
index bec7003a94..a68a74dab3 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
@@ -13,28 +13,22 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Parser_Directives_Suggest
     {
-        private CliConfiguration _configuration;
+        public Command eatCommand;
 
         [GlobalSetup]
         public void Setup()
         {
-            CliOption<string> fruitOption = new("--fruit");
+            Option<string> fruitOption = new("--fruit");
             fruitOption.CompletionSources.Add("apple", "banana", "cherry");
 
-            CliOption<string> vegetableOption = new("--vegetable");
+            Option<string> vegetableOption = new("--vegetable");
             vegetableOption.CompletionSources.Add("asparagus", "broccoli", "carrot");
 
-            var eatCommand = new CliCommand("eat")
+            eatCommand = new Command("eat")
             {
                 fruitOption,
                 vegetableOption
             };
-
-            _configuration = new CliConfiguration(eatCommand)
-            {
-                Directives = { new SuggestDirective() },
-                Output = System.IO.TextWriter.Null
-            };
         }
 
         [Params(
@@ -45,7 +39,7 @@ public void Setup()
 
         [Benchmark]
         public Task InvokeSuggest()
-            => _configuration.InvokeAsync(TestCmdArgs);
+            => eatCommand.Parse(TestCmdArgs).InvokeAsync();
 
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
index 2faae64a67..d9f4702cab 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
@@ -13,8 +13,7 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_NestedCommands
     {
         private string _testSymbolsAsString;
-        private CliCommand _rootCommand;
-        private CliConfiguration _configuration;
+        private Command _rootCommand;
 
         /// <remarks>
         /// 1 - cmd-root
@@ -31,7 +30,7 @@ public class Perf_Parser_NestedCommands
         [Params(1, 2, 5)]
         public int TestCommandsDepth;
 
-        private void GenerateTestNestedCommands(CliCommand parent, int depth, int countPerLevel)
+        private void GenerateTestNestedCommands(Command parent, int depth, int countPerLevel)
         {
             if (depth == 0)
                 return;
@@ -39,7 +38,7 @@ private void GenerateTestNestedCommands(CliCommand parent, int depth, int countP
             for (int i = 0; i < countPerLevel; i++)
             {
                 string cmdName = $"{parent.Name}_{depth}.{i}";
-                CliCommand cmd = new(cmdName);
+                Command cmd = new(cmdName);
                 parent.Subcommands.Add(cmd);
                 GenerateTestNestedCommands(cmd, depth - 1, countPerLevel);
             }
@@ -49,12 +48,12 @@ private void GenerateTestNestedCommands(CliCommand parent, int depth, int countP
         public void SetupRootCommand()
         {
             string rootCommandName = "root";
-            var rootCommand = new CliCommand(rootCommandName);
+            var rootCommand = new Command(rootCommandName);
             _testSymbolsAsString = rootCommandName;
             GenerateTestNestedCommands(rootCommand, TestCommandsDepth, TestCommandsDepth);
 
             // Choose only one path from the commands tree for the test arguments string
-            CliCommand currentCmd = rootCommand;
+            Command currentCmd = rootCommand;
             while (currentCmd is not null && currentCmd.Subcommands.Count > 0)
             {
                 currentCmd = currentCmd.Subcommands[0];
@@ -62,10 +61,9 @@ public void SetupRootCommand()
             }
 
             _rootCommand = rootCommand;
-            _configuration = new CliConfiguration(rootCommand);
         }
 
         [Benchmark]
-        public ParseResult Parser_Parse() => CliParser.Parse(_rootCommand, _testSymbolsAsString, _configuration);
+        public ParseResult Parser_Parse() => _rootCommand.Parse(_testSymbolsAsString);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
index 12e241b92b..2bd06c4550 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
@@ -15,14 +15,14 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Parser_Options_Bare
     {
-        private IEnumerable<CliOption> _testSymbols;
+        private IEnumerable<Option> _testSymbols;
+        private Command _testCommand;
         private string _testSymbolsAsString;
-        private CliConfiguration _testConfiguration;
 
-        private IEnumerable<CliOption> GenerateTestOptions(int count, ArgumentArity arity)
+        private IEnumerable<Option> GenerateTestOptions(int count, ArgumentArity arity)
             => Enumerable.Range(0, count)
                          .Select(i =>
-                                     new CliOption<string>($"-option{i}")
+                                     new Option<string>($"-option{i}")
                                      {
                                          Arity = arity,
                                          Description = $"Description for -option {i} ...."
@@ -49,7 +49,7 @@ public void SetupTestOptions()
         }
 
         [Benchmark]
-        public CliConfiguration ParserFromOptions_Ctor()
+        public Command ParserFromOptions_Ctor()
         {
             return _testSymbols.CreateConfiguration();
         }
@@ -58,11 +58,11 @@ public CliConfiguration ParserFromOptions_Ctor()
         public void SetupParserFromOptions_Parse()
         {
             var testSymbolsArr = GenerateTestOptions(TestSymbolsCount, ArgumentArity.Zero).ToArray();
-            _testConfiguration = testSymbolsArr.CreateConfiguration();
+            _testCommand = testSymbolsArr.CreateConfiguration();
             _testSymbolsAsString = GenerateTestOptionsAsStringExpr(testSymbolsArr.Length);
         }
 
         [Benchmark]
-        public ParseResult ParserFromOptions_Parse() => _testConfiguration.Parse(_testSymbolsAsString);
+        public ParseResult ParserFromOptions_Parse() => _testCommand.Parse(_testSymbolsAsString);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
index 5d754c84a2..3e5af4e22b 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
@@ -16,11 +16,11 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_Options_With_Arguments
     {
         private string _testSymbolsAsString;
-        private CliConfiguration _configuration;
+        private Command _command;
 
-        private IEnumerable<CliOption> GenerateTestOptions(int count, ArgumentArity arity)
+        private IEnumerable<Option> GenerateTestOptions(int count, ArgumentArity arity)
             => Enumerable.Range(0, count)
-                         .Select(i => new CliOption<string>($"-option{i}")
+                         .Select(i => new Option<string>($"-option{i}")
                              {
                                  Arity = arity,
                                  Description = $"Description for -option {i} ...."
@@ -54,11 +54,11 @@ private string GenerateTestOptionsWithArgumentsAsStringExpr(int optionsCount, in
         public void SetupParserFromOptionsWithArguments_Parse()
         {
             var testSymbolsArr = GenerateTestOptions(TestOptionsCount, ArgumentArity.OneOrMore).ToArray();
-            _configuration = testSymbolsArr.CreateConfiguration();
+            _command = testSymbolsArr.CreateConfiguration();
             _testSymbolsAsString = GenerateTestOptionsWithArgumentsAsStringExpr(testSymbolsArr.Length, TestArgumentsCount);
         }
 
         [Benchmark]
-        public ParseResult ParserFromOptionsWithArguments_Parse() => _configuration.Parse(_testSymbolsAsString);
+        public ParseResult ParserFromOptionsWithArguments_Parse() => _command.Parse(_testSymbolsAsString);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_ParsedArgument.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_ParsedArgument.cs
new file mode 100644
index 0000000000..5a8ab2086b
--- /dev/null
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_ParsedArgument.cs
@@ -0,0 +1,56 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.CommandLine.Benchmarks.Helpers;
+using System.CommandLine.Parsing;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace System.CommandLine.Benchmarks.CommandLine
+{
+    /// <summary>
+    /// Measures the performance of <see cref="CliParser"/> when parsing options with arguments.
+    /// </summary>
+    [BenchmarkCategory(Categories.CommandLine)]
+    public class Perf_Parser_Options_With_Parsed_Arguments
+    {
+        private string _testSymbolsAsString;
+        private Command _command;
+
+        private IEnumerable<Option> GenerateTestOptions(int count)
+            => Enumerable.Range(0, count)
+                         .Select(i => new Option<DateOnly>($"-option{i}")
+                             {
+                                 Arity = ArgumentArity.ExactlyOne,
+                                 Description = $"Description for -option {i} ...."
+                             }
+                         );
+
+        /// <remarks>
+        /// For optionsCount: 5, argumentsCount: 5 will return:
+        /// -option0 arg0..arg4 -option1 arg0..arg4 ... -option4 arg0..arg4
+        /// </remarks>
+        private string GenerateTestOptionsWithArgumentsAsStringExpr(int optionsCount)
+        {
+            return Enumerable
+                .Range(0, optionsCount)
+                .Select(i => $"-option{i} 2022/02/02 ")
+                .Aggregate("", (ac, next) => ac + " " + next);
+        }
+
+        [Params(1, 5, 20, 50, 100)]
+        public int TestOptionsCount;
+
+        [GlobalSetup(Target = nameof(ParserFromOptionsWithArguments_Parse))]
+        public void SetupParserFromOptionsWithArguments_Parse()
+        {
+            var testSymbolsArr = GenerateTestOptions(TestOptionsCount).ToArray();
+            _command = testSymbolsArr.CreateConfiguration();
+            _testSymbolsAsString = GenerateTestOptionsWithArgumentsAsStringExpr(testSymbolsArr.Length);
+        }
+
+        [Benchmark]
+        public ParseResult ParserFromOptionsWithArguments_Parse() => _command.Parse(_testSymbolsAsString);
+    }
+}
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_ParsedArgument_Variants.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_ParsedArgument_Variants.cs
new file mode 100644
index 0000000000..3a342f9b9d
--- /dev/null
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_ParsedArgument_Variants.cs
@@ -0,0 +1,77 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.CommandLine.Benchmarks.Helpers;
+using System.CommandLine.Parsing;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace System.CommandLine.Benchmarks.CommandLine
+{
+    internal enum Kind { Default, Parseable, SpanParseable }
+
+    /// <summary>
+    /// Measures the performance of <see cref="CliParser"/> when parsing options with arguments.
+    /// </summary>
+    [BenchmarkCategory(Categories.CommandLine)]
+    public class Perf_Parser_Options_With_Parsed_Arguments_Variants
+    {
+        private string _testSymbolsAsString;
+        private Command _defaultCommand;
+        private RootCommand _parseableCommand;
+        private RootCommand _spanParseableCommand;
+
+        private IEnumerable<Option> GenerateTestOptions(int count, Kind kind)
+            => Enumerable.Range(0, count)
+                         .Select(i =>
+                            kind switch
+                            {
+                                Kind.Default => new Option<DateOnly>($"-option{i}")
+                                {
+                                    Arity = ArgumentArity.ExactlyOne,
+                                    Description = $"Description for -option {i} ...."
+                                },
+                                Kind.Parseable => new ParsableOption<DateOnly>($"-option{i}")
+                                {
+                                    Arity = ArgumentArity.ExactlyOne,
+                                    Description = $"Description for -option {i} ...."
+                                },
+                                Kind.SpanParseable => new SpanParsableOption<DateOnly>($"-option{i}")
+                            }
+                         );
+
+        /// <remarks>
+        /// For optionsCount: 5, argumentsCount: 5 will return:
+        /// -option0 arg0..arg4 -option1 arg0..arg4 ... -option4 arg0..arg4
+        /// </remarks>
+        private string GenerateTestOptionsWithArgumentsAsStringExpr(int optionsCount)
+        {
+            return Enumerable
+                .Range(0, optionsCount)
+                .Select(i => $"-option{i} 2022/02/02 ")
+                .Aggregate("", (ac, next) => ac + " " + next);
+        }
+
+        [Params(1, 5, 20, 50, 100)]
+        public int TestOptionsCount;
+
+        [GlobalSetup]
+        public void SetupParserFromOptionsWithArguments_Parse()
+        {
+            _defaultCommand = GenerateTestOptions(TestOptionsCount, Kind.Default).ToArray().CreateConfiguration();
+            _parseableCommand = GenerateTestOptions(TestOptionsCount, Kind.Parseable).ToArray().CreateConfiguration();
+            _spanParseableCommand = GenerateTestOptions(TestOptionsCount, Kind.SpanParseable).ToArray().CreateConfiguration();
+            _testSymbolsAsString = GenerateTestOptionsWithArgumentsAsStringExpr(TestOptionsCount);
+        }
+
+        [Benchmark]
+        public ParseResult Default() => _defaultCommand.Parse(_testSymbolsAsString);
+
+        [Benchmark]
+        public ParseResult Parseable() => _parseableCommand.Parse(_testSymbolsAsString);
+
+        [Benchmark]
+        public ParseResult SpanParseable() => _spanParseableCommand.Parse(_testSymbolsAsString);
+    }
+}
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
index e6e926ae97..71145b6bf3 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
@@ -18,19 +18,15 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Parser_ParseResult
     {
-        private readonly CliConfiguration _configuration;
+        private readonly Command _command;
         private readonly StringWriter _output;
 
         public Perf_Parser_ParseResult()
         {
             _output = new StringWriter();
-            var option = new CliOption<bool>("-opt");
+            var option = new Option<bool>("-opt");
 
-            _configuration = new CliConfiguration(new CliRootCommand { option })
-            {
-                Directives = { new DiagramDirective() },
-                Output = _output
-            };
+            _command = new RootCommand { option };
         }
 
         public IEnumerable<string> GenerateTestInputs() 
@@ -45,12 +41,12 @@ public IEnumerable<string> GenerateTestInputs()
 
         public IEnumerable<object> GenerateTestParseResults()
             => GenerateTestInputs()
-               .Select(input => new BdnParam<ParseResult>(_configuration.Parse(input), input));
+               .Select(input => new BdnParam<ParseResult>(_command.Parse(input), input));
 
         [Benchmark]
         [ArgumentsSource(nameof(GenerateTestInputs))]
         public ParseResult ParseResult_Directives(string input)
-            => _configuration.Parse(input);
+            => _command.Parse(input);
 
         [Benchmark]
         [ArgumentsSource(nameof(GenerateTestParseResults))]
@@ -61,7 +57,10 @@ public string ParseResult_Diagram(BdnParam<ParseResult> parseResult)
             // clear the contents, so each benchmark has the same starting state
             stringBuilder.Clear();
 
-            ((SynchronousCliAction)parseResult.Value.Action)!.Invoke(parseResult.Value);
+            parseResult.Value.Invoke(new InvocationConfiguration
+            {
+                Output = _output,
+            });
 
             return stringBuilder.ToString();
         }
@@ -75,7 +74,10 @@ public async Task<string> ParseResult_DiagramAsync(BdnParam<ParseResult> parseRe
             // clear the contents, so each benchmark has the same starting state
             stringBuilder.Clear();
 
-            await ((AsynchronousCliAction)parseResult.Value.Action!).InvokeAsync(parseResult.Value);
+            await parseResult.Value.InvokeAsync(new InvocationConfiguration
+            {
+                Output = _output,
+            });
 
             return stringBuilder.ToString();
         }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs
index 100d2ad772..3cfbddd9ad 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs
@@ -9,6 +9,12 @@ public class Perf_Parser_Simple
         [Params(new string[0], new string[4] { "--bool", "true", "-s", "test" })]
         public string[] Args { get; set; }
 
+        private InvocationConfiguration _minimalInvocationConfig = new()
+        {
+            EnableDefaultExceptionHandler = false,
+            ProcessTerminationTimeout = null
+        };
+
         [Benchmark]
         public int DefaultsSync() => BuildCommand().Parse(Args).Invoke();
 
@@ -16,38 +22,34 @@ public class Perf_Parser_Simple
         public Task<int> DefaultsAsync() => BuildCommand().Parse(Args).InvokeAsync();
 
         [Benchmark]
-        public int MinimalSync() => BuildMinimalConfig(BuildCommand()).Invoke(Args);
+        public int MinimalSync() => BuildCommand(minimal: true).Parse(Args).Invoke();
 
         [Benchmark]
-        public Task<int> MinimalAsync() => BuildMinimalConfig(BuildCommand()).InvokeAsync(Args);
+        public Task<int> MinimalAsync() => BuildCommand(minimal: true).Parse(Args).InvokeAsync(_minimalInvocationConfig);
 
-        private static CliRootCommand BuildCommand()
+        private static RootCommand BuildCommand(bool minimal = true)
         {
-            CliOption<bool> boolOption = new("--bool", "-b") { Description = "Bool option" };
-            CliOption<string> stringOption = new("--string", "-s") { Description = "String option" };
+            Option<bool> boolOption = new("--bool", "-b") { Description = "Bool option" };
+            Option<string> stringOption = new("--string", "-s") { Description = "String option" };
 
-            CliRootCommand command = new()
+            RootCommand command = new()
             {
                 boolOption,
                 stringOption
             };
 
-            command.SetAction(parseResult => 
+            command.SetAction(parseResult =>
             {
                 bool boolean = parseResult.GetValue(boolOption);
                 string text = parseResult.GetValue(stringOption);
             });
 
-            return command;
-        }
+            if (minimal)
+            {
+                command.Directives.Clear();
+            }
 
-        private static CliConfiguration BuildMinimalConfig(CliCommand command)
-        {
-            CliConfiguration config = new(command);
-            config.Directives.Clear();
-            config.EnableDefaultExceptionHandler = false;
-            config.ProcessTerminationTimeout = null;
-            return config;
+            return command;
         }
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
index 90a7350f25..e3ea0698ce 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
@@ -15,16 +15,13 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Parser_TypoCorrection
     {
-        private readonly CliConfiguration _configuration;
+        private readonly Command _command;
 
         public Perf_Parser_TypoCorrection()
         {
-            var option = new CliOption<bool>("--0123456789");
+            var option = new Option<bool>("--0123456789");
 
-            _configuration = new CliConfiguration(new CliRootCommand { option })
-            {
-                Output = System.IO.TextWriter.Null
-            };
+            _command = new RootCommand { option };
         }
 
         public IEnumerable<BdnParam<ParseResult>> GenerateTestParseResults()
@@ -48,7 +45,7 @@ public IEnumerable<BdnParam<ParseResult>> GenerateTestParseResults()
                     "--1023546798",
                     "--1032546798"
                 }
-                .Select(opt => new BdnParam<ParseResult>(_configuration.Parse(opt), opt));
+                .Select(opt => new BdnParam<ParseResult>(_command.Parse(opt), opt));
 
         [Benchmark]
         [ArgumentsSource(nameof(GenerateTestParseResults))]
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
index 9cd3b91fb6..d51c247476 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
@@ -15,7 +15,7 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Suggestions
     {
-        private CliOption _testSymbol;
+        private Option _testSymbol;
         private ParseResult _testParseResult;
 
         /// <remarks>
@@ -27,9 +27,9 @@ private string[] GenerateSuggestionsArray(int count)
                          .Select(i => $"suggestion{i}")
                          .ToArray();
 
-        private IEnumerable<CliOption> GenerateOptionsArray(int count)
+        private IEnumerable<Option> GenerateOptionsArray(int count)
             => Enumerable.Range(0, count)
-                         .Select(i => new CliOption<string>($"suggestion{i}"));
+                         .Select(i => new Option<string>($"suggestion{i}"));
 
         [Params(1, 5, 20, 100)]
         public int TestSuggestionsCount;
@@ -37,7 +37,7 @@ private IEnumerable<CliOption> GenerateOptionsArray(int count)
         [GlobalSetup(Target = nameof(SuggestionsFromSymbol))]
         public void Setup_FromSymbol()
         {
-            _testSymbol = new CliOption<string>("--hello");
+            _testSymbol = new Option<string>("--hello");
             _testSymbol.CompletionSources.Add(GenerateSuggestionsArray(TestSuggestionsCount));
         }
 
@@ -50,7 +50,7 @@ public void SuggestionsFromSymbol()
         [GlobalSetup(Target = nameof(SuggestionsFromParseResult))]
         public void Setup_FromParseResult()
         {
-            var testCommand = new CliCommand("command");
+            var testCommand = new Command("command");
 
             foreach (var option in GenerateOptionsArray(TestSuggestionsCount))
             {
diff --git a/src/System.CommandLine.Benchmarks/Helpers/NullStreamWriter.cs b/src/System.CommandLine.Benchmarks/Helpers/NullStreamWriter.cs
deleted file mode 100644
index 256e3791e2..0000000000
--- a/src/System.CommandLine.Benchmarks/Helpers/NullStreamWriter.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using System.CommandLine.IO;
-
-namespace System.CommandLine.Benchmarks.Helpers
-{
-    internal class NullStreamWriter : IStandardStreamWriter
-    {
-        public void Write(string value)
-        {
-            // do nothing
-        }
-    }
-}
diff --git a/src/System.CommandLine.Benchmarks/Helpers/Utils.cs b/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
index 8e17111e67..835c43309f 100644
--- a/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
+++ b/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
@@ -44,16 +44,16 @@ internal static string CreateTestAssemblyInTempFileFromString(string sourceCode,
             return pathToAssemblyFile;
         }
 
-        public static CliConfiguration CreateConfiguration(this IEnumerable<CliOption> symbols)
+        public static RootCommand CreateConfiguration(this IEnumerable<Option> symbols)
         {
-            var rootCommand = new CliRootCommand();
+            var rootCommand = new RootCommand();
 
             foreach (var symbol in symbols)
             {
                 rootCommand.Add(symbol);
             }
 
-            return new CliConfiguration(rootCommand);
+            return rootCommand;
         }
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/RecommendedConfig.cs b/src/System.CommandLine.Benchmarks/RecommendedConfig.cs
index 622002973e..1b2362fd8d 100644
--- a/src/System.CommandLine.Benchmarks/RecommendedConfig.cs
+++ b/src/System.CommandLine.Benchmarks/RecommendedConfig.cs
@@ -15,22 +15,17 @@ namespace System.CommandLine.Benchmarks
 {
     public static class RecommendedConfig
     {
-#pragma warning disable CA1801 // Review unused parameters
         public static IConfig Create(DirectoryInfo artifactsPath, ImmutableHashSet<string> mandatoryCategories)
-#pragma warning restore CA1801 // Review unused parameters
-#pragma warning disable CA1062 // Validate arguments of public methods
             => DefaultConfig.Instance
-                .With(Job.Default
+                .AddJob(Job.Default
                     .WithWarmupCount(1)
                     .WithIterationTime(TimeInterval.FromMilliseconds(250))
                     .WithMinIterationCount(15)
                     .WithMaxIterationCount(20)
                     .AsDefault())
                 .WithArtifactsPath(artifactsPath.FullName)
-                .With(MemoryDiagnoser.Default)
-                .With(JsonExporter.Full)
-                .With(StatisticColumn.Median, StatisticColumn.Min, StatisticColumn.Max)
-                .WithSummaryStyle(SummaryStyle.Default.WithSizeUnit(SizeUnit.B));
-#pragma warning restore CA1062 // Validate arguments of public methods
+                .AddDiagnoser(MemoryDiagnoser.Default)
+                .AddExporter(JsonExporter.Full)
+                .AddColumn(StatisticColumn.Median, StatisticColumn.Min, StatisticColumn.Max);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj b/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj
index 2fb608e5a7..b94fa943f2 100644
--- a/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj
+++ b/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>$(NetMinimum)</TargetFramework>
+    <TargetFrameworks>$(NetMinimum);net9.0;net10.0</TargetFrameworks>
     <OutputType>Exe</OutputType>
   </PropertyGroup>
 
diff --git a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
index 454942a873..09bd147027 100644
--- a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
+++ b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
@@ -10,9 +10,11 @@
 using System.Net;
 using FluentAssertions.Execution;
 using Xunit;
+using System.Reflection;
 
 namespace System.CommandLine.Tests.Binding
 {
+    // need to test these across all versions of Options and arguments
     public class TypeConversionTests
     {
         protected T GetValue<T>(Option<T> option, string commandLine)
@@ -40,6 +42,18 @@ public void Option_argument_of_FileInfo_can_be_bound_without_custom_conversion_l
                   .Be("the-file.txt");
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForFileInfo))]
+        public void Option_argument_of_FileInfo_can_be_bound_across_option_variants(string variant)
+        {
+            var file = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "the-file.txt"));
+            var option = CreateOptionVariant<FileInfo>("--file", variant);
+            GetValue(option, $"--file {file.FullName}")
+                  .Name
+                  .Should()
+                  .Be("the-file.txt");
+        }
+
         [Fact]
         public void Command_argument_of_FileInfo_can_be_bound_without_custom_conversion_logic()
         {
@@ -59,6 +73,17 @@ public void Command_argument_of_FileInfo_can_be_bound_without_custom_conversion_
                   .Be("the-file.txt");
         }
 
+        [Theory]
+        [MemberData(nameof(ArgumentVariantLabelsForFileInfo))]
+        public void Command_argument_of_FileInfo_can_be_bound_across_argument_variants(string variant)
+        {
+            var file = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "the-file.txt"));
+            var argument = CreateArgumentVariant<FileInfo>("the-arg", variant);
+            var command = new Command("the-command") { argument };
+            var result = command.Parse($"{file.FullName}");
+            result.GetValue(argument).Name.Should().Be("the-file.txt");
+        }
+
         [Fact]
         public void Command_argument_of_FileInfo_returns_null_when_argument_is_not_provided()
         {
@@ -115,6 +140,14 @@ public void Argument_defaults_arity_to_One_for_non_IEnumerable_types()
             argument.Arity.Should().BeEquivalentTo(ArgumentArity.ExactlyOne);
         }
 
+        [Theory]
+        [MemberData(nameof(ArgumentVariantLabelsForInt))]
+        public void Argument_defaults_arity_to_One_for_non_IEnumerable_types_across_variants(string variant)
+        {
+            var argument = CreateArgumentVariant<int>("arg", variant);
+            argument.Arity.Should().BeEquivalentTo(ArgumentArity.ExactlyOne);
+        }
+
         [Fact]
         public void Argument_defaults_arity_to_ExactlyOne_for_string()
         {
@@ -134,6 +167,15 @@ public void Command_Argument_defaults_arity_to_ZeroOrOne_for_nullable_types()
             command.Arguments.Single().Arity.Should().BeEquivalentTo(ArgumentArity.ZeroOrOne);
         }
 
+        [Theory]
+        [MemberData(nameof(ArgumentVariantLabelsForNullableInt))]
+        public void Command_Argument_defaults_arity_to_ZeroOrOne_for_nullable_types_across_variants(string variant)
+        {
+            var argument = CreateArgumentVariant<int?>("arg", variant);
+            var command = new Command("the-command") { argument };
+            command.Arguments.Single().Arity.Should().BeEquivalentTo(ArgumentArity.ZeroOrOne);
+        }
+
         [Theory]
         [InlineData(typeof(int[]))]
         [InlineData(typeof(IEnumerable<int>))]
@@ -204,7 +246,7 @@ public void Nullable_bool_with_unparseable_argument_does_not_throw()
             rootCommand.Options.Add(option);
             var result = rootCommand.Parse("--test ouch");
 
-            result.Invoking(r =>  r.GetValue(option))
+            result.Invoking(r => r.GetValue(option))
                   .Should().NotThrow();
         }
 
@@ -485,6 +527,16 @@ public void Values_can_be_correctly_converted_to_DateTime_without_the_parser_spe
             GetValue(option, $"-x {dateString}").Should().Be(DateTime.Parse(dateString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForDateTime))]
+        public void Values_can_be_correctly_converted_to_DateTime_across_option_variants(string variant)
+        {
+            var dateString = "2022-02-06T01:46:03.0000000-08:00";
+            var expected = DateTime.Parse(dateString);
+            var option = CreateOptionVariant<DateTime>("-x", variant);
+            GetValue(option, $"-x {dateString}").Should().Be(expected);
+        }
+
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_DateTime_without_the_parser_specifying_a_custom_converter()
@@ -496,6 +548,16 @@ public void Values_can_be_correctly_converted_to_nullable_DateTime_without_the_p
             GetValue(option, $"-x {dateString}").Should().Be(DateTime.Parse(dateString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableDateTime))]
+        public void Values_can_be_correctly_converted_to_nullable_DateTime_across_option_variants(string variant)
+        {
+            var dateString = "2022-02-06T01:46:03.0000000-08:00";
+            var expected = DateTime.Parse(dateString);
+            var option = CreateOptionVariant<DateTime?>("-x", variant);
+            GetValue(option, $"-x {dateString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_DateTimeOffset_without_the_parser_specifying_a_custom_converter()
         {
@@ -506,6 +568,16 @@ public void Values_can_be_correctly_converted_to_DateTimeOffset_without_the_pars
             GetValue(option, $"-x {dateString}").Should().Be(DateTime.Parse(dateString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForDateTimeOffset))]
+        public void Values_can_be_correctly_converted_to_DateTimeOffset_across_option_variants(string variant)
+        {
+            var dateString = "2022-02-06T09:52:54.5275055-08:00";
+            var expected = DateTime.Parse(dateString);
+            var option = CreateOptionVariant<DateTimeOffset>("-x", variant);
+            GetValue(option, $"-x {dateString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_DateTimeOffset_without_the_parser_specifying_a_custom_converter()
         {
@@ -516,30 +588,88 @@ public void Values_can_be_correctly_converted_to_nullable_DateTimeOffset_without
             GetValue(option, $"-x {dateString}").Should().Be(DateTime.Parse(dateString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableDateTimeOffset))]
+        public void Values_can_be_correctly_converted_to_nullable_DateTimeOffset_across_option_variants(string variant)
+        {
+            var dateString = "2022-02-06T09:52:54.5275055-08:00";
+            var expected = DateTime.Parse(dateString);
+            var option = CreateOptionVariant<DateTimeOffset?>("-x", variant);
+            GetValue(option, $"-x {dateString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_decimal_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<decimal>("-x"), "-x 123.456").Should().Be(123.456m);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForDecimal))]
+        public void Values_can_be_correctly_converted_to_decimal_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<decimal>("-x", variant);
+            GetValue(option, "-x 123.456").Should().Be(123.456m);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_decimal_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<decimal?>("-x"), "-x 123.456").Should().Be(123.456m);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableDecimal))]
+        public void Values_can_be_correctly_converted_to_nullable_decimal_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<decimal?>("-x", variant);
+            GetValue(option, "-x 123.456").Should().Be(123.456m);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_double_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<double>("-x"), "-x 123.456").Should().Be(123.456d);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForDouble))]
+        public void Values_can_be_correctly_converted_to_double_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<double>("-x", variant);
+            GetValue(option, "-x 123.456").Should().Be(123.456d);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_double_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<double?>("-x"), "-x 123.456").Should().Be(123.456d);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableDouble))]
+        public void Values_can_be_correctly_converted_to_nullable_double_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<double?>("-x", variant);
+            GetValue(option, "-x 123.456").Should().Be(123.456d);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_float_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<float>("-x"), "-x 123.456").Should().Be(123.456f);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForFloat))]
+        public void Values_can_be_correctly_converted_to_float_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<float>("-x", variant);
+            GetValue(option, "-x 123.456").Should().Be(123.456f);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_float_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<float?>("-x"), "-x 123.456").Should().Be(123.456f);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableFloat))]
+        public void Values_can_be_correctly_converted_to_nullable_float_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<float?>("-x", variant);
+            GetValue(option, "-x 123.456").Should().Be(123.456f);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_Guid_without_the_parser_specifying_a_custom_converter()
         {
@@ -548,6 +678,16 @@ public void Values_can_be_correctly_converted_to_Guid_without_the_parser_specify
             GetValue(new Option<Guid>("-x"), $"-x {guidString}").Should().Be(Guid.Parse(guidString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForGuid))]
+        public void Values_can_be_correctly_converted_to_Guid_across_option_variants(string variant)
+        {
+            const string guidString = "75517282-018F-46BB-B15F-1D8DBFE23F6E";
+            var expected = Guid.Parse(guidString);
+            var option = CreateOptionVariant<Guid>("-x", variant);
+            GetValue(option, $"-x {guidString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_Guid_without_the_parser_specifying_a_custom_converter()
         {
@@ -556,6 +696,16 @@ public void Values_can_be_correctly_converted_to_nullable_Guid_without_the_parse
             GetValue(new Option<Guid?>("-x"), $"-x {guidString}").Should().Be(Guid.Parse(guidString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableGuid))]
+        public void Values_can_be_correctly_converted_to_nullable_Guid_across_option_variants(string variant)
+        {
+            const string guidString = "75517282-018F-46BB-B15F-1D8DBFE23F6E";
+            var expected = Guid.Parse(guidString);
+            var option = CreateOptionVariant<Guid?>("-x", variant);
+            GetValue(option, $"-x {guidString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_TimeSpan_without_the_parser_specifying_a_custom_converter()
         {
@@ -564,6 +714,16 @@ public void Values_can_be_correctly_converted_to_TimeSpan_without_the_parser_spe
             GetValue(new Option<TimeSpan>("-x"), $"-x {timeSpanString}").Should().Be(TimeSpan.Parse(timeSpanString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForTimeSpan))]
+        public void Values_can_be_correctly_converted_to_TimeSpan_across_option_variants(string variant)
+        {
+            const string timeSpanString = "30";
+            var expected = TimeSpan.Parse(timeSpanString);
+            var option = CreateOptionVariant<TimeSpan>("-x", variant);
+            GetValue(option, $"-x {timeSpanString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_TimeSpan_without_the_parser_specifying_a_custom_converter()
         {
@@ -572,10 +732,20 @@ public void Values_can_be_correctly_converted_to_nullable_TimeSpan_without_the_p
             GetValue(new Option<TimeSpan?>("-x"), $"-x {timeSpanString}").Should().Be(TimeSpan.Parse(timeSpanString));
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableTimeSpan))]
+        public void Values_can_be_correctly_converted_to_nullable_TimeSpan_across_option_variants(string variant)
+        {
+            const string timeSpanString = "30";
+            var expected = TimeSpan.Parse(timeSpanString);
+            var option = CreateOptionVariant<TimeSpan?>("-x", variant);
+            GetValue(option, $"-x {timeSpanString}").Should().Be(expected);
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_Uri_when_custom_parser_is_provided()
         {
-            Option<Uri> option = new ("-x")
+            Option<Uri> option = new("-x")
             {
                 CustomParser = (argumentResult) => Uri.TryCreate(argumentResult.Tokens.Last().Value, UriKind.RelativeOrAbsolute, out var uri) ? uri : null
             };
@@ -591,6 +761,16 @@ public void Options_with_arguments_specified_can_be_correctly_converted_to_bool_
             GetValue(new Option<bool>("-x"), "-x true").Should().BeTrue();
         }
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForBool))]
+        public void Options_with_arguments_specified_can_be_correctly_converted_to_bool_across_variants(string variant)
+        {
+            using var _ = new AssertionScope();
+            var option = CreateOptionVariant<bool>("-x", variant);
+            GetValue(option, "-x false").Should().BeFalse();
+            GetValue(option, "-x true").Should().BeTrue();
+        }
+
         [Fact]
         public void Values_can_be_correctly_converted_to_long_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<long>("-x"), "-x 123456790").Should().Be(123456790L);
@@ -634,8 +814,8 @@ public void Values_can_be_correctly_converted_to_nullable_sbyte_without_the_pars
         [Fact]
         public void Values_can_be_correctly_converted_to_ipaddress_when_custom_parser_is_provided()
         {
-            Option<IPAddress> option = new ("-us")
-            { 
+            Option<IPAddress> option = new("-us")
+            {
                 CustomParser = (argumentResult) => IPAddress.Parse(argumentResult.Tokens.Last().Value)
             };
 
@@ -736,7 +916,7 @@ public void Max_arity_greater_than_1_converts_to_enumerable_types(
 
         [Fact]
         public void Values_can_be_correctly_converted_to_List_of_int_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<List<int>>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(new[] {1, 2, 3});
+            => GetValue(new Option<List<int>>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(new[] { 1, 2, 3 });
 
         [Fact]
         public void Values_can_be_correctly_converted_to_IEnumerable_of_int_without_the_parser_specifying_a_custom_converter()
@@ -746,10 +926,133 @@ public void Values_can_be_correctly_converted_to_IEnumerable_of_int_without_the_
         public void Enum_values_can_be_correctly_converted_based_on_enum_value_name_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<DayOfWeek>("-x"), "-x Monday").Should().Be(DayOfWeek.Monday);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForDayOfWeek))]
+        public void Enum_values_can_be_correctly_converted_based_on_enum_value_name_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<DayOfWeek>("-x", variant);
+            GetValue(option, "-x Monday").Should().Be(DayOfWeek.Monday);
+        }
+
         [Fact]
         public void Nullable_enum_values_can_be_correctly_converted_based_on_enum_value_name_without_the_parser_specifying_a_custom_converter()
             => GetValue(new Option<DayOfWeek?>("-x"), "-x Monday").Should().Be(DayOfWeek.Monday);
 
+        [Theory]
+        [MemberData(nameof(OptionVariantLabelsForNullableDayOfWeek))]
+        public void Nullable_enum_values_can_be_correctly_converted_based_on_enum_value_name_across_option_variants(string variant)
+        {
+            var option = CreateOptionVariant<DayOfWeek?>("-x", variant);
+            GetValue(option, "-x Monday").Should().Be(DayOfWeek.Monday);
+        }
+
+        // Helper factories + variant label providers
+        private static Option<T> CreateOptionVariant<T>(string name, string variant, params string[] aliases)
+        {
+            return variant switch
+            {
+                "Default" => new Option<T>(name, aliases),
+#if NET7_0_OR_GREATER
+                "SpanParsable" => CreateSpecializedOption<T>(name, aliases, "System.CommandLine.SpanParsableOption`1"),
+                "Parsable" => CreateSpecializedOption<T>(name, aliases, "System.CommandLine.ParsableOption`1"),
+#endif
+                _ => throw new ArgumentOutOfRangeException(nameof(variant), variant, null)
+            };
+        }
+
+        private static Argument<T> CreateArgumentVariant<T>(string name, string variant)
+        {
+            return variant switch
+            {
+                "Default" => new Argument<T>(name),
+#if NET7_0_OR_GREATER
+                "SpanParsable" => CreateSpecializedArgument<T>(name, "System.CommandLine.SpanParsableArgument`1"),
+                "Parsable" => CreateSpecializedArgument<T>(name, "System.CommandLine.ParsableArgument`1"),
+#endif
+                _ => throw new ArgumentOutOfRangeException(nameof(variant), variant, null)
+            };
+        }
+
+#if NET7_0_OR_GREATER
+        private static Option<T> CreateSpecializedOption<T>(string name, string[] aliases, string qname)
+        {
+            var type = typeof(Option<>).Assembly.GetType(qname)!;
+            var closed = type.MakeGenericType(typeof(T));
+            return (Option<T>)Activator.CreateInstance(closed, new object[] { name, aliases })!;
+        }
+
+        private static Argument<T> CreateSpecializedArgument<T>(string name, string qname)
+        {
+            var type = typeof(Argument<>).Assembly.GetType(qname)!;
+            var closed = type.MakeGenericType(typeof(T));
+            return (Argument<T>)Activator.CreateInstance(closed, new object[] { name })!;
+        }
+
+        private static IEnumerable<object[]> VariantLabelsFor<T>()
+        {
+            yield return new object[] { "Default" };
+            var t = typeof(T);
+            if (Implements(t, typeof(ISpanParsable<>))) yield return new object[] { "SpanParsable" };
+            if (Implements(t, typeof(IParsable<>))) yield return new object[] { "Parsable" };
+        }
+#endif
+
+        public static IEnumerable<object[]> OptionVariantLabelsForFileInfo() => OptionVariantLabelsFor<FileInfo>();
+        public static IEnumerable<object[]> OptionVariantLabelsForDateTime() => OptionVariantLabelsFor<DateTime>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableDateTime() => OptionVariantLabelsFor<DateTime?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForDateTimeOffset() => OptionVariantLabelsFor<DateTimeOffset>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableDateTimeOffset() => OptionVariantLabelsFor<DateTimeOffset?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForDecimal() => OptionVariantLabelsFor<decimal>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableDecimal() => OptionVariantLabelsFor<decimal?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForDouble() => OptionVariantLabelsFor<double>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableDouble() => OptionVariantLabelsFor<double?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForFloat() => OptionVariantLabelsFor<float>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableFloat() => OptionVariantLabelsFor<float?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForGuid() => OptionVariantLabelsFor<Guid>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableGuid() => OptionVariantLabelsFor<Guid?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForTimeSpan() => OptionVariantLabelsFor<TimeSpan>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableTimeSpan() => OptionVariantLabelsFor<TimeSpan?>();
+        public static IEnumerable<object[]> OptionVariantLabelsForBool() => OptionVariantLabelsFor<bool>();
+        public static IEnumerable<object[]> OptionVariantLabelsForDayOfWeek() => OptionVariantLabelsFor<DayOfWeek>();
+        public static IEnumerable<object[]> OptionVariantLabelsForNullableDayOfWeek() => OptionVariantLabelsFor<DayOfWeek?>();
+
+        public static IEnumerable<object[]> ArgumentVariantLabelsForFileInfo() => ArgumentVariantLabelsFor<FileInfo>();
+        public static IEnumerable<object[]> ArgumentVariantLabelsForInt() => ArgumentVariantLabelsFor<int>();
+        public static IEnumerable<object[]> ArgumentVariantLabelsForNullableInt() => ArgumentVariantLabelsFor<int?>();
+
+        private static IEnumerable<object[]> OptionVariantLabelsFor<T>()
+        {
+#if NET7_0_OR_GREATER
+            foreach (var o in VariantLabelsFor<T>()) yield return o;
+#else
+            yield return new object[] { "Default" };
+#endif
+        }
+
+        private static IEnumerable<object[]> ArgumentVariantLabelsFor<T>()
+        {
+#if NET7_0_OR_GREATER
+            foreach (var o in VariantLabelsFor<T>()) yield return o;
+#else
+            yield return new object[] { "Default" };
+#endif
+        }
+
+#if NET7_0_OR_GREATER
+        private static bool Implements(Type t, Type openInterface)
+        {
+            if (!openInterface.IsInterface || !openInterface.IsGenericTypeDefinition) return false;
+            foreach (var i in t.GetInterfaces())
+            {
+                if (i.IsGenericType && i.GetGenericTypeDefinition() == openInterface && i.GenericTypeArguments[0] == t)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+#endif
+
         [Fact]
         public void Enum_values_that_cannot_be_parsed_result_in_an_informative_error()
         {
@@ -800,7 +1103,7 @@ public void When_getting_an_array_of_values_and_specifying_a_conversion_type_tha
         public void String_defaults_to_null_when_not_specified_only_for_not_required_arguments()
             => GetValue(
                 new Argument<string>("arg")
-                { 
+                {
                     Arity = ArgumentArity.ZeroOrMore
                 }, "").Should().BeNull();
 
@@ -829,5 +1132,40 @@ public void Sequence_type_defaults_to_empty_when_not_specified(Type sequenceType
 
         private void AssertParsedValueIsEmpty<T>(Argument<T> argument) where T : IEnumerable
             => GetValue(argument, "").Should().BeEquivalentTo(Enumerable.Empty<T>());
+
+#if NET7_0_OR_GREATER
+        [Fact]
+        public void Can_create_spanparseable_option_for_collection()
+        {
+            var o = new ParsableListOption<DateTime>("-x")
+            {
+                Arity = new ArgumentArity(1, 3)
+            };
+            GetValue(o, "-x 2020-01-01 -x 2020-01-02 -x 2020-01-03").Should().BeEquivalentTo(new[]
+            {
+                new DateTime(2020, 1, 1),
+                new DateTime(2020, 1, 2),
+                new DateTime(2020, 1, 3)
+            });
+        }
+#endif
+
+
+#if NET9_0_OR_GREATER
+        [Fact]
+        public void Can_create_spanparseable_option_for_collection()
+        {
+            var o = new SpanPar<DateTime>("-x")
+            {
+                Arity = new ArgumentArity(1, 3)
+            };
+            GetValue(o, "-x 2020-01-01 -x 2020-01-02 -x 2020-01-03").Should().BeEquivalentTo(new[]
+            {
+                new DateTime(2020, 1, 1),
+                new DateTime(2020, 1, 2),
+                new DateTime(2020, 1, 3)
+            });
+        }
+#endif
     }
 }
\ No newline at end of file
diff --git a/src/System.CommandLine/Argument.Specialized.cs b/src/System.CommandLine/Argument.Specialized.cs
new file mode 100644
index 0000000000..8123cd8bff
--- /dev/null
+++ b/src/System.CommandLine/Argument.Specialized.cs
@@ -0,0 +1,102 @@
+// Copyright (c) .NET Foundation and contributors.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.CommandLine.Binding;
+using System.CommandLine.Parsing;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+
+namespace System.CommandLine
+{
+
+#if NET7_0_OR_GREATER
+    public sealed class SpanParsableArgument<T> : Argument<T> where T : ISpanParsable<T>
+    {
+        public SpanParsableArgument(string name) : base(name)
+        {
+            ConvertArguments = (ArgumentResult result, out object? value) =>
+            {
+                var arg = result.Argument;
+                if (arg.Arity.MaximumNumberOfValues == 1 && result.Tokens.Count > 0)
+                {
+                    var text = result.Tokens[result.Tokens.Count - 1].Value;
+                    if (T.TryParse(text.AsSpan(), CultureInfo.CurrentCulture, out var parsed))
+                    {
+                        value = parsed;
+                        return true;
+                    }
+                    value = null;
+                    return false;
+                }
+
+                // Delegate to existing pipeline for multi-token scenarios
+                var success = ArgumentConverter.TryConvertArgument(result, out value);
+                return success;
+            };
+        }
+    }
+
+    public sealed class ParsableArgument<T> : Argument<T> where T : IParsable<T>
+    {
+        public ParsableArgument(string name) : base(name)
+        {
+            ConvertArguments = (ArgumentResult result, out object? value) =>
+            {
+                var arg = result.Argument;
+                if (arg.Arity.MaximumNumberOfValues == 1 && result.Tokens.Count > 0)
+                {
+                    var text = result.Tokens[result.Tokens.Count - 1].Value;
+                    if (T.TryParse(text, CultureInfo.CurrentCulture, out var parsed))
+                    {
+                        value = parsed;
+                        return true;
+                    }
+                    value = null;
+                    return false;
+                }
+
+                var success = ArgumentConverter.TryConvertArgument(result, out value);
+                return success;
+            };
+        }
+    }
+
+    public sealed class ParsableListArgument<T> : Argument<List<T>> where T : IParsable<T>
+    {
+        public ParsableListArgument(string name) : base(name)
+        {
+            ConvertArguments = (ArgumentResult result, out object? value) =>
+            {
+                var arg = result.Argument;
+                var list = new List<T>();
+                var addedError = false;
+                foreach (var token in result.Tokens)
+                {
+                    if (T.TryParse(token.Value, CultureInfo.CurrentCulture, out var parsed))
+                    {
+                        list.Add(parsed);
+                    }
+                    else
+                    {
+                        addedError = true;
+                        result.AddError($"Failed to parse '{token.Value}' as {typeof(T).Name}.");
+                    }
+                }
+                if (!addedError)
+                {
+                    value = list;
+                    return true;
+                }
+                else
+                {
+                    value = null;
+                    return false;
+                }
+            };
+        }
+    }
+#endif
+
+}
diff --git a/src/System.CommandLine/Option.Specialized.cs b/src/System.CommandLine/Option.Specialized.cs
new file mode 100644
index 0000000000..4f98b2379c
--- /dev/null
+++ b/src/System.CommandLine/Option.Specialized.cs
@@ -0,0 +1,44 @@
+// Copyright (c) .NET Foundation and contributors.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace System.CommandLine
+{
+#if NET7_0_OR_GREATER
+    /// <summary>
+    /// Option specialized for types implementing ISpanParsable{T}. Uses SpanParsableArgument{T} directly.
+    /// </summary>
+    public sealed class SpanParsableOption<T> : Option<T> where T : ISpanParsable<T>
+    {
+        public SpanParsableOption(string name, params string[] aliases)
+            : base(name, aliases, new SpanParsableArgument<T>(name))
+        {
+        }
+    }
+
+    /// <summary>
+    /// Option specialized for types implementing IParsable{T}. Uses ParsableArgument{T} directly.
+    /// </summary>
+    public sealed class ParsableOption<T> : Option<T> where T : IParsable<T>
+    {
+        public ParsableOption(string name, params string[] aliases)
+            : base(name, aliases, new ParsableArgument<T>(name))
+        {
+        }
+    }
+
+    
+    /// <summary>
+    /// Option specialized for types implementing IParsable{T}. Uses ParsableArgument{T} directly.
+    /// </summary>
+    public sealed class ParsableListOption<T> : Option<List<T>> where T : IParsable<T>
+    {
+        public ParsableListOption(string name, params string[] aliases)
+            : base(name, aliases, new ParsableListArgument<T>(name))
+        {
+        }
+    }
+#endif
+}
diff --git a/src/System.CommandLine/System.CommandLine.csproj b/src/System.CommandLine/System.CommandLine.csproj
index 09fd8f326a..edca17c5c0 100644
--- a/src/System.CommandLine/System.CommandLine.csproj
+++ b/src/System.CommandLine/System.CommandLine.csproj
@@ -10,9 +10,7 @@
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' == '$(NetMinimum)'">
-    <IsTrimmable>true</IsTrimmable>
-    <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
-    <EnableSingleFileAnalyzer>true</EnableSingleFileAnalyzer>
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
    
   <ItemGroup>