Repository navigation
Description
Related: #2361, PowerShell/PowerShell#13068 (comment), and #6239
Summary of the new document or enhancement
Many special considerations apply when you call an external command-line executable (aka native application / utility), which aren't currently covered comprehensively, in one place:
-
That the only data type supported is text (
[string]), both on input and output, and how raw byte data is fundamentally unsupported - both when collecting the output in PowerShell and when piping between native programs.- Update: v7.4 introduced raw byte support.
-
How there are syntax pitfalls due to PowerShell's extended set of metacharacters (compared to other shells) causing potential misinterpretation of arguments, which must be avoided with quoting (e.g., To pass literal
@foo, which works unquoted incmd.exeandbash, you must use'@foo'in PowerShell).- How
--%can be used (primarily on Windows) to selectively deactivate PowerShell's parsing.
- How
-
How "native globbing" is automatically applied to arguments such as
*.txton Unix-like platforms; that is,*.txtis implicitly replaced with the array of file names / paths matching that wildcard pattern. -
How output data is sent through the pipeline line by line, resulting in an array of strings (lines), if collected in a variable.
-
How stderr (standard error) output is passed through to the host rather than going through PowerShell's error stream and can only be captured with a
2>redirection. -
How redirections (
>) generally do not pass the native program's output through as-is, but invariably treat it as[Console]::OutputEncodingencoded text that on writing to the target file is written with PowerShell's default encoding (BOM-less UTF-8 in PowerShell 6+, UTF-16LE in Windows PowerShell). -
How external-program calls aren't integrated with PowerShell's error handling and require explicit checking of
$?/$LASTEXITCODEto detect failure, except in PowerShell 7, where pipeline chain operators&&and||can now be used. See also: the RFC that proposes improvements to the integration. -
How
&, the call operator, must be used to invoke executables whose paths are / must be quoted (as a whole) and/or contain variable references or subexpressions (this requirement isn't specific to external programs, but most likely to surface in that context). -
How
Start-Processis typically not the right tool for invoking external programs - see Provide guidance as to when Start-Process is appropriate vs. direct / &-based invocation #6239.
Details of requested document:
- Proposed title: about_Native_Calls
- Propose location in the TOC: Among the `about_* topics
- Target audience: end users
- Purpose or scenario: guidance for invoking native command-line programs
- List of related articles to link to: about_Parsing, about_Quoting_Rules, about_Redirection, about_Pipelines, about_pwsh, about_Operators (section "Pipeline chain operators && and ||")
Activity
yecril71pl commentedon Dec 13, 2022
C:\'Program Files\Acme Inc.\Your Terrific App.exe'is a perfect invocation and it does not use the&operator.mklement0 commentedon Dec 14, 2022
True: what matters is whether the token starts with a quote, which in turn only works if the whole token is quoted.
It is for this reason that compound string arguments composed of quoted and unquoted tokens are best avoided in PowerShell - the fact that a quoted first token invariably becomes its own argument is counterintuitive and invites confusion:
yecril71pl commentedon Dec 14, 2022
But that makes
&recommended, not required as you have suggested.mklement0 commentedon Dec 14, 2022
It is required for (a) command names / paths that are quoted as a whole and/or (b) contain variable references or subexpressions. I've inserted "(as a whole)" in the initial post to clarify.
mklement0 commentedon Dec 14, 2022
In short:
You're free to always use
&You must use
&in the scenarios described above.surfingoldelephant commentedon Dec 28, 2025
I agree that this concept (native commands) as a whole needs to be fleshed out quite a bit. I often see users struggle in this area, especially with argument passing and encoding issues.
Here's bits and pieces of the existing native command documentation spread out across many articles:
$_& Pipeline chain operators with native commands$PSNativeCommandArgumentPassingStart-Process(includes a note on when to avoid it in favor of native command invocation)Switch-Process/exec(Unix)$ErrorActioNPreference&$PSNativeCommandUseErrorActionPreferenceParameterBindingoperations for native commands$OutputEncodingConsolidating this into a single article (with links to existing articles) would go a long way, I think. As would filling in the gaps for the missing information/guidance mentioned in the OP.
These to me are the most pressing areas that need additional content:
Start-Processvs native command invocationWe should also standardize terminology. Right now, it's inconsistent. E.g., these are all used to describe the same concept throughout the documentation:
CommandNotFoundException)CommandNotFoundException)I suggest "native command" going forward. It's already used in the various formal definitions on the topic and is what's used most commonly in existing documentation. It also follows suit with the internal
NativeCommandProcessorclass name (although, that's not a strong argument in itself).Thoughts?
ApplicationInfoinstance or variable with a string/ApplicationInfovalue.ApplicationInfoinstance byGet-Command..ps1, etc) can be native commands, not just executables (PATHEXT).Start-Process, rather than executable vs non-executable file types. E.g., "runcmd.exeas a native command", "run.\foo.txtnatively", etc refer to the same concept..\foo.txt | Write-Outputerrors (and is referred to as a "document") whereasnotepad .\foo.txt | Write-Outputworks just fine to force synchronous behavior.Start-Processprovides an alternative method to running a native command with more granular control over execution behavior, but has its own set of drawbacks/pitfalls.