This file describes how to install, or build, and use Julia on Windows.
We highly recommend running Julia using a modern terminal application, in particular Windows Terminal, which can be installed from the Microsoft Store.
Julia uses binary-mode files exclusively. Unlike many other Windows programs, if you write
\n to a file, you get a
\n in the file, not some other bit pattern. This matches the behavior exhibited by other operating systems. If you have installed Git for Windows, it is suggested, but not required, that you configure your system Git to use the same convention:
git config --global core.eol lf git config --global core.autocrlf input
%USERPROFILE%\.gitconfig and add/edit the lines:
[core] eol = lf autocrlf = input
For the binary distribution installation notes on Windows please see the instructions at https://julialang.org/downloads/platform/#windows.
The recommended way of compiling Julia from source on Windows is by cross compiling from Cygwin, using versions of the MinGW-w64 compilers available through Cygwin's package manager.
Download and run Cygwin setup for 32 bit or 64 bit. Note, that you can compile either 32 or 64 bit Julia from either 32 or 64 bit Cygwin. 64 bit Cygwin has a slightly smaller but often more up-to-date selection of packages.
Advanced: you may skip steps 2-4 by running:
setup-x86_64.exe -s <url> -q -P cmake,gcc-g++,git,make,patch,curl,m4,python3,p7zip,mingw64-i686-gcc-g++,mingw64-i686-gcc-fortran,mingw64-x86_64-gcc-g++,mingw64-x86_64-gcc-fortran :: replace <url> with a site from https://cygwin.com/mirrors.html :: or run setup manually first and select a mirror
Select installation location and download mirror.
At the 'Select Packages' step, select the following:
- From the Devel category:
- From the Net category:
- From Interpreters (or Python) category:
- From the Archive category:
- For 32 bit Julia, and also from the Devel category:
- For 64 bit Julia, and also from the Devel category:
- From the Devel category:
Allow Cygwin installation to finish, then start from the installed shortcut a 'Cygwin Terminal', or 'Cygwin64 Terminal', respectively.
Build Julia and its dependencies from source:
Get the Julia sources
git clone https://github.com/JuliaLang/julia.git cd julia
Tip: If you get an
error: cannot fork() for fetch-pack: Resource temporarily unavailablefrom git, add
alias git="env PATH=/usr/bin git"to
~/.bashrcand restart Cygwin.
Make.userto indicate MinGW-w64 cross compilation
echo 'XC_HOST = i686-w64-mingw32' > Make.user # for 32 bit Julia # or echo 'XC_HOST = x86_64-w64-mingw32' > Make.user # for 64 bit Julia
Start the build
make -j 4 # Adjust the number of threads (4) to match your build environment.
> Protip: build both! > ```sh > make O=julia-win32 configure > make O=julia-win64 configure > echo 'XC_HOST = i686-w64-mingw32' > julia-win32/Make.user > echo 'XC_HOST = x86_64-w64-mingw32' > julia-win64/Make.user > echo 'ifeq ($(BUILDROOT),$(JULIAHOME)) > $(error "in-tree build disabled") > endif' >> Make.user > make -C julia-win32 # build for Windows x86 in julia-win32 folder > make -C julia-win64 # build for Windows x86-64 in julia-win64 folder > ```
- Run Julia using the Julia executables directly
MSYS2 provides a robust MSYS experience.
Note: MSYS2 requires 64 bit Windows 7 or newer.
Install and configure MSYS2, Software Distribution and Building Platform for Windows.
Download and run the latest installer for the 64-bit distribution. The installer will have a name like
Open MSYS2. Update package database and base packages:
sh pacman -Syu
Exit and restart MSYS2, Update the rest of the base packages:
sh pacman -Syu
Then install tools required to build julia: ```sh
pacman -S cmake diffutils git m4 make patch tar p7zip curl python
For 64 bit Julia, install x86_64
pacman -S mingw-w64-x86_64-gcc
For 32 bit Julia, install i686
pacman -S mingw-w64-i686-gcc ```
Configuration of MSYS2 is complete. Now
exitthe MSYS2 shell.
Build Julia and its dependencies with pre-build dependencies.
Open a new MINGW64/MINGW32 shell. Currently we can't use both mingw32 and mingw64, so if you want to build the x86_64 and i686 versions, you'll need to build them in each environment separately.
and clone the Julia sources
sh git clone https://github.com/JuliaLang/julia.git cd julia
Start the build
sh make -j$(nproc)
Protip: build in dir
make O=julia-mingw-w64 configure echo 'ifeq ($(BUILDROOT),$(JULIAHOME)) $(error "in-tree build disabled") endif' >> Make.user make -C julia-mingw-w64
You can also use MinGW-w64 cross compilers to build a Windows version of Julia from Linux, Mac, or the Windows Subsystem for Linux (WSL).
First, you will need to ensure your system has the required dependencies. We need wine (>=1.7.5), a system compiler, and some downloaders. Note: a cygwin install might interfere with this method if using WSL.
On Ubuntu (on other Linux systems the dependency names are likely to be similar):
apt-get install wine-stable gcc wget p7zip-full winbind mingw-w64 gfortran-mingw-w64 dpkg --add-architecture i386 && apt-get update && apt-get install wine32 # add sudo to each if needed # switch all of the following to their "-posix" variants (interactively): for pkg in i686-w64-mingw32-g++ i686-w64-mingw32-gcc i686-w64-mingw32-gfortran x86_64-w64-mingw32-g++ x86_64-w64-mingw32-gcc x86_64-w64-mingw32-gfortran; do sudo update-alternatives --config $pkg; done
Then run the build:
git clone https://github.com/JuliaLang/julia.git julia-win32
echo override XC_HOST = i686-w64-mingw32 >> Make.user
make win-extras(Necessary before running
make exeto create the Windows installer.
- move the
julia-*.exeinstaller to the target machine
If you are building for 64-bit windows, the steps are essentially the same. Just replace
x86_64. (note: on Mac, wine only runs in 32-bit mode).
The most effective way to debug a cross-compiled version of Julia on the cross-compilation host is to install a windows version of gdb and run it under wine as usual. The pre-built packages available as part of the MSYS2 project are known to work. Apart from the GDB package you may also need the python and termcap packages. Finally, GDB's prompt may not work when launch from the command line. This can be worked around by prepending
wineconsole to the regular GDB invocation.
Compiling using one of the options above creates a basic Julia build, but not some extra components that are included if you run the full Julia binary installer. If you need these components, the easiest way to get them is to build the installer yourself using
make win-extras followed by
make binary-dist and
make exe. Then running the resulting installer.
- Run gdb under the windows console (cmd) instead. gdb may not function properly under mintty with non- cygwin applications. You can use
cmd /c startto start the windows console from mintty if necessary.
- Use the PID from the windows task manager or
pscommand instead of the PID from unix style command line tools (e.g.
pgrep). You may need to add the PID column if it is not shown by default in the windows task manager.
- When attaching to the julia process, GDB may not be attaching to the right thread. Use
info threadscommand to show all the threads and
thread <threadno>to switch threads.
- Be sure to use a 32 bit version of GDB to debug a 32 bit build of Julia, or a 64 bit version of GDB to debug a 64 bit build of Julia.
As mentioned in the link above: excessive memory use by
svchostspecifically may be investigated in the Task Manager by clicking on the high-memory
svchost.exeprocess and selecting
Go to Services. Disable child services one-by-one until a culprit is found.
Beware of BLODA. The vmmap tool is indispensable for identifying such software conflicts. Use vmmap to inspect the list of loaded DLLs for bash, mintty, or another persistent process used to drive the build. Essentially any DLL outside of the Windows System directory is potential BLODA.