diff --git a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
index 85ecb916213e..fcdcf705378d 100644
--- a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
+++ b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Immutable;
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.Data;
@@ -17,8 +16,6 @@ internal sealed class CommandLineOptions
 {
     public const string DefaultCommand = "run";
 
-    private static readonly ImmutableArray<string> s_binaryLogOptionNames = ["-bl", "/bl", "-binaryLogger", "--binaryLogger", "/binaryLogger"];
-
     public bool List { get; init; }
     public required GlobalOptions GlobalOptions { get; init; }
 
@@ -157,17 +154,14 @@ internal sealed class CommandLineOptions
             }
         }
 
-        var commandArguments = GetCommandArguments(parseResult, watchOptions, explicitCommand, out var binLogToken, out var binLogPath);
+        var commandArguments = GetCommandArguments(parseResult, watchOptions, explicitCommand);
 
         // We assume that forwarded options, if any, are intended for dotnet build.
         var buildArguments = buildOptions.Select(option => ((IForwardedOption)option).GetForwardingFunction()(parseResult)).SelectMany(args => args).ToList();
 
-        if (binLogToken != null)
-        {
-            buildArguments.Add(binLogToken);
-        }
-
         var targetFrameworkOption = (Option<string>?)buildOptions.SingleOrDefault(option => option.Name == "--framework");
+        var binaryLoggerOption = (Option<BinaryLoggerParameters?>?)buildOptions.SingleOrDefault(option => option.Name == "--binaryLogger");
+        var binaryLoggerOptions = binaryLoggerOption != null ? parseResult.GetValue(binaryLoggerOption) : null;
 
         return new()
         {
@@ -178,7 +172,7 @@ internal sealed class CommandLineOptions
                 NoHotReload = parseResult.GetValue(noHotReloadOption),
                 NonInteractive = parseResult.GetValue(NonInteractiveOption),
                 Verbose = parseResult.GetValue(verboseOption),
-                BinaryLogPath = ParseBinaryLogFilePath(binLogPath),
+                BinaryLogPath = GetBinaryLogFilePath(binaryLoggerOptions),
             },
 
             CommandArguments = commandArguments,
@@ -193,35 +187,31 @@ internal sealed class CommandLineOptions
     }
 
     /// <summary>
-    /// Parses the value of msbuild option `-binaryLogger[:[LogFile=]output.binlog[;ProjectImports={None,Embed,ZipFile}]]`.
-    /// Emulates https://github.com/dotnet/msbuild/blob/7f69ea906c29f2478cc05423484ad185de66e124/src/Build/Logging/BinaryLogger/BinaryLogger.cs#L481.
-    /// See https://github.com/dotnet/msbuild/issues/12256
+    /// Gets the binary log file path from the binary logger options.
     /// </summary>
-    internal static string? ParseBinaryLogFilePath(string? value)
-        => value switch
+    internal static string? GetBinaryLogFilePath(BinaryLoggerParameters? parameters)
+    {
+        if (parameters == null)
         {
-            null => null,
-            _ => (from parameter in value.Split(';', StringSplitOptions.RemoveEmptyEntries)
-                  where !string.Equals(parameter, "ProjectImports=None", StringComparison.OrdinalIgnoreCase) &&
-                        !string.Equals(parameter, "ProjectImports=Embed", StringComparison.OrdinalIgnoreCase) &&
-                        !string.Equals(parameter, "ProjectImports=ZipFile", StringComparison.OrdinalIgnoreCase) &&
-                        !string.Equals(parameter, "OmitInitialInfo", StringComparison.OrdinalIgnoreCase)
-                  let path = (parameter.StartsWith("LogFile=", StringComparison.OrdinalIgnoreCase) ? parameter["LogFile=".Length..] : parameter).Trim('"')
-                  let pathWithExtension = path.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase) ? path : $"{path}.binlog"
-                  select pathWithExtension)
-                 .LastOrDefault("msbuild.binlog")
-        };
+            return null;
+        }
+
+        if (!string.IsNullOrEmpty(parameters.LogFile))
+        {
+            return parameters.LogFile.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase) 
+                ? parameters.LogFile 
+                : $"{parameters.LogFile}.binlog";
+        }
+
+        return "msbuild.binlog";
+    }
 
     private static IReadOnlyList<string> GetCommandArguments(
         ParseResult parseResult,
         IReadOnlyList<Option> watchOptions,
-        Command? explicitCommand,
-        out string? binLogToken,
-        out string? binLogPath)
+        Command? explicitCommand)
     {
         var arguments = new List<string>();
-        binLogToken = null;
-        binLogPath = null;
 
         foreach (var child in parseResult.CommandResult.Children)
         {
@@ -276,25 +266,6 @@ private static IReadOnlyList<string> GetCommandArguments(
                     seenCommand = true;
                     continue;
                 }
-
-                // Workaround: commands do not have forwarding option for -bl
-                // https://github.com/dotnet/sdk/issues/49989
-                foreach (var name in s_binaryLogOptionNames)
-                {
-                    if (token.StartsWith(name, StringComparison.OrdinalIgnoreCase))
-                    {
-                        if (token.Length == name.Length)
-                        {
-                            binLogToken = token;
-                            binLogPath = "";
-                        }
-                        else if (token.Length > name.Length + 1 && token[name.Length] == ':')
-                        {
-                            binLogToken = token;
-                            binLogPath = token[(name.Length + 1)..];
-                        }
-                    }
-                }
             }
 
             if (!dashDashInserted && i >= unmatchedTokensBeforeDashDash)
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
index 12bea5e09309..b05ae14be3ee 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
@@ -91,6 +91,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
 
         command.SetAction(BuildCommand.Run);
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
index aff818886fe8..11f0931937df 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
@@ -59,6 +59,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArtifactsPathOption);
         command.Options.Add(NoLogoOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
         command.Subcommands.Add(CleanFileBasedAppArtifactsCommandParser.Command);
 
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
index 67c2a47f1051..c8a0f944bed6 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
@@ -38,7 +38,7 @@ private static MSBuildArgs ConcatTelemetryLogger(MSBuildArgs msbuildArgs)
     /// Mostly intended for quick/one-shot usage - most 'core' SDK commands should do more hands-on parsing.
     /// </summary>
     public MSBuildForwardingApp(IEnumerable<string> rawMSBuildArgs, string? msbuildPath = null) : this(
-        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.VerbosityOption()),
+        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.VerbosityOption(), CommonOptions.BinaryLoggerOption),
         msbuildPath)
     {
     }
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
index 929f274ac3a7..e4b2b8658318 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
@@ -86,6 +86,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.VersionSuffixOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
 
         // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
index 8de1ebee7792..58927484e3b2 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
@@ -89,6 +89,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
 
         command.SetAction(PublishCommand.Run);
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
index e986e495e2d3..f7363ad15c30 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
@@ -69,6 +69,7 @@ private static Command ConstructCommand()
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
 
         command.Options.AddRange(FullRestoreOptions());
 
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
index 067ff538a740..4e9262db0b16 100644
--- a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
@@ -108,7 +108,8 @@ public override RunApiOutput Execute()
                 applicationArgs: [],
                 readCodeFromStdin: false,
                 environmentVariables: ReadOnlyDictionary<string, string>.Empty,
-                msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty);
+                msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty,
+                binaryLoggerParameters: null);
 
             runCommand.TryGetLaunchProfileSettingsIfNeeded(out var launchSettings);
             var targetCommand = (Utils.Command)runCommand.GetTargetCommand(buildCommand.CreateProjectInstance);
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index 6a1876c3a886..261161856dbc 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -46,6 +46,11 @@ public class RunCommand
 
     public ReadOnlyDictionary<string, string>? RestoreProperties { get; }
 
+    /// <summary>
+    /// Binary logger parameters, if specified on the command line.
+    /// </summary>
+    public BinaryLoggerParameters? BinaryLoggerParameters { get; }
+
     /// <summary>
     /// unparsed/arbitrary CLI tokens to be passed to the running application
     /// </summary>
@@ -89,7 +94,8 @@ public RunCommand(
         string[] applicationArgs,
         bool readCodeFromStdin,
         IReadOnlyDictionary<string, string> environmentVariables,
-        ReadOnlyDictionary<string, string>? msbuildRestoreProperties)
+        ReadOnlyDictionary<string, string>? msbuildRestoreProperties,
+        BinaryLoggerParameters? binaryLoggerParameters)
     {
         Debug.Assert(projectFileFullPath is null ^ entryPointFileFullPath is null);
         Debug.Assert(!readCodeFromStdin || entryPointFileFullPath is not null);
@@ -108,6 +114,7 @@ public RunCommand(
         MSBuildArgs = SetupSilentBuildArgs(msbuildArgs);
         EnvironmentVariables = environmentVariables;
         RestoreProperties = msbuildRestoreProperties;
+        BinaryLoggerParameters = binaryLoggerParameters;
     }
 
     public int Execute()
@@ -356,7 +363,7 @@ internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? pro
             return CreateCommandForCscBuiltProgram(EntryPointFileFullPath);
         }
 
-        FacadeLogger? logger = LoggerUtility.DetermineBinlogger([..MSBuildArgs.OtherMSBuildArgs], "dotnet-run");
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(BinaryLoggerParameters, "dotnet-run");
         var project = EvaluateProject(ProjectFileFullPath, projectFactory, MSBuildArgs, logger);
         ValidatePreconditions(project);
         InvokeRunArgumentsTarget(project, NoBuild, logger, MSBuildArgs);
@@ -596,23 +603,14 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             parseResult = ModifyParseResultForShorthandProjectOption(parseResult);
         }
 
-        // if the application arguments contain any binlog args then we need to remove them from the application arguments and apply
-        // them to the restore args.
-        // this is because we can't model the binlog command structure in MSbuild in the System.CommandLine parser, but we need
-        // bl information to synchronize the restore and build logger configurations
+        // Get application arguments (no need to separate binary log args since they're now handled as a ForwardedOption)
         var applicationArguments = parseResult.GetValue(RunCommandParser.ApplicationArguments)?.ToList();
 
-        LoggerUtility.SeparateBinLogArguments(applicationArguments, out var binLogArgs, out var nonBinLogArgs);
-
         var msbuildProperties = parseResult.OptionValuesToBeForwarded(RunCommandParser.GetCommand()).ToList();
-        if (binLogArgs.Count > 0)
-        {
-            msbuildProperties.AddRange(binLogArgs);
-        }
 
         // Only consider `-` to mean "read code from stdin" if it is before double dash `--`
         // (otherwise it should be forwarded to the target application as its command-line argument).
-        bool readCodeFromStdin = nonBinLogArgs is ["-", ..] &&
+        bool readCodeFromStdin = applicationArguments is ["-", ..] &&
             parseResult.Tokens.TakeWhile(static t => t.Type != TokenType.DoubleDash)
                 .Any(static t => t is { Type: TokenType.Argument, Value: "-" });
 
@@ -624,7 +622,7 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandParser.ProjectOption.Name, RunCommandParser.FileOption.Name);
         }
 
-        string[] args = [.. nonBinLogArgs];
+        string[] args = [.. applicationArguments ?? []];
         string? projectFilePath = DiscoverProjectFilePath(
             filePath: fileOption,
             projectFileOrDirectoryPath: projectOption,
@@ -661,8 +659,11 @@ public static RunCommand FromParseResult(ParseResult parseResult)
                 stdinStream.CopyTo(fileStream);
             }
 
-            Debug.Assert(nonBinLogArgs[0] == "-");
-            nonBinLogArgs[0] = entryPointFilePath;
+            Debug.Assert(applicationArguments?[0] == "-");
+            if (applicationArguments != null)
+            {
+                applicationArguments[0] = entryPointFilePath;
+            }
         }
 
         var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandParser.VerbosityOption);
@@ -681,7 +682,8 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             applicationArgs: args,
             readCodeFromStdin: readCodeFromStdin,
             environmentVariables: parseResult.GetValue(CommonOptions.EnvOption) ?? ImmutableDictionary<string, string>.Empty,
-            msbuildRestoreProperties: parseResult.GetValue(CommonOptions.RestorePropertiesOption)
+            msbuildRestoreProperties: parseResult.GetValue(CommonOptions.RestorePropertiesOption),
+            binaryLoggerParameters: parseResult.GetValue(CommonOptions.BinaryLoggerOption)
         );
 
         return command;
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
index 2049fe08b1e1..067d83966509 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
@@ -105,6 +105,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(CommonOptions.ArtifactsPathOption);
         command.Options.Add(CommonOptions.EnvOption);
 
diff --git a/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs b/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
index 5f98a6006e6a..658bd2cbdcd8 100644
--- a/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
@@ -89,6 +89,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.VerbosityOption());
         command.Options.Add(CommonOptions.CurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
 
         command.SetAction(StoreCommand.Run);
 
diff --git a/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
index 5944ad4f677d..764ab18aad25 100644
--- a/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
@@ -32,7 +32,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
                 Path.GetDirectoryName(solutionModel.Description)! :
                 SolutionAndProjectUtility.GetRootDirectory(solutionFilePath);
 
-        FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. buildOptions.MSBuildArgs], dotnetTestVerb);
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerParameters, dotnetTestVerb);
         var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs([.. buildOptions.MSBuildArgs]), loggers: logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
 
         ConcurrentBag<ParallelizableTestModuleGroupWithSequentialInnerModules> projects = GetProjectsProperties(collection, solutionModel.SolutionProjects.Select(p => Path.Combine(rootDirectory, p.FilePath)), buildOptions);
@@ -50,7 +50,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
             return (Array.Empty<ParallelizableTestModuleGroupWithSequentialInnerModules>(), isBuiltOrRestored);
         }
 
-        FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. buildOptions.MSBuildArgs], dotnetTestVerb);
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerParameters, dotnetTestVerb);
         var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs([.. buildOptions.MSBuildArgs]), logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
 
         IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModules> projects = SolutionAndProjectUtility.GetProjectProperties(projectFilePath, collection, buildOptions.NoLaunchProfile);
@@ -71,6 +71,9 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             parseResult.GetValue(TestingPlatformOptions.SolutionOption),
             parseResult.GetValue(TestingPlatformOptions.DirectoryOption));
 
+        // Get the binary logger parameters from the parse result
+        var binaryLoggerParameters = parseResult.GetValue(CommonOptions.BinaryLoggerOption);
+
         return new BuildOptions(
             pathOptions,
             parseResult.GetValue(CommonOptions.NoRestoreOption),
@@ -80,7 +83,8 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             parseResult.GetValue(TestingPlatformOptions.NoLaunchProfileArgumentsOption),
             degreeOfParallelism,
             otherArgs,
-            msbuildArgs);
+            msbuildArgs,
+            binaryLoggerParameters);
     }
 
     private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOptions buildOptions)
diff --git a/src/Cli/dotnet/Commands/Test/Options.cs b/src/Cli/dotnet/Commands/Test/Options.cs
index ff64e4e7ce5a..cc7a72903651 100644
--- a/src/Cli/dotnet/Commands/Test/Options.cs
+++ b/src/Cli/dotnet/Commands/Test/Options.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.DotNet.Cli;
+
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal record TestOptions(bool HasFilterMode, bool IsHelp);
@@ -14,5 +16,7 @@ internal record BuildOptions(
     Utils.VerbosityOptions? Verbosity,
     bool NoLaunchProfile,
     bool NoLaunchProfileArguments,
-    int DegreeOfParallelism, List<string> UnmatchedTokens,
-    IEnumerable<string> MSBuildArgs);
+    int DegreeOfParallelism, 
+    List<string> UnmatchedTokens,
+    IEnumerable<string> MSBuildArgs,
+    BinaryLoggerParameters? BinaryLoggerParameters);
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
index cf9539c1439c..97b98f10ac7c 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
@@ -250,6 +250,7 @@ private static Command GetTestingPlatformCliCommand()
         command.Options.Add(TestingPlatformOptions.OutputOption);
         command.Options.Add(TestingPlatformOptions.NoLaunchProfileOption);
         command.Options.Add(TestingPlatformOptions.NoLaunchProfileArgumentsOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(MTPTargetOption);
 
         return command;
@@ -294,6 +295,7 @@ private static Command GetVSTestCliCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(VsTestTargetOption);
         command.SetAction(TestCommand.Run);
 
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index aff691d5f250..6f3549787eb3 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -7,6 +7,7 @@
 using System.CommandLine.Completions;
 using System.CommandLine.Parsing;
 using System.CommandLine.StaticCompletions;
+using Microsoft.Build.Framework;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
 
@@ -47,6 +48,150 @@ internal static class CommonOptions
         .ForwardAsMSBuildProperty()
         .AllowSingleArgPerToken();
 
+    public static Option<BinaryLoggerParameters?> BinaryLoggerOption =
+        new ForwardedOption<BinaryLoggerParameters?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
+        {
+            Description = "Log all build output to a binary log file. Optionally specify a file path and optional parameters.",
+            HelpName = "PATH",
+            Arity = ArgumentArity.ZeroOrOne,
+            Hidden = true,
+            CustomParser = ParseBinaryLoggerParameters
+        }
+        .SetForwardingFunction(ForwardBinaryLoggerParameters)
+        .AllowSingleArgPerToken();
+
+    private static BinaryLoggerParameters? ParseBinaryLoggerParameters(ArgumentResult result)
+    {
+        if (result.Tokens.Count == 0)
+        {
+            // Flag form (e.g., -bl without parameters)
+            return new BinaryLoggerParameters();
+        }
+
+        if (result.Tokens.Count == 1)
+        {
+            // Parameter form (e.g., -bl:file.binlog or -bl file.binlog)
+            var argumentValue = result.Tokens[0].Value;
+            return ParseBinaryLoggerArgumentString(argumentValue);
+        }
+
+        return null;
+    }
+
+    private static BinaryLoggerParameters ParseBinaryLoggerArgumentString(string arguments)
+    {
+        if (string.IsNullOrEmpty(arguments))
+        {
+            return new BinaryLoggerParameters();
+        }
+
+        var parts = arguments.Split(';');
+        string? logFile = null;
+        ProjectImportsMode? projectImports = null;
+        LoggerVerbosity? verbosity = null;
+        var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        
+        // Parse each part
+        for (int i = 0; i < parts.Length; i++)
+        {
+            var part = parts[i].Trim();
+            if (string.IsNullOrEmpty(part))
+                continue;
+
+            var equalIndex = part.IndexOf('=');
+            
+            if (equalIndex > 0)
+            {
+                // keyword=value format
+                string key = part.Substring(0, equalIndex).Trim();
+                string value = part.Substring(equalIndex + 1).Trim();
+
+                switch (key.ToLowerInvariant())
+                {
+                    case "logfile":
+                        logFile = value;
+                        break;
+                    case "projectimports":
+                        if (Enum.TryParse<ProjectImportsMode>(value, ignoreCase: true, out var importMode))
+                        {
+                            projectImports = importMode;
+                        }
+                        else
+                        {
+                            parameters[key] = value;
+                        }
+                        break;
+                    case "verbosity":
+                        if (Enum.TryParse<LoggerVerbosity>(value, ignoreCase: true, out var verb))
+                        {
+                            verbosity = verb;
+                        }
+                        else
+                        {
+                            parameters[key] = value;
+                        }
+                        break;
+                    default:
+                        parameters[key] = value;
+                        break;
+                }
+            }
+            else if (i == 0)
+            {
+                // First part without '=' is treated as the log file
+                logFile = part;
+            }
+            else
+            {
+                // Treat as a parameter with empty value
+                parameters[part] = "";
+            }
+        }
+
+        return new BinaryLoggerParameters(
+            logFile, 
+            projectImports, 
+            verbosity, 
+            parameters.Count > 0 ? parameters : null);
+    }
+
+    private static IEnumerable<string> ForwardBinaryLoggerParameters(BinaryLoggerParameters? parameters, ParseResult parseResult)
+    {
+        if (parameters == null)
+        {
+            return [];
+        }
+
+        // Get the option result to access the original token that was used
+        var optionResult = parseResult.GetResult(BinaryLoggerOption);
+        if (optionResult == null)
+        {
+            return [];
+        }
+
+        // Find the original token that was used to invoke this option
+        string originalToken = "--binaryLogger"; // default fallback
+        if (optionResult.IdentifierToken != null)
+        {
+            originalToken = optionResult.IdentifierToken.Value;
+        }
+
+        // Check if it's flag form (no arguments) or parameter form
+        if (optionResult.Tokens.Count == 0)
+        {
+            // Flag form: forward just the original token
+            return [originalToken];
+        }
+        else if (optionResult.Tokens.Count == 1)
+        {
+            // Parameter form: forward with colon syntax using the original argument
+            var originalArguments = optionResult.Tokens[0].Value;
+            return [$"{originalToken}:{originalArguments}"];
+        }
+
+        return [];
+    }
+
     private static ReadOnlyDictionary<string, string>? ParseMSBuildTokensIntoDictionary(ArgumentResult result)
     {
         if (result.Tokens.Count == 0)
@@ -478,3 +623,35 @@ public class DynamicOption<T>(string name, params string[] aliases) : Option<T>(
 public class DynamicArgument<T>(string name) : Argument<T>(name), IDynamicArgument
 {
 }
+
+/// <summary>
+/// Represents the structured parameters for binary logging.
+/// </summary>
+/// <param name="LogFile">The log file path, or null if not specified</param>
+/// <param name="ProjectImports">How to handle project imports</param>
+/// <param name="Verbosity">The logger verbosity level</param>
+/// <param name="Parameters">Additional keyword-value parameters</param>
+public record BinaryLoggerParameters(
+    string? LogFile = null, 
+    ProjectImportsMode? ProjectImports = null,
+    LoggerVerbosity? Verbosity = null,
+    IReadOnlyDictionary<string, string>? Parameters = null);
+
+/// <summary>
+/// Represents how the binary logger should handle project imports.
+/// </summary>
+public enum ProjectImportsMode
+{
+    /// <summary>
+    /// Don't collect the project imports.
+    /// </summary>
+    None,
+    /// <summary>
+    /// Embed project imports in the log file (default).
+    /// </summary>
+    Embed,
+    /// <summary>
+    /// Save project files to {output}.projectimports.zip.
+    /// </summary>
+    ZipFile
+}
diff --git a/src/Cli/dotnet/LoggerUtility.cs b/src/Cli/dotnet/LoggerUtility.cs
index 0210c47c02f5..1b31dc6419cd 100644
--- a/src/Cli/dotnet/LoggerUtility.cs
+++ b/src/Cli/dotnet/LoggerUtility.cs
@@ -8,6 +8,62 @@ namespace Microsoft.DotNet.Cli;
 
 internal static class LoggerUtility
 {
+    public static FacadeLogger? CreateBinaryLogger(BinaryLoggerParameters? parameters, string verb)
+    {
+        if (parameters == null)
+        {
+            return null;
+        }
+
+        List<BinaryLogger> binaryLoggers = [];
+
+        string filename;
+        if (!string.IsNullOrEmpty(parameters.LogFile))
+        {
+            filename = parameters.LogFile;
+            if (filename.EndsWith(".binlog"))
+            {
+                filename = filename.Substring(0, filename.Length - ".binlog".Length);
+                filename = $"{filename}-{verb}.binlog";
+            }
+        }
+        else
+        {
+            // Default filename when no specific file is provided
+            filename = $"msbuild-{verb}.binlog";
+        }
+
+        // Build the parameters string for the BinaryLogger
+        var parametersList = new List<string> { filename };
+        
+        // Add ProjectImports parameter if specified
+        if (parameters.ProjectImports.HasValue)
+        {
+            parametersList.Add($"ProjectImports={parameters.ProjectImports.Value}");
+        }
+        
+        // Add Verbosity parameter if specified
+        if (parameters.Verbosity.HasValue)
+        {
+            parametersList.Add($"Verbosity={parameters.Verbosity.Value}");
+        }
+        
+        // Add any additional parameters
+        if (parameters.Parameters != null)
+        {
+            foreach (var kvp in parameters.Parameters)
+            {
+                parametersList.Add($"{kvp.Key}={kvp.Value}");
+            }
+        }
+
+        string parameterString = string.Join(";", parametersList);
+        binaryLoggers.Add(new BinaryLogger { Parameters = parameterString });
+
+        // Create the facade logger
+        return CreateFacadeLogger(binaryLoggers);
+    }
+
     public static FacadeLogger? DetermineBinlogger(string[] restoreArgs, string verb)
     {
         List<BinaryLogger> binaryLoggers = [];