This file describes how to install, or build, and use Julia on Windows.
For more general information about Julia, please see the main README or the documentation.
The built-in Windows fonts have rather poor coverage of the Unicode character
space. The free DejaVu Sans Mono
font can be used
as a replacement font in the Windows console. Since Windows 2000, simply
downloading the font and installing it is insufficient, since Windows keeps a
list of approved fonts in the registry.
Instructions for adding fonts to the terminal are available at this answer on superuser.com
Additionally, rather than sticking with the default command prompt, you may want
to use a different terminal emulator program, such as
Conemu or Mintty (note that running Julia on Mintty needs a
copy of stty.exe
in your %PATH%
to work properly). Alternatively, you may
prefer the features of a more full-function IDE, such as Juno,
Sublime-IJulia, or
IJulia.
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
or edit %USERPROFILE%\.gitconfig
and add/edit the lines:
[core]
eol = lf
autocrlf = input
Julia runs on Windows 7 and later. Both the 32-bit and 64-bit versions are supported. The 32-bit (i686) binary will run on either a 32-bit and 64-bit operating system. The 64-bit (x86_64) binary will only run on 64-bit Windows and will otherwise refuse to launch.
-
Download the latest version of Julia. Extract the binary to a reasonable destination folder, e.g.
C:\julia
. -
Double-click the
julia
shortcut to launch Julia. -
Julia's home directory is the location pointed to by the Windows environment variable
%HOME%
: this directory is for instance where the startup file.julia/config/startup.jl
resides.%HOMEDRIVE%\%HOMEPATH%
is used as a fallback if%HOME%
is not defined.
- Windows 10: supported (32 and 64 bits)
- Windows 8: supported (32 and 64 bits)
- Windows 7: supported (32 and 64 bits)
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,python,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:
cmake
,gcc-g++
,git
,make
,patch
- From the Net category:
curl
- From Interpreters (or Python) category:
m4
,python
- From the Archive category:
p7zip
- For 32 bit Julia, and also from the Devel category:
mingw64-i686-gcc-g++
andmingw64-i686-gcc-fortran
- For 64 bit Julia, and also from the Devel category:
mingw64-x86_64-gcc-g++
andmingw64-x86_64-gcc-fortran
- From the Devel category:
-
At the 'Resolving Dependencies' step, be sure to leave 'Select required packages (RECOMMENDED)' enabled.
-
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 unavailable
from git, addalias git="env PATH=/usr/bin git"
to~/.bashrc
and restart Cygwin. -
Set the
XC_HOST
variable inMake.user
to indicate MinGW-w64 cross compilationecho '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!
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
usr/bin/julia.exe usr/bin/julia-debug.exe
Compiling Julia from source using MSYS2 has worked in the past but is not actively supported. Pull requests to restore support would be welcome. See a past version of this file for the former instructions for compiling using MSYS2.
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).
For maximum compatibility with packages that use WinRPM.jl for binary dependencies on Windows, it
is recommended that you use OpenSUSE 42.2 for cross-compiling a Windows build
of Julia. If you use a different Linux distribution or OS X, install
Vagrant and use the following Vagrantfile
:
# Vagrantfile for MinGW-w64 cross-compilation of Julia
$script = <<SCRIPT
# Change the following to i686-w64-mingw32 for 32 bit Julia:
export XC_HOST=x86_64-w64-mingw32
# Change the following to 32 for 32 bit Julia:
export BITS=64
zypper addrepo http://download.opensuse.org/repositories/windows:mingw:win$BITS/openSUSE_Leap_42.2/windows:mingw:win$BITS.repo
zypper --gpg-auto-import-keys refresh
zypper -n install --no-recommends git make cmake tar wine which curl \
python python-xml patch gcc-c++ m4 p7zip.i586 libxml2-tools winbind
zypper -n install mingw$BITS-cross-gcc-c++ mingw$BITS-cross-gcc-fortran \
mingw$BITS-libstdc++6 mingw$BITS-libgfortran3 mingw$BITS-libssp0
# opensuse packages the mingw runtime dlls under sys-root/mingw/bin, not /usr/lib64/gcc
cp /usr/$XC_HOST/sys-root/mingw/bin/*.dll /usr/lib*/gcc/$XC_HOST/*/
git clone git://github.com/JuliaLang/julia.git julia
cd julia
make -j4 win-extras julia-ui-release
export WINEDEBUG=-all # suppress wine fixme's
# this last step may need to be run interactively
make -j4 binary-dist
SCRIPT
Vagrant.configure("2") do |config|
config.vm.box = "bento/opensuse-leap-42.2"
config.vm.provider :virtualbox do |vb|
# Use VBoxManage to customize the VM. For example to change memory:
vb.memory = 2048
end
config.vm.provision :shell, :inline => $script
end
If you don't care that the build is potentially incompatible with the WinRPM ecosystem (or happen to be on opensuse), use the following steps to cross- compile julia:
First, you will need to ensure your system has the required dependencies. We need wine (>=1.7.5), a system compiler, and some downloaders.
On Ubuntu (on other linux systems, the dependency names are likely to be similar):
apt-get install wine subversion cvs gcc wget p7zip-full winbind mingw-w64
On Mac: Install XCode, XCode command line tools, X11 (now XQuartz), and MacPorts
or Homebrew. Then run port install wine wget mingw-w64
,
or brew install wine wget mingw-w64
, as appropriate.
Then run the build:
git clone https://github.com/JuliaLang/julia.git julia-win32
echo override XC_HOST = i686-w64-mingw32 >> Make.user
make
make win-extras
(Necessary before runningmake binary-dist
)make binary-dist
- move the
julia-*.exe
installer to the target machine
If you are building for 64-bit windows, the steps are essentially the same.
Just replace i686
in XC_HOST
with 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.
Vagrant can also be used with a Windows
guest VM via the Vagrantfile
in contrib/windows,
just run vagrant up
from that folder.
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 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 start
to start the windows console from mintty if necessary.
- Use the PID from the windows task manager or
WINPID
from theps
command 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 threads
command to show all the threads andthread <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.
-
Disable the Windows Superfetch and Program Compatibility Assistant services, as they are known to have spurious interactions with MinGW/Cygwin.
As mentioned in the link above: excessive memory use by
svchost
specifically may be investigated in the Task Manager by clicking on the high-memorysvchost.exe
process and selectingGo 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.