Back to LAMMPS Packages for Windows Overview
LAMMPS Windows Installer Repository
This repository is hosting pre-compiled Windows installers of the
molecular dynamics simulation software package.
The binaries are built with MinGW64 Linux to Windows
cross-compilers on Fedora Linux using the standard LAMMPS sources.
The LAMMPS binaries contain all optional packages included in
the source distribution except:
The serial executable additionally does not contain the
MPIIO and LATBOLTZ packages, since those require
MPI-IO functions, which are not available without linking
to a real MPI library.
- ADIOS (requires an external library),
- H5MD (requires an external library),
- KIM (not fully ported to Windows),
- KOKKOS (does not fully support cross-compilation with GCC),
- MESSAGE (obsolete),
- ML-PACE (external library not compatible),
- ML-QUIP (requires an external library),
- MSCG (requires an external library),
- NETCDF (requires an external library),
- PLUGIN (does not support Windows),
- PLUMED (not fully ported to Windows),
- QMMM (only useful when linking to a QM software),
- SCAFACOS (requires an external library).
- VTK (requires an external library).
The LAMMPS Python module
(to call LAMMPS from Python)
is included in all
packages in a way, that it should work with a suitable Python installation of your own,
since a LAMMPS shared library (i.e. a DLL file on Windows) is included.
(to call Python from LAMMPS) however, is only included in the installer
package with Python in the name. Those packages also include a full
Python runtime environment with all standard Python modules and
the NumPy module since those have to be consistent with the Python library
used to compile LAMMPS. Please note that the 64-bit Windows NumPy
module is considered very experimental
and thus one
should expect crashes that are not bugs in LAMMPS.
Important Note on Changes to the Installer packages
As of LAMMPS version 27 May 2021, the LAMMPS installer packages will detect
if LAMMPS (version 27 May 2021 or later) has already been installed and will
offer to uninstall, in case it is. This should be independent from whether
it was 32-bit or 64-bit version and with or without MPI or Python. Having
multiple versions/variants of LAMMPS installed at the same time is no longer
supported. Also, the name of the LAMMPS executable has been simplified to
lmp.exe in all packages since there is no longer a need to
differentiate between the MPI and non-MPI version.
Some Notes on GPU Support
These Windows binaries include GPU acceleration via the GPU
This is achieved through compiling the GPU package in OpenCL mode and linking
to an OpenCL
compatible ICD loader. The included OpenCL loader library is compatible
with OpenCL version 1.2 to 3.0. This means the executables do not contain
any vendor provided code and should be compatible with current GPUs from
, and Nvidia
The GPU package has been compiled for mixed precision computation and
as of LAMMPS version 10 March 2021 will automatically tune itself for
the OpenCL capable hardware in use.
In the case of having multiple Vendor provided OpenCL runtimes
installed, you may run into the situation of the "wrong" runtime
being set as the default and used by LAMMPS. In this case, you may
need to remove unwanted vendors from the windows registry database. Look for the
and remove vendors with non-functional OpenCL support.
When reporting problems, please always include the exact
version of the installer and the output of the
LAMMPS Python module
These Windows binaries are built to include a shared library
(liblammps.dll) and and also contain the LAMMPS Python wrapper
module which is placed in a directory included in
environment variable. That makes it
possible to import it into a suitable Python interpreter on
Windows without any additional setup. This has been tested with
the Python interpreters bundled with Microsoft Visual Studio
and those downloaded from
but should be usable with any Python interpreter that
is for the same architecture (32-bit or 64-bit x86).
This module is always included and the packages with a Python
runtime include may import the LAMMPS python module from within their
Python functions or classes. However, the LAMMPS installer packages
do not include a Python executable for standalone use.
These Windows packages also include the
a customized LAMMPS executable enhanced for interactive use.
Installing LAMMPS on Windows
There are installer packages for 32-bit and 64-bit
versions of Windows available.
The respective download directory will contain installer
packages that are labeled with the date of the LAMMPS version
and packages labeled as latest
. It is usually
recommended to download and install the latest package.
The other packages are provided in case there is a problem with it.
Download the installer executable suitable for your machine,
execute it, and follow the instructions in the dialogs.
Each version will install into a different directory, so it
is possible to have multiple versions installed at the same
time (however it is not recommended). Both kinds of packages contain:
- Either: a regular multi-threaded LAMMPS executable called
This should always work.
- Or: a multi-threaded LAMMPS executable that also
supports parallel execution via MPI message passing. This
executable is called
requires installation of a suitable MPICH2 package to
- the LAMMPS manual in PDF format
- the colvars
reference manual in PDF format
- several additional PDF format guides for specific packages or styles
- the potential files bundled with the LAMMPS source code
- most of the example inputs, reference outputs and related files
- the benchmark inputs and reference outputs
- the tools
binary2txt, chain, msi2lmp, abf_integrate,
createatoms, ocl_get_devices, lammps-shell
Both executables will run in serial when executed directly.
Please see below for instructions on how to perform parallel runs.
To use the MPI based parallelism, you also need to install
MPICH2 from Argonne lab.
For 32-bit Windows you have to download and install
mpich2-1.4.1p1-win-ia32.msi. This is the latest available binary 32-bit
MPI package compatible with the GNU cross compilers used to compile LAMMPS.
Correspondingly, for 64-bit Windows you have to download and install
mpich2-1.4.1p1-win-x86-64.msi. This is the latest available binary 64-bit
MPI package compatible with the GNU cross compilers used to compile LAMMPS.
Installing LAMMPS globally on Windows with administrator privilege
The installer packages listed above will install LAMMPS into a user's
personal storage area and thus it cannot be used by all users. This behavior
was changed with the stable release of LAMMPS in October 2020.
Installer packages from previous LAMMPS versions and current versions that
require administrator privilege to be installed can be found
their own download area
The content is otherwise the same, only the packaging is different.
Running LAMMPS on Windows
LAMMPS is a text mode program, so you have to click on the
Command Prompt entry in the windows start menu, launch the
Windows Power Shell, or simply execute the command
cmd from Start -> Run.
The LAMMPS manual and the colvars reference manual in PDF format
are linked from the start men, also references to open the
file system browser to view the Benchmarks and Examples
directory tree. The PATH environment variable is automatically
set by the installer, so that the bundled executables from everywhere
in the system. Also the LAMMPS_POTENTIALS environment variable
is preset to the folder with the bundled manybody potential files,
so they do not need to be copied into the respective working directory.
To run a LAMMPS simulations please open a console window as outlined above
and change to the directory with your input script and then run
lmp as described in the LAMMPS
manual. For more details and additional command line flags, please
check out the
Multi-threaded Parallel Execution
All LAMMPS binaries from this repository support multi-threading via OpenMP,
however by default only one thread is enabled. To enable more threads, e.g. four,
you need to either set it at the command line prompt via
set OMP_NUM_THREADS=4, via the
-pk omp 4 command line flag, or via the
package omp 4
command in your input script.
After enabling the use of multiple threads, you also have to select
styles in LAMMPS, that are multi-thread enabled. Those are usually identified
by the /omp suffix. Those can be selected explicitly and selectively,
or with the
command or - most conveniently - via using the
command line flag to the LAMMPS executable.
lmp -pk omp 4 -sf omp -in in.melt
Message Passing (MPI) Parallel Execution
Only the executable from the LAMMPS-MPI packages supports parallel execution
via MPI (which can be combined with OpenMP multi-threading). For that you also
need to install a specific version of MPICH2 from Argonne lab linked above.
The installer does not contain it and does not check for it. Please note, that
you need to download a very specific (and rather old) version of the MPICH
package, as this is what LAMMPS was compiled with and the latest available
Windows binary version compatible with the GNU compilers used to compile LAMMPS.
After the installation of the MPICH software, it needs to be integrated into the system.
For this you need to start a Command Prompt in Administrator Mode (right
click on the icon and select it). Change into the MPICH2 installation directory, then
into the subdirectory
bin and execute
MPI parallel executables have to be launched with
mpiexec -localonly # lmp ...
mpiexec -np # lmp ... with "#" being then number
of parallel processes to start. For the latter you may be asked for your password.
Known Issues: while running in MPI parallel mode any
output to the screen is block buffered and not line buffered as
usual. That is, output will not show up immediately, but only
after a certain amount of output has accumulated. This is done for
efficiency reasons. Multi-threaded parallel or serial runs are
not affected. Also when running under mpiexec, you should not use
multi-threading since MPICH restricts processes to a single
physical CPU thus it will run less efficient.
Last modified: Thu Jul 29 02:01:37 UTC 2021 by akohlmey