Start (command)

The start command is a command in the command-line interpreters of OS/2, Microsoft Windows, and ReactOS that starts a program or batch file or opens files or URLs in their associated applications.^[1] In Windows, it is a built-in utility in the Command Prompt (cmd.exe) that launches a specified program, command, or file in a separate Command Prompt window, allowing asynchronous execution without interrupting the current session. It is an essential tool for scripting, batch file automation, and direct command-line interactions in Windows environments, including both client and server editions. The Windows version of the start command was introduced as part of the Windows NT command-line tools in 1993. It enables users to control various aspects of the launched process, such as the window's title, startup directory, visibility state, and CPU affinity. Key options include /min to minimize the window, /max to maximize it, /wait to pause until the process completes, and /b to run the command in the background without opening a new window. More advanced parameters, like /low through /realtime for setting process priority or /node for NUMA node specification, provide fine-grained control suitable for system administration and performance tuning. A preview feature in Windows 11 (Build 22557 and later) adds the /machine option to specify target architecture, such as x86 or arm64, enhancing compatibility in mixed environments.^[2]

Syntax

The general syntax for the start command is:

This structure allows flexible invocation, where "title" sets the console window's caption, /d <path> defines the working directory, and /i inherits the parent's environment variables.^[2] Note that syntax varies by platform; the above is for Windows.

Usage Examples

• To launch an application like Notepad: start notepad.exe – This opens Notepad in a new window.^[2]
• To run a command and wait for it to finish: start /wait myprogram.exe – The prompt remains blocked until myprogram.exe terminates.^[2]
• To start in the background: start /b script.bat – Executes script.bat without creating an additional window.^[2]
• To view command help in a maximized window: start /max start /? – Displays the full syntax reference in an enlarged console.^[2]

The command's versatility makes it a cornerstone for Windows automation, often integrated into batch scripts to streamline workflows like opening files with default applications or initiating network diagnostics.^[2]

Overview and History

Purpose and Functionality

The start command serves as a utility in command-line environments for initiating the execution of programs, batch files, or files using their associated applications, thereby launching them in a separate process or window.^[2] This functionality enables users to invoke external resources without interrupting the ongoing session in the current command prompt.^[2] A core aspect of the start command is its support for asynchronous execution, which allows the originating command prompt to return control immediately after invocation, keeping the session available for further commands.^[2] For instance, when launching graphical user interface (GUI) applications or console programs, the command prevents the parent session from blocking, unlike synchronous direct execution where the prompt may wait for completion, particularly with console applications.^[2] This non-blocking behavior facilitates multitasking within text-based interfaces by detaching the new process from the caller's execution flow.^[2] Native to command-line interpreters such as cmd.exe, the start command emphasizes efficient process management by leveraging system file associations and environment variables to handle diverse file types and executables seamlessly.^[2] It distinguishes itself from direct command invocation—such as typing notepad.exe alone—by consistently ensuring the launched item operates independently, often in a new window, thus avoiding any dependency on the parent's lifecycle.^[2]

Development and Evolution

The START command originated in IBM's OS/2 operating system during the late 1980s, introduced as part of the OS/2 command-line interpreter to enable launching programs in separate sessions, supporting the multitasking capabilities of the DOS-compatible environment.^[3] Microsoft adopted the START command in Windows NT 3.1, released in 1993, integrating it into the new cmd.exe shell as a means to overcome limitations in DOS-based behaviors by starting programs or commands in independent windows.^[4] The command maintained a basic form in consumer Windows versions like 95 and 98, where it operated within the MS-DOS command.com environment,^[5] but saw enhancements in Windows 2000 through command extensions that improved handling of non-executable files, including URLs, by leveraging file associations to launch them in the default browser or associated application.^[6] These extensions, enabled by default in later NT-based systems, allowed START to open directories in Windows Explorer and process URLs more seamlessly without major syntax alterations.^[6] Building on Windows Vista's introduction of User Account Control (UAC) in 2007, post-2010 updates refined the command's interaction with elevation prompts; when START launches a process requiring administrative privileges, it triggers a UAC consent dialog if run from a standard user context, enhancing security without altering the command's syntax.^[7] The command has persisted largely unchanged through Windows 10 and 11, with a preview addition in Windows 11 (Build 22557 and later, as of November 2025) of the /machine option to specify target architecture such as x86 or arm64.^[2]

Platforms and Implementations

In OS/2

The start command was introduced in OS/2 1.0, released in December 1987, as part of the COMMAND.COM command-line interpreter to facilitate launching programs or sessions within the operating system's protected-mode multitasking environment based on the Intel 80286 processor.^[8][9] This design allowed users to initiate separate execution sessions, enabling concurrent operation of multiple applications without disrupting the foreground process, a key feature for OS/2's emphasis on session isolation in its 16-bit protected mode architecture.^[8] The basic syntax of the start command in OS/2 follows the form start [title] [command] [parameters], where an optional title string sets the session name displayed in the task list, followed by the target command and its arguments, supporting the launch of DOS sessions or native OS/2 programs.^[3] It handles executable file types such as .EXE (OS/2 protected-mode executables), .COM (DOS-compatible), and .BAT (batch files) by automatically detecting and routing them to appropriate session types, differing from later Windows implementations that unified handling under a single console subsystem.^[3] A unique aspect rooted in OS/2's IBM heritage is its integration with the Presentation Manager (PM), the graphical user interface introduced in OS/2 1.1, where the /PM option launches compatible programs in a windowed PM session, such as start /PM program.exe, enabling seamless graphical starts while maintaining backward compatibility with text-based sessions.^[3] Despite these capabilities, the start command in OS/2 exhibited limitations compared to subsequent evolutions, lacking advanced window management options like automatic minimization or maximization—features added in later versions via switches such as /MIN and /MAX—and instead prioritizing session separation over fine-grained UI control to align with OS/2's focus on robust multitasking in a pre-Warp era.^[3] The command became largely obsolete following the release of OS/2 Warp 4 in September 1996, with its final significant update in the Warp 4.52 fixpack issued in December 2001, after which IBM shifted emphasis to the Workplace Shell for program launching; however, it remains preserved in eComStation and ArcaOS derivatives for legacy compatibility with older scripts and applications.^[10][11]

In Windows and ReactOS

The start command is implemented as part of the cmd.exe command-line interpreter in the Windows NT lineage, beginning with Windows NT 3.1 in 1993, where it extends the foundational syntax inherited from OS/2 to support launching Win32 applications and processes in a new window or asynchronously.^[2][12] In ReactOS, an open-source operating system designed for binary compatibility with Windows software, the start command emulates the behavior of Windows cmd.exe, allowing seamless execution of Windows batch scripts and commands without behavioral deviations to maintain interoperability.^[13] Key enhancements in the Windows implementation include support for launching programs via Universal Naming Convention (UNC) paths, such as \\server\share\program.exe, which enables direct access to network resources without prior drive mapping.^[2] Additionally, invoking start with a URL, like start http://example.com, automatically opens the default web browser to that address through shell integration.^[2] The command also integrates with Windows Explorer for handling file associations and directories; if the specified argument matches a folder path, it launches Explorer to display its contents.^[2] Version-specific differences affect privilege handling: In pre-Windows Vista releases, the start command operates without User Account Control (UAC) awareness, as UAC was introduced in Vista, leading to direct execution without elevation prompts for administrative tasks.^[7] From Windows 7 onward, improved UAC integration allows start to trigger elevation prompts more reliably when launching applications requiring administrative privileges, though the command itself does not inherently elevate processes and relies on the parent cmd.exe session's context.^[7] As of 2025, ReactOS continues development to enhance compatibility with Windows 10 applications and drivers, including ongoing efforts to support newer features like the Windows Display Driver Model (WDDM) for broader hardware and software interoperability.^[14]

Syntax and Parameters

Core Syntax Structure

The core syntax of the start command in Windows and ReactOS follows the structure: start ["title"] [<command> | <program>] [parameters], where optional elements allow for flexible invocation of programs or files in a new process or window.^[2][6][13] The ["title"] component is an optional quoted string that specifies the title displayed for the new console window or in the task list, defaulting to the executable name if omitted; in cases where the command or path itself requires quotes (such as paths containing spaces), an empty quoted string "" serves as a placeholder to prevent misinterpretation as the title.^[2][6] When invoking the command, unquoted strings are parsed as executable names or commands to search in the system's PATH, while quoted strings denote full paths to executables or files, enabling handling of spaces in filenames without ambiguity.^[2][6] Any arguments following the command or path are appended directly as parameters to the target program, with the /d option available to set a specific starting directory if needed, though the core parsing appends trailing elements verbatim.^[2] This fundamental grammatical form ensures basic invocations without variations in element ordering or required delimiters in Windows and ReactOS.^[2][13]

Command Options and Modifiers

The start command in Windows supports a variety of optional flags and modifiers that allow users to customize the launch behavior of programs, commands, or files, including control over window appearance, process execution, and environment settings. These options extend the core syntax by altering default behaviors, such as the initial window state or resource allocation, and are particularly useful in batch scripts for automated workflows. All options must precede the target command or program in the syntax.^[2] Window state options determine how the launched application's window appears on startup. The /min flag starts the program in a minimized state, reducing visual clutter by sending the window to the taskbar without closing it. Conversely, /max launches the application maximized, expanding it to fill the available screen space for immediate full-view interaction. These modifiers apply primarily to console-based or GUI applications that create visible windows and do not affect background processes.^[2] Execution modifiers provide fine-grained control over how the launched process runs, including timing, priority, and resource binding. The /wait option instructs the command prompt to pause until the started program terminates, enabling sequential execution in scripts where subsequent steps depend on completion. Process priority can be set using /low, /normal (default), /high, /realtime, /abovenormal, or /belownormal, which influence CPU scheduling to optimize performance for time-sensitive tasks— for instance, /realtime reserves higher resources but risks system instability if misused. Additionally, /affinity <hexaffinity> specifies a hexadecimal mask to bind the process to particular CPU cores, useful for multi-processor systems to enforce affinity and improve efficiency. The /node <NUMA node> modifier targets Non-Uniform Memory Access (NUMA) nodes by decimal integer, enhancing memory locality on advanced hardware configurations.^[2] Path and environment options manage the context in which the program executes. The /d <path> flag sets the starting directory for the launched application, overriding the current working directory. The /i modifier loads the program's environment from the system default (Cmd.exe startup settings) rather than inheriting the parent's environment variables, preventing unintended variable propagation in chained scripts. For 16-bit applications on supported platforms, {/separate | /shared} controls memory sharing, though this is unsupported on 64-bit Windows versions.^[2] Special cases address non-standard launch scenarios. The /b option starts the program in the same console window without creating a new one, ideal for background tasks that should not spawn additional prompts, though it disables CTRL+C handling by default unless explicitly enabled. In Windows 11 (build 22557 and later), the /machine <x86|amd64|arm|arm64> flag allows specifying the target architecture for emulation or compatibility, aiding cross-architecture deployments; this remains a preview feature subject to change as of November 2025.^[2][15] These modifiers collectively enable precise control, but their availability may vary by Windows version and application type.^[2]

Usage Examples

Basic Program Launches

The start command provides a straightforward method to launch executable programs in a new window or session from the command line, enhancing user interaction by isolating the process from the current console. For instance, entering start notepad.exe initiates the Notepad text editor in a separate window, allowing it to run independently without affecting the originating command prompt session.^[2][6] This basic invocation relies on the system's PATH environment variable to locate the executable if no full path is specified.^[2] Beyond executables, the command facilitates opening files through their default associations, promoting seamless integration with associated applications. The syntax start document.txt automatically launches the file in the system's designated text editor, such as Notepad on Windows, based on file extension mappings configured in the operating system.^[2][1] Similarly, for web content, start https://example.com invokes the default web browser to navigate to the specified URL, treating it as a shell-executable resource.^[2][1] To customize the launched window, users can specify a title as the first quoted argument, which appears in the task manager or window frame. For example, start "Calculator" calc.exe opens the Calculator application with the title "Calculator," distinguishing it from other instances if multiple are running.^[2][6] This feature aids in process identification without altering core functionality. Options like /min can further modify the window state, such as starting minimized, though these are detailed elsewhere.^[2]

Script and Batch Integration

The start command plays a crucial role in Windows batch scripting by enabling the launch of external programs, commands, or additional batch files as separate processes, allowing for parallel or sequential execution within scripts. This integration facilitates automation tasks where multiple operations need to run concurrently without blocking the primary script flow, such as opening applications in the background or initiating subtasks in new windows. In batch files (.bat or .cmd), start is invoked directly via the command prompt environment, inheriting the script's working directory unless overridden with the /d parameter.^[2][16] By default, start executes its target asynchronously, meaning the batch script continues processing subsequent lines immediately after launching the process, which is ideal for non-blocking operations like starting a web browser or a monitoring tool alongside other script actions. To enforce synchronous behavior, the /wait option halts the script until the launched process terminates, ensuring dependencies are met—for instance, compiling a program before running it. The /b flag further integrates by running the command in the same console window without creating a new one, useful for lightweight tasks that should not spawn additional windows, though this may redirect output to the parent script's console. Special considerations in batch contexts include using double quotes around paths with spaces and providing an empty title string ("") as the first argument to avoid misinterpretation of parameters as window titles.^[2][16] In scripting workflows, start often combines with variables and loops for dynamic launches; for example, a batch file might iterate over a list of files using a for loop and invoke start on each to open them in parallel editors, enhancing efficiency in bulk operations. Error handling is preserved, as the command returns an errorlevel of 0 on success or 9059 on failure (e.g., invalid syntax), which can be checked with if errorlevel constructs in the script. Limitations include incompatibility of /separate and /shared options on 64-bit Windows systems, and the need for full paths or extensions to prevent ambiguity in command resolution.^[2][16] Representative examples illustrate this integration:

• Asynchronous launch in a batch script:

  @echo off start notepad.exe echo Notepad launched; continuing script...

  @echo off start notepad.exe echo Notepad launched; continuing script...

  This opens Notepad in a new window while the script proceeds, demonstrating non-blocking behavior.^[2][16]
• Synchronous execution with wait:

  @echo off start /wait calc.exe echo Calculator closed; next step.

  @echo off start /wait calc.exe echo Calculator closed; next step.

  Here, the script pauses until the calculator is closed, ensuring sequential flow.^[2][16]
• Background task without new window:

  @echo off start /b dir > output.txt echo Directory listing started in background.

  @echo off start /b dir > output.txt echo Directory listing started in background.

  The dir command runs silently in the current console, capturing output to a file without interrupting the script.^[2][16]
• Launching another batch file with custom directory:

  @echo off start /d "C:\Scripts" /wait mysubscript.bat arg1 arg2

  @echo off start /d "C:\Scripts" /wait mysubscript.bat arg1 arg2

  This runs mysubscript.bat from a specified directory and waits for completion, passing arguments for modular scripting.^[2][16]

These patterns highlight start's versatility in batch integration, from simple automation to complex workflows, while maintaining compatibility across Windows versions since its introduction in early NT releases.^[2][16]