WOLFRAM

Wolfram Language & System Documentation Center

LaunchKernels[]

launches all currently configured parallel subkernels.

LaunchKernels[n]

launches n local subkernels on the current computer.

LaunchKernels[ker]

launches the kernel specified by ker.

LaunchKernels[{ker1,ker2,…}]

launches the kernels keri.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Kernel Specifications  
Local Kernels  
SSH Kernels  
WSTPServer Kernels  
LWG Kernels  
Link Kernels  
Generalizations & Extensions  
Options  
ProgressReporting  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Tech Notes
Related Guides
History
Cite this Page

LaunchKernels

LaunchKernels[]

launches all currently configured parallel subkernels.

LaunchKernels[n]

launches n local subkernels on the current computer.

LaunchKernels[ker]

launches the kernel specified by ker.

LaunchKernels[{ker1,ker2,…}]

launches the kernels keri.

Details and Options

  • LaunchKernels[] uses $DefaultParallelKernels to determine the list of kernels to launch.
  • LaunchKernels[] (no arguments) launches the default kernels only if no kernels are currently running.
  • The following kernel specifications are recognized:
  • "ssh://user@hostname:port/path"a kernel on the given machine, accessed using SSH
    "ssh://hostname"use the default path, user and port on the given machine
    "hostname"equivalent to "ssh://hostname"
    "wstp://server:port/pool"a kernel on a WSTPServer
    "wstp://server"use the default port and kernel pool
    "Local"the default local kernel
    "localhost"a kernel on the same machine
    nn local parallel kernels
    "file:///path/to/wolfram"the given kernel on the same machine
    "file://"the default kernel on the same machine
    "https://www.wolframcloud.com/"a kernel in the Wolfram Cloud
    "lwg://host.example.com:port/path"a kernel on a LightweightGrid server
    "lwg://host.example.com:port"use the default path to the LightweightGrid manager
    "lwg://host.example.com"use the default port (3737) of the LightweightGrid server
    LinkObject[…]a WSTP link to a running kernel
  • Additional configurations for kernels on remote machines can be made available with the Wolfram Lightweight Grid and the Cluster Integration Package.
  • The ProgressReporting option specifies whether to report the progress of kernel launching.
  • The default value is ProgressReporting:>$ProgressReporting.

Examples

open all close all

Basic Examples  (4)

Launch the default kernels:

Wolfram Language code: LaunchKernels[]

Close any running kernels and launch the default local kernels only:

Wolfram Language code: CloseKernels[];LaunchKernels["Local"];$KernelCount

Close all running kernels and start 12 local kernels:

Wolfram Language code: CloseKernels[]; LaunchKernels[12];$KernelCount

LaunchKernels by default displays information about its progress:

Wolfram Language code: LaunchKernels[{"ssh://andromeda/?64", 24, "ssh://vega/?4"}];

Scope  (13)

Kernel Specifications  (4)

Launch the default kernels as described in $DefaultParallelKernels:

Wolfram Language code: $DefaultParallelKernels
Wolfram Language code: LaunchKernels[]

Launch two more local kernels, in addition to those already running:

Wolfram Language code: $KernelCount
Wolfram Language code: LaunchKernels[2]
Wolfram Language code: Kernels[]

Launch kernels on a remote machine:

Wolfram Language code: LaunchKernels["ssh://prokyon?2"]

Use KernelConfiguration to specify additional details of the desired kernels:

Wolfram Language code: LaunchKernels[KernelConfiguration["localhost", "KernelCommand" -> "wolfram141", "KernelCount" -> 4]]
Wolfram Language code: ParallelEvaluate[{First[$CommandLine], $Version}]

Local Kernels  (3)

Use a specific local kernel, given by its absolute path:

Wolfram Language code: LaunchKernels["file:///usr/local/bin/wolfram141?4"]

Alternatively, specify the properties with KernelConfiguration:

Wolfram Language code: LaunchKernels[KernelConfiguration["localhost", "KernelCommand" -> "/usr/local/bin/wolfram141", "KernelCount" -> 2]]

For local kernels, the default number of parallel kernels is equal to $ProcessorCount, license permitting:

Wolfram Language code: KernelConfiguration["Local"]["KernelCount"]
Wolfram Language code: $ProcessorCount

SSH Kernels  (3)

Give the path to the remote kernel and number of kernels as URL parameters:

Wolfram Language code: LaunchKernels["ssh://prokyon//usr/local/bin/wolfram140?4"]

Alternatively, specify the path and kernel count as properties of KernelConfiguration:

Wolfram Language code: LaunchKernels[KernelConfiguration["ssh://prokyon", "KernelCommand" -> "/usr/local/bin/wolfram140", "KernelCount" -> 4]]

Specify the remote operating system to automatically choose a suitable kernel command:

Wolfram Language code: LaunchKernels[KernelConfiguration["ssh://mac.example.com", "OperatingSystem" -> "MacOSX", "KernelCount" -> 4]]
Wolfram Language code: ParallelEvaluate[First[$CommandLine], First[Kernels[]]]

When using a URL short form, the number of parallel kernels can be specified with "?n":

Wolfram Language code: LaunchKernels["ssh://andromeda?64"];
Wolfram Language code: $KernelCount

WSTPServer Kernels  (1)

Connect to a WSTPServer and request a number of parallel kernels:

Wolfram Language code: LaunchKernels["wstp://raspi8?2"]

LWG Kernels  (1)

Launch two parallel kernels from a LightweightGrid server with default port and manager URL:

Wolfram Language code: LaunchKernels["lwg://gcov.wolfram.com?2"]

Link Kernels  (1)

Launch two kernels that can be used as parallel subkernels:

Wolfram Language code: links = Table[LinkLaunch["wolfram -subkernel"], 2]

Use them for parallel computing:

Wolfram Language code: LaunchKernels[links]
Wolfram Language code: ParallelEvaluate[$ProcessID]

Generalizations & Extensions  (1)

Close all kernels:

Wolfram Language code: CloseKernels[]

Launch copies of the previously running kernels:

Wolfram Language code: LaunchKernels[%]

Options  (2)

ProgressReporting  (2)

Do not show a temporary progress report:

Wolfram Language code: LaunchKernels[24, ProgressReporting -> False];

Show a progress report even if the default $ProgressReporting may be False:

Wolfram Language code: LaunchKernels["ssh://andromeda/?64", ProgressReporting -> True];

Applications  (1)

Measure the speedup of the same calculation with different numbers of kernels used:

Wolfram Language code: Block[{$ProgressReporting = False}, Table[ CloseKernels[];LaunchKernels[n]; {n, AbsoluteTiming[ParallelDo[Pause[0.1], {8}]][[1]]}, {n, 1, 4}] ]

Properties & Relations  (1)

Distributed definitions and shared variables apply to running kernels and new ones:

Wolfram Language code: n = 17; DistributeDefinitions[n]; xs = 0;SetSharedVariable[xs];
Wolfram Language code: ParallelEvaluate[{n, xs++}]

Packages read with ParallelNeeds also apply to running and new kernels:

Wolfram Language code: ParallelNeeds["ComputerArithmetic`"]

Close all running kernels and launch new ones:

Wolfram Language code: CloseKernels[];LaunchKernels[]

The new kernels inherit previously distributed definitions and shared variables:

Wolfram Language code: ParallelEvaluate[{n, xs++}]

The new kernels also inherit packages read previously:

Wolfram Language code: ParallelEvaluate[$ContextPath, First[Kernels[]]]

Possible Issues  (3)

If any kernels are already running, LaunchKernels[] does not launch the default kernels:

Wolfram Language code: $KernelCount
Wolfram Language code: LaunchKernels[]

Close all running kernels, then launch the default set of kernels:

Wolfram Language code: CloseKernels[];LaunchKernels[]

Kernels may be automatically launched when first needed:

Wolfram Language code: $KernelCount
Wolfram Language code: ParallelTable[Prime[i], {i, 10}]
Wolfram Language code: $KernelCount

Manually close the kernels:

Wolfram Language code: CloseKernels[];

Now, no kernels are launched automatically:

Wolfram Language code: ParallelTable[Prime[i], {i, 10}]

If no kernels are available, most parallel calculations are done sequentially:

Wolfram Language code: CloseKernels[];
Wolfram Language code: ParallelTable[Prime[i], {i, 5}]

Neat Examples  (1)

Specify a kernel on a remote machine:

Wolfram Language code: threadripper = KernelConfiguration["ssh://andromeda"]

Ask it for the number of processor cores:

Wolfram Language code: RemoteEvaluate[threadripper, $ProcessorCount]

Update the kernel specification with the kernel number returned:

Wolfram Language code: threadripper = KernelConfiguration[threadripper, "KernelCount" -> %]
Wolfram Language code: Information[threadripper]

Launch the parallel kernels:

Wolfram Language code: LaunchKernels[threadripper];
Wolfram Language code: $KernelCount
Wolfram Research (2008), LaunchKernels, Wolfram Language function, https://reference.wolfram.com/language/ref/LaunchKernels.html.

Text

Wolfram Research (2008), LaunchKernels, Wolfram Language function, https://reference.wolfram.com/language/ref/LaunchKernels.html.

CMS

Wolfram Language. 2008. "LaunchKernels." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/LaunchKernels.html.

APA

Wolfram Language. (2008). LaunchKernels. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/LaunchKernels.html

BibTeX

@misc{reference.wolfram_2026_launchkernels, author="Wolfram Research", title="{LaunchKernels}", year="2008", howpublished="\url{https://reference.wolfram.com/language/ref/LaunchKernels.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_launchkernels, organization={Wolfram Research}, title={LaunchKernels}, year={2008}, url={https://reference.wolfram.com/language/ref/LaunchKernels.html}, note=[Accessed: 13-June-2026]}